Repo Intel x402 Integration

Analyze repos of any size - security scanning, code analysis, monorepo support.

Overview

Repository: nirholas/repo-intel
MCP Registry: io.github.nirholas/repo-intel
x402 Use Case: Premium deep scans, security audits, continuous monitoring

Installation

npm install @nirholas/x402-ecosystem @nirholas/repo-intel

Integration Pattern

import { PaywallBuilder, PricingStrategy } from '@nirholas/x402-ecosystem/premium';
import { RepoIntel } from '@nirholas/repo-intel';

// Analysis depth pricing
const intelPricing = PricingStrategy.resourceBased({
  'quick-scan': 0,             // Free: basic overview
  'standard-scan': 0.05,       // $0.05: full analysis
  'deep-scan': 0.25,           // $0.25: dependencies + security
  'security-audit': 1.00,      // $1.00: full security audit
  'monorepo-scan': 0.50,       // $0.50: per package
  'continuous': 10.00,         // $10/month: continuous monitoring
  'custom-rules': 0.25         // $0.25: per custom rule set
});

const intel = new PaywallBuilder()
  .service('repo-intel')
  .pricing(intelPricing)
  .build();

Scan Levels

// Scan depth configurations
const scanLevels = {
  quick: {
    includes: ['structure', 'languages', 'readme'],
    timeout: '30s',
    cost: 0
  },
  standard: {
    includes: ['structure', 'languages', 'readme', 'dependencies', 'license'],
    timeout: '2m',
    cost: 0.05
  },
  deep: {
    includes: ['all', 'vulnerabilities', 'code-quality', 'complexity'],
    timeout: '10m',
    cost: 0.25
  },
  security: {
    includes: ['all', 'sast', 'secrets', 'supply-chain', 'sbom'],
    timeout: '30m',
    cost: 1.00
  }
};

// Analyze repository
async function analyzeRepo(repoUrl: string, level: keyof typeof scanLevels = 'standard') {
  const config = scanLevels[level];

  if (config.cost > 0) {
    await intel.charge(config.cost, { repo: repoUrl, level });
  }

  return RepoIntel.analyze(repoUrl, { depth: level });
}

Security Audit

// Premium security audit
async function securityAudit(repoUrl: string, options: AuditOptions = {}) {
  await intel.charge(1.00, { type: 'security-audit', repo: repoUrl });

  const audit = await RepoIntel.securityAudit(repoUrl, {
    sast: true,           // Static analysis
    secrets: true,        // Secret detection
    dependencies: true,   // Vulnerability scanning
    supplyChain: true,    // Supply chain risks
    generateSBOM: true    // Software bill of materials
  });

  return {
    summary: audit.summary,
    criticalIssues: audit.issues.filter(i => i.severity === 'critical'),
    highIssues: audit.issues.filter(i => i.severity === 'high'),
    recommendations: audit.recommendations,
    sbom: audit.sbom,
    score: audit.securityScore // 0-100
  };
}

Monorepo Analysis

import { PayableAgent } from '@nirholas/x402-ecosystem/agent';

const agent = new PayableAgent({
  wallet: agentWallet,
  approvedServices: ['repo-intel'],
  dailyLimit: 25
});

// Analyze monorepo (per-package pricing)
async function analyzeMonorepo(repoUrl: string) {
  // First, detect packages
  const structure = await RepoIntel.detectPackages(repoUrl);
  const packageCount = structure.packages.length;

  const cost = packageCount * 0.50;

  await agent.pay({
    service: 'repo-intel',
    amount: cost,
    description: `Analyze monorepo with ${packageCount} packages`
  });

  return RepoIntel.analyzeMonorepo(repoUrl, {
    packages: structure.packages,
    crossDependencies: true,
    sharedCode: true
  });
}

Continuous Monitoring

// Premium continuous monitoring
async function enableContinuousMonitoring(repoUrl: string, config: MonitorConfig) {
  await intel.charge(10.00, { 
    type: 'continuous',
    period: 'monthly',
    repo: repoUrl 
  });

  return RepoIntel.monitor(repoUrl, {
    frequency: config.frequency || 'daily',
    alerts: {
      newVulnerabilities: true,
      dependencyUpdates: true,
      securityScoreChange: true,
      threshold: config.alertThreshold || 'high'
    },
    notifications: config.notifications
  });
}

Analysis Output

interface RepoAnalysis {
  // Basic info
  name: string;
  url: string;
  languages: { [lang: string]: number };

  // Structure
  structure: {
    files: number;
    directories: number;
    packages?: string[];
  };

  // Dependencies (standard+)
  dependencies?: {
    direct: Dependency[];
    transitive: number;
    outdated: Dependency[];
  };

  // Security (deep+)
  security?: {
    score: number;
    vulnerabilities: Vulnerability[];
    secrets: SecretFinding[];
    recommendations: string[];
  };

  // Quality metrics
  quality?: {
    complexity: number;
    maintainability: number;
    testCoverage?: number;
  };
}

Feature Matrix

Feature	Free	Standard	Deep	Security
Structure analysis	✅	✅	✅	✅
Language detection	✅	✅	✅	✅
Dependency scan	❌	✅	✅	✅
License check	❌	✅	✅	✅
Vulnerability scan	❌	❌	✅	✅
Code quality	❌	❌	✅	✅
SAST	❌	❌	❌	✅
Secret detection	❌	❌	❌	✅
SBOM generation	❌	❌	❌	✅
Price	$0	$0.05	$0.25	$1.00

Revenue Model

const revenueSplit = {
  developer: 0.65,      // Repo Intel maintainer
  ecosystem: 0.25,      // Universal Crypto MCP
  infrastructure: 0.10  // x402 + security scan costs
};

MCP Tool Registration

server.tool('analyze_repository', {
  description: 'Analyze GitHub repository with optional premium features',
  inputSchema: z.object({
    repoUrl: z.string().url(),
    depth: z.enum(['quick', 'standard', 'deep', 'security']).default('standard'),
    includeSBOM: z.boolean().default(false)
  }),
  handler: async (params) => {
    if (params.depth === 'security') {
      return securityAudit(params.repoUrl, { sbom: params.includeSBOM });
    }
    return analyzeRepo(params.repoUrl, params.depth);
  }
});