@vibecodetown/mcp-server 2.1.0

package/build/tools/vibe_pm/status.js

@@ -0,0 +1,153 @@
+// adapters/mcp-ts/src/tools/vibe_pm/status.ts
+// vibe_pm.status - Project status query
+import { runEngineWithCache } from "../../engine.js";
+import { safeJsonParse } from "../../cli.js";
+import { resolveRunId, resolveProjectId, getRunContext, readRunState } from "./context.js";
+import { formatMode, formatPhase, signalToReview } from "./pm_language.js";
+import { validateToolInput } from "../../security/input-validator.js";
+import { SpecHighValidateOutputSchema } from "../../generated/spec_high_validate_output.js";
+/**
+ * vibe_pm.status - Query current project status
+ *
+ * Internal mapping:
+ *   → spec-high validate <run_id>
+ *   → status summary generation
+ */
+export async function status(input) {
+    const basePath = process.cwd();
+    validateToolInput({ project_id: input.project_id });
+    // Resolve run_id
+    const { run_id, is_new } = resolveRunId(input.project_id, basePath);
+    const project_id = resolveProjectId(run_id, basePath);
+    // If no existing run, return empty status
+    if (is_new) {
+        return {
+            project_id,
+            project: {
+                name: project_id,
+                mode: "미설정",
+                started_at: "없음"
+            },
+            current_state: {
+                phase: "프로젝트가 없습니다",
+                decisions_made: 0,
+                decisions_pending: 0
+            },
+            risks: ["프로젝트를 먼저 시작해주세요"],
+            next_action: {
+                tool: "vibe_pm.briefing",
+                label: "다음 할 일: 프로젝트 시작하기"
+            }
+        };
+    }
+    // Get run context and state
+    const context = getRunContext(run_id, basePath);
+    const runState = readRunState(run_id, basePath);
+    // Run spec-high validate to get current status (with caching)
+    let validateResult = null;
+    try {
+        const { code, stdout } = await runEngineWithCache("spec-high", ["--root", "engines/spec_high", "validate", run_id], {
+            timeoutMs: 60_000
+        });
+        if (code === 0 && stdout) {
+            const parsed = safeJsonParse(stdout);
+            if (parsed.ok) {
+                const validated = SpecHighValidateOutputSchema.safeParse(parsed.value);
+                if (validated.success)
+                    validateResult = validated.data;
+            }
+        }
+    }
+    catch {
+        // Continue with state-based status if validate fails
+    }
+    // Determine phase and status from various sources
+    const phase = runState?.phase ?? validateResult?.phase ?? "unknown";
+    const mode = runState?.mode ?? "balanced";
+    const decisionsMade = validateResult?.decisions_made ?? runState?.decisions_made ?? 0;
+    const decisionsPending = validateResult?.decisions_pending ?? runState?.decisions_pending ?? 0;
+    // Get last review status
+    let lastReviewStatus;
+    if (validateResult?.signal_level) {
+        lastReviewStatus = signalToReview(validateResult.signal_level).result;
+    }
+    else if (runState?.last_review_status) {
+        lastReviewStatus = runState.last_review_status;
+    }
+    // Collect risks
+    const risks = validateResult?.risks ?? [];
+    // Determine next action based on state
+    const nextAction = determineNextAction(phase, decisionsPending, lastReviewStatus);
+    return {
+        project_id,
+        project: {
+            name: project_id,
+            mode: formatMode(mode),
+            started_at: runState?.created_at ?? "알 수 없음"
+        },
+        current_state: {
+            phase: formatPhase(phase),
+            decisions_made: decisionsMade,
+            decisions_pending: decisionsPending,
+            last_review_status: lastReviewStatus
+        },
+        risks,
+        next_action: nextAction
+    };
+}
+function determineNextAction(phase, decisionsPending, lastReviewStatus) {
+    // If there are pending decisions
+    if (decisionsPending > 0) {
+        return {
+            tool: "vibe_pm.get_decision",
+            label: `다음 할 일: 결재 ${decisionsPending}건 처리`
+        };
+    }
+    // Based on phase
+    switch (phase) {
+        case "init":
+        case "briefing":
+            return {
+                tool: "vibe_pm.get_decision",
+                label: "다음 할 일: 결재 요청 확인"
+            };
+        case "decision":
+            return {
+                tool: "vibe_pm.create_work_order",
+                label: "다음 할 일: 작업 지시서 발행"
+            };
+        case "work_order":
+        case "implementation":
+            return {
+                tool: "vibe_pm.inspect_code",
+                label: "다음 할 일: 구현 후 검수 요청"
+            };
+        case "review":
+            if (lastReviewStatus === "GO") {
+                return {
+                    tool: "vibe_pm.create_work_order",
+                    label: "다음 할 일: 다음 작업 지시서 받기"
+                };
+            }
+            else if (lastReviewStatus === "FIX" || lastReviewStatus === "BLOCK") {
+                return {
+                    tool: "vibe_pm.repair_plan",
+                    label: "다음 할 일: 수정 계획 확인"
+                };
+            }
+            return {
+                tool: "vibe_pm.inspect_code",
+                label: "다음 할 일: 검수 재시도"
+            };
+        case "completed":
+            return {
+                tool: "vibe_pm.briefing",
+                label: "다음 할 일: 새 프로젝트 시작"
+            };
+        default:
+            return {
+                tool: "vibe_pm.status",
+                label: "다음 할 일: 상태 확인"
+            };
+    }
+}

package/build/tools/vibe_pm/submit_decision.js

@@ -0,0 +1,87 @@
+// adapters/mcp-ts/src/tools/vibe_pm/submit_decision.ts
+// vibe_pm.submit_decision - Submit decision
+import { runEngine, invalidateEngineCache } from "../../engine.js";
+import { safeJsonParse } from "../../cli.js";
+import { resolveRunId, resolveProjectId, invalidateStateCache } from "./context.js";
+import { validateToolInput } from "../../security/input-validator.js";
+import { VibecodingHelperAnswerOutputSchema } from "../../generated/vibecoding_helper_answer_output.js";
+/**
+ * vibe_pm.submit_decision - Submit an approval decision
+ *
+ * Internal mapping:
+ *   → spec-high answer <run_id> --text <choice>
+ *   → spec-high derive <run_id>
+ */
+export async function submitDecision(input) {
+    const basePath = process.cwd();
+    validateToolInput({ project_id: input.project_id, note: input.note });
+    // Resolve run_id
+    const { run_id } = resolveRunId(input.project_id, basePath);
+    const project_id = resolveProjectId(run_id, basePath);
+    // Format answer text (combine choice with note if provided)
+    const answerText = input.note ? `${input.choice}: ${input.note}` : input.choice;
+    // Step 1: Submit answer
+    const answerResult = await runEngine("vibecoding-helper", ["answer", run_id, "--text", answerText], { timeoutMs: 120_000 });
+    if (answerResult.code !== 0) {
+        throw new Error(`결재 제출 실패: ${answerResult.stderr || "알 수 없는 오류"}`);
+    }
+    // Parse answer response
+    let remaining = 0;
+    const answerParsed = safeJsonParse(answerResult.stdout);
+    if (!answerParsed.ok) {
+        throw new Error("결재 결과를 파싱할 수 없습니다. 업데이트 후 다시 시도해주세요.");
+    }
+    const validated = VibecodingHelperAnswerOutputSchema.safeParse(answerParsed.value);
+    if (!validated.success) {
+        throw new Error("결재 결과 형식이 예상과 다릅니다. 업데이트 후 다시 시도해주세요.");
+    }
+    remaining = validated.data.remaining ?? validated.data.ask_queue_remaining ?? 0;
+    // Step 2: Run derive to propagate decisions
+    try {
+        await runEngine("spec-high", ["--root", "engines/spec_high", "derive", run_id], { timeoutMs: 60_000 });
+    }
+    catch {
+        // Derive failure is non-fatal, continue
+    }
+    // Step 3: Invalidate caches after state mutation
+    invalidateEngineCache(new RegExp(run_id));
+    invalidateStateCache(run_id, basePath);
+    // Generate summary based on choice
+    const summary = generateDecisionSummary(input.choice, input.note);
+    // Determine next action
+    const nextAction = remaining > 0
+        ? {
+            tool: "vibe_pm.get_decision",
+            reason: `아직 ${remaining}건의 결재가 남아있습니다`
+        }
+        : {
+            tool: "vibe_pm.create_work_order",
+            reason: "모든 결재가 완료되었습니다. 작업 지시서를 발행합니다"
+        };
+    return {
+        project_id,
+        result: {
+            decision_id: input.decision_id,
+            chosen: input.choice,
+            summary
+        },
+        remaining_decisions: remaining,
+        next_action: nextAction
+    };
+}
+/**
+ * Generate user-friendly decision summary
+ */
+function generateDecisionSummary(choice, note) {
+    const choiceSummaries = {
+        A: "첫 번째 옵션으로 결정되었습니다",
+        B: "두 번째 옵션으로 결정되었습니다",
+        C: "세 번째 옵션으로 결정되었습니다",
+        U: "추가 검토가 필요한 것으로 표시되었습니다"
+    };
+    let summary = choiceSummaries[choice] ?? `${choice} 옵션으로 결정되었습니다`;
+    if (note) {
+        summary += ` (참고: ${note})`;
+    }
+    return summary;
+}

package/build/tools/vibe_pm/system_design/issue_mapping.js

@@ -0,0 +1,47 @@
+import { lookupRuleMeta } from "./rulebook.js";
+export function designRiskForPrinciple(principleId) {
+    switch (principleId) {
+        case "STRATEGY_ENFORCEMENT":
+            return "분기 로직이 비대해져 변경/확장이 어려워질 수 있습니다.";
+        case "ADAPTER_ENFORCEMENT":
+            return "외부 의존이 섞이면 테스트/보안/교체 비용이 급증할 수 있습니다.";
+        case "OBSERVER_ENFORCEMENT":
+            return "이벤트 흐름이 분산되면 추적/재현이 어려워질 수 있습니다.";
+        case "BUILDER_ENFORCEMENT":
+            return "옵션 폭발로 유지보수 비용이 증가할 수 있습니다.";
+        case "SINGLETON_GUARD":
+            return "전역 mutable 상태는 테스트/동시성 버그를 유발할 수 있습니다.";
+        case "UNMAPPED_RULE":
+        default:
+            return "설계 규칙 위반 가능성이 있어 확인이 필요합니다.";
+    }
+}
+export function semgrepFindingsToIssues(args) {
+    const issues = [];
+    let error_count = 0;
+    for (const f of args.findings) {
+        const meta = lookupRuleMeta(args.rulebook, f.check_id);
+        const principleId = meta?.principle_id ?? "UNMAPPED_RULE";
+        const patternName = meta?.pattern ?? null;
+        if (f.severity === "ERROR" || f.severity === "CRITICAL") {
+            error_count += 1;
+        }
+        issues.push({
+            type: "RULE_VIOLATION",
+            business_risk: designRiskForPrinciple(principleId),
+            plain_explanation: f.message,
+            technical_detail: {
+                file_path: f.path,
+                line_range: f.start_line && f.end_line ? [f.start_line, f.end_line] : undefined,
+                rule_violated: f.check_id,
+                principle_id: principleId,
+                pattern: patternName ?? undefined,
+                rule_engine: "semgrep",
+                rule_id: f.check_id,
+                severity: f.severity,
+                evidence_ref: args.evidence_ref
+            }
+        });
+    }
+    return { issues, error_count };
+}

package/build/tools/vibe_pm/system_design/rulebook.js

@@ -0,0 +1,112 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { z } from "zod";
+const RuleMetaSchema = z.object({
+    principle_id: z.string().min(1),
+    pattern: z.string().min(1).nullable().optional(),
+    default_severity: z.string().min(1).optional(),
+    notes: z.string().optional()
+});
+const RulebookSchema = z.object({
+    version: z.string().optional(),
+    engine: z.string().optional(),
+    rules: z.record(RuleMetaSchema).default({})
+});
+const BUILTIN_RULEBOOK = {
+    version: "v1",
+    engine: "semgrep",
+    rules: {
+        "strategy-no-long-if-elif-chain-python": {
+            principle_id: "STRATEGY_ENFORCEMENT",
+            pattern: "Strategy",
+            default_severity: "WARNING"
+        },
+        "strategy-no-long-else-if-chain-ts": {
+            principle_id: "STRATEGY_ENFORCEMENT",
+            pattern: "Strategy",
+            default_severity: "WARNING"
+        },
+        "adapter-no-network-in-core-python": {
+            principle_id: "ADAPTER_ENFORCEMENT",
+            pattern: "Adapter",
+            default_severity: "WARNING"
+        },
+        "adapter-no-network-in-core-ts": {
+            principle_id: "ADAPTER_ENFORCEMENT",
+            pattern: "Adapter",
+            default_severity: "WARNING"
+        },
+        "observer-publish-only-in-events-python": {
+            principle_id: "OBSERVER_ENFORCEMENT",
+            pattern: "Observer",
+            default_severity: "WARNING"
+        },
+        "observer-publish-only-in-events-ts": {
+            principle_id: "OBSERVER_ENFORCEMENT",
+            pattern: "Observer",
+            default_severity: "WARNING"
+        },
+        "observer-no-eventbus-instantiation-outside-factory-ts": {
+            principle_id: "OBSERVER_ENFORCEMENT",
+            pattern: "Observer",
+            default_severity: "WARNING"
+        },
+        "observer-no-eventbus-getinstance-outside-events-ts": {
+            principle_id: "OBSERVER_ENFORCEMENT",
+            pattern: "Observer",
+            default_severity: "WARNING"
+        },
+        "observer-no-eventbus-instantiation-outside-factory-python": {
+            principle_id: "OBSERVER_ENFORCEMENT",
+            pattern: "Observer",
+            default_severity: "WARNING"
+        },
+        "observer-no-eventbus-getinstance-outside-events-python": {
+            principle_id: "OBSERVER_ENFORCEMENT",
+            pattern: "Observer",
+            default_severity: "WARNING"
+        },
+        "builder-too-many-init-params-python": {
+            principle_id: "BUILDER_ENFORCEMENT",
+            pattern: "Builder",
+            default_severity: "WARNING"
+        },
+        "builder-too-many-constructor-params-ts": {
+            principle_id: "BUILDER_ENFORCEMENT",
+            pattern: "Builder",
+            default_severity: "WARNING"
+        },
+        "singleton-no-global-mutable-python": {
+            principle_id: "SINGLETON_GUARD",
+            pattern: "Singleton",
+            default_severity: "WARNING"
+        },
+        "singleton-no-exported-mutable-singletons-ts": {
+            principle_id: "SINGLETON_GUARD",
+            pattern: "Singleton",
+            default_severity: "WARNING"
+        }
+    }
+};
+function repoRulebookPath(basePath) {
+    return path.join(basePath, "docs", "DEV_SPEC", "system_design_mapping", "RULEBOOK_SEMGREP_MAP.v1.json");
+}
+export function loadRulebook(basePath) {
+    const candidate = repoRulebookPath(basePath);
+    if (!fs.existsSync(candidate))
+        return { source: "builtin", rulebook: BUILTIN_RULEBOOK };
+    try {
+        const raw = JSON.parse(fs.readFileSync(candidate, "utf-8"));
+        const parsed = RulebookSchema.safeParse(raw);
+        if (parsed.success)
+            return { source: "repo_file", rulebook: parsed.data };
+    }
+    catch {
+        // ignore
+    }
+    return { source: "builtin", rulebook: BUILTIN_RULEBOOK };
+}
+export function lookupRuleMeta(rulebook, checkId) {
+    const meta = (rulebook.rules ?? {})[checkId];
+    return meta ?? null;
+}

package/build/tools/vibe_pm/system_design/semgrep.js

@@ -0,0 +1,132 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { z } from "zod";
+import { runCmd, safeJsonParse } from "../../../cli.js";
+import { resolveRunDir } from "../context.js";
+const SemgrepResultSchema = z.object({
+    results: z
+        .array(z.object({
+        check_id: z.string().optional(),
+        path: z.string().optional(),
+        start: z
+            .object({
+            line: z.number().int().positive().optional(),
+            col: z.number().int().positive().optional()
+        })
+            .optional(),
+        end: z
+            .object({
+            line: z.number().int().positive().optional(),
+            col: z.number().int().positive().optional()
+        })
+            .optional(),
+        extra: z
+            .object({
+            message: z.string().optional(),
+            severity: z.string().optional()
+        })
+            .optional()
+    }))
+        .default([])
+});
+function findConfigPath(basePath) {
+    const candidates = [
+        path.join(basePath, "semgrep", "rules", "design_patterns.yml"),
+        path.join(basePath, "semgrep", "rules", "design_patterns.yaml"),
+        path.join(basePath, "docs", "DEV_SPEC", "system_design_mapping", "semgrep_design_enforcement_rules.yml")
+    ];
+    for (const c of candidates) {
+        if (fs.existsSync(c))
+            return c;
+    }
+    return null;
+}
+function tryWriteEvidence(basePath, run_id, stdout) {
+    if (!stdout.trim())
+        return null;
+    const resolved = resolveRunDir(run_id, basePath);
+    if (!resolved)
+        return null;
+    try {
+        const abs = path.join(resolved.run_dir, "evidence", "semgrep_results.json");
+        fs.mkdirSync(path.dirname(abs), { recursive: true });
+        fs.writeFileSync(abs, stdout, "utf-8");
+        return path.relative(basePath, abs).replace(/\\\\/g, "/");
+    }
+    catch {
+        return null;
+    }
+}
+export async function runSemgrepDesignEnforcement(args) {
+    const configPath = findConfigPath(args.basePath);
+    if (!configPath) {
+        return {
+            status: "SKIPPED",
+            findings: [],
+            error: { type: "config_missing", message: "design semgrep config not found" }
+        };
+    }
+    const targetArgs = [];
+    for (const t of args.targets) {
+        if (!t)
+            continue;
+        const abs = path.isAbsolute(t) ? t : path.join(args.basePath, t);
+        if (!fs.existsSync(abs))
+            continue;
+        targetArgs.push(path.isAbsolute(t) ? t : t.replace(/\\\\/g, "/"));
+    }
+    if (targetArgs.length === 0) {
+        return { status: "SKIPPED", findings: [] };
+    }
+    const cmdArgs = ["scan", "--config", configPath, "--json", "--quiet", "--metrics", "off", ...targetArgs];
+    const { code, stdout, stderr } = await runCmd("semgrep", cmdArgs, {
+        cwd: args.basePath,
+        timeoutMs: args.timeoutMs ?? 60_000
+    });
+    const evidence_ref = tryWriteEvidence(args.basePath, args.run_id, stdout) ?? undefined;
+    if (code !== 0) {
+        return {
+            status: "ERROR",
+            findings: [],
+            evidence_ref,
+            error: { type: "semgrep_failed", message: `semgrep exit_code=${code}`, stderr: (stderr ?? "").slice(0, 2000) }
+        };
+    }
+    const parsedJson = safeJsonParse(stdout);
+    if (!parsedJson.ok) {
+        return {
+            status: "ERROR",
+            findings: [],
+            evidence_ref,
+            error: { type: "json_parse_error", message: parsedJson.error, stderr: (stderr ?? "").slice(0, 2000) }
+        };
+    }
+    const validated = SemgrepResultSchema.safeParse(parsedJson.value);
+    if (!validated.success) {
+        return {
+            status: "ERROR",
+            findings: [],
+            evidence_ref,
+            error: { type: "schema_mismatch", message: "unexpected semgrep json shape", stderr: (stderr ?? "").slice(0, 2000) }
+        };
+    }
+    const findings = [];
+    for (const r of validated.data.results) {
+        const check_id = (r.check_id ?? "").trim();
+        const p = (r.path ?? "").trim();
+        if (!check_id || !p)
+            continue;
+        const sevRaw = (r.extra?.severity ?? "").trim().toUpperCase();
+        const severity = sevRaw || "WARNING";
+        const message = (r.extra?.message ?? "").trim() || "설계 규칙 위반 가능성이 있습니다";
+        findings.push({
+            check_id,
+            path: p.replace(/\\\\/g, "/"),
+            start_line: r.start?.line,
+            end_line: r.end?.line,
+            severity,
+            message
+        });
+    }
+    return { status: "OK", findings, evidence_ref };
+}