@vibecodetown/mcp-server 2.1.0

package/build/tools/vibe_pm/intent/generator.js

@@ -0,0 +1,294 @@
+// adapters/mcp-ts/src/tools/vibe_pm/intent/generator.ts
+// Intent Document Generator
+// briefing 결과를 Intent 문서로 변환
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as crypto from "node:crypto";
+import * as yaml from "yaml";
+/**
+ * Generate an Intent document from briefing data
+ */
+export function generateIntentFromBriefing(data) {
+    const now = new Date().toISOString();
+    // Convert include/exclude to ScopeItems
+    const includeItems = (data.include || []).map((item) => ({
+        item,
+        reason: "MVP 범위에 포함"
+    }));
+    const excludeItems = (data.exclude || []).map((item) => ({
+        item,
+        reason: "MVP 이후 구현 예정"
+    }));
+    // Generate default constraints based on mode
+    const constraints = generateModeConstraints(data.mode);
+    // Generate risks from top_risk
+    const risks = data.topRisk
+        ? [
+            {
+                id: "R-001",
+                description: data.topRisk,
+                impact: "high",
+                mitigation: "범위 명확화 및 우선순위 조정"
+            }
+        ]
+        : [];
+    // Generate acceptance criteria from first milestone
+    const acceptance = [
+        {
+            id: "AC-001",
+            description: `${data.firstMilestone}이(가) 동작함`,
+            verifiable: true,
+            verification_method: "수동 테스트"
+        },
+        {
+            id: "AC-002",
+            description: "앱이 정상적으로 실행됨",
+            verifiable: true,
+            verification_method: "빌드 및 실행 확인"
+        }
+    ];
+    return {
+        version: "1.0",
+        created_at: now,
+        updated_at: now,
+        run_id: data.runId,
+        overview: {
+            project_name: data.projectName,
+            goal: data.goal,
+            target_user: data.targetUser,
+            mode: data.mode,
+            first_milestone: data.firstMilestone
+        },
+        scope: {
+            include: includeItems,
+            exclude: excludeItems,
+            do_not_touch: data.doNotTouch || []
+        },
+        constraints,
+        risks,
+        acceptance
+    };
+}
+/**
+ * Generate mode-specific constraints
+ */
+function generateModeConstraints(mode) {
+    switch (mode) {
+        case "mvp_fast":
+            return [
+                {
+                    type: "time",
+                    description: "빠른 출시가 최우선",
+                    priority: "must"
+                },
+                {
+                    type: "tech",
+                    description: "임시 코드 허용, 리팩토링은 나중에",
+                    priority: "should"
+                }
+            ];
+        case "balanced":
+            return [
+                {
+                    type: "time",
+                    description: "적정 시간 내 출시",
+                    priority: "must"
+                },
+                {
+                    type: "tech",
+                    description: "기본 품질 유지, 확장성 고려",
+                    priority: "should"
+                }
+            ];
+        case "quality_first":
+            return [
+                {
+                    type: "tech",
+                    description: "코드 품질 및 테스트 커버리지 우선",
+                    priority: "must"
+                },
+                {
+                    type: "tech",
+                    description: "확장 가능한 아키텍처",
+                    priority: "must"
+                }
+            ];
+    }
+}
+// ============================================================
+// Intent File Operations
+// ============================================================
+/**
+ * Save intent document to runs/<run_id>/intent/
+ */
+export async function saveIntent(runsDir, intent) {
+    const intentDir = path.join(runsDir, intent.run_id, "intent");
+    await fs.promises.mkdir(intentDir, { recursive: true });
+    // Save main intent document
+    const intentPath = path.join(intentDir, "intent.yaml");
+    const content = yaml.stringify(intent);
+    await fs.promises.writeFile(intentPath, content, "utf-8");
+    // Create/update index
+    await updateIntentIndex(intentDir, intent);
+    return intentPath;
+}
+/**
+ * Update intent index file
+ */
+async function updateIntentIndex(intentDir, intent) {
+    const indexPath = path.join(intentDir, "_index.yaml");
+    const intentPath = path.join(intentDir, "intent.yaml");
+    const checksum = crypto
+        .createHash("sha256")
+        .update(yaml.stringify(intent))
+        .digest("hex")
+        .slice(0, 16);
+    const index = {
+        version: "1.0",
+        run_id: intent.run_id,
+        created_at: intent.created_at,
+        documents: [
+            {
+                path: "intent.yaml",
+                type: "overview",
+                checksum,
+                last_modified: intent.updated_at
+            }
+        ],
+        status: "draft"
+    };
+    await fs.promises.writeFile(indexPath, yaml.stringify(index), "utf-8");
+}
+/**
+ * Load intent document from runs/<run_id>/intent/
+ */
+export async function loadIntent(runsDir, runId) {
+    const intentPath = path.join(runsDir, runId, "intent", "intent.yaml");
+    try {
+        const content = await fs.promises.readFile(intentPath, "utf-8");
+        return yaml.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Load intent index from runs/<run_id>/intent/
+ */
+export async function loadIntentIndex(runsDir, runId) {
+    const indexPath = path.join(runsDir, runId, "intent", "_index.yaml");
+    try {
+        const content = await fs.promises.readFile(indexPath, "utf-8");
+        return yaml.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Update intent status
+ */
+export async function updateIntentStatus(runsDir, runId, status) {
+    const index = await loadIntentIndex(runsDir, runId);
+    if (!index)
+        return;
+    index.status = status;
+    const indexPath = path.join(runsDir, runId, "intent", "_index.yaml");
+    await fs.promises.writeFile(indexPath, yaml.stringify(index), "utf-8");
+}
+// ============================================================
+// Intent Markdown Generation (for human readability)
+// ============================================================
+/**
+ * Generate markdown representation of intent
+ */
+export function intentToMarkdown(intent) {
+    const lines = [];
+    lines.push(`# ${intent.overview.project_name}`);
+    lines.push("");
+    lines.push(`> ${intent.overview.goal}`);
+    lines.push("");
+    // Overview
+    lines.push("## Overview");
+    lines.push("");
+    lines.push(`- **Target User**: ${intent.overview.target_user}`);
+    lines.push(`- **Mode**: ${intent.overview.mode}`);
+    lines.push(`- **First Milestone**: ${intent.overview.first_milestone}`);
+    lines.push("");
+    // Scope
+    lines.push("## Scope");
+    lines.push("");
+    lines.push("### Include");
+    for (const item of intent.scope.include) {
+        lines.push(`- ${item.item}${item.reason ? ` (${item.reason})` : ""}`);
+    }
+    lines.push("");
+    lines.push("### Exclude");
+    for (const item of intent.scope.exclude) {
+        lines.push(`- ${item.item}${item.reason ? ` (${item.reason})` : ""}`);
+    }
+    lines.push("");
+    if (intent.scope.do_not_touch.length > 0) {
+        lines.push("### Do Not Touch");
+        for (const item of intent.scope.do_not_touch) {
+            lines.push(`- ${item}`);
+        }
+        lines.push("");
+    }
+    // Constraints
+    if (intent.constraints.length > 0) {
+        lines.push("## Constraints");
+        lines.push("");
+        for (const c of intent.constraints) {
+            lines.push(`- **[${c.type}/${c.priority}]** ${c.description}`);
+        }
+        lines.push("");
+    }
+    // Risks
+    if (intent.risks.length > 0) {
+        lines.push("## Risks");
+        lines.push("");
+        for (const r of intent.risks) {
+            lines.push(`### ${r.id}: ${r.description}`);
+            lines.push(`- Impact: ${r.impact}`);
+            if (r.mitigation) {
+                lines.push(`- Mitigation: ${r.mitigation}`);
+            }
+            lines.push("");
+        }
+    }
+    // Acceptance Criteria
+    if (intent.acceptance.length > 0) {
+        lines.push("## Acceptance Criteria");
+        lines.push("");
+        for (const ac of intent.acceptance) {
+            const verifiable = ac.verifiable ? "✅" : "❓";
+            lines.push(`- **${ac.id}** ${verifiable} ${ac.description}`);
+            if (ac.verification_method) {
+                lines.push(`  - Verification: ${ac.verification_method}`);
+            }
+        }
+        lines.push("");
+    }
+    // Metadata
+    lines.push("---");
+    lines.push(`*Generated: ${intent.created_at}*`);
+    lines.push(`*Run ID: ${intent.run_id}*`);
+    return lines.join("\n");
+}
+/**
+ * Save intent as both YAML and Markdown
+ */
+export async function saveIntentWithMarkdown(runsDir, intent) {
+    const intentDir = path.join(runsDir, intent.run_id, "intent");
+    await fs.promises.mkdir(intentDir, { recursive: true });
+    // Save YAML
+    const yamlPath = path.join(intentDir, "intent.yaml");
+    await fs.promises.writeFile(yamlPath, yaml.stringify(intent), "utf-8");
+    // Save Markdown
+    const mdPath = path.join(intentDir, "intent.md");
+    await fs.promises.writeFile(mdPath, intentToMarkdown(intent), "utf-8");
+    // Update index
+    await updateIntentIndex(intentDir, intent);
+    return { yamlPath, mdPath };
+}

package/build/tools/vibe_pm/intent/index.js

@@ -0,0 +1,5 @@
+// adapters/mcp-ts/src/tools/vibe_pm/intent/index.ts
+// Intent Module Exports
+export { ScopeItemSchema, ConstraintSchema, RiskSchema, AcceptanceCriterionSchema, IntentDocumentSchema, IntentIndexSchema, isIntentDocument, isIntentIndex } from "./types.js";
+export { generateIntentFromBriefing, saveIntent, loadIntent, loadIntentIndex, updateIntentStatus, intentToMarkdown, saveIntentWithMarkdown } from "./generator.js";
+export { verifyAgainstIntent, toInspectionData, runIntentVerification, formatVerificationForPM } from "./verifier.js";

package/build/tools/vibe_pm/intent/prompt_density.js

@@ -0,0 +1,227 @@
+// adapters/mcp-ts/src/tools/vibe_pm/intent/prompt_density.ts
+// Prompt density evaluator (hybrid scoring) + run artifact persistence.
+//
+// Spec: docs/DEV_SPEC/PROMPT_DENSITY_ADAPTIVE_UX_V1/PROMPT_DENSITY_ADAPTIVE_UX_SPEC_v1.md
+import * as fs from "node:fs";
+import * as path from "node:path";
+const MODE_0_MAX = 39;
+const MODE_1_MAX = 69;
+const HYSTERESIS_DELTA = 5;
+const THRESHOLDS = {
+    mode0_to_mode1: MODE_0_MAX + 1 + HYSTERESIS_DELTA, // 45
+    mode1_to_mode0: MODE_0_MAX - HYSTERESIS_DELTA, // 34
+    mode1_to_mode2: MODE_1_MAX + 1 + HYSTERESIS_DELTA, // 75
+    mode2_to_mode1: MODE_1_MAX - HYSTERESIS_DELTA, // 64
+};
+const RE = {
+    goal: /(만들|구현|개발|작성|자동화|서비스|앱|웹|도구|게임|플러그인|확장|extension)/i,
+    scopeInclude: /(이번|우선|먼저|v1|mvp|초기|1차)/i,
+    scopeExclude: /(나중|추후|v2|2차|미루|제외|out\s*of\s*scope)/i,
+    scopeExplicit: /(in\s*scope|out\s*of\s*scope|include|exclude)/i,
+    constraints: /(금지|쓰지|사용하지|하면\s*안|절대|못\s*쓰|지양|must\s+not|do\s+not|forbid)/i,
+    done: /(완료|수용|통과|기준|AC\b|acceptance|dod\b|definition\s+of\s+done)/i,
+    stageAwareness: /(mvp|v1|prototype|프로토타입|실험|최소|초기|1차)/i,
+    verification: /(테스트|검증|확인|리뷰|점검|verify|test|ci\b|check)/i,
+    failure: /(실패|안\s*되|오류|에러|문제|막히|fail|error|exception)/i,
+    reversibility: /(바꿀|되돌|변경|나중에\s*수정|rollback|revert|switch)/i,
+    mushy: /(아무거나|상관없|대충|알아서|whatever|anything\s+is\s+fine)/i,
+    overscopeMarker: /(그리고|또|추가|뿐만\s+아니라|그리고\s+나서|그리고\s+또)/gi,
+};
+function countMatches(text, re) {
+    if (!re.global) {
+        return re.test(text) ? 1 : 0;
+    }
+    const m = text.match(re);
+    return m ? m.length : 0;
+}
+function clampScore(n) {
+    if (!Number.isFinite(n))
+        return 0;
+    return Math.max(0, Math.min(100, Math.floor(n)));
+}
+export function modeByScoreTotal(scoreTotal) {
+    const total = clampScore(scoreTotal);
+    if (total <= MODE_0_MAX)
+        return "mode_0";
+    if (total <= MODE_1_MAX)
+        return "mode_1";
+    return "mode_2";
+}
+/**
+ * Mode hysteresis to prevent boundary jitter around 39↔40 and 69↔70.
+ * - Applies only when previous mode exists.
+ * - Uses fixed ±5 stabilization window (SSOT).
+ */
+export function resolveModeWithHysteresis(previousMode, scoreTotal) {
+    const total = clampScore(scoreTotal);
+    switch (previousMode) {
+        case "mode_0":
+            return total >= THRESHOLDS.mode0_to_mode1 ? "mode_1" : "mode_0";
+        case "mode_1":
+            if (total <= THRESHOLDS.mode1_to_mode0)
+                return "mode_0";
+            if (total >= THRESHOLDS.mode1_to_mode2)
+                return "mode_2";
+            return "mode_1";
+        case "mode_2":
+            return total <= THRESHOLDS.mode2_to_mode1 ? "mode_1" : "mode_2";
+    }
+}
+export function computePromptDensity(projectBrief, runId) {
+    const text = String(projectBrief ?? "").trim();
+    const signals = [];
+    // ---------------------------
+    // A) Structure (0~40)
+    // ---------------------------
+    let structure = 0;
+    const hasGoal = text.length >= 8 && RE.goal.test(text);
+    if (hasGoal) {
+        structure += 10;
+        signals.push({ key: "has_goal", points: 10 });
+    }
+    const hasScopeSplit = RE.scopeExplicit.test(text) || (RE.scopeInclude.test(text) && RE.scopeExclude.test(text));
+    if (hasScopeSplit) {
+        structure += 10;
+        signals.push({ key: "has_scope_split", points: 10 });
+    }
+    const hasConstraints = RE.constraints.test(text);
+    if (hasConstraints) {
+        structure += 10;
+        signals.push({ key: "has_constraints", points: 10 });
+    }
+    const hasDoneDefinition = RE.done.test(text);
+    if (hasDoneDefinition) {
+        structure += 10;
+        signals.push({ key: "has_done_definition", points: 10 });
+    }
+    // ---------------------------
+    // B) Conflict (0~30)
+    // ---------------------------
+    let conflict = 0;
+    const notMushy = !RE.mushy.test(text);
+    if (notMushy) {
+        conflict += 10;
+        signals.push({ key: "no_self_contradiction", points: 10 });
+    }
+    const markerCount = countMatches(text, RE.overscopeMarker);
+    const notOverscoped = text.length <= 1200 && markerCount <= 6;
+    if (notOverscoped) {
+        conflict += 10;
+        signals.push({ key: "no_overscope", points: 10 });
+    }
+    const hasStageAwareness = RE.stageAwareness.test(text);
+    if (hasStageAwareness) {
+        conflict += 10;
+        signals.push({ key: "stage_awareness", points: 10 });
+    }
+    // ---------------------------
+    // C) Verification Awareness (0~30)
+    // ---------------------------
+    let verification = 0;
+    const mentionsVerification = RE.verification.test(text);
+    if (mentionsVerification) {
+        verification += 10;
+        signals.push({ key: "mentions_verification", points: 10 });
+    }
+    const mentionsFailure = RE.failure.test(text);
+    if (mentionsFailure) {
+        verification += 10;
+        signals.push({ key: "mentions_failure", points: 10 });
+    }
+    const mentionsReversibility = RE.reversibility.test(text);
+    if (mentionsReversibility) {
+        verification += 10;
+        signals.push({ key: "mentions_reversibility", points: 10 });
+    }
+    const total = clampScore(structure + conflict + verification);
+    const mode = modeByScoreTotal(total);
+    return {
+        version: "1.0",
+        computed_at: new Date().toISOString(),
+        run_id: runId,
+        score_total: total,
+        mode,
+        subscores: {
+            structure,
+            conflict,
+            verification,
+        },
+        signals_matched: signals,
+    };
+}
+export function applyPromptDensityHysteresis(args) {
+    if (!args.previous)
+        return args.current;
+    const baseMode = args.current.mode;
+    const stableMode = resolveModeWithHysteresis(args.previous.mode, args.current.score_total);
+    return {
+        ...args.current,
+        previous_mode: args.previous.mode,
+        mode_without_hysteresis: baseMode,
+        hysteresis_applied: stableMode !== baseMode,
+        mode: stableMode,
+    };
+}
+export function getPromptDensityPath(runsDir, runId) {
+    return path.join(runsDir, runId, "intent", "prompt_density.json");
+}
+export function savePromptDensity(runsDir, runId, result) {
+    const p = getPromptDensityPath(runsDir, runId);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify(result, null, 2), "utf-8");
+}
+export function loadPromptDensity(runsDir, runId) {
+    const p = getPromptDensityPath(runsDir, runId);
+    try {
+        if (!fs.existsSync(p))
+            return null;
+        const raw = fs.readFileSync(p, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object")
+            return null;
+        if (parsed.version !== "1.0")
+            return null;
+        if (!parsed.mode || (parsed.mode !== "mode_0" && parsed.mode !== "mode_1" && parsed.mode !== "mode_2")) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Best-effort: load the latest prompt density artifact for a given project_id.
+ * Used for hysteresis stabilization across repeated briefings.
+ */
+export function loadLatestPromptDensityForProject(runsDir, projectId) {
+    try {
+        if (!fs.existsSync(runsDir))
+            return null;
+        const prefix = `${projectId}_`;
+        const dirs = fs
+            .readdirSync(runsDir, { withFileTypes: true })
+            .filter((d) => d.isDirectory() && d.name.startsWith(prefix))
+            .map((d) => d.name);
+        const candidates = dirs
+            .map((runId) => {
+            try {
+                const stat = fs.statSync(path.join(runsDir, runId));
+                return { runId, mtime: stat.mtime.getTime() };
+            }
+            catch {
+                return { runId, mtime: 0 };
+            }
+        })
+            .sort((a, b) => b.mtime - a.mtime);
+        for (const c of candidates) {
+            const parsed = loadPromptDensity(runsDir, c.runId);
+            if (parsed)
+                return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}

package/build/tools/vibe_pm/intent/types.js

@@ -0,0 +1,70 @@
+// adapters/mcp-ts/src/tools/vibe_pm/intent/types.ts
+// Intent Document TypeScript Interfaces
+// Intent = AI가 이해하는 "프로젝트 의도" 문서 구조
+import { z } from "zod";
+// ============================================================
+// Zod Schemas for Validation
+// ============================================================
+export const ScopeItemSchema = z.object({
+    item: z.string(),
+    reason: z.string().optional()
+});
+export const ConstraintSchema = z.object({
+    type: z.enum(["tech", "time", "resource", "legal", "business"]),
+    description: z.string(),
+    priority: z.enum(["must", "should", "nice_to_have"])
+});
+export const RiskSchema = z.object({
+    id: z.string(),
+    description: z.string(),
+    impact: z.enum(["high", "medium", "low"]),
+    mitigation: z.string().optional()
+});
+export const AcceptanceCriterionSchema = z.object({
+    id: z.string(),
+    description: z.string(),
+    verifiable: z.boolean(),
+    verification_method: z.string().optional()
+});
+export const IntentDocumentSchema = z.object({
+    version: z.string(),
+    created_at: z.string(),
+    updated_at: z.string(),
+    run_id: z.string(),
+    overview: z.object({
+        project_name: z.string(),
+        goal: z.string(),
+        target_user: z.string(),
+        mode: z.enum(["mvp_fast", "balanced", "quality_first"]),
+        first_milestone: z.string()
+    }),
+    scope: z.object({
+        include: z.array(ScopeItemSchema),
+        exclude: z.array(ScopeItemSchema),
+        do_not_touch: z.array(z.string())
+    }),
+    constraints: z.array(ConstraintSchema),
+    risks: z.array(RiskSchema),
+    acceptance: z.array(AcceptanceCriterionSchema)
+});
+export const IntentIndexSchema = z.object({
+    version: z.string(),
+    run_id: z.string(),
+    created_at: z.string(),
+    documents: z.array(z.object({
+        path: z.string(),
+        type: z.enum(["overview", "scope", "constraints", "acceptance"]),
+        checksum: z.string(),
+        last_modified: z.string()
+    })),
+    status: z.enum(["draft", "approved", "implemented", "verified"])
+});
+// ============================================================
+// Type Guards
+// ============================================================
+export function isIntentDocument(obj) {
+    return IntentDocumentSchema.safeParse(obj).success;
+}
+export function isIntentIndex(obj) {
+    return IntentIndexSchema.safeParse(obj).success;
+}