@vibecodetown/mcp-server 2.1.0

package/build/tools/vibe_pm/get_decision.js

@@ -0,0 +1,281 @@
+// adapters/mcp-ts/src/tools/vibe_pm/get_decision.ts
+// vibe_pm.get_decision - Fetch approval items
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { runEngineWithCache } from "../../engine.js";
+import { safeJsonParse } from "../../cli.js";
+import { getRunsDir, resolveRunId, resolveProjectId, resolveSpecHighRunDir } from "./context.js";
+import { transformAskQueueText } from "./pm_language.js";
+import { maybeGetLocalMemoryContextBlock } from "./local_memory.js";
+import { validateToolInput } from "../../security/input-validator.js";
+import { loadPromptDensity } from "./intent/prompt_density.js";
+import { SpecHighAskQueueItemsFileSchema } from "../../generated/spec_high_ask_queue_items_file.js";
+import { VibecodingHelperShowAskQueueOutputSchema } from "../../generated/vibecoding_helper_show_ask_queue_output.js";
+/**
+ * vibe_pm.get_decision - Fetch approval items in PM language
+ *
+ * Internal mapping:
+ *   → vibecoding-helper show-ask-queue <run_id>
+ *   → PM language transform
+ */
+export async function getDecision(input, 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);
+    // Prompt density mode (internal only; never expose to user)
+    const promptDensityMode = loadPromptDensity(getRunsDir(basePath), run_id)?.mode ?? "mode_0";
+    // If no existing run, return empty
+    if (is_new) {
+        return {
+            project_id,
+            decision_requests: [],
+            next_action: null
+        };
+    }
+    let items = [];
+    // Prefer reading Spec-High ask_queue_items.json directly (SSOT).
+    // This keeps get_decision deterministic and avoids parsing human text.
+    const fromSpecHigh = loadAskQueueItemsFromSpecHigh(run_id, basePath);
+    if (fromSpecHigh) {
+        items = fromSpecHigh;
+    }
+    else {
+        // Fallback: run show-ask-queue command (with caching)
+        const { code, stdout } = await runEngineWithCache("vibecoding-helper", ["show-ask-queue", run_id], { timeoutMs: 60_000 });
+        if (code === 0) {
+            // Parse response
+            const parsed = safeJsonParse(stdout);
+            if (parsed.ok) {
+                const validated = VibecodingHelperShowAskQueueOutputSchema.safeParse(parsed.value);
+                if (validated.success) {
+                    items = validated.data.items ?? validated.data.ask_queue ?? [];
+                }
+                else {
+                    items = [];
+                }
+            }
+            else {
+                // Try to parse as plain text format
+                items = parseTextAskQueue(stdout);
+            }
+        }
+    }
+    // Apply max_items limit
+    const maxItems = input.max_items ?? 2;
+    const limitedItems = items.slice(0, maxItems);
+    // Local Memory reference injection can be expensive and depends on installed engines.
+    // Only run it in the "real" MCP runtime path (default basePath = process.cwd()).
+    const shouldInjectLocalMemory = path.resolve(basePath) === path.resolve(process.cwd());
+    // Transform to PM language
+    const decisionRequests = await Promise.all(limitedItems.map(async (item, index) => {
+        const base = transformToDecisionRequest(item, index + 1, promptDensityMode);
+        if (!shouldInjectLocalMemory || promptDensityMode === "mode_2")
+            return base;
+        try {
+            const query = `${base.title}\n${base.context}`.trim();
+            const refs = await maybeGetLocalMemoryContextBlock({ query, maxItems: 3 });
+            if (refs) {
+                const sanitized = transformAskQueueText(refs);
+                const clipped = sanitized.length > 1200 ? `${sanitized.slice(0, 1200).trimEnd()}…` : sanitized;
+                return { ...base, context: `${base.context}\n\n[참고 문헌]\n${clipped}` };
+            }
+        }
+        catch {
+            // ignore
+        }
+        return base;
+    }));
+    // Determine next action
+    const hasDecisions = decisionRequests.length > 0;
+    return {
+        project_id,
+        decision_requests: decisionRequests,
+        next_action: hasDecisions
+            ? {
+                tool: "vibe_pm.submit_decision",
+                reason: `${decisionRequests.length}건의 결재가 필요합니다`
+            }
+            : null
+    };
+}
+function loadAskQueueItemsFromSpecHigh(runId, basePath) {
+    const resolved = resolveSpecHighRunDir(runId, basePath);
+    if (!resolved)
+        return null;
+    const filePath = path.join(resolved.run_dir, "ask_queue_items.json");
+    try {
+        if (!fs.existsSync(filePath))
+            return null;
+        const raw = fs.readFileSync(filePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const validated = SpecHighAskQueueItemsFileSchema.safeParse(parsed);
+        if (!validated.success)
+            return null;
+        const rawItems = validated.data.items ?? [];
+        if (rawItems.length === 0)
+            return [];
+        const out = [];
+        for (const it of rawItems) {
+            if (it.kind && it.kind !== "decision_ui")
+                continue;
+            const cardId = it.internal?.card_id?.trim();
+            const decisionId = (cardId && cardId.length > 0 ? cardId : it.id) ?? "";
+            const question = it.ui?.question ?? "결정이 필요합니다";
+            // Prefer Korean summary bullets if present; otherwise use why_this_question.
+            const bullets = it.ui?.summary_bullets?.filter(Boolean) ?? [];
+            const desc = bullets.length > 0
+                ? bullets[0]
+                : it.ui?.why_this_question ?? "";
+            const options = (it.ui?.options ?? []).map((o) => ({
+                key: o.key,
+                label: o.label,
+                description: o.next_action_hint,
+            }));
+            out.push({
+                id: decisionId,
+                question,
+                description: desc,
+                options,
+            });
+        }
+        return out;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Transform internal ask_queue item to user-facing DecisionRequest
+ */
+function transformToDecisionRequest(item, index, mode) {
+    const decisionId = item.id ?? item.card_id ?? `D-${String(index).padStart(3, "0")}`;
+    // Get title - transform technical terms
+    const rawTitle = item.title ?? item.question ?? "결정이 필요합니다";
+    const title = transformAskQueueText(rawTitle);
+    // Get context - transform technical terms
+    const rawContext = item.context ?? item.description ?? "";
+    // Transform choices
+    const rawOptions = item.options ?? item.choices ?? [];
+    const choices = transformChoices(rawOptions);
+    // Ensure there's always an "Unknown" option
+    if (!choices.some((c) => c.key === "U")) {
+        choices.push({
+            key: "U",
+            label: "잘 모르겠어요",
+            description: "더 자세한 설명이 필요합니다"
+        });
+    }
+    const context = shapeDecisionContext({
+        mode,
+        rawContext: transformAskQueueText(rawContext),
+        recommendedKey: pickRecommendedKey(choices),
+    });
+    return {
+        decision_id: decisionId,
+        title,
+        context,
+        choices
+    };
+}
+function pickRecommendedKey(choices) {
+    // v1: deterministic, avoid overconfidence. Prefer A if present, else B/C.
+    const keys = choices.map((c) => c.key);
+    if (keys.includes("A"))
+        return "A";
+    if (keys.includes("B"))
+        return "B";
+    return "C";
+}
+function shapeDecisionContext(args) {
+    const baseReason = args.rawContext?.trim();
+    if (args.mode === "mode_2") {
+        return "이미 정리가 잘 되어 있습니다. 충돌 여부만 확인하겠습니다.";
+    }
+    if (args.mode === "mode_1") {
+        const lines = [];
+        lines.push(`입력하신 조건 기준으로는 ${args.recommendedKey}가 가장 안정적입니다.`);
+        if (baseReason)
+            lines.push(`이유: ${baseReason}`);
+        return lines.join("\n");
+    }
+    // mode_0 (Sparse): recommendation + reasons + micro SWOT + sovereignty + U help
+    const lines = [];
+    lines.push(`Vibe PM 추천: ${args.recommendedKey}`);
+    lines.push("이유:");
+    if (baseReason) {
+        lines.push(`- ${baseReason}`);
+    }
+    else {
+        lines.push("- v1에서는 속도와 사고 방지가 둘 다 필요합니다.");
+        lines.push("- 지금은 되돌리기 쉬운 균형이 안정적입니다.");
+    }
+    lines.push("");
+    lines.push("[S] 빠르게 만들고, 실패 비용이 낮습니다.");
+    lines.push("[W] 나중에 구조 변경이 필요할 수 있습니다.");
+    lines.push("[O] 지금 바로 사용자 반응을 확인할 수 있습니다.");
+    lines.push("[T] 핵심이 커지면 다시 설계가 필요합니다.");
+    lines.push("");
+    lines.push("이 추천은 참고용입니다. 선택은 언제든 바꿀 수 있고, 바꾸려면 다시 물어봅니다.");
+    lines.push("아직 확신이 없다면 ‘모르겠다’를 선택해도 됩니다. 질문을 더 쉽게 바꿔서 다시 묻습니다.");
+    return lines.join("\n");
+}
+/**
+ * Transform raw options to user-facing choices
+ */
+function transformChoices(rawOptions) {
+    const validKeys = ["A", "B", "C", "U"];
+    return rawOptions.slice(0, 4).map((opt, index) => {
+        const key = validKeys[index] ?? "U";
+        const label = opt.label ? transformAskQueueText(opt.label) : `선택지 ${key}`;
+        const description = opt.description ? transformAskQueueText(opt.description) : undefined;
+        return {
+            key,
+            label,
+            description
+        };
+    });
+}
+/**
+ * Parse plain text ask_queue output (fallback)
+ */
+function parseTextAskQueue(text) {
+    const items = [];
+    // Simple pattern matching for text-based ask queue
+    // Format: "Q1: question text\n  A) option A\n  B) option B"
+    const questionPattern = /Q(\d+):\s*(.+?)(?=Q\d+:|$)/gs;
+    let match;
+    while ((match = questionPattern.exec(text)) !== null) {
+        const questionNum = match[1];
+        const questionBlock = match[2].trim();
+        const lines = questionBlock.split("\n");
+        const questionText = lines[0].trim();
+        const options = [];
+        for (let i = 1; i < lines.length; i++) {
+            const optMatch = lines[i].match(/^\s*([A-D])\)\s*(.+)/);
+            if (optMatch) {
+                options.push({
+                    key: optMatch[1],
+                    label: optMatch[2].trim()
+                });
+            }
+        }
+        items.push({
+            id: `D-${String(questionNum).padStart(3, "0")}`,
+            question: questionText,
+            options
+        });
+    }
+    // If no structured format, create single item from whole text
+    if (items.length === 0 && text.trim()) {
+        items.push({
+            id: "D-001",
+            question: text.trim().split("\n")[0],
+            options: [
+                { key: "A", label: "예" },
+                { key: "B", label: "아니오" }
+            ]
+        });
+    }
+    return items;
+}