@vibecodetown/mcp-server 2.1.0

package/build/tools/vibe_pm/briefing.js

@@ -0,0 +1,178 @@
+// adapters/mcp-ts/src/tools/vibe_pm/briefing.ts
+// vibe_pm.briefing - Project intake and structuring
+import { runEngine } from "../../engine.js";
+import { safeJsonParse } from "../../cli.js";
+import { generateRunId, resolveProjectId, ensureRunsDir, getRunsDir } from "./context.js";
+import { validateBriefingInput } from "../../security/input-validator.js";
+import { ensureResearchForBriefing } from "./modules/ensure.js";
+import { memorySync } from "./memory_sync.js";
+import { getAuthGate } from "../../auth/index.js";
+import { SpecHighDecisionDraftOutputSchema } from "../../generated/spec_high_decision_draft_output.js";
+import { applyPromptDensityHysteresis, computePromptDensity, loadLatestPromptDensityForProject, savePromptDensity } from "./intent/prompt_density.js";
+import { generateIntentFromBriefing, saveIntentWithMarkdown } from "./intent/index.js";
+/**
+ * vibe_pm.briefing - Project intake and structuring
+ *
+ * Internal mapping:
+ *   → spec-high init <auto_run_id>
+ *   → spec-high input-set <run_id> --text <project_brief>
+ *   → spec-high decision-draft <run_id>
+ *   → summary generation
+ */
+export async function briefing(input) {
+    const basePath = process.cwd();
+    // Security: Validate input first
+    validateBriefingInput(input);
+    // Ensure runs directory exists
+    ensureRunsDir(basePath);
+    // Generate or use provided project_id/run_id
+    const project_id = input.project_id ?? resolveProjectId(undefined, basePath);
+    const run_id = generateRunId(project_id, basePath);
+    // Best-effort: keep Local Memory up-to-date (PRO only; do not block briefing on failure)
+    if (shouldKickoffAutoMemorySync()) {
+        void kickoffAutoMemorySyncProOnly(project_id);
+    }
+    // Mode defaults to balanced
+    const mode = input.mode ?? "balanced";
+    // Step 1: Initialize the run
+    const initResult = await runEngine("spec-high", ["--root", "engines/spec_high", "init", run_id, "--mode", mode], { timeoutMs: 60_000 });
+    if (initResult.code !== 0) {
+        throw new Error(`프로젝트 초기화 실패: ${initResult.stderr || "알 수 없는 오류"}`);
+    }
+    // Step 2: Set the project brief as input
+    const inputSetResult = await runEngine("spec-high", ["--root", "engines/spec_high", "input-set", run_id, "--text", input.project_brief], { timeoutMs: 60_000 });
+    if (inputSetResult.code !== 0) {
+        throw new Error(`프로젝트 설명 입력 실패: ${inputSetResult.stderr || "알 수 없는 오류"}`);
+    }
+    // Step 3: Generate decision draft (creates ask_queue)
+    let summary = {
+        goal: extractGoal(input.project_brief),
+        target_user: "일반 사용자",
+        first_milestone: `MVP: ${extractFirstFeature(input.project_brief)}`,
+        top_risk: "범위가 명확하지 않음"
+    };
+    try {
+        const draftResult = await runEngine("spec-high", ["--root", "engines/spec_high", "decision-draft", run_id], { timeoutMs: 120_000 });
+        if (draftResult.code === 0) {
+            const parsed = safeJsonParse(draftResult.stdout);
+            if (parsed.ok) {
+                const validated = SpecHighDecisionDraftOutputSchema.safeParse(parsed.value);
+                if (validated.success && validated.data.summary) {
+                    summary = {
+                        goal: validated.data.summary.goal ?? summary.goal,
+                        target_user: validated.data.summary.target_user ?? summary.target_user,
+                        first_milestone: validated.data.summary.first_milestone ?? summary.first_milestone,
+                        top_risk: validated.data.summary.top_risk ?? summary.top_risk
+                    };
+                }
+            }
+        }
+    }
+    catch {
+        // Use default summary if decision-draft fails
+    }
+    // Generate and save Intent document
+    try {
+        const runsDir = getRunsDir(basePath);
+        const intentData = {
+            runId: run_id,
+            projectName: extractGoal(input.project_brief),
+            goal: summary.goal,
+            targetUser: summary.target_user,
+            mode: mode,
+            firstMilestone: summary.first_milestone,
+            topRisk: summary.top_risk
+        };
+        const intent = generateIntentFromBriefing(intentData);
+        await saveIntentWithMarkdown(runsDir, intent);
+    }
+    catch {
+        // Intent generation is optional - continue if it fails
+    }
+    // Research module is best-effort (do not block briefing)
+    try {
+        ensureResearchForBriefing({ basePath, runId: run_id, projectBrief: input.project_brief });
+    }
+    catch {
+        // ignore
+    }
+    // Prompt density is best-effort (do not block briefing)
+    try {
+        const runsDir = getRunsDir(basePath);
+        const previous = loadLatestPromptDensityForProject(runsDir, project_id);
+        const current = computePromptDensity(input.project_brief, run_id);
+        const density = applyPromptDensityHysteresis({ current, previous });
+        savePromptDensity(runsDir, run_id, density);
+    }
+    catch {
+        // ignore
+    }
+    return {
+        project_id,
+        run_id,
+        pm_summary: summary,
+        next_action: {
+            tool: "vibe_pm.get_decision",
+            reason: "범위를 정하기 위해 결재가 필요합니다"
+        }
+    };
+}
+/**
+ * Extract project goal from brief text
+ */
+function extractGoal(brief) {
+    // Take first sentence or up to 50 characters
+    const firstSentence = brief.split(/[.!?]/)[0].trim();
+    if (firstSentence.length <= 50) {
+        return firstSentence;
+    }
+    return firstSentence.slice(0, 47) + "...";
+}
+/**
+ * Extract first feature mention from brief
+ */
+function extractFirstFeature(brief) {
+    // Look for common feature-related keywords
+    const featurePatterns = [
+        /(?:만들|구현|개발|추가).+?(?:기능|페이지|화면|버튼|폼)/,
+        /(.+?)\s*(?:앱|웹|사이트|서비스)/,
+        /MVP.+/
+    ];
+    for (const pattern of featurePatterns) {
+        const match = brief.match(pattern);
+        if (match) {
+            const feature = match[0].trim();
+            if (feature.length <= 30) {
+                return feature;
+            }
+            return feature.slice(0, 27) + "...";
+        }
+    }
+    // Default: first few words
+    const words = brief.split(/\s+/).slice(0, 5);
+    return words.join(" ") + " 구현";
+}
+function shouldKickoffAutoMemorySync() {
+    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(project_id) {
+    try {
+        const gate = getAuthGate();
+        const allowed = await gate.check("local_memory_pro_tools");
+        if (!allowed.allowed)
+            return;
+        await memorySync({ project_id, docs_root: "docs", mode: "on_demand", force_full: false });
+    }
+    catch {
+        // ignore (best-effort)
+    }
+}

package/build/tools/vibe_pm/context.js

@@ -0,0 +1,439 @@
+// adapters/mcp-ts/src/tools/vibe_pm/context.ts
+// Run context auto-discovery utilities
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { TieredCache, createCacheKey } from "../../cache/index.js";
+import { validatePath } from "../../security/path-policy.js";
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+import { RunStateFileSchema } from "../../generated/run_state_file.js";
+// ============================================================
+// Constants
+// ============================================================
+const RUNS_DIR = "runs";
+const ENGINES_DIR = "engines";
+const SPEC_HIGH_DIRNAME = "spec_high";
+const HANDOFF_DIR = "handoff";
+const BRIDGE_FILENAME_YAML = "clinic_bridge.yaml";
+const BRIDGE_FILENAME_JSON = "clinic_bridge.json";
+const STATE_FILENAME = "state.json";
+// ============================================================
+// Caches
+// ============================================================
+/**
+ * Cache for run state (state.json)
+ * TTL: 5 minutes, max 20 entries
+ * Validates against file mtime
+ */
+const stateCache = new TieredCache({
+    ttlMs: 300_000,
+    maxEntries: 20,
+    name: "run-state",
+});
+/**
+ * Cache for bridge path resolution
+ * TTL: 5 minutes, max 30 entries
+ */
+const bridgePathCache = new TieredCache({
+    ttlMs: 300_000,
+    maxEntries: 30,
+    name: "bridge-path",
+});
+/**
+ * Cache for run context
+ * TTL: 15 seconds, max 20 entries
+ */
+const runContextCache = new TieredCache({
+    ttlMs: 15_000,
+    maxEntries: 20,
+    name: "run-context",
+});
+function normalizeRunState(raw) {
+    const parsed = RunStateFileSchema.safeParse(raw);
+    if (!parsed.success)
+        return null;
+    const value = parsed.data;
+    const out = {};
+    if (typeof value?.phase === "string")
+        out.phase = value.phase;
+    if (typeof value?.mode === "string")
+        out.mode = value.mode;
+    if (typeof value?.created_at === "string")
+        out.created_at = value.created_at;
+    if (typeof value?.decisions_made === "number")
+        out.decisions_made = value.decisions_made;
+    if (typeof value?.decisions_pending === "number")
+        out.decisions_pending = value.decisions_pending;
+    if (typeof value?.last_review_status === "string")
+        out.last_review_status = value.last_review_status;
+    // Spec-High state.json (v1) doesn't expose decisions_made/pending directly.
+    // Derive stable counts from required_slots when present.
+    if ((out.decisions_made === undefined || out.decisions_pending === undefined) &&
+        value?.required_slots &&
+        typeof value.required_slots === "object") {
+        const slots = Object.values(value.required_slots);
+        const filled = slots.filter((s) => s === "filled").length;
+        const missing = slots.filter((s) => s === "missing").length;
+        if (out.decisions_made === undefined)
+            out.decisions_made = filled;
+        if (out.decisions_pending === undefined)
+            out.decisions_pending = missing;
+    }
+    return out;
+}
+// ============================================================
+// Auto-Discovery Functions
+// ============================================================
+/**
+ * Get the runs directory path
+ */
+export function getRunsDir(basePath = process.cwd()) {
+    return path.join(basePath, RUNS_DIR);
+}
+/**
+ * Get Spec-High runs directory path (preferred v1 run root)
+ */
+export function getSpecHighRunsDir(basePath = process.cwd()) {
+    return path.join(basePath, ENGINES_DIR, SPEC_HIGH_DIRNAME, RUNS_DIR);
+}
+/**
+ * Resolve Spec-High run directory with v1 priority:
+ *   1) engines/spec_high/runs/examples/<run_id>
+ *   2) engines/spec_high/runs/fixtures/<run_id>
+ *   3) engines/spec_high/runs/<run_id>
+ *
+ * Returns null if not found.
+ */
+export function resolveSpecHighRunDir(runId, basePath = process.cwd()) {
+    assertSafeId(runId, "run_id");
+    const specRuns = getSpecHighRunsDir(basePath);
+    const candidates = [
+        ["spec_high_examples", path.join(specRuns, "examples", runId)],
+        ["spec_high_fixtures", path.join(specRuns, "fixtures", runId)],
+        ["spec_high_legacy", path.join(specRuns, runId)],
+    ];
+    for (const [source, p] of candidates) {
+        if (fs.existsSync(p) && fs.statSync(p).isDirectory()) {
+            return { run_id: runId, run_dir: p, source };
+        }
+    }
+    return null;
+}
+/**
+ * Resolve run directory (preferred Spec-High run dir, fallback legacy runs/<run_id>)
+ */
+export function resolveRunDir(runId, basePath = process.cwd()) {
+    const resolved = resolveSpecHighRunDir(runId, basePath);
+    if (resolved)
+        return resolved;
+    const legacy = path.join(getRunsDir(basePath), runId);
+    if (fs.existsSync(legacy) && fs.statSync(legacy).isDirectory()) {
+        return { run_id: runId, run_dir: legacy, source: "legacy" };
+    }
+    return null;
+}
+/**
+ * List all available run IDs
+ */
+export function listRunIds(basePath = process.cwd()) {
+    const out = new Set();
+    const specRunsDir = getSpecHighRunsDir(basePath);
+    if (fs.existsSync(specRunsDir)) {
+        try {
+            const entries = fs.readdirSync(specRunsDir, { withFileTypes: true });
+            for (const e of entries) {
+                if (!e.isDirectory())
+                    continue;
+                if (e.name === "examples" || e.name === "fixtures")
+                    continue;
+                out.add(e.name);
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    const runsDir = getRunsDir(basePath);
+    if (fs.existsSync(runsDir)) {
+        try {
+            const entries = fs.readdirSync(runsDir, { withFileTypes: true });
+            for (const e of entries) {
+                if (!e.isDirectory())
+                    continue;
+                out.add(e.name);
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return Array.from(out.values()).sort();
+}
+/**
+ * Find the most recent run_id based on directory modification time
+ */
+export function findLatestRunId(basePath = process.cwd()) {
+    const runIds = listRunIds(basePath);
+    if (runIds.length === 0) {
+        return null;
+    }
+    // Sort by modification time (most recent first), preferring Spec-High run roots
+    const sorted = runIds
+        .map((id) => {
+        const resolved = resolveRunDir(id, basePath);
+        const runPath = resolved?.run_dir ?? path.join(getRunsDir(basePath), id);
+        try {
+            const stat = fs.statSync(runPath);
+            return { id, mtime: stat.mtime.getTime() };
+        }
+        catch {
+            return { id, mtime: 0 };
+        }
+    })
+        .sort((a, b) => b.mtime - a.mtime);
+    return sorted[0]?.id ?? null;
+}
+/**
+ * Generate a new run_id based on project folder name and timestamp
+ */
+export function generateRunId(projectId, basePath = process.cwd()) {
+    const base = projectId ?? path.basename(basePath);
+    const timestamp = new Date().toISOString().replace(/[-:T]/g, "").slice(0, 14);
+    return `${sanitizeForId(base)}_${timestamp}`;
+}
+/**
+ * Sanitize a string for use as an ID
+ */
+function sanitizeForId(str) {
+    return str
+        .toLowerCase()
+        .replace(/[^a-z0-9_-]/g, "_")
+        .replace(/_+/g, "_")
+        .replace(/^_|_$/g, "")
+        .slice(0, 32);
+}
+function assertSafeId(value, field) {
+    if (!value || value.trim().length === 0) {
+        throw new McpError(ErrorCode.InvalidParams, `[SECURITY] ${field} is required`, {
+            vibeCode: -32_064,
+            category: "SECURITY",
+            context: { field },
+        });
+    }
+    if (value.includes("..") || value.includes("/") || value.includes("\\") || value.includes("\0")) {
+        throw new McpError(ErrorCode.InvalidParams, `[SECURITY] Invalid ${field}: path traversal detected`, {
+            vibeCode: -32_065,
+            category: "SECURITY",
+            context: { field },
+        });
+    }
+}
+/**
+ * Resolve run_id: use provided value, or find latest, or generate new
+ */
+export function resolveRunId(providedId, basePath = process.cwd()) {
+    if (providedId) {
+        assertSafeId(providedId, "run_id");
+        return { run_id: providedId, is_new: false };
+    }
+    const latestId = findLatestRunId(basePath);
+    if (latestId) {
+        return { run_id: latestId, is_new: false };
+    }
+    return { run_id: generateRunId(undefined, basePath), is_new: true };
+}
+/**
+ * Resolve project_id from run_id or folder name
+ */
+export function resolveProjectId(runId, basePath = process.cwd()) {
+    if (runId) {
+        assertSafeId(runId, "run_id");
+        // Extract project name from run_id (before the timestamp)
+        const parts = runId.split("_");
+        if (parts.length > 1) {
+            // Remove the timestamp part (last part if it looks like a timestamp)
+            const lastPart = parts[parts.length - 1];
+            if (/^\d{14}$/.test(lastPart)) {
+                return parts.slice(0, -1).join("_");
+            }
+        }
+        return runId;
+    }
+    return sanitizeForId(path.basename(basePath));
+}
+// ============================================================
+// Run Context Functions
+// ============================================================
+/**
+ * Get full context for a run (with caching)
+ */
+export function getRunContext(runId, basePath = process.cwd()) {
+    const cacheKey = createCacheKey("run-context", runId, basePath);
+    // Check cache first
+    const cached = runContextCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const projectId = resolveProjectId(runId, basePath);
+    const resolved = resolveRunDir(runId, basePath);
+    const runsPath = resolved?.run_dir ?? path.join(basePath, RUNS_DIR, runId);
+    const handoffPath = path.join(runsPath, HANDOFF_DIR);
+    // Find bridge file (prefer YAML)
+    let bridgePath = null;
+    const yamlBridge = path.join(handoffPath, BRIDGE_FILENAME_YAML);
+    const jsonBridge = path.join(handoffPath, BRIDGE_FILENAME_JSON);
+    if (fs.existsSync(yamlBridge)) {
+        bridgePath = yamlBridge;
+    }
+    else if (fs.existsSync(jsonBridge)) {
+        bridgePath = jsonBridge;
+    }
+    // Find state file
+    const statePath = path.join(runsPath, STATE_FILENAME);
+    const stateExists = fs.existsSync(statePath);
+    const context = {
+        run_id: runId,
+        project_id: projectId,
+        runs_path: runsPath,
+        handoff_path: handoffPath,
+        bridge_path: bridgePath,
+        state_path: stateExists ? statePath : null
+    };
+    // Cache the result
+    runContextCache.set(cacheKey, context);
+    return context;
+}
+/**
+ * Read run state from state.json (with mtime-based caching)
+ */
+export function readRunState(runId, basePath = process.cwd()) {
+    const context = getRunContext(runId, basePath);
+    if (!context.state_path) {
+        return null;
+    }
+    const cacheKey = createCacheKey("state", runId, basePath);
+    const statePath = context.state_path;
+    // Create mtime getter for validation
+    const getMtime = () => {
+        try {
+            return fs.statSync(statePath).mtime.getTime();
+        }
+        catch {
+            return null;
+        }
+    };
+    // Check cache with mtime validation
+    const cached = stateCache.get(cacheKey, getMtime);
+    if (cached) {
+        return cached;
+    }
+    try {
+        const content = fs.readFileSync(statePath, "utf-8");
+        const raw = JSON.parse(content);
+        const state = normalizeRunState(raw);
+        if (!state)
+            return null;
+        const mtime = getMtime();
+        // Cache with mtime
+        if (mtime !== null) {
+            stateCache.set(cacheKey, state, mtime);
+        }
+        return state;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if a run exists
+ */
+export function runExists(runId, basePath = process.cwd()) {
+    return resolveRunDir(runId, basePath) !== null;
+}
+/**
+ * Ensure runs directory exists
+ */
+export function ensureRunsDir(basePath = process.cwd()) {
+    const runsDir = getRunsDir(basePath);
+    if (!fs.existsSync(runsDir)) {
+        fs.mkdirSync(runsDir, { recursive: true });
+    }
+}
+// ============================================================
+// Bridge Auto-Discovery
+// ============================================================
+/**
+ * Find the latest bridge file across all runs
+ */
+export function findLatestBridge(basePath = process.cwd()) {
+    const runIds = listRunIds(basePath);
+    let latestBridge = null;
+    for (const runId of runIds) {
+        const context = getRunContext(runId, basePath);
+        if (context.bridge_path) {
+            try {
+                const stat = fs.statSync(context.bridge_path);
+                if (!latestBridge || stat.mtime.getTime() > latestBridge.mtime) {
+                    latestBridge = { path: context.bridge_path, mtime: stat.mtime.getTime() };
+                }
+            }
+            catch {
+                // Skip if stat fails
+            }
+        }
+    }
+    return latestBridge?.path ?? null;
+}
+/**
+ * Resolve bridge path: use provided value, find from run_id, or find latest (with caching)
+ */
+export function resolveBridgePath(providedPath, runId, basePath = process.cwd()) {
+    if (providedPath) {
+        return validatePath(providedPath, basePath);
+    }
+    // Check cache for run_id-based lookup
+    if (runId) {
+        const cacheKey = createCacheKey("bridge-path", runId, basePath);
+        const cached = bridgePathCache.get(cacheKey);
+        if (cached !== null) {
+            return cached;
+        }
+        const context = getRunContext(runId, basePath);
+        if (context.bridge_path) {
+            bridgePathCache.set(cacheKey, context.bridge_path);
+            return context.bridge_path;
+        }
+    }
+    return findLatestBridge(basePath);
+}
+// ============================================================
+// Cache Invalidation
+// ============================================================
+/**
+ * Invalidate all state-related caches for a run
+ */
+export function invalidateStateCache(runId, basePath) {
+    if (runId && basePath) {
+        const stateKey = createCacheKey("state", runId, basePath);
+        const contextKey = createCacheKey("run-context", runId, basePath);
+        const bridgeKey = createCacheKey("bridge-path", runId, basePath);
+        stateCache.invalidate(stateKey);
+        runContextCache.invalidate(contextKey);
+        bridgePathCache.invalidate(bridgeKey);
+    }
+    else {
+        // Clear all caches
+        stateCache.clear();
+        runContextCache.clear();
+        bridgePathCache.clear();
+    }
+}
+/**
+ * Get cache statistics for debugging
+ */
+export function getContextCacheStats() {
+    return {
+        state: stateCache.stats(),
+        context: runContextCache.stats(),
+        bridge: bridgePathCache.stats(),
+    };
+}