@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/mcp/tools/vibe_pm/mapping/rebinder/evidence_collector.js

@@ -0,0 +1,214 @@
+/**
+ * Evidence Collector — Load and aggregate evidence from all sources.
+ *
+ * Reuses existing loader functions from ant, signals, scorecard, and mapping.
+ * The buildFileProfiles() function is pure (no I/O).
+ *
+ * @since P40
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { loadRemediationLog } from '../../../../../domains/ant/remediation_log.js';
+import { readAllSignals } from '../../signals/logger.js';
+import { readScorecard } from '../../scorecard/writer.js';
+import { loadChangeMap } from '../orchestrator.js';
+import { getPmRunsDir } from '../../../../../kernel/paths.js';
+// ============================================================================
+// Evidence Loading
+// ============================================================================
+/**
+ * Load remediation records from JSONL log.
+ * Thin wrapper around Ant's loadRemediationLog.
+ */
+export async function collectRemediations(basePath) {
+    return await loadRemediationLog(basePath);
+}
+/**
+ * Load all signals from the observer signal log.
+ */
+export async function collectSignals(basePath) {
+    try {
+        return await readAllSignals(basePath);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Scan .vibe/runs/ and load scorecards + change maps from recent runs.
+ */
+export async function collectRunEvidence(basePath, maxRuns) {
+    const runsDir = getPmRunsDir(basePath);
+    let runIds = [];
+    try {
+        if (!fs.existsSync(runsDir))
+            return { scorecards: [], changeMaps: [], runIds: [] };
+        const entries = fs.readdirSync(runsDir, { withFileTypes: true });
+        const dirs = entries.filter(e => e.isDirectory());
+        // Sort by mtime descending, take maxRuns
+        const withMtime = dirs.map(d => {
+            const fullPath = path.join(runsDir, d.name);
+            try {
+                const stat = fs.statSync(fullPath);
+                return { name: d.name, mtime: stat.mtimeMs };
+            }
+            catch {
+                return { name: d.name, mtime: 0 };
+            }
+        });
+        withMtime.sort((a, b) => b.mtime - a.mtime);
+        runIds = withMtime.slice(0, maxRuns).map(d => d.name);
+    }
+    catch {
+        return { scorecards: [], changeMaps: [], runIds: [] };
+    }
+    const scorecards = [];
+    const changeMaps = [];
+    for (const runId of runIds) {
+        // Load scorecard
+        try {
+            const sc = await readScorecard(basePath, runId);
+            if (sc && sc.entries) {
+                scorecards.push(...sc.entries);
+            }
+        }
+        catch {
+            // Skip this run's scorecard
+        }
+        // Load change map
+        try {
+            const cm = loadChangeMap(basePath, runId);
+            if (cm) {
+                changeMaps.push(cm);
+            }
+        }
+        catch {
+            // Skip this run's change map
+        }
+    }
+    return { scorecards, changeMaps, runIds };
+}
+/**
+ * Master aggregator: loads all evidence sources.
+ */
+export async function collectAllEvidence(basePath, config) {
+    const [remediations, signals, runEvidence] = await Promise.all([
+        collectRemediations(basePath),
+        collectSignals(basePath),
+        collectRunEvidence(basePath, config.maxRunsToScan),
+    ]);
+    return {
+        remediations,
+        signals,
+        scorecards: runEvidence.scorecards,
+        changeMaps: runEvidence.changeMaps,
+        collectedAt: new Date().toISOString(),
+        runIds: runEvidence.runIds,
+    };
+}
+// ============================================================================
+// Profile Building (Pure Function)
+// ============================================================================
+/**
+ * Build per-file evidence profiles from aggregated evidence.
+ * Pure function (no I/O).
+ */
+export function buildFileProfiles(evidence, spec) {
+    const profiles = new Map();
+    function getOrCreate(filePath) {
+        let profile = profiles.get(filePath);
+        if (!profile) {
+            profile = {
+                filePath,
+                unmappedCount: 0,
+                lowConfidenceCount: 0,
+                violationCodes: {},
+                remediationCount: 0,
+                domainDriftDetected: false,
+                suggestedOwners: [],
+            };
+            profiles.set(filePath, profile);
+        }
+        return profile;
+    }
+    // Process change maps
+    for (const cm of evidence.changeMaps) {
+        // Unmapped files
+        for (const unmapped of cm.unmapped) {
+            const profile = getOrCreate(unmapped.file);
+            profile.unmappedCount++;
+            profile.lastSeenRunId = cm.run_id;
+            // Aggregate suggested owners
+            for (const suggestion of unmapped.suggested_owners) {
+                const existing = profile.suggestedOwners.find(s => s.ownerId === suggestion.owner_id);
+                if (existing) {
+                    existing.totalConfidence += suggestion.confidence;
+                    existing.occurrences++;
+                }
+                else {
+                    profile.suggestedOwners.push({
+                        ownerId: suggestion.owner_id,
+                        domainId: suggestion.domain_id,
+                        layer: suggestion.layer,
+                        totalConfidence: suggestion.confidence,
+                        occurrences: 1,
+                    });
+                }
+            }
+        }
+        // Mapped files (check for low confidence)
+        for (const mapped of cm.mapped) {
+            const profile = getOrCreate(mapped.file);
+            profile.lastSeenRunId = cm.run_id;
+            // Track best mapped owner
+            if (!profile.bestMappedOwner) {
+                profile.bestMappedOwner = {
+                    ownerId: mapped.owner_id,
+                    domainId: mapped.domain_id,
+                    layer: mapped.layer,
+                    avgConfidence: mapped.confidence,
+                    occurrences: 1,
+                };
+            }
+            else {
+                const bmo = profile.bestMappedOwner;
+                bmo.avgConfidence =
+                    (bmo.avgConfidence * bmo.occurrences + mapped.confidence) / (bmo.occurrences + 1);
+                bmo.occurrences++;
+            }
+            // Check low confidence (use spec threshold or default 0.75)
+            const threshold = spec.rules.confidence_thresholds.mapped_min + 0.2; // mapped_min + margin
+            if (mapped.confidence < threshold) {
+                profile.lowConfidenceCount++;
+            }
+        }
+        // Violations
+        for (const violation of cm.violations) {
+            const profile = getOrCreate(violation.file);
+            profile.violationCodes[violation.code] = (profile.violationCodes[violation.code] ?? 0) + 1;
+        }
+    }
+    // Process remediations
+    for (const rem of evidence.remediations) {
+        const profile = getOrCreate(rem.filePath);
+        profile.remediationCount++;
+        // Check domain drift: is the remediated file mapped to a different domain?
+        if (profile.bestMappedOwner) {
+            const owner = spec.owners.find(o => o.id === profile.bestMappedOwner.ownerId);
+            if (owner) {
+                const matchesOwnerPath = owner.paths.some(p => {
+                    const prefix = p.replace('/**', '').replace('/*', '').replace('*', '');
+                    return rem.filePath.startsWith(prefix);
+                });
+                if (!matchesOwnerPath) {
+                    profile.domainDriftDetected = true;
+                }
+            }
+        }
+    }
+    // Sort suggested owners by total confidence descending
+    for (const profile of profiles.values()) {
+        profile.suggestedOwners.sort((a, b) => b.totalConfidence - a.totalConfidence);
+    }
+    return profiles;
+}

package/build/mcp/tools/vibe_pm/mapping/rebinder/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Evidence-to-Spec Rebinder — barrel export.
+ * @since P40
+ */
+export { runRebinder, saveProposal, loadProposal } from './rebinder.js';
+export { collectAllEvidence, buildFileProfiles } from './evidence_collector.js';
+export { detectAllPatterns } from './pattern_detector.js';
+export { buildSuggestions, buildDiffPreview, buildProposal } from './proposal_builder.js';
+export { DEFAULT_REBINDER_CONFIG } from './rebinder_types.js';
+export type { RebindingProposal, RebinderConfig, EvidenceBundle, FileEvidenceProfile, DetectedPattern, SpecMapSuggestion, SpecMapDiffEntry, PatternType, SuggestionType, } from './rebinder_types.js';

package/build/mcp/tools/vibe_pm/mapping/rebinder/index.js

@@ -0,0 +1,9 @@
+/**
+ * Evidence-to-Spec Rebinder — barrel export.
+ * @since P40
+ */
+export { runRebinder, saveProposal, loadProposal } from './rebinder.js';
+export { collectAllEvidence, buildFileProfiles } from './evidence_collector.js';
+export { detectAllPatterns } from './pattern_detector.js';
+export { buildSuggestions, buildDiffPreview, buildProposal } from './proposal_builder.js';
+export { DEFAULT_REBINDER_CONFIG } from './rebinder_types.js';

package/build/mcp/tools/vibe_pm/mapping/rebinder/pattern_detector.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Pattern Detector — Rule-based heuristic detection of SpecMap drift.
+ *
+ * All public functions are pure (except detectStalePaths which checks filesystem).
+ * Each detector returns DetectedPattern[] for its specific pattern type.
+ *
+ * @since P40
+ */
+import type { DetectedPattern, FileEvidenceProfile, EvidenceBundle, RebinderConfig, SpecMap } from './rebinder_types.js';
+/**
+ * Detect files that appear in unmapped[] across >= minOccurrences runs.
+ */
+export declare function detectUnmappedRecurring(profiles: Map<string, FileEvidenceProfile>, config: RebinderConfig): DetectedPattern[];
+/**
+ * Detect files mapped with confidence below threshold repeatedly.
+ */
+export declare function detectLowConfidence(profiles: Map<string, FileEvidenceProfile>, config: RebinderConfig): DetectedPattern[];
+/**
+ * Detect repeated boundary violations (DENY_PATH_TOUCHED, BOUNDARY_CONFLICT).
+ */
+export declare function detectBoundaryViolations(profiles: Map<string, FileEvidenceProfile>, evidence: EvidenceBundle, config: RebinderConfig): DetectedPattern[];
+/**
+ * Detect files remediated outside their mapped domain.
+ */
+export declare function detectDomainDrift(profiles: Map<string, FileEvidenceProfile>, evidence: EvidenceBundle, spec: SpecMap, config: RebinderConfig): DetectedPattern[];
+/**
+ * Detect files with repeated OWNER_AMBIGUOUS violations.
+ */
+export declare function detectOwnerAmbiguity(profiles: Map<string, FileEvidenceProfile>, config: RebinderConfig): DetectedPattern[];
+/**
+ * Detect owner paths that don't match any file in the workspace.
+ * Requires filesystem access.
+ */
+export declare function detectStalePaths(spec: SpecMap, basePath: string): DetectedPattern[];
+/**
+ * Run all pattern detectors and return combined results.
+ */
+export declare function detectAllPatterns(profiles: Map<string, FileEvidenceProfile>, evidence: EvidenceBundle, spec: SpecMap, basePath: string, config: RebinderConfig): DetectedPattern[];

package/build/mcp/tools/vibe_pm/mapping/rebinder/pattern_detector.js

@@ -0,0 +1,226 @@
+/**
+ * Pattern Detector — Rule-based heuristic detection of SpecMap drift.
+ *
+ * All public functions are pure (except detectStalePaths which checks filesystem).
+ * Each detector returns DetectedPattern[] for its specific pattern type.
+ *
+ * @since P40
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+// ============================================================================
+// Rule 1: UNMAPPED_RECURRING
+// ============================================================================
+/**
+ * Detect files that appear in unmapped[] across >= minOccurrences runs.
+ */
+export function detectUnmappedRecurring(profiles, config) {
+    const patterns = [];
+    for (const [filePath, profile] of profiles) {
+        if (profile.unmappedCount >= config.minOccurrences) {
+            const hasSuggestion = profile.suggestedOwners.length > 0;
+            const bestSuggestion = profile.suggestedOwners[0];
+            patterns.push({
+                type: 'UNMAPPED_RECURRING',
+                confidence: Math.min(1, profile.unmappedCount / (config.minOccurrences * 2)),
+                filePath,
+                evidence: [
+                    `unmapped_count:${profile.unmappedCount}`,
+                    ...(bestSuggestion
+                        ? [
+                            `best_suggestion:${bestSuggestion.ownerId}(conf:${bestSuggestion.totalConfidence.toFixed(2)})`,
+                        ]
+                        : ['no_suggestion']),
+                ],
+                occurrences: profile.unmappedCount,
+                suggestedAction: hasSuggestion ? 'ADD_PATH' : 'ADD_OWNER',
+            });
+        }
+    }
+    return patterns;
+}
+// ============================================================================
+// Rule 2: LOW_CONFIDENCE_RECURRING
+// ============================================================================
+/**
+ * Detect files mapped with confidence below threshold repeatedly.
+ */
+export function detectLowConfidence(profiles, config) {
+    const patterns = [];
+    for (const [filePath, profile] of profiles) {
+        if (profile.lowConfidenceCount >= config.minOccurrences && profile.bestMappedOwner) {
+            patterns.push({
+                type: 'LOW_CONFIDENCE_RECURRING',
+                confidence: Math.min(1, profile.lowConfidenceCount / (config.minOccurrences * 2)),
+                filePath,
+                ownerId: profile.bestMappedOwner.ownerId,
+                evidence: [
+                    `low_confidence_count:${profile.lowConfidenceCount}`,
+                    `avg_confidence:${profile.bestMappedOwner.avgConfidence.toFixed(2)}`,
+                    `owner:${profile.bestMappedOwner.ownerId}`,
+                ],
+                occurrences: profile.lowConfidenceCount,
+                suggestedAction: 'ADD_KEYWORD',
+            });
+        }
+    }
+    return patterns;
+}
+// ============================================================================
+// Rule 3: BOUNDARY_VIOLATION
+// ============================================================================
+/**
+ * Detect repeated boundary violations (DENY_PATH_TOUCHED, BOUNDARY_CONFLICT).
+ */
+export function detectBoundaryViolations(profiles, evidence, config) {
+    const patterns = [];
+    // Count MAPPING_BLOCK signals per file
+    const mappingBlockSignals = evidence.signals.filter(s => s.type === 'MAPPING_BLOCK');
+    const signalCountByFile = new Map();
+    for (const sig of mappingBlockSignals) {
+        const file = sig.data?.file ?? '';
+        if (file) {
+            signalCountByFile.set(file, (signalCountByFile.get(file) ?? 0) + 1);
+        }
+    }
+    for (const [filePath, profile] of profiles) {
+        const denyCount = profile.violationCodes['DENY_PATH_TOUCHED'] ?? 0;
+        const boundaryCount = profile.violationCodes['BOUNDARY_CONFLICT'] ?? 0;
+        const signalCount = signalCountByFile.get(filePath) ?? 0;
+        const total = denyCount + boundaryCount + signalCount;
+        if (total >= config.minOccurrences) {
+            patterns.push({
+                type: 'BOUNDARY_VIOLATION',
+                confidence: Math.min(0.9, 0.7 + (total - config.minOccurrences) * 0.05),
+                filePath,
+                evidence: [
+                    ...(denyCount > 0 ? [`DENY_PATH_TOUCHED:${denyCount}`] : []),
+                    ...(boundaryCount > 0 ? [`BOUNDARY_CONFLICT:${boundaryCount}`] : []),
+                    ...(signalCount > 0 ? [`MAPPING_BLOCK_signals:${signalCount}`] : []),
+                ],
+                occurrences: total,
+                suggestedAction: denyCount > 0 ? 'REMOVE_BOUNDARY' : 'ADD_BOUNDARY_EXCEPTION',
+            });
+        }
+    }
+    return patterns;
+}
+// ============================================================================
+// Rule 4: DOMAIN_DRIFT
+// ============================================================================
+/**
+ * Detect files remediated outside their mapped domain.
+ */
+export function detectDomainDrift(profiles, evidence, spec, config) {
+    const patterns = [];
+    for (const [filePath, profile] of profiles) {
+        if (!profile.domainDriftDetected)
+            continue;
+        if (profile.remediationCount < config.minOccurrences)
+            continue;
+        const mappedDomain = profile.bestMappedOwner?.domainId;
+        patterns.push({
+            type: 'DOMAIN_DRIFT',
+            confidence: Math.min(0.95, 0.75 + profile.remediationCount * 0.05),
+            filePath,
+            ownerId: profile.bestMappedOwner?.ownerId,
+            evidence: [
+                `remediation_count:${profile.remediationCount}`,
+                `mapped_domain:${mappedDomain ?? 'none'}`,
+                'file_modified_outside_mapped_domain',
+            ],
+            occurrences: profile.remediationCount,
+            suggestedAction: mappedDomain ? 'ADD_PATH' : 'ADD_OWNER',
+        });
+    }
+    return patterns;
+}
+// ============================================================================
+// Rule 5: OWNER_AMBIGUOUS
+// ============================================================================
+/**
+ * Detect files with repeated OWNER_AMBIGUOUS violations.
+ */
+export function detectOwnerAmbiguity(profiles, config) {
+    const patterns = [];
+    for (const [filePath, profile] of profiles) {
+        const ambiguousCount = profile.violationCodes['OWNER_AMBIGUOUS'] ?? 0;
+        if (ambiguousCount >= config.minOccurrences) {
+            patterns.push({
+                type: 'OWNER_AMBIGUOUS',
+                confidence: Math.min(0.85, 0.65 + ambiguousCount * 0.05),
+                filePath,
+                evidence: [
+                    `OWNER_AMBIGUOUS:${ambiguousCount}`,
+                    ...(profile.bestMappedOwner ? [`current_best:${profile.bestMappedOwner.ownerId}`] : []),
+                ],
+                occurrences: ambiguousCount,
+                suggestedAction: 'ADD_KEYWORD',
+            });
+        }
+    }
+    return patterns;
+}
+// ============================================================================
+// Rule 6: STALE_PATH
+// ============================================================================
+/**
+ * Detect owner paths that don't match any file in the workspace.
+ * Requires filesystem access.
+ */
+export function detectStalePaths(spec, basePath) {
+    const patterns = [];
+    for (const owner of spec.owners) {
+        for (const ownerPath of owner.paths) {
+            // Convert glob to directory prefix
+            const prefix = ownerPath.replace('/**', '').replace('/*', '').replace('*', '');
+            const absPrefix = path.join(basePath, prefix);
+            // Check if the directory or any matching file exists
+            let exists = false;
+            try {
+                if (fs.existsSync(absPrefix)) {
+                    const stat = fs.statSync(absPrefix);
+                    if (stat.isDirectory()) {
+                        // Check if directory has any files
+                        const entries = fs.readdirSync(absPrefix);
+                        exists = entries.length > 0;
+                    }
+                    else {
+                        exists = true;
+                    }
+                }
+            }
+            catch {
+                exists = false;
+            }
+            if (!exists) {
+                patterns.push({
+                    type: 'STALE_PATH',
+                    confidence: 0.9,
+                    ownerId: owner.id,
+                    evidence: [`path:${ownerPath}`, `owner:${owner.id}`, 'no_matching_files_found'],
+                    occurrences: 1,
+                    suggestedAction: 'REMOVE_PATH',
+                });
+            }
+        }
+    }
+    return patterns;
+}
+// ============================================================================
+// Master Detection
+// ============================================================================
+/**
+ * Run all pattern detectors and return combined results.
+ */
+export function detectAllPatterns(profiles, evidence, spec, basePath, config) {
+    const all = [
+        ...detectUnmappedRecurring(profiles, config),
+        ...detectLowConfidence(profiles, config),
+        ...detectBoundaryViolations(profiles, evidence, config),
+        ...detectDomainDrift(profiles, evidence, spec, config),
+        ...detectOwnerAmbiguity(profiles, config),
+        ...(config.detectStalePaths ? detectStalePaths(spec, basePath) : []),
+    ];
+    return all;
+}

package/build/mcp/tools/vibe_pm/mapping/rebinder/proposal_builder.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Proposal Builder — Convert detected patterns into SpecMap change suggestions.
+ *
+ * All functions are pure (no I/O, no side effects).
+ *
+ * @since P40
+ */
+import type { DetectedPattern, FileEvidenceProfile, SpecMapSuggestion, SpecMapDiffEntry, RebindingProposal, EvidenceBundle, RebinderConfig, SpecMap } from './rebinder_types.js';
+/**
+ * Convert detected patterns into concrete SpecMap suggestions.
+ */
+export declare function buildSuggestions(patterns: DetectedPattern[], profiles: Map<string, FileEvidenceProfile>, spec: SpecMap, config: RebinderConfig): SpecMapSuggestion[];
+/**
+ * Generate a JSON-pointer-based diff preview of spec_map changes.
+ */
+export declare function buildDiffPreview(suggestions: SpecMapSuggestion[], spec: SpecMap): SpecMapDiffEntry[];
+/**
+ * Build the complete RebindingProposal.
+ */
+export declare function buildProposal(patterns: DetectedPattern[], suggestions: SpecMapSuggestion[], diff: SpecMapDiffEntry[], evidence: EvidenceBundle, specSha256: string): RebindingProposal;