@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/tier/production_bridge.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Production Bridge — Self-Healing Orchestrator
+ *
+ * Connects the Swarm/AntLane engine to production MCP tools.
+ *
+ * Pipeline: Gate check → InferenceFn → SwarmDispatcher → PayloadBuilder
+ *           → VerdictRouter → AntLane → AuditLog
+ *
+ * FAIL-SAFE: Never throws. Returns SelfHealingResult with error details.
+ * PRO-ONLY: Skips with skipReason when not PRO or inference unavailable.
+ *
+ * @since v1.11.0
+ */
+import type { BlockDeps } from '../kernel/deps.js';
+export interface SelfHealingInput {
+    /** Workspace root path (basePath) */
+    basePath: string;
+    /** Files modified by auto-fix */
+    modifiedFiles: string[];
+    /** Inspect verdict that triggered healing (e.g., 'FIX') */
+    verdict: string;
+    /** Human-readable reason */
+    reason: string;
+}
+export interface SelfHealingResult {
+    /** Whether healing was attempted */
+    attempted: boolean;
+    /** Why healing was skipped (if not attempted) */
+    skipReason?: string;
+    /** Action taken by verdict router */
+    action?: 'EXECUTED' | 'QUEUED' | 'REJECTED' | 'SKIPPED';
+    /** Swarm consensus verdict */
+    consensusVerdict?: string;
+    /** Risk score from Red evaluation */
+    riskScore?: number;
+    /** AntLane task ID (if task created) */
+    taskId?: string;
+    /** Error message (if pipeline failed) */
+    error?: string;
+}
+/**
+ * Execute the self-healing pipeline (PRO-only, FAIL-SAFE).
+ *
+ * 1. Gate check (PRO + inference available + FIX verdict + files exist)
+ * 2. Build payload from first modified file on disk
+ * 3. Dispatch Swarm (Blue/Red consensus)
+ * 4. Route verdict → AntLane (EXECUTE/WARNING/ABORT)
+ * 5. Record audit trail
+ *
+ * Returns a result object — never throws.
+ */
+export declare function executeSelfHealing(input: SelfHealingInput, deps?: BlockDeps): Promise<SelfHealingResult>;

package/build/tier/production_bridge.js

@@ -0,0 +1,127 @@
+/**
+ * Production Bridge — Self-Healing Orchestrator
+ *
+ * Connects the Swarm/AntLane engine to production MCP tools.
+ *
+ * Pipeline: Gate check → InferenceFn → SwarmDispatcher → PayloadBuilder
+ *           → VerdictRouter → AntLane → AuditLog
+ *
+ * FAIL-SAFE: Never throws. Returns SelfHealingResult with error details.
+ * PRO-ONLY: Skips with skipReason when not PRO or inference unavailable.
+ *
+ * @since v1.11.0
+ */
+import { ContextAssembler } from '../kernel/blocks/assembler.js';
+import { getFeatureGate, POST_ANALYSIS_FEATURES } from './feature_gate.js';
+import { createInferenceFn, isInferenceAvailable } from './inference_factory.js';
+import { dispatchSwarmChain } from '../domains/swarm/swarm_chain_dispatcher.js';
+import { buildPayloadFromDisk } from '../domains/ant/payload_builder.js';
+import { routeSwarmVerdict, recordSwarmRemediation, } from '../domains/swarm/swarm_verdict_router.js';
+import { AntLane } from '../domains/ant/ant_lane.js';
+import { resolveChainManager } from '../kernel/resolve_deps.js';
+// ============================================================================
+// Constants
+// ============================================================================
+const CAMPAIGN_ID = 'self-healing';
+// ============================================================================
+// Self-Healing Pipeline
+// ============================================================================
+/**
+ * Execute the self-healing pipeline (PRO-only, FAIL-SAFE).
+ *
+ * 1. Gate check (PRO + inference available + FIX verdict + files exist)
+ * 2. Build payload from first modified file on disk
+ * 3. Dispatch Swarm (Blue/Red consensus)
+ * 4. Route verdict → AntLane (EXECUTE/WARNING/ABORT)
+ * 5. Record audit trail
+ *
+ * Returns a result object — never throws.
+ */
+export async function executeSelfHealing(input, deps) {
+    try {
+        // ---- Gate checks ----
+        const skipReason = checkGates(input);
+        if (skipReason) {
+            return { attempted: false, skipReason };
+        }
+        // ---- Setup ----
+        const { basePath, modifiedFiles, reason } = input;
+        const { blockStore: store, chainManager } = resolveChainManager(basePath, deps);
+        const lane = new AntLane(basePath, CAMPAIGN_ID);
+        // ---- Build payload from first modified file ----
+        const targetFile = modifiedFiles[0];
+        const payloadResult = await buildPayloadFromDisk(store, targetFile, basePath, reason);
+        if (!payloadResult.success || !payloadResult.payload) {
+            return {
+                attempted: true,
+                action: 'SKIPPED',
+                error: `PAYLOAD_BUILD_FAILED: ${payloadResult.error ?? 'unknown'}`,
+            };
+        }
+        // ---- Swarm dispatch (chain-based N-step reasoning) ----
+        const inferFn = createInferenceFn();
+        const assembler = new ContextAssembler(store);
+        const swarmRequest = {
+            files: modifiedFiles,
+            context: `Auto-fix applied to ${modifiedFiles.length} file(s)`,
+            patchDescription: reason,
+            reason,
+        };
+        const consensus = await dispatchSwarmChain(swarmRequest, {
+            infer: inferFn,
+            chainManager,
+            assembler,
+        });
+        // ---- Route verdict → AntLane ----
+        const routeResult = await routeSwarmVerdict({ consensus, remediation: payloadResult.payload }, lane, store, chainManager);
+        // ---- Audit log ----
+        await recordSwarmRemediation(basePath, routeResult, {
+            consensus,
+            remediation: payloadResult.payload,
+        });
+        return {
+            attempted: true,
+            action: routeResult.action,
+            consensusVerdict: consensus.verdict,
+            riskScore: consensus.riskScore,
+            taskId: routeResult.taskId,
+        };
+    }
+    catch (e) {
+        return {
+            attempted: true,
+            error: e instanceof Error ? e.message : String(e),
+        };
+    }
+}
+// ============================================================================
+// Gate Checks
+// ============================================================================
+/**
+ * Check preconditions for self-healing. Returns skip reason or null.
+ */
+function checkGates(input) {
+    // 1. PRO tier required
+    try {
+        const gate = getFeatureGate();
+        if (!gate.isAllowed(POST_ANALYSIS_FEATURES.AUTO_FIX)) {
+            return 'PRO_REQUIRED';
+        }
+    }
+    catch {
+        return 'GATE_ERROR';
+    }
+    // 2. Inference binary must be available
+    if (!isInferenceAvailable()) {
+        return 'NO_INFERENCE';
+    }
+    // 3. Only FIX verdict triggers healing
+    if (input.verdict !== 'FIX') {
+        return 'NOT_FIX';
+    }
+    // 4. Must have modified files
+    if (!input.modifiedFiles || input.modifiedFiles.length === 0) {
+        return 'NO_FILES';
+    }
+    return null;
+}

package/build/tier/scorecard.d.ts

@@ -45,7 +45,7 @@ export interface WorkImpact {
     /** Number of lines removed */
     linesRemoved: number;
     /** Risk level assessment */
-    riskLevel: "low" | "medium" | "high" | "critical";
+    riskLevel: 'low' | 'medium' | 'high' | 'critical';
     /** Affected modules/areas */
     affectedAreas: string[];
 }
@@ -54,7 +54,7 @@ export interface WorkImpact {
  */
 export interface ScorecardResult {
     /** Schema version */
-    schemaVersion: "scorecard.v1";
+    schemaVersion: 'scorecard.v1';
     /** When this scorecard was generated */
     generatedAt: string;
     /** Workspace path */
@@ -62,7 +62,7 @@ export interface ScorecardResult {
     /** Overall score (0-100) */
     overallScore: number;
     /** Score grade */
-    grade: "A" | "B" | "C" | "D" | "F";
+    grade: 'A' | 'B' | 'C' | 'D' | 'F';
     /** Quality metrics breakdown */
     quality: QualityMetrics;
     /** Work impact assessment */
@@ -75,7 +75,7 @@ export interface ScorecardResult {
     trend?: {
         previousScore: number;
         delta: number;
-        direction: "up" | "down" | "stable";
+        direction: 'up' | 'down' | 'stable';
     };
 }
 /**
@@ -136,7 +136,3 @@ export declare class Scorecard {
  * Generate a scorecard for the given workspace
  */
 export declare function generateScorecard(options: ScorecardOptions): Promise<ScorecardResult>;
-/**
- * Format scorecard for display
- */
-export declare function formatScorecard(result: ScorecardResult): string;

package/build/tier/scorecard.js

@@ -10,30 +10,31 @@
  * @since v1.3.0
  * @tier PRO
  */
-import * as fs from "fs";
-import * as path from "path";
-import { getFeatureGate, POST_ANALYSIS_FEATURES } from "./feature_gate.js";
+import * as fs from 'fs';
+import * as path from 'path';
+import { getFeatureGate, POST_ANALYSIS_FEATURES } from './feature_gate.js';
+import { logger } from '../shared/logger.js';
 // ============================================================================
 // Constants
 // ============================================================================
 /** Default metric weights */
 const DEFAULT_WEIGHTS = {
     complexity: 0.25,
-    duplication: 0.20,
+    duplication: 0.2,
     documentation: 0.15,
     testCoverage: 0.25,
     naming: 0.15,
 };
 /** Score to grade mapping */
 const GRADE_THRESHOLDS = [
-    { min: 90, grade: "A" },
-    { min: 80, grade: "B" },
-    { min: 70, grade: "C" },
-    { min: 60, grade: "D" },
-    { min: 0, grade: "F" },
+    { min: 90, grade: 'A' },
+    { min: 80, grade: 'B' },
+    { min: 70, grade: 'C' },
+    { min: 60, grade: 'D' },
+    { min: 0, grade: 'F' },
 ];
 /** Scorecard cache file */
-const SCORECARD_CACHE_FILE = "scorecard.v1.json";
+const SCORECARD_CACHE_FILE = 'scorecard.v1.json';
 // ============================================================================
 // Analysis Functions
 // ============================================================================
@@ -78,7 +79,7 @@ function analyzeComplexity(content) {
  * Detect code duplication patterns
  */
 function analyzeDuplication(content) {
-    const lines = content.split("\n").filter((l) => l.trim().length > 10);
+    const lines = content.split('\n').filter(l => l.trim().length > 10);
     if (lines.length < 5)
         return 100;
     // Simple: count repeated lines
@@ -87,12 +88,12 @@ function analyzeDuplication(content) {
         const trimmed = line.trim();
         lineCounts.set(trimmed, (lineCounts.get(trimmed) || 0) + 1);
     }
-    const duplicatedLines = Array.from(lineCounts.values()).filter((c) => c > 1).length;
+    const duplicatedLines = Array.from(lineCounts.values()).filter(c => c > 1).length;
     const duplicationRatio = duplicatedLines / lines.length;
     // Convert to score (lower duplication = higher score)
     if (duplicationRatio <= 0.05)
         return 100;
-    if (duplicationRatio <= 0.10)
+    if (duplicationRatio <= 0.1)
         return 85;
     if (duplicationRatio <= 0.15)
         return 70;
@@ -129,8 +130,8 @@ function analyzeDocumentation(content) {
 function analyzeTestCoverage(workspace, files) {
     // Check for test files
     const testPatterns = [/\.test\.(ts|js|tsx|jsx)$/, /\.spec\.(ts|js|tsx|jsx)$/, /__tests__\//];
-    const sourceFiles = files.filter((f) => !testPatterns.some((p) => p.test(f)));
-    const testFiles = files.filter((f) => testPatterns.some((p) => p.test(f)));
+    const sourceFiles = files.filter(f => !testPatterns.some(p => p.test(f)));
+    const testFiles = files.filter(f => testPatterns.some(p => p.test(f)));
     if (sourceFiles.length === 0)
         return 100;
     const ratio = testFiles.length / sourceFiles.length;
@@ -170,15 +171,15 @@ function analyzeNaming(content) {
  */
 function calculateRiskLevel(filesChanged, linesChanged, affectedAreas) {
     // High-risk areas
-    const criticalAreas = ["auth", "security", "payment", "database", "migration"];
-    const hasCriticalArea = affectedAreas.some((a) => criticalAreas.some((c) => a.toLowerCase().includes(c)));
+    const criticalAreas = ['auth', 'security', 'payment', 'database', 'migration'];
+    const hasCriticalArea = affectedAreas.some(a => criticalAreas.some(c => a.toLowerCase().includes(c)));
     if (hasCriticalArea && linesChanged > 100)
-        return "critical";
+        return 'critical';
     if (filesChanged > 20 || linesChanged > 500)
-        return "high";
+        return 'high';
     if (filesChanged > 10 || linesChanged > 200)
-        return "medium";
-    return "low";
+        return 'medium';
+    return 'low';
 }
 /**
  * Generate improvement suggestions based on scores
@@ -186,22 +187,22 @@ function calculateRiskLevel(filesChanged, linesChanged, affectedAreas) {
 function generateSuggestions(quality) {
     const suggestions = [];
     if (quality.complexity.score < 70) {
-        suggestions.push("Consider breaking down complex functions into smaller, focused units");
+        suggestions.push('Consider breaking down complex functions into smaller, focused units');
     }
     if (quality.duplication.score < 70) {
-        suggestions.push("Extract duplicated code into reusable functions or modules");
+        suggestions.push('Extract duplicated code into reusable functions or modules');
     }
     if (quality.documentation.score < 70) {
-        suggestions.push("Add JSDoc comments to public functions and classes");
+        suggestions.push('Add JSDoc comments to public functions and classes');
     }
     if (quality.testCoverage.score < 70) {
-        suggestions.push("Increase test coverage, especially for critical paths");
+        suggestions.push('Increase test coverage, especially for critical paths');
     }
     if (quality.naming.score < 70) {
-        suggestions.push("Review variable and function names for clarity and consistency");
+        suggestions.push('Review variable and function names for clarity and consistency');
     }
     if (suggestions.length === 0) {
-        suggestions.push("Code quality is good. Keep up the good work!");
+        suggestions.push('Code quality is good. Keep up the good work!');
     }
     return suggestions;
 }
@@ -223,7 +224,7 @@ export class Scorecard {
         const gate = getFeatureGate();
         const gateResult = gate.check(POST_ANALYSIS_FEATURES.SCORECARD);
         if (!gateResult.allowed) {
-            throw new Error(gateResult.reason ?? "Scorecard requires Pro tier");
+            throw new Error(gateResult.reason ?? 'Scorecard requires Pro tier');
         }
         // Get files to analyze
         const targetFiles = files ?? this.getChangedFiles();
@@ -233,7 +234,7 @@ export class Scorecard {
             const fullPath = path.isAbsolute(file) ? file : path.join(this.workspace, file);
             if (fs.existsSync(fullPath)) {
                 try {
-                    fileContents.set(file, fs.readFileSync(fullPath, "utf-8"));
+                    fileContents.set(file, fs.readFileSync(fullPath, 'utf-8'));
                 }
                 catch {
                     // Skip unreadable files
@@ -241,7 +242,7 @@ export class Scorecard {
             }
         }
         // Combine all content for aggregate analysis
-        const allContent = Array.from(fileContents.values()).join("\n");
+        const allContent = Array.from(fileContents.values()).join('\n');
         // Calculate quality metrics
         const quality = this.calculateQualityMetrics(allContent, targetFiles);
         // Calculate work impact
@@ -256,7 +257,7 @@ export class Scorecard {
         // Load previous scorecard for trend
         const trend = this.calculateTrend(overallScore);
         const result = {
-            schemaVersion: "scorecard.v1",
+            schemaVersion: 'scorecard.v1',
             generatedAt: new Date().toISOString(),
             workspace: this.workspace,
             overallScore,
@@ -282,34 +283,34 @@ export class Scorecard {
         const namingScore = analyzeNaming(content);
         return {
             complexity: {
-                name: "Complexity",
+                name: 'Complexity',
                 score: complexityScore,
                 weight: this.weights.complexity,
-                details: complexityScore < 70 ? "High cyclomatic complexity detected" : undefined,
+                details: complexityScore < 70 ? 'High cyclomatic complexity detected' : undefined,
             },
             duplication: {
-                name: "Duplication",
+                name: 'Duplication',
                 score: duplicationScore,
                 weight: this.weights.duplication,
-                details: duplicationScore < 70 ? "Code duplication detected" : undefined,
+                details: duplicationScore < 70 ? 'Code duplication detected' : undefined,
             },
             documentation: {
-                name: "Documentation",
+                name: 'Documentation',
                 score: documentationScore,
                 weight: this.weights.documentation,
-                details: documentationScore < 70 ? "Missing documentation" : undefined,
+                details: documentationScore < 70 ? 'Missing documentation' : undefined,
             },
             testCoverage: {
-                name: "Test Coverage",
+                name: 'Test Coverage',
                 score: testCoverageScore,
                 weight: this.weights.testCoverage,
-                details: testCoverageScore < 70 ? "Low test coverage" : undefined,
+                details: testCoverageScore < 70 ? 'Low test coverage' : undefined,
             },
             naming: {
-                name: "Naming",
+                name: 'Naming',
                 score: namingScore,
                 weight: this.weights.naming,
-                details: namingScore < 70 ? "Naming convention issues" : undefined,
+                details: namingScore < 70 ? 'Naming convention issues' : undefined,
             },
         };
     }
@@ -318,9 +319,9 @@ export class Scorecard {
      */
     calculateWorkImpact(fileContents) {
         let linesAdded = 0;
-        let linesRemoved = 0;
+        const linesRemoved = 0;
         for (const content of fileContents.values()) {
-            linesAdded += content.split("\n").length;
+            linesAdded += content.split('\n').length;
         }
         // Extract affected areas from file paths
         const affectedAreas = new Set();
@@ -330,7 +331,7 @@ export class Scorecard {
                 affectedAreas.add(parts[0]);
             }
             if (parts.length > 2) {
-                affectedAreas.add(parts.slice(0, 2).join("/"));
+                affectedAreas.add(parts.slice(0, 2).join('/'));
             }
         }
         const filesChanged = fileContents.size;
@@ -364,29 +365,29 @@ export class Scorecard {
                 return grade;
             }
         }
-        return "F";
+        return 'F';
     }
     /**
      * Get list of changed files in workspace
      */
     getChangedFiles() {
         // Try to get from .vibe/dirty_files.json
-        const dirtyPath = path.join(this.workspace, ".vibe", "dirty_files.json");
+        const dirtyPath = path.join(this.workspace, '.vibe', 'dirty_files.json');
         if (fs.existsSync(dirtyPath)) {
             try {
-                const dirty = JSON.parse(fs.readFileSync(dirtyPath, "utf-8"));
+                const dirty = JSON.parse(fs.readFileSync(dirtyPath, 'utf-8'));
                 if (Array.isArray(dirty.files)) {
                     return dirty.files;
                 }
             }
-            catch {
-                // Fall through
+            catch (e) {
+                logger.warn(`[Scorecard] dirty_files.json parse failed: ${e}`);
             }
         }
         // Default: scan src directory for TypeScript files
-        const srcDir = path.join(this.workspace, "src");
+        const srcDir = path.join(this.workspace, 'src');
         if (fs.existsSync(srcDir)) {
-            return this.walkDir(srcDir, ".ts");
+            return this.walkDir(srcDir, '.ts');
         }
         return [];
     }
@@ -400,7 +401,7 @@ export class Scorecard {
             for (const entry of entries) {
                 const fullPath = path.join(dir, entry.name);
                 const relativePath = path.relative(this.workspace, fullPath);
-                if (entry.isDirectory() && !entry.name.startsWith(".")) {
+                if (entry.isDirectory() && !entry.name.startsWith('.')) {
                     files.push(...this.walkDir(fullPath, ext));
                 }
                 else if (entry.isFile() && entry.name.endsWith(ext)) {
@@ -417,20 +418,21 @@ export class Scorecard {
      * Calculate trend from previous scorecard
      */
     calculateTrend(currentScore) {
-        const cachePath = path.join(this.workspace, ".vibe", "cache", SCORECARD_CACHE_FILE);
+        const cachePath = path.join(this.workspace, '.vibe', 'cache', SCORECARD_CACHE_FILE);
         if (!fs.existsSync(cachePath)) {
             return undefined;
         }
         try {
-            const previous = JSON.parse(fs.readFileSync(cachePath, "utf-8"));
+            const previous = JSON.parse(fs.readFileSync(cachePath, 'utf-8'));
             const delta = currentScore - previous.overallScore;
             return {
                 previousScore: previous.overallScore,
                 delta,
-                direction: delta > 0 ? "up" : delta < 0 ? "down" : "stable",
+                direction: delta > 0 ? 'up' : delta < 0 ? 'down' : 'stable',
             };
         }
-        catch {
+        catch (e) {
+            logger.warn(`[Scorecard] cache parse failed: ${e}`);
             return undefined;
         }
     }
@@ -438,7 +440,7 @@ export class Scorecard {
      * Save scorecard to cache for trend comparison
      */
     saveScorecard(result) {
-        const cacheDir = path.join(this.workspace, ".vibe", "cache");
+        const cacheDir = path.join(this.workspace, '.vibe', 'cache');
         const cachePath = path.join(cacheDir, SCORECARD_CACHE_FILE);
         try {
             if (!fs.existsSync(cacheDir)) {
@@ -461,36 +463,3 @@ export async function generateScorecard(options) {
     const scorecard = new Scorecard(options);
     return scorecard.generate(options.files);
 }
-/**
- * Format scorecard for display
- */
-export function formatScorecard(result) {
-    const lines = [
-        `# Scorecard - Grade: ${result.grade} (${result.overallScore}/100)`,
-        "",
-        "## Quality Metrics",
-        `| Metric | Score | Weight |`,
-        `|--------|-------|--------|`,
-    ];
-    for (const metric of result.metrics) {
-        lines.push(`| ${metric.name} | ${metric.score} | ${(metric.weight * 100).toFixed(0)}% |`);
-    }
-    lines.push("");
-    lines.push("## Work Impact");
-    lines.push(`- Files changed: ${result.impact.filesChanged}`);
-    lines.push(`- Lines added: ${result.impact.linesAdded}`);
-    lines.push(`- Risk level: ${result.impact.riskLevel}`);
-    lines.push(`- Affected areas: ${result.impact.affectedAreas.join(", ") || "none"}`);
-    if (result.trend) {
-        lines.push("");
-        lines.push("## Trend");
-        const arrow = result.trend.direction === "up" ? "↑" : result.trend.direction === "down" ? "↓" : "→";
-        lines.push(`${arrow} ${Math.abs(result.trend.delta)} points from previous (${result.trend.previousScore})`);
-    }
-    lines.push("");
-    lines.push("## Suggestions");
-    for (const suggestion of result.suggestions) {
-        lines.push(`- ${suggestion}`);
-    }
-    return lines.join("\n");
-}

package/build/utils/with_timeout.d.ts

@@ -0,0 +1 @@
+export declare function withTimeout<T>(work: Promise<T>, timeoutMs: number, label?: string): Promise<T>;

package/build/utils/with_timeout.js

@@ -0,0 +1,16 @@
+export async function withTimeout(work, timeoutMs, label = 'Operation') {
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+        return work;
+    }
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
+    });
+    try {
+        return await Promise.race([work, timeout]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}

package/build/workers/base/health.d.ts

@@ -72,6 +72,7 @@ export declare class HealthChecker {
     private checkDiskSpace;
     private getQueuePath;
     private recoverTask;
+    private getRetryCount;
 }
 /**
  * Create a pre-configured health checker