@vibecodetown/mcp-server 1.3.1

package/build/mcp/tools/vibe_pm/ingress.d.ts

@@ -0,0 +1,29 @@
+import { IngressInputSchema, type IngressInput } from "../../generated/ingress_input.js";
+import { type IngressOutputSSOT } from "../../generated/ingress_output.js";
+export type IngressResolution = "INGRESS_RESOLVED_RESUME" | "INGRESS_RESOLVED_NEW_TASK" | "INGRESS_RESOLVED_ADOPT" | "INGRESS_ABORTED";
+export interface IngressArtifact {
+    path: string;
+    exists: boolean;
+}
+/**
+ * vibe_pm.ingress - Ingress artifact generation
+ *
+ * Generates and manages ingress artifacts for a run:
+ * - ingress_summary.json
+ * - ingress_resolution.json
+ * - project_fingerprint
+ * - repo_map (if available)
+ */
+export declare function ingress(input: IngressInput): Promise<IngressOutputSSOT>;
+/**
+ * Get current ingress state for a run
+ */
+export declare function getIngressState(runId: string, basePath: string): "ready" | "stale" | "missing" | "failed";
+/**
+ * Check if ingress artifacts exist
+ */
+export declare function checkIngressArtifacts(runId: string, basePath: string): {
+    exists: boolean;
+    artifacts: Record<string, IngressArtifact>;
+};
+export { IngressInputSchema };

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

@@ -0,0 +1,435 @@
+// MVP Core - vibe_pm.ingress
+// Ingress artifact generation and management
+//
+// 설계 원칙:
+// - best_effort 모드에서는 일부 실패해도 OK 반환
+// - strict 모드에서는 필수 산출물 실패 시 ERROR
+// - dirty 감지를 통해 재실행 필요성 판단
+import * as fsPromises from "node:fs/promises";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as crypto from "node:crypto";
+import { fileURLToPath } from "node:url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+import { resolveRunId, readRunState } from "./context.js";
+import { IngressInputSchema } from "../../generated/ingress_input.js";
+import { runMappingPipelineSmart, hasSpecMap } from "./mapping/index.js";
+import { ensureDirSync, getPmRunDir, getPmRunsDir, resolvePmRunDirForRead } from "../../paths.js";
+import { prunePmRunsBestEffort } from "../../run-retention.js";
+import { runPreprocess } from "../../preprocess.js";
+// ============================================================
+// Main Handler
+// ============================================================
+/**
+ * vibe_pm.ingress - Ingress artifact generation
+ *
+ * Generates and manages ingress artifacts for a run:
+ * - ingress_summary.json
+ * - ingress_resolution.json
+ * - project_fingerprint
+ * - repo_map (if available)
+ */
+export async function ingress(input) {
+    const basePath = input.workspace_path ?? process.cwd();
+    const startTime = Date.now();
+    // Ensure PM runs directory (repo-local `.vibe/runs/`)
+    ensureDirSync(getPmRunsDir(basePath));
+    // Resolve run_id
+    const { run_id, is_new } = resolveRunId(input.run_id ?? input.project_id, basePath);
+    // Best-effort preprocess (airlock/router/chunking)
+    try {
+        const rawText = JSON.stringify({
+            workspace_path: basePath,
+            project_id: input.project_id ?? null,
+            run_id,
+            auto_resolve: input.auto_resolve ?? false,
+            resolution: input.resolution ?? null,
+            context_scan: input.context_scan ?? false,
+        });
+        await runPreprocess({
+            workspaceRoot: basePath,
+            runId: run_id,
+            rawText,
+            filePath: "ingress.json",
+            taskType: "ingress",
+        });
+    }
+    catch {
+        // ignore (best-effort)
+    }
+    // Best-effort pruning (disabled by default; opt-in via env)
+    prunePmRunsBestEffort({ workspaceRoot: basePath, protectRunId: run_id });
+    // PM run dir (do not write into engine run roots)
+    const pmRunDir = getPmRunDir(basePath, run_id);
+    const ingressDir = path.join(pmRunDir, "ingress");
+    // Create ingress directory
+    await fsPromises.mkdir(ingressDir, { recursive: true });
+    // Check existing state
+    const hasVibeState = fs.existsSync(path.join(basePath, ".vibe"));
+    const runState = is_new ? null : readRunState(run_id, basePath);
+    // Determine resolution
+    let resolution;
+    let autoResolveReason;
+    if (input.resolution) {
+        resolution = input.resolution;
+    }
+    else if (input.auto_resolve) {
+        // Auto-resolve based on state
+        if (runState && runState.phase && runState.phase !== "completed") {
+            resolution = "INGRESS_RESOLVED_RESUME";
+            autoResolveReason = `기존 run 상태 발견 (phase: ${runState.phase})`;
+        }
+        else if (is_new) {
+            resolution = "INGRESS_RESOLVED_NEW_TASK";
+            autoResolveReason = "새 프로젝트 시작";
+        }
+        else {
+            resolution = "INGRESS_RESOLVED_ADOPT";
+            autoResolveReason = "기존 컨텍스트 채택";
+        }
+    }
+    else {
+        // Default resolution
+        resolution = is_new ? "INGRESS_RESOLVED_NEW_TASK" : "INGRESS_RESOLVED_RESUME";
+    }
+    // Generate artifacts
+    const artifacts = {};
+    const warnings = [];
+    // 1. Generate project fingerprint
+    try {
+        const fingerprint = await generateProjectFingerprint(basePath);
+        const fingerprintPath = path.join(ingressDir, "project_fingerprint.json");
+        if (input.write_files) {
+            await fsPromises.writeFile(fingerprintPath, JSON.stringify(fingerprint, null, 2) + "\n", "utf-8");
+        }
+        artifacts.project_fingerprint = fingerprintPath;
+    }
+    catch (e) {
+        warnings.push(`project_fingerprint 생성 실패: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    // 2. Generate ingress summary
+    const summaryPath = path.join(ingressDir, "ingress_summary.json");
+    try {
+        const summary = {
+            format_version: "ingress.summary.v1",
+            run_id,
+            project_id: input.project_id ?? run_id,
+            created_at: new Date().toISOString(),
+            producer: {
+                name: "@vibecodetown/mcp-server",
+                version: getPackageVersion(),
+            },
+            pointers: {
+                project_fingerprint: artifacts.project_fingerprint ?? "",
+                repo_map: "",
+                entrypoints: "",
+                docs_index: "",
+                risk_flags: "",
+            },
+            high_level: {
+                entrypoint_status: "AMBIGUOUS",
+                clarification_recommended: true,
+                clarification_reasons: ["초기 분석 필요"],
+                docs_index_count: 0,
+            },
+            consumption_policy: {
+                front_reads: ["ingress_summary.json"],
+                bridge_reads: ["ingress_resolution.json"],
+                back_reads: ["project_fingerprint.json"],
+            },
+        };
+        if (input.write_files) {
+            await fsPromises.writeFile(summaryPath, JSON.stringify(summary, null, 2) + "\n", "utf-8");
+        }
+        artifacts.ingress_summary = summaryPath;
+    }
+    catch (e) {
+        warnings.push(`ingress_summary 생성 실패: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    // 3. Generate ingress resolution
+    const resolutionPath = path.join(ingressDir, "ingress_resolution.json");
+    try {
+        const resolutionDoc = {
+            schema_version: "ingress.resolution.v2",
+            run_id,
+            project_id: input.project_id ?? run_id,
+            workspace_path: path.resolve(basePath),
+            resolution,
+            has_vibe_state: hasVibeState,
+            context_scan_required: input.context_scan,
+            context_scan_completed: false, // Will be updated after scan
+            created_at: new Date().toISOString(),
+        };
+        if (input.write_files) {
+            await fsPromises.writeFile(resolutionPath, JSON.stringify(resolutionDoc, null, 2) + "\n", "utf-8");
+        }
+    }
+    catch (e) {
+        warnings.push(`ingress_resolution 생성 실패: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    // Context scan (if enabled)
+    let contextScanCompleted = false;
+    if (input.context_scan) {
+        try {
+            // Simple context scan: count files, check package.json, etc.
+            const scanResult = await runContextScan(basePath);
+            contextScanCompleted = true;
+            // Update resolution with scan results
+            if (input.write_files) {
+                const resolutionDoc = JSON.parse(await fsPromises.readFile(resolutionPath, "utf-8"));
+                resolutionDoc.context_scan_completed = true;
+                resolutionDoc.scan_result = scanResult;
+                await fsPromises.writeFile(resolutionPath, JSON.stringify(resolutionDoc, null, 2) + "\n", "utf-8");
+            }
+        }
+        catch (e) {
+            warnings.push(`context_scan 실패: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    // 4. Mapping Guard: Generate change_map (if spec_map exists)
+    let mappingResult = null;
+    let mappingInfo = undefined;
+    try {
+        if (hasSpecMap(basePath)) {
+            mappingResult = await runMappingPipelineSmart({
+                workspaceRoot: basePath,
+                run_id,
+                useStaged: true, // Use staged files for ingress
+            });
+            // Add change_map to artifacts
+            artifacts.change_map = mappingResult.changeMapPath;
+            // Build mapping info for output
+            mappingInfo = {
+                change_map_path: mappingResult.changeMapPath,
+                mapped_count: mappingResult.changeMap.summary.mapped_files,
+                unmapped_count: mappingResult.changeMap.summary.unmapped_files,
+                domains_touched: mappingResult.changeMap.summary.domains_touched,
+                verdict: mappingResult.decision.verdict,
+            };
+        }
+    }
+    catch (e) {
+        warnings.push(`mapping_pipeline 실패: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    // Determine success
+    const success = artifacts.ingress_summary !== undefined || !input.force;
+    // Check for strict mode failure
+    if (input.force && !artifacts.ingress_summary) {
+        return {
+            success: false,
+            project_id: input.project_id ?? run_id,
+            run_id,
+            workspace_path: path.resolve(basePath),
+            has_vibe_state: hasVibeState,
+            resolution,
+            auto_resolve_reason: autoResolveReason,
+            context_scan_required: input.context_scan,
+            context_scan_completed: contextScanCompleted,
+            ingress_resolution_path: resolutionPath,
+            artifacts: artifacts.ingress_summary ? artifacts : undefined,
+            mapping: mappingInfo,
+            warnings: warnings.length > 0 ? warnings : undefined,
+            message: "필수 산출물(ingress_summary) 생성 실패",
+            next_action: {
+                tool: "vibe_pm.ingress",
+                reason: "ingress 재실행 필요",
+            },
+        };
+    }
+    // Determine next action
+    let nextAction = null;
+    if (success) {
+        if (resolution === "INGRESS_RESOLVED_NEW_TASK") {
+            nextAction = {
+                tool: "vibe_pm.briefing",
+                reason: "새 프로젝트 시작을 위해 briefing 필요",
+            };
+        }
+        else if (resolution === "INGRESS_RESOLVED_RESUME") {
+            nextAction = {
+                tool: "vibe_pm.get_decision",
+                reason: "기존 프로젝트 재개를 위해 결재 확인 필요",
+            };
+        }
+    }
+    return {
+        success,
+        project_id: input.project_id ?? run_id,
+        run_id,
+        workspace_path: path.resolve(basePath),
+        has_vibe_state: hasVibeState,
+        resolution,
+        auto_resolve_reason: autoResolveReason,
+        context_scan_required: input.context_scan,
+        context_scan_completed: contextScanCompleted,
+        ingress_resolution_path: resolutionPath,
+        artifacts: Object.keys(artifacts).length > 0 ? artifacts : undefined,
+        mapping: mappingInfo,
+        warnings: warnings.length > 0 ? warnings : undefined,
+        message: success
+            ? `Ingress 완료 (${Date.now() - startTime}ms)`
+            : "Ingress 실패",
+        next_action: nextAction,
+    };
+}
+// ============================================================
+// Helper Functions
+// ============================================================
+/**
+ * Generate project fingerprint
+ */
+async function generateProjectFingerprint(basePath) {
+    const fingerprint = {
+        generated_at: new Date().toISOString(),
+        workspace_path: path.resolve(basePath),
+    };
+    // Check for package.json
+    const packageJsonPath = path.join(basePath, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+        try {
+            const pkg = JSON.parse(await fsPromises.readFile(packageJsonPath, "utf-8"));
+            fingerprint.package_name = pkg.name;
+            fingerprint.package_version = pkg.version;
+            fingerprint.has_package_json = true;
+        }
+        catch {
+            fingerprint.has_package_json = false;
+        }
+    }
+    // Check for common project files
+    const markers = ["tsconfig.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml"];
+    const detectedMarkers = [];
+    for (const marker of markers) {
+        if (fs.existsSync(path.join(basePath, marker))) {
+            detectedMarkers.push(marker);
+        }
+    }
+    fingerprint.project_markers = detectedMarkers;
+    // Count files (limited scan)
+    try {
+        const entries = await fsPromises.readdir(basePath, { withFileTypes: true });
+        fingerprint.root_file_count = entries.filter(e => e.isFile()).length;
+        fingerprint.root_dir_count = entries.filter(e => e.isDirectory()).length;
+    }
+    catch {
+        fingerprint.root_file_count = 0;
+        fingerprint.root_dir_count = 0;
+    }
+    // Generate hash
+    const hash = crypto.createHash("sha256");
+    hash.update(JSON.stringify(fingerprint));
+    fingerprint.fingerprint_hash = hash.digest("hex").slice(0, 16);
+    return fingerprint;
+}
+/**
+ * Run simple context scan
+ */
+async function runContextScan(basePath) {
+    const result = {
+        scanned_at: new Date().toISOString(),
+    };
+    // Check .vibe folder
+    const vibeDir = path.join(basePath, ".vibe");
+    result.has_vibe_dir = fs.existsSync(vibeDir);
+    // Check src folder
+    const srcDir = path.join(basePath, "src");
+    if (fs.existsSync(srcDir)) {
+        try {
+            const entries = await fsPromises.readdir(srcDir, { recursive: true });
+            result.src_file_count = entries.length;
+        }
+        catch {
+            result.src_file_count = 0;
+        }
+    }
+    // Check lockfiles
+    const lockfiles = ["package-lock.json", "yarn.lock", "pnpm-lock.yaml", "bun.lockb"];
+    const foundLockfiles = [];
+    for (const lockfile of lockfiles) {
+        if (fs.existsSync(path.join(basePath, lockfile))) {
+            foundLockfiles.push(lockfile);
+        }
+    }
+    result.lockfiles = foundLockfiles;
+    return result;
+}
+/**
+ * Get package version from MCP server's package.json (not user's project)
+ */
+function getPackageVersion() {
+    try {
+        // __dirname 기준으로 MCP 서버 루트의 package.json 찾기
+        // ingress.ts 위치: src/mcp/tools/vibe_pm/ingress.ts
+        // package.json 위치: package.json (루트)
+        // 상대 경로: ../../../../package.json
+        const pkgPath = path.resolve(__dirname, "../../../../package.json");
+        if (fs.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+            return pkg.version ?? "0.0.0";
+        }
+    }
+    catch {
+        // ignore
+    }
+    return "0.0.0";
+}
+// ============================================================
+// State Helpers
+// ============================================================
+/**
+ * Get current ingress state for a run
+ */
+export function getIngressState(runId, basePath) {
+    try {
+        const runDir = resolvePmRunDirForRead(basePath, runId);
+        const summaryPath = path.join(runDir, "ingress", "ingress_summary.json");
+        if (!fs.existsSync(summaryPath)) {
+            return "missing";
+        }
+        // Check if summary is recent (within 1 hour)
+        const stats = fs.statSync(summaryPath);
+        const ageMs = Date.now() - stats.mtimeMs;
+        const oneHourMs = 60 * 60 * 1000;
+        if (ageMs > oneHourMs) {
+            return "stale";
+        }
+        return "ready";
+    }
+    catch {
+        return "missing";
+    }
+}
+/**
+ * Check if ingress artifacts exist
+ */
+export function checkIngressArtifacts(runId, basePath) {
+    try {
+        const runDir = resolvePmRunDirForRead(basePath, runId);
+        const ingressDir = path.join(runDir, "ingress");
+        const artifacts = {
+            ingress_summary: {
+                path: path.join(ingressDir, "ingress_summary.json"),
+                exists: fs.existsSync(path.join(ingressDir, "ingress_summary.json")),
+            },
+            ingress_resolution: {
+                path: path.join(ingressDir, "ingress_resolution.json"),
+                exists: fs.existsSync(path.join(ingressDir, "ingress_resolution.json")),
+            },
+            project_fingerprint: {
+                path: path.join(ingressDir, "project_fingerprint.json"),
+                exists: fs.existsSync(path.join(ingressDir, "project_fingerprint.json")),
+            },
+        };
+        const exists = artifacts.ingress_summary.exists;
+        return { exists, artifacts };
+    }
+    catch {
+        return {
+            exists: false,
+            artifacts: {},
+        };
+    }
+}
+// Re-export schema
+export { IngressInputSchema };

package/build/mcp/tools/vibe_pm/init_docs.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { type DocsStructureResult } from "./docs_structure.js";
+export declare const InitDocsInputSchema: z.ZodObject<{
+    workspace_path: z.ZodOptional<z.ZodString>;
+    force: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    force: boolean;
+    workspace_path?: string | undefined;
+}, {
+    force?: boolean | undefined;
+    workspace_path?: string | undefined;
+}>;
+export type InitDocsInput = z.infer<typeof InitDocsInputSchema>;
+export interface InitDocsOutput {
+    status: "created" | "already_exists" | "updated";
+    docs_root: string;
+    structure: DocsStructureResult["structure"];
+    created_paths?: string[];
+    message: string;
+}
+export declare function initDocs(input: InitDocsInput): Promise<InitDocsOutput>;

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

@@ -0,0 +1,38 @@
+// vibe_pm.init_docs - 명시적 docs 구조 초기화 도구
+import { z } from "zod";
+import { ensureDocsStructure, checkDocsStructure } from "./docs_structure.js";
+import { findVibeConfigRoot } from "../../workspace-root.js";
+export const InitDocsInputSchema = z.object({
+    workspace_path: z.string().optional().describe("작업 폴더 (생략 시 현재 작업 폴더)"),
+    force: z.boolean().optional().default(false).describe("이미 존재해도 누락된 부분만 생성"),
+});
+export async function initDocs(input) {
+    const workspaceRoot = input.workspace_path || findVibeConfigRoot() || process.cwd();
+    const current = checkDocsStructure(workspaceRoot);
+    if (current.ok && !input.force) {
+        return {
+            status: "already_exists",
+            docs_root: current.docsRoot,
+            structure: current.structure,
+            message: "docs/ 구조가 이미 존재합니다.",
+        };
+    }
+    const result = ensureDocsStructure(workspaceRoot);
+    if (!result.created) {
+        return {
+            status: "already_exists",
+            docs_root: result.docsRoot,
+            structure: result.structure,
+            message: "docs/ 구조가 이미 완전합니다.",
+        };
+    }
+    const status = current.ok ? "updated" : "created";
+    const verb = status === "created" ? "생성" : "업데이트";
+    return {
+        status,
+        docs_root: result.docsRoot,
+        structure: result.structure,
+        created_paths: result.createdPaths,
+        message: `docs/ 구조를 ${verb}했습니다: ${result.createdPaths?.join(", ")}`,
+    };
+}

package/build/mcp/tools/vibe_pm/inspect_code.d.ts

@@ -0,0 +1,10 @@
+import type { InspectCodeInput, InspectCodeOutput } from "./types.js";
+/**
+ * vibe_pm.inspect_code - Code review and validation (MVP)
+ *
+ * Internal mapping:
+ *   → vibecoding-helper one-loop <run_id> --output selection
+ *   → issue classification
+ *   → prompt_block generation (if FIX/BLOCK)
+ */
+export declare function inspectCode(input: InspectCodeInput): Promise<InspectCodeOutput>;