@vibecodetown/mcp-server 2.1.0

package/build/tools/vibe_pm/finalize_work.js

@@ -0,0 +1,393 @@
+// adapters/mcp-ts/src/tools/vibe_pm/finalize_work.ts
+// vibe_pm.finalize_work - Document updates + DEV_LOG + Git commit/push
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { simpleGit } from "simple-git";
+import { memorySync } from "./memory_sync.js";
+import { getAuthGate } from "../../auth/index.js";
+import { advisoryReview } from "./advisory_review.js";
+import { runDocStatusTriage } from "./doc_status_gate.js";
+import { kickoffKceSyncBestEffort } from "./kce/on_finalize.js";
+import { updateVersionFile } from "../../version-check.js";
+import { CONTRACTS_VERSION, CONTRACTS_BUNDLE_SHA256 } from "../../generated/contracts_bundle_info.js";
+/**
+ * vibe_pm.finalize_work - Complete work with documentation and Git
+ *
+ * Steps:
+ * 1. Calculate date (YYYY-MM-DD)
+ * 2. Create/append DEV_LOG file (docs/dev_logs/{date}.md)
+ * 3. Update CURRENT_SPEC.md sections (if spec_changes provided)
+ * 4. git add .
+ * 5. git commit with conventional commit format
+ * 6. git push (if remote origin exists)
+ * 7. Return result
+ */
+export async function finalizeWork(input, basePath = process.cwd()) {
+    const updatedFiles = [];
+    let warning;
+    // Step 1: Calculate date
+    const today = new Date();
+    const dateStr = today.toISOString().split("T")[0]; // YYYY-MM-DD
+    const timestamp = today.toISOString();
+    // Step 1.5: Archive Logic (Clean Desk Policy)
+    let sessionSummary = input.task_summary;
+    if (input.completed_plan_path) {
+        try {
+            const planPath = path.resolve(basePath, input.completed_plan_path);
+            const planningDir = path.resolve(basePath, "docs", "planning");
+            // Validate: must be inside docs/planning and exist
+            if (fs.existsSync(planPath) && planPath.startsWith(planningDir)) {
+                const archiveDir = path.join(basePath, "docs", "archive");
+                if (!fs.existsSync(archiveDir))
+                    fs.mkdirSync(archiveDir, { recursive: true });
+                const fileName = path.basename(planPath);
+                const datePrefix = dateStr.replace(/-/g, ""); // 20240520
+                const archiveName = `${datePrefix}_${fileName}`;
+                const archivePath = path.join(archiveDir, archiveName);
+                fs.renameSync(planPath, archivePath);
+                const relativeArchive = path.relative(basePath, archivePath);
+                updatedFiles.push(relativeArchive);
+                sessionSummary += `\n\n> **Archived Plan**: \`${relativeArchive}\``;
+            }
+            else {
+                warning = warning ? `${warning}; Invalid plan path` : "Invalid plan path (not in planning dir or missing)";
+            }
+        }
+        catch (e) {
+            warning = warning ? `${warning}; Archive error: ${e}` : `Archive error: ${e}`;
+        }
+    }
+    // Step 2: Create/append DEV_LOG
+    const devLogDir = path.join(basePath, "docs", "dev_logs");
+    const devLogPath = path.join(devLogDir, `${dateStr}.md`);
+    try {
+        // Ensure directory exists
+        if (!fs.existsSync(devLogDir)) {
+            fs.mkdirSync(devLogDir, { recursive: true });
+        }
+        const logEntry = formatDevLogEntry(sessionSummary, timestamp, input.git_commit);
+        if (fs.existsSync(devLogPath)) {
+            // Append to existing file
+            fs.appendFileSync(devLogPath, `\n${logEntry}`);
+        }
+        else {
+            // Create new file with header
+            const header = `# DEV LOG - ${dateStr}\n\n`;
+            fs.writeFileSync(devLogPath, header + logEntry);
+        }
+        updatedFiles.push(devLogPath);
+    }
+    catch (err) {
+        warning = `DEV_LOG 생성 실패: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    // Step 3: Update CURRENT_SPEC.md (if spec_changes provided)
+    if (input.spec_changes && input.spec_changes.length > 0) {
+        const specPath = path.join(basePath, "docs", "CURRENT_SPEC.md");
+        try {
+            if (fs.existsSync(specPath)) {
+                let specContent = fs.readFileSync(specPath, "utf-8");
+                for (const change of input.spec_changes) {
+                    specContent = applySpecChange(specContent, change.section, change.content, change.action ?? "REPLACE");
+                }
+                fs.writeFileSync(specPath, specContent);
+                updatedFiles.push(specPath);
+            }
+            else {
+                // Create new CURRENT_SPEC.md
+                let newContent = "# CURRENT_SPEC\n\n";
+                for (const change of input.spec_changes) {
+                    newContent += `## ${change.section}\n\n${change.content}\n\n`;
+                }
+                fs.writeFileSync(specPath, newContent);
+                updatedFiles.push(specPath);
+            }
+        }
+        catch (err) {
+            const errMsg = `CURRENT_SPEC.md 갱신 실패: ${err instanceof Error ? err.message : String(err)}`;
+            warning = warning ? `${warning}; ${errMsg}` : errMsg;
+        }
+    }
+    // Step 3.5: Doc Status Triage (must run before git add/commit; idempotent best-effort)
+    try {
+        const touched = updatedFiles
+            .map((p) => {
+            const abs = path.isAbsolute(p) ? p : path.resolve(basePath, p);
+            return path.relative(basePath, abs).replace(/\\\\/g, "/");
+        })
+            .filter(Boolean);
+        const triage = runDocStatusTriage({ basePath, touched_paths: touched, now: today });
+        for (const p of [...triage.tagged, ...triage.archived, ...triage.tombstoned]) {
+            if (!updatedFiles.includes(p))
+                updatedFiles.push(p);
+        }
+    }
+    catch (err) {
+        warning = appendWarning(warning, `DOC_STATUS_TRIAGE_FAILED: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    // Best-effort: keep Local Memory up-to-date after doc updates (do not block finalize_work)
+    if (shouldKickoffAutoMemorySync(basePath)) {
+        void kickoffAutoMemorySyncProOnly();
+    }
+    // Step 4-6: Git (add/commit/pull-rebase/push)
+    const commitMessage = formatCommitMessage(input.git_commit);
+    let commitHash = "no-commit";
+    let pushedToRemote = false;
+    let remoteUrl;
+    try {
+        const git = simpleGit({ baseDir: basePath });
+        const isRepo = await git.checkIsRepo();
+        if (isRepo) {
+            // Stage + commit (only when there are changes)
+            const status = await git.status();
+            const hasChanges = status.files.length > 0;
+            let commitCreated = false;
+            // Best-effort: pre-finalize triage (never blocks finalize_work)
+            if (hasChanges && shouldKickoffAutoAdvisoryTriage(basePath)) {
+                try {
+                    void advisoryReview({
+                        mode: "triage",
+                        trigger: "pre_finalize",
+                        budget: "low",
+                        changed_paths: status.files.map((f) => f.path)
+                    });
+                }
+                catch {
+                    // ignore
+                }
+            }
+            if (hasChanges) {
+                await git.add(".");
+                try {
+                    await git.commit(commitMessage);
+                    commitHash = (await git.revparse(["HEAD"])).trim() || "unknown";
+                    commitCreated = true;
+                }
+                catch (err) {
+                    warning = appendWarning(warning, `Git commit 실패: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            else {
+                commitHash = "no-changes";
+                warning = appendWarning(warning, "커밋할 변경사항 없음");
+            }
+            // Remote origin (optional)
+            try {
+                remoteUrl = (await git.raw(["remote", "get-url", "origin"])).trim();
+            }
+            catch {
+                remoteUrl = undefined;
+            }
+            const canPull = commitCreated || commitHash === "no-changes";
+            if (remoteUrl && canPull) {
+                // Default: current branch (fallback: main)
+                let branchName = "main";
+                try {
+                    const branch = await git.branch();
+                    if (branch.current)
+                        branchName = branch.current;
+                }
+                catch {
+                    // ignore
+                }
+                if (branchName !== "main") {
+                    warning = appendWarning(warning, `NOT_ON_MAIN: current=${branchName}`);
+                }
+                // Smart sync: pull --rebase before push
+                try {
+                    await git.pull("origin", branchName, { "--rebase": "true" });
+                }
+                catch (err) {
+                    // Rebase conflict stop (no auto-resolve)
+                    try {
+                        await git.rebase(["--abort"]);
+                    }
+                    catch {
+                        // ignore
+                    }
+                    return {
+                        success: false,
+                        updated_files: updatedFiles,
+                        commit_hash: commitHash,
+                        pushed_to_remote: false,
+                        remote_url: remoteUrl,
+                        warning: appendWarning(warning, "MERGE_CONFLICT: manual_resolution_required"),
+                        next_action: {
+                            tool: "vibe_pm.status",
+                            reason: "작업 완료 상태를 확인하세요",
+                        },
+                    };
+                }
+                // Push only when we produced a new commit
+                if (commitCreated && commitHash !== "no-commit" && commitHash !== "no-changes") {
+                    try {
+                        await git.push("origin", branchName);
+                        pushedToRemote = true;
+                    }
+                    catch (err) {
+                        warning = appendWarning(warning, `Git push 실패: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                }
+            }
+        }
+    }
+    catch (err) {
+        // Git not available / not a repo / unexpected error: keep docs work, but surface warning
+        warning = appendWarning(warning, `Git 처리 실패: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    // Best-effort: KCE sync (do not block finalize_work)
+    if (shouldKickoffAutoMemorySync(basePath)) {
+        void kickoffKceSyncBestEffort();
+    }
+    // Best-effort: Update .vibe/version.json (finalize_work + release 정책)
+    try {
+        const pkgJsonPath = path.join(basePath, "package.json");
+        let appVersion = "0.0.0";
+        if (fs.existsSync(pkgJsonPath)) {
+            const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+            appVersion = pkgJson.version ?? "0.0.0";
+        }
+        updateVersionFile({
+            repoRoot: basePath,
+            version: appVersion,
+            channel: "stable",
+            contractsSemver: CONTRACTS_VERSION,
+            contractsSha256: `sha256:${CONTRACTS_BUNDLE_SHA256}`,
+        });
+    }
+    catch {
+        // Best-effort: do not block finalize_work
+    }
+    return {
+        success: commitHash !== "no-commit" || updatedFiles.length > 0,
+        updated_files: updatedFiles,
+        commit_hash: commitHash,
+        pushed_to_remote: pushedToRemote,
+        remote_url: remoteUrl,
+        warning,
+        next_action: {
+            tool: "vibe_pm.status",
+            reason: "작업 완료 상태를 확인하세요"
+        }
+    };
+}
+/**
+ * Format DEV_LOG entry
+ */
+function formatDevLogEntry(summary, timestamp, commit) {
+    const time = timestamp.split("T")[1]?.slice(0, 5) ?? "";
+    const typeLabel = getCommitTypeLabel(commit.type);
+    const scope = commit.scope ? `(${commit.scope})` : "";
+    return `## ${time} - ${typeLabel}${scope}: ${commit.subject}
+
+${summary}
+
+---
+`;
+}
+function shouldKickoffAutoMemorySync(basePath) {
+    // Skip for tests / library calls where basePath is injected
+    if (path.resolve(basePath) !== path.resolve(process.cwd()))
+        return false;
+    const raw = (process.env.VIBECODE_AUTOMEMORY ?? "").trim().toLowerCase();
+    if (raw && (raw === "0" || raw === "false" || raw === "no" || raw === "off"))
+        return false;
+    const nodeEnv = (process.env.NODE_ENV ?? "").trim().toLowerCase();
+    if (nodeEnv === "test")
+        return false;
+    const vitest = (process.env.VITEST ?? "").trim().toLowerCase();
+    if (vitest && vitest !== "0" && vitest !== "false" && vitest !== "no" && vitest !== "off")
+        return false;
+    return true;
+}
+async function kickoffAutoMemorySyncProOnly() {
+    try {
+        const gate = getAuthGate();
+        const allowed = await gate.check("local_memory_pro_tools");
+        if (!allowed.allowed)
+            return;
+        await memorySync({ docs_root: "docs", mode: "pre_finalize", force_full: false });
+    }
+    catch {
+        // ignore (best-effort)
+    }
+}
+function shouldKickoffAutoAdvisoryTriage(basePath) {
+    // Skip for tests / library calls where basePath is injected
+    if (path.resolve(basePath) !== path.resolve(process.cwd()))
+        return false;
+    const raw = (process.env.VIBECODE_AUTOADVISORY ?? "").trim().toLowerCase();
+    if (raw && (raw === "0" || raw === "false" || raw === "no" || raw === "off"))
+        return false;
+    const nodeEnv = (process.env.NODE_ENV ?? "").trim().toLowerCase();
+    if (nodeEnv === "test")
+        return false;
+    const vitest = (process.env.VITEST ?? "").trim().toLowerCase();
+    if (vitest && vitest !== "0" && vitest !== "false" && vitest !== "no" && vitest !== "off")
+        return false;
+    return true;
+}
+/**
+ * Get human-readable commit type label
+ */
+function getCommitTypeLabel(type) {
+    const labels = {
+        feat: "새 기능",
+        fix: "버그 수정",
+        docs: "문서",
+        style: "스타일",
+        refactor: "리팩토링",
+        test: "테스트",
+        chore: "기타"
+    };
+    return labels[type] ?? type;
+}
+/**
+ * Format commit message in conventional commit style
+ */
+function formatCommitMessage(commit) {
+    const scope = commit.scope ? `(${commit.scope})` : "";
+    let message = `${commit.type}${scope}: ${commit.subject}`;
+    if (commit.body) {
+        message += `\n\n${commit.body}`;
+    }
+    if (commit.footer) {
+        message += `\n\n${commit.footer}`;
+    }
+    return message;
+}
+/**
+ * Apply spec change to content
+ */
+function applySpecChange(content, section, newContent, action) {
+    // Find section pattern: ## Section Name or # Section Name
+    const sectionPattern = new RegExp(`(^#{1,3}\\s*${escapeRegExp(section)}\\s*$)([\\s\\S]*?)(?=^#{1,3}\\s|$)`, "m");
+    const match = content.match(sectionPattern);
+    if (match) {
+        if (action === "REPLACE") {
+            return content.replace(sectionPattern, `$1\n\n${newContent}\n\n`);
+        }
+        else {
+            // APPEND
+            const existingContent = match[2].trim();
+            return content.replace(sectionPattern, `$1\n\n${existingContent}\n\n${newContent}\n\n`);
+        }
+    }
+    else {
+        // Section not found, append at end
+        return content + `\n\n## ${section}\n\n${newContent}\n`;
+    }
+}
+/**
+ * Escape string for shell argument
+ */
+function appendWarning(existing, next) {
+    if (!existing)
+        return next;
+    return `${existing}; ${next}`;
+}
+/**
+ * Escape string for regex
+ */
+function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/build/tools/vibe_pm/gate.js

@@ -0,0 +1,33 @@
+// adapters/mcp-ts/src/tools/vibe_pm/gate.ts
+// vibe_pm.gate - System Design Gate check (direct)
+import { GateInputSchema } from "../../generated/gate_input.js";
+import { GateOutputSchema } from "../../generated/gate_output.js";
+import { WorkOrderV1Schema } from "../../generated/work_order_v1.js";
+import { checkGate } from "../../control_plane/gate.js";
+// SSOT-generated (JSON Schema → Zod)
+export const gateInputSchema = GateInputSchema;
+export const gateOutputSchema = GateOutputSchema;
+/**
+ * vibe_pm.gate
+ *
+ * Validates a WorkOrderV1 against System Design Gate.
+ * Returns GateOutput (GateResultV1-compatible shape).
+ */
+export async function gate(input) {
+    const basePath = process.cwd();
+    // Fail-closed on tool input drift
+    const parsed = gateInputSchema.parse(input);
+    const workOrder = WorkOrderV1Schema.parse(parsed.work_order);
+    const opts = parsed.options;
+    const out = await checkGate(workOrder, {
+        repoRoot: basePath,
+        failFast: opts?.fail_fast,
+        semgrep: opts?.semgrep,
+        runtime: opts?.runtime
+    });
+    if (!out.result) {
+        throw new Error(out.error ?? "Gate returned no result");
+    }
+    // Fail-closed on output drift
+    return gateOutputSchema.parse(out.result);
+}