@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/mcp/tools/vibe_pm/knowledge_search.js

@@ -0,0 +1,51 @@
+/**
+ * Knowledge Search MCP Tool — RAG-powered document retrieval.
+ *
+ * Gated by MUSU_RAG_ENABLED=1 environment variable.
+ * Delegates to RagRetriever which calls Prime /v1/rag/search.
+ */
+import { z } from 'zod';
+import { RagRetriever } from '../../../domains/rag/index.js';
+export const knowledgeSearchInputSchema = z.object({
+    query: z.string().min(1).describe('Search query (natural language)'),
+    max_results: z.number().int().min(1).max(50).optional().describe('Maximum results (default: 5)'),
+    strategy: z.enum(['hybrid', 'dense_only', 'sparse_only']).optional().describe('Search strategy (default: hybrid)'),
+});
+export const KNOWLEDGE_SEARCH_DESCRIPTION = 'Search the knowledge network for relevant documents, evidence, and artifacts.';
+export async function handleKnowledgeSearch(input) {
+    const retriever = new RagRetriever();
+    if (!retriever.isEnabled()) {
+        return {
+            available: false,
+            reason: 'rag_not_enabled',
+            hint: 'Set MUSU_RAG_ENABLED=1 and configure MUSU_PRIME_URL to enable knowledge search.',
+        };
+    }
+    const response = await retriever.search({
+        query: input.query,
+        max_results: input.max_results ?? 5,
+        strategy: input.strategy ?? 'hybrid',
+    });
+    if (!response.ok || !response.context) {
+        return {
+            available: true,
+            results: [],
+            error: response.error ?? 'no_results',
+        };
+    }
+    const results = response.context.blocks.map((block) => ({
+        doc_id: block.doc_facts.doc_id,
+        title: block.doc_facts.title,
+        snippet: block.snippet,
+        score: block.score,
+        source: block.doc_facts.source_ref,
+    }));
+    return {
+        available: true,
+        query: input.query,
+        strategy: response.context.strategy,
+        total: response.context.total_retrieved,
+        elapsed_ms: response.context.elapsed_ms,
+        results,
+    };
+}

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

@@ -5,4 +5,4 @@ export { scanImportHints, resolveImportPath } from "./import_scan.js";
 export { buildChangeMap } from "./change_map.js";
 export { buildSkeletonMapPatch, mergeSkeletonMapPatch } from "./skeleton_patch.js";
 export { judgeMappingGate, countViolations } from "./gate_judge.js";
-export { runMappingPipeline, runMappingPipelineAsync, runMappingPipelineSmart, hasSpecMap, hasChangeMap, loadChangeMap, type MappingPipelineResult, type MappingPipelineOptions, } from "./orchestrator.js";
+export { runMappingPipelineAsync, runMappingPipelineSmart, hasSpecMap, hasChangeMap, loadChangeMap, type MappingPipelineResult, type MappingPipelineOptions, } from "./orchestrator.js";

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

@@ -7,4 +7,4 @@ export { buildChangeMap } from "./change_map.js";
 export { buildSkeletonMapPatch, mergeSkeletonMapPatch } from "./skeleton_patch.js";
 export { judgeMappingGate, countViolations } from "./gate_judge.js";
 // Orchestrator
-export { runMappingPipeline, runMappingPipelineAsync, runMappingPipelineSmart, hasSpecMap, hasChangeMap, loadChangeMap, } from "./orchestrator.js";
+export { runMappingPipelineAsync, runMappingPipelineSmart, hasSpecMap, hasChangeMap, loadChangeMap, } from "./orchestrator.js";

package/build/mcp/tools/vibe_pm/mapping/orchestrator.d.ts

@@ -1,10 +1,29 @@
-import { GateDecision, ChangeMap, SkeletonMapPatch } from "./types.js";
+import { GateDecision, ChangeMap, SkeletonMapPatch } from './types.js';
+import type { DiagramViewerData } from '../ui/types.js';
+export type MappingDiagramArtifacts = {
+    manifestPath: string;
+    gateVerdictPath: string;
+    pumlPath: string;
+    svgPath: string | null;
+    annotationsPath: string | null;
+    verdict: 'GO' | 'WARN' | 'BLOCK';
+    reasons: string[];
+    unifiedVerdictSummary?: string;
+    bitnetAnnotations?: DiagramViewerData['bitnet_annotations'];
+};
+export type MappingUIArtifacts = {
+    manifestPath: string;
+    resourceId: string;
+    htmlPath: string;
+};
 export type MappingPipelineResult = {
     decision: GateDecision;
     changeMap: ChangeMap;
     skeletonPatch: SkeletonMapPatch;
     changeMapPath: string;
     skeletonPatchPath: string;
+    diagram?: MappingDiagramArtifacts;
+    ui?: MappingUIArtifacts;
 };
 export type MappingPipelineOptions = {
     workspaceRoot: string;
@@ -13,12 +32,6 @@ export type MappingPipelineOptions = {
     headRef?: string;
     useStaged?: boolean;
 };
-/**
- * 매핑 파이프라인 실행 (동기 버전)
- * @deprecated Use runMappingPipelineAsync or runMappingPipelineSmart instead.
- * Sync operations block the event loop.
- */
-export declare function runMappingPipeline(options: MappingPipelineOptions): MappingPipelineResult;
 /**
  * spec_map 존재 여부 확인
  */

package/build/mcp/tools/vibe_pm/mapping/orchestrator.js

@@ -1,21 +1,74 @@
 // release/mvp_core_clinic/src/mcp/tools/vibe_pm/mapping/orchestrator.ts
-import fs from "fs";
-import fsPromises from "fs/promises";
-import path from "path";
-import { loadSpecMap } from "./spec_map.js";
-import { scanChangedFiles, scanStagedFiles, scanChangedFilesAsync, scanStagedFilesAsync, scanChangedFilesSmart, scanStagedFilesSmart, } from "./diff_scan.js";
-import { scanImportHints } from "./import_scan.js";
-import { buildChangeMap } from "./change_map.js";
-import { buildSkeletonMapPatch } from "./skeleton_patch.js";
-import { judgeMappingGate } from "./gate_judge.js";
-import { getPmRunDir, resolvePmRunDirForRead, resolveSpecMapPath } from "../../../paths.js";
-import { emitEvent } from "../../../events/emitter.js";
+import fs from 'fs';
+import fsPromises from 'fs/promises';
+import path from 'path';
+import { loadSpecMap } from './spec_map.js';
+import { scanChangedFilesAsync, scanStagedFilesAsync, scanChangedFilesSmart, scanStagedFilesSmart, } from './diff_scan.js';
+import { scanImportHints } from './import_scan.js';
+import { buildChangeMap } from './change_map.js';
+import { buildSkeletonMapPatch } from './skeleton_patch.js';
+import { judgeMappingGate } from './gate_judge.js';
+import { getPmRunDir, resolvePmRunDirForRead, resolveSpecMapPath, } from '../../../../kernel/paths.js';
+import { emitEvent } from '../../../events/emitter.js';
+import { generateChangeImpactPuml } from '../diagrams/generator.js';
+import { writeDiagramArtifacts } from '../diagrams/manifest.js';
+import { buildBitNetAnnotations } from '../diagrams/annotations.js';
+import { computeUnifiedVerdict } from '../diagrams/unified_verdict.js';
+import { generateDiagramViewer } from '../ui/viewer_bundle.js';
+import { getUIManifestPath } from '../ui/manifest.js';
 /**
  * 상대 경로 계산
  */
 function rel(root, abs) {
     const r = path.relative(root, abs);
-    return r.startsWith("..") ? abs : r;
+    return r.startsWith('..') ? abs : r;
+}
+function shouldRenderDiagramSvg() {
+    const value = (process.env.VIBE_DIAGRAM_RENDER_SVG ?? process.env.VIBE_DIAGRAM_RENDER ?? '')
+        .trim()
+        .toLowerCase();
+    return value === '1' || value === 'true' || value === 'yes' || value === 'on';
+}
+function shouldInjectDiagramNotes() {
+    const value = (process.env.VIBE_DIAGRAM_NOTES ?? '').trim().toLowerCase();
+    return value === '1' || value === 'true' || value === 'yes' || value === 'on';
+}
+function toViewerVerdict(verdict) {
+    if (verdict === 'WARN')
+        return 'FIX';
+    return verdict;
+}
+function toViewerData(runId, changeMap, diagramVerdict) {
+    const mappedFileByNodeId = new Map();
+    for (const mapped of changeMap.mapped) {
+        const nodeId = `${mapped.domain_id}.${mapped.layer}.${mapped.owner_id}`.replace(/[^a-zA-Z0-9_.]/g, '_');
+        if (!mappedFileByNodeId.has(nodeId)) {
+            mappedFileByNodeId.set(nodeId, mapped.file);
+        }
+    }
+    return {
+        run_id: runId,
+        svg_path: 'diagrams/change_impact.svg',
+        gate_verdict: {
+            verdict: toViewerVerdict(diagramVerdict.verdict),
+            reasons: diagramVerdict.reasons.map((reason, index) => ({
+                code: `DG_REASON_${index + 1}`,
+                message: reason,
+                level: toViewerVerdict(diagramVerdict.verdict),
+            })),
+        },
+        nodes: Array.from(mappedFileByNodeId.entries()).map(([node_id, file_path]) => ({
+            node_id,
+            label: node_id.split('.').slice(-1)[0] ?? node_id,
+            file_path,
+            tooltip: {
+                where: file_path,
+                why: 'Mapping-derived impact node',
+                next: 'Review linked diff and gate reasons',
+            },
+        })),
+        bitnet_annotations: diagramVerdict.bitnetAnnotations,
+    };
 }
 /**
  * Core pipeline logic: import hints → change map → skeleton patch → gate
@@ -24,22 +77,22 @@ function rel(root, abs) {
 function executePipelineCoreSync(args) {
     const { workspaceRoot, run_id, base, head, useStaged, changed, spec, specAbs } = args;
     // Import hints
-    const importHints = scanImportHints(workspaceRoot, changed.map((c) => c.file));
+    const importHints = scanImportHints(workspaceRoot, changed.map(c => c.file));
     // Change map
     const changeMap = buildChangeMap({
         run_id,
-        base: useStaged ? "staged" : base,
-        head: useStaged ? "working" : head,
+        base: useStaged ? 'staged' : base,
+        head: useStaged ? 'working' : head,
         spec,
         changed,
         imports: importHints,
     });
     // Output directory
-    const outDir = path.join(getPmRunDir(workspaceRoot, run_id), "mapping");
+    const outDir = path.join(getPmRunDir(workspaceRoot, run_id), 'mapping');
     fs.mkdirSync(outDir, { recursive: true });
     // Save change_map
-    const changeMapPath = path.join(outDir, "change_map.v1.json");
-    fs.writeFileSync(changeMapPath, JSON.stringify(changeMap, null, 2), "utf-8");
+    const changeMapPath = path.join(outDir, 'change_map.v1.json');
+    fs.writeFileSync(changeMapPath, JSON.stringify(changeMap, null, 2), 'utf-8');
     // Skeleton patch
     const skeletonPatch = buildSkeletonMapPatch({
         workspaceRoot,
@@ -48,14 +101,14 @@ function executePipelineCoreSync(args) {
         changeMapAbsPath: changeMapPath,
         changeMap,
     });
-    const skeletonPatchPath = path.join(outDir, "skeleton_map_patch.v1.json");
-    fs.writeFileSync(skeletonPatchPath, JSON.stringify(skeletonPatch, null, 2), "utf-8");
+    const skeletonPatchPath = path.join(outDir, 'skeleton_map_patch.v1.json');
+    fs.writeFileSync(skeletonPatchPath, JSON.stringify(skeletonPatch, null, 2), 'utf-8');
     emitEvent({
         runId: run_id,
-        type: "artifact.mapping_written",
-        reason: "mapping_sync",
+        type: 'artifact.mapping_written',
+        reason: 'mapping_sync',
         paths: [changeMapPath, skeletonPatchPath],
-        component: "mapping_orchestrator",
+        component: 'mapping_orchestrator',
         workspaceRoot: workspaceRoot,
     });
     // Gate decision
@@ -74,22 +127,22 @@ function executePipelineCoreSync(args) {
 async function executePipelineCoreAsync(args) {
     const { workspaceRoot, run_id, base, head, useStaged, changed, spec, specAbs } = args;
     // Import hints
-    const importHints = scanImportHints(workspaceRoot, changed.map((c) => c.file));
+    const importHints = scanImportHints(workspaceRoot, changed.map(c => c.file));
     // Change map
     const changeMap = buildChangeMap({
         run_id,
-        base: useStaged ? "staged" : base,
-        head: useStaged ? "working" : head,
+        base: useStaged ? 'staged' : base,
+        head: useStaged ? 'working' : head,
         spec,
         changed,
         imports: importHints,
     });
     // Output directory
-    const outDir = path.join(getPmRunDir(workspaceRoot, run_id), "mapping");
+    const outDir = path.join(getPmRunDir(workspaceRoot, run_id), 'mapping');
     await fsPromises.mkdir(outDir, { recursive: true });
     // Save change_map
-    const changeMapPath = path.join(outDir, "change_map.v1.json");
-    await fsPromises.writeFile(changeMapPath, JSON.stringify(changeMap, null, 2), "utf-8");
+    const changeMapPath = path.join(outDir, 'change_map.v1.json');
+    await fsPromises.writeFile(changeMapPath, JSON.stringify(changeMap, null, 2), 'utf-8');
     // Skeleton patch
     const skeletonPatch = buildSkeletonMapPatch({
         workspaceRoot,
@@ -98,14 +151,14 @@ async function executePipelineCoreAsync(args) {
         changeMapAbsPath: changeMapPath,
         changeMap,
     });
-    const skeletonPatchPath = path.join(outDir, "skeleton_map_patch.v1.json");
-    await fsPromises.writeFile(skeletonPatchPath, JSON.stringify(skeletonPatch, null, 2), "utf-8");
+    const skeletonPatchPath = path.join(outDir, 'skeleton_map_patch.v1.json');
+    await fsPromises.writeFile(skeletonPatchPath, JSON.stringify(skeletonPatch, null, 2), 'utf-8');
     emitEvent({
         runId: run_id,
-        type: "artifact.mapping_written",
-        reason: "mapping_async",
+        type: 'artifact.mapping_written',
+        reason: 'mapping_async',
         paths: [changeMapPath, skeletonPatchPath],
-        component: "mapping_orchestrator",
+        component: 'mapping_orchestrator',
         workspaceRoot: workspaceRoot,
     });
     // Gate decision
@@ -115,24 +168,104 @@ async function executePipelineCoreAsync(args) {
         changeMap,
         changeMapPath: rel(workspaceRoot, changeMapPath),
     });
-    return { decision, changeMap, skeletonPatch, changeMapPath, skeletonPatchPath };
-}
-/**
- * 매핑 파이프라인 실행 (동기 버전)
- * @deprecated Use runMappingPipelineAsync or runMappingPipelineSmart instead.
- * Sync operations block the event loop.
- */
-export function runMappingPipeline(options) {
-    const { workspaceRoot, run_id, baseRef, headRef, useStaged = false } = options;
-    const { spec, absPath: specAbs } = loadSpecMap(workspaceRoot);
-    const base = baseRef ?? "HEAD~1";
-    const head = headRef ?? "HEAD";
-    const changed = useStaged
-        ? scanStagedFiles(workspaceRoot)
-        : scanChangedFiles(base, head, workspaceRoot);
-    return executePipelineCoreSync({
-        workspaceRoot, run_id, base, head, useStaged, changed, spec, specAbs,
-    });
+    let diagramArtifacts;
+    let uiArtifacts;
+    const runDir = getPmRunDir(workspaceRoot, run_id);
+    try {
+        const { puml, model } = generateChangeImpactPuml(changeMap, {
+            includeSummaryNote: shouldInjectDiagramNotes(),
+        });
+        const bitnetAnnotations = buildBitNetAnnotations({ changeMap, model });
+        const totalFiles = changeMap.summary.mapped_files + changeMap.summary.unmapped_files;
+        const rendered = await writeDiagramArtifacts({
+            runDir,
+            runId: run_id,
+            changeMapPath,
+            changeMapContent: JSON.stringify(changeMap),
+            puml,
+            model,
+            totalFiles,
+            bitnetAnnotations,
+            renderSvg: shouldRenderDiagramSvg(),
+        });
+        const unifiedVerdict = computeUnifiedVerdict({
+            diagramVerdict: rendered.gateVerdict.verdict,
+            bitnetRiskScore: bitnetAnnotations.summary?.risk_score,
+            bitnetRiskCounts: bitnetAnnotations.summary?.risk_counts,
+        });
+        diagramArtifacts = {
+            manifestPath: rendered.paths.manifest,
+            gateVerdictPath: rendered.paths.gateVerdict,
+            pumlPath: rendered.paths.puml,
+            svgPath: rendered.paths.svg,
+            annotationsPath: rendered.paths.annotations,
+            verdict: rendered.gateVerdict.verdict,
+            reasons: rendered.gateVerdict.reasons,
+            unifiedVerdictSummary: unifiedVerdict.summary,
+            bitnetAnnotations,
+        };
+        decision.evidence = {
+            ...decision.evidence,
+            diagram_manifest_path: rel(workspaceRoot, rendered.paths.manifest),
+            diagram_gate_verdict_path: rel(workspaceRoot, rendered.paths.gateVerdict),
+            diagram_change_impact_path: rel(workspaceRoot, rendered.paths.puml),
+            diagram_annotations_path: rendered.paths.annotations
+                ? rel(workspaceRoot, rendered.paths.annotations)
+                : null,
+            diagram_verdict: rendered.gateVerdict.verdict,
+            diagram_unified_verdict: unifiedVerdict.verdict ?? null,
+            diagram_unified_verdict_summary: unifiedVerdict.summary ?? null,
+        };
+        emitEvent({
+            runId: run_id,
+            type: 'artifact.diagram_written',
+            reason: 'diagram_as_code',
+            paths: [
+                rendered.paths.puml,
+                rendered.paths.manifest,
+                rendered.paths.gateVerdict,
+                ...(rendered.paths.annotations ? [rendered.paths.annotations] : []),
+            ],
+            component: 'mapping_orchestrator',
+            workspaceRoot,
+            note: `diagram_verdict=${rendered.gateVerdict.verdict}`,
+            metadata: {
+                diagram_verdict: rendered.gateVerdict.verdict,
+                diagram_unified_verdict: unifiedVerdict.verdict ?? null,
+                diagram_unified_verdict_summary: unifiedVerdict.summary ?? null,
+                reason_count: rendered.gateVerdict.reasons.length,
+                bitnet_annotations_count: bitnetAnnotations.annotations?.length ?? 0,
+            },
+        });
+        const viewerData = toViewerData(run_id, changeMap, diagramArtifacts);
+        const viewer = await generateDiagramViewer(runDir, viewerData);
+        uiArtifacts = {
+            manifestPath: getUIManifestPath(runDir),
+            resourceId: viewer.resource.id,
+            htmlPath: viewer.htmlPath,
+        };
+        emitEvent({
+            runId: run_id,
+            type: 'artifact.ui_manifest_written',
+            reason: 'diagram_viewer_generated',
+            paths: [uiArtifacts.manifestPath, uiArtifacts.htmlPath],
+            component: 'mapping_orchestrator',
+            workspaceRoot,
+            metadata: { resource_id: uiArtifacts.resourceId },
+        });
+    }
+    catch {
+        // Fail-open: mapping pipeline remains the source of truth.
+    }
+    return {
+        decision,
+        changeMap,
+        skeletonPatch,
+        changeMapPath,
+        skeletonPatchPath,
+        diagram: diagramArtifacts,
+        ui: uiArtifacts,
+    };
 }
 /**
  * spec_map 존재 여부 확인
@@ -146,7 +279,7 @@ export function hasSpecMap(workspaceRoot) {
  */
 export function hasChangeMap(workspaceRoot, run_id) {
     const runDir = resolvePmRunDirForRead(workspaceRoot, run_id);
-    const changeMapPath = path.join(runDir, "mapping", "change_map.v1.json");
+    const changeMapPath = path.join(runDir, 'mapping', 'change_map.v1.json');
     return fs.existsSync(changeMapPath);
 }
 /**
@@ -154,11 +287,11 @@ export function hasChangeMap(workspaceRoot, run_id) {
  */
 export function loadChangeMap(workspaceRoot, run_id) {
     const runDir = resolvePmRunDirForRead(workspaceRoot, run_id);
-    const changeMapPath = path.join(runDir, "mapping", "change_map.v1.json");
+    const changeMapPath = path.join(runDir, 'mapping', 'change_map.v1.json');
     if (!fs.existsSync(changeMapPath))
         return null;
     try {
-        const raw = fs.readFileSync(changeMapPath, "utf-8");
+        const raw = fs.readFileSync(changeMapPath, 'utf-8');
         return JSON.parse(raw);
     }
     catch {
@@ -174,13 +307,20 @@ export function loadChangeMap(workspaceRoot, run_id) {
 export async function runMappingPipelineAsync(options) {
     const { workspaceRoot, run_id, baseRef, headRef, useStaged = false } = options;
     const { spec, absPath: specAbs } = loadSpecMap(workspaceRoot);
-    const base = baseRef ?? "HEAD~1";
-    const head = headRef ?? "HEAD";
+    const base = baseRef ?? 'HEAD~1';
+    const head = headRef ?? 'HEAD';
     const changed = useStaged
         ? await scanStagedFilesAsync(workspaceRoot)
         : await scanChangedFilesAsync(base, head, workspaceRoot);
     return executePipelineCoreAsync({
-        workspaceRoot, run_id, base, head, useStaged, changed, spec, specAbs,
+        workspaceRoot,
+        run_id,
+        base,
+        head,
+        useStaged,
+        changed,
+        spec,
+        specAbs,
     });
 }
 /**
@@ -189,12 +329,19 @@ export async function runMappingPipelineAsync(options) {
 export async function runMappingPipelineSmart(options) {
     const { workspaceRoot, run_id, baseRef, headRef, useStaged = false } = options;
     const { spec, absPath: specAbs } = loadSpecMap(workspaceRoot);
-    const base = baseRef ?? "HEAD~1";
-    const head = headRef ?? "HEAD";
+    const base = baseRef ?? 'HEAD~1';
+    const head = headRef ?? 'HEAD';
     const changed = useStaged
         ? await scanStagedFilesSmart(workspaceRoot, run_id)
         : await scanChangedFilesSmart(base, head, workspaceRoot, run_id);
     return executePipelineCoreAsync({
-        workspaceRoot, run_id, base, head, useStaged, changed, spec, specAbs,
+        workspaceRoot,
+        run_id,
+        base,
+        head,
+        useStaged,
+        changed,
+        spec,
+        specAbs,
     });
 }

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

@@ -0,0 +1,35 @@
+/**
+ * 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 type { EvidenceBundle, FileEvidenceProfile, RebinderConfig, RemediationRecord, SignalEvent, ScorecardEntry, ChangeMap, SpecMap } from './rebinder_types.js';
+/**
+ * Load remediation records from JSONL log.
+ * Thin wrapper around Ant's loadRemediationLog.
+ */
+export declare function collectRemediations(basePath: string): Promise<RemediationRecord[]>;
+/**
+ * Load all signals from the observer signal log.
+ */
+export declare function collectSignals(basePath: string): Promise<SignalEvent[]>;
+/**
+ * Scan .vibe/runs/ and load scorecards + change maps from recent runs.
+ */
+export declare function collectRunEvidence(basePath: string, maxRuns: number): Promise<{
+    scorecards: ScorecardEntry[];
+    changeMaps: ChangeMap[];
+    runIds: string[];
+}>;
+/**
+ * Master aggregator: loads all evidence sources.
+ */
+export declare function collectAllEvidence(basePath: string, config: RebinderConfig): Promise<EvidenceBundle>;
+/**
+ * Build per-file evidence profiles from aggregated evidence.
+ * Pure function (no I/O).
+ */
+export declare function buildFileProfiles(evidence: EvidenceBundle, spec: SpecMap): Map<string, FileEvidenceProfile>;