@vibecodetown/mcp-server 1.3.1

package/build/mcp/tools/vibe_pm/create_work_order.js

@@ -0,0 +1,252 @@
+// MVP Core - vibe_pm.create_work_order
+// Issue work order for implementation (simplified MVP version)
+//
+// Engine Requirement Policy:
+// - spec-high 엔진 필수
+// - 엔진 없으면 GitHub 릴리즈에서 자동 다운로드 시도
+// - 다운로드 실패 시 명확한 에러 메시지 반환
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { parse as parseYaml } from "yaml";
+import { runEngine, invalidateEngineCache } from "../../engine.js";
+import { safeJsonParse } from "../../cli.js";
+import { resolveRunId, resolveProjectId, getRunContext, readRunState, invalidateStateCache } from "./context.js";
+import { generateWorkOrderText } from "./pm_language.js";
+import { ClinicBridgeFileSchema } from "../../generated/clinic_bridge_file.js";
+import { writeCurrentWorkOrderState, generateWorkOrderId } from "./state-store.js";
+import { emitEvent } from "../../events/emitter.js";
+/**
+ * vibe_pm.create_work_order - Issue work order for implementation (MVP)
+ *
+ * Internal mapping:
+ *   → spec-high ssot-generate <run_id>
+ *   → spec-high atomic-generate <run_id>
+ *   → spec-high clinic-bridge <run_id> --write --format yaml
+ *
+ * Engine requirement:
+ *   - spec-high engine is required
+ *   - Auto-downloads from GitHub releases if not installed
+ *   - Throws error if download fails (with installation instructions)
+ */
+export async function createWorkOrder(input) {
+    const basePath = process.cwd();
+    // Resolve run_id
+    const { run_id } = resolveRunId(input.project_id, basePath);
+    const project_id = resolveProjectId(run_id, basePath);
+    const context = getRunContext(run_id, basePath);
+    const runState = readRunState(run_id, basePath);
+    let intentWarning;
+    // Step 1: Generate SSOT
+    // runEngine() will auto-download engine from GitHub if not installed
+    try {
+        const ssotResult = await runEngine("spec-high", ["--root", "engines/spec_high", "ssot-generate", run_id], { timeoutMs: 120_000 });
+        if (ssotResult.code !== 0) {
+            throw new Error(`ssot-generate 실패: ${ssotResult.stderr}`);
+        }
+        // Phase 16: Direct emit hook for ssot-generate (replaces watcher dependency)
+        emitEvent({
+            runId: run_id,
+            type: "artifact.ssot_generated",
+            reason: "ssot_generate",
+            paths: [path.join(basePath, "engines", "spec_high", "runs", run_id, "ssot")],
+            component: "create_work_order",
+            actor: "engine",
+            workspaceRoot: basePath,
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`spec-high 엔진 실행 실패: ${msg}\n\n` +
+            `해결 방법:\n` +
+            `1. vibe_pm.doctor 도구 실행 (자동 설치 시도)\n` +
+            `2. 인터넷 연결 확인\n` +
+            `3. VIBECODE_DEBUG=1 환경변수로 상세 로그 확인`);
+    }
+    // Step 2: Generate atomic specs
+    try {
+        const atomicResult = await runEngine("spec-high", ["--root", "engines/spec_high", "atomic-generate", run_id], { timeoutMs: 120_000 });
+        if (atomicResult.code !== 0) {
+            throw new Error(`atomic-generate 실패: ${atomicResult.stderr}`);
+        }
+        emitEvent({
+            runId: run_id,
+            type: "artifact.spec_generated",
+            reason: "atomic_generate",
+            paths: [path.join(basePath, "engines", "spec_high", "runs", run_id, "atomic_specs.json")],
+            component: "create_work_order",
+            workspaceRoot: basePath,
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`atomic-generate 실패: ${msg}`);
+    }
+    // Step 3: Generate clinic bridge
+    let bridgeResult;
+    try {
+        bridgeResult = await runEngine("spec-high", ["--root", "engines/spec_high", "clinic-bridge", run_id, "--write", "--format", "yaml"], { timeoutMs: 120_000 });
+        if (bridgeResult.code !== 0) {
+            throw new Error(`clinic-bridge 실패: ${bridgeResult.stderr}`);
+        }
+        emitEvent({
+            runId: run_id,
+            type: "artifact.work_order_updated",
+            reason: "clinic_bridge_written",
+            paths: [path.join(basePath, "engines", "spec_high", "runs", run_id, "handoff", "clinic_bridge.yaml")],
+            component: "create_work_order",
+            workspaceRoot: basePath,
+        });
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`clinic-bridge 실패: ${msg}`);
+    }
+    // Step 4: Generate intent documents (optional, non-critical)
+    try {
+        const intentResult = await runEngine("spec-high", ["--root", "engines/spec_high", "intent-generate", run_id, "--write", "--force"], { timeoutMs: 60_000 });
+        if (intentResult.code !== 0) {
+            intentWarning = "의도 문서 생성 중 문제가 발생했습니다 (작업 지시서는 정상 생성됨)";
+        }
+        else {
+            // Phase 16: Direct emit hook for intent-generate (replaces watcher dependency)
+            emitEvent({
+                runId: run_id,
+                type: "artifact.intent_generated",
+                reason: "intent_generate",
+                paths: [path.join(basePath, "engines", "spec_high", "runs", run_id, "intent")],
+                component: "create_work_order",
+                actor: "engine",
+                workspaceRoot: basePath,
+            });
+        }
+    }
+    catch {
+        intentWarning = "의도 문서 생성을 건너뛰었습니다 (작업 지시서는 정상 생성됨)";
+    }
+    // Invalidate caches after state mutation
+    invalidateEngineCache(new RegExp(run_id));
+    invalidateStateCache(run_id, basePath);
+    // Get bridge path from response or use default
+    let bridgePath = `engines/spec_high/runs/${run_id}/handoff/clinic_bridge.yaml`;
+    const bridgeParsed = safeJsonParse(bridgeResult.stdout);
+    if (bridgeParsed.ok && bridgeParsed.value.bridge_path) {
+        bridgePath = bridgeParsed.value.bridge_path;
+    }
+    // Read and parse bridge file
+    const fullBridgePath = path.isAbsolute(bridgePath)
+        ? bridgePath
+        : path.join(basePath, bridgePath);
+    let bridgeData = {};
+    try {
+        if (fs.existsSync(fullBridgePath)) {
+            const content = fs.readFileSync(fullBridgePath, "utf-8");
+            bridgeData = fullBridgePath.endsWith(".json") ? JSON.parse(content) : parseYaml(content);
+            const validated = ClinicBridgeFileSchema.safeParse(bridgeData);
+            if (!validated.success) {
+                console.error("[create_work_order] Bridge file validation failed, using defaults");
+                bridgeData = {};
+            }
+            else {
+                bridgeData = validated.data;
+            }
+        }
+    }
+    catch (e) {
+        console.error(`[create_work_order] Failed to read bridge file: ${e}`);
+        bridgeData = {};
+    }
+    // Extract data from bridge
+    const projectName = project_id;
+    const mode = runState?.mode ?? "balanced";
+    const headline = "프로젝트 구현";
+    const dg = bridgeData?.decision_guard;
+    const legacyScope = bridgeData?.scope;
+    const scopeInclude = Array.isArray(dg?.allow_paths)
+        ? dg.allow_paths
+        : Array.isArray(legacyScope?.include)
+            ? legacyScope.include
+            : [];
+    const scopeExclude = Array.isArray(dg?.deny_paths)
+        ? dg.deny_paths
+        : Array.isArray(legacyScope?.exclude)
+            ? legacyScope.exclude
+            : [];
+    const doNotTouch = Array.isArray(dg?.read_only_paths)
+        ? dg.read_only_paths
+        : Array.isArray(bridgeData?.do_not_touch)
+            ? bridgeData.do_not_touch
+            : [];
+    const verifyCriteria = Array.isArray(bridgeData?.verification?.required)
+        ? bridgeData.verification.required
+            .map((c) => (typeof c?.cmd === "string" ? c.cmd.trim() : ""))
+            .filter(Boolean)
+        : Array.isArray(bridgeData?.verify_criteria)
+            ? bridgeData.verify_criteria.filter((s) => typeof s === "string" && s.trim())
+            : [];
+    // Add SSOT compliance verification criterion
+    verifyCriteria.push("변경 사항이 기존 SSOT 문서(docs/ssot/*.md)와 충돌하지 않는지 확인");
+    // Generate paste_to_agent text
+    let pasteToAgent = generateWorkOrderText({
+        projectName,
+        mode,
+        headline,
+        includes: scopeInclude,
+        excludes: scopeExclude,
+        doNotTouch,
+        verifyCriteria
+    });
+    if (input.additional_instructions && input.additional_instructions.trim()) {
+        pasteToAgent += `\n\n[추가 지시]\n- ${input.additional_instructions.trim()}\n`;
+    }
+    // Build work order
+    const workOrder = {
+        headline,
+        scope: {
+            include: scopeInclude,
+            exclude: scopeExclude
+        },
+        do_not_touch: doNotTouch,
+        verify_criteria: verifyCriteria,
+        paste_to_agent: pasteToAgent
+    };
+    // PR-H3: Persist repo-local SSOT work order file with work_order_id
+    // Path: .vibe/state/current_work_order.json
+    try {
+        const workOrderId = generateWorkOrderId(run_id);
+        await writeCurrentWorkOrderState(basePath, {
+            version: "v1",
+            work_order_id: workOrderId,
+            run_id,
+            created_at: new Date().toISOString(),
+            topic: headline,
+            scope: { include: scopeInclude, exclude: scopeExclude },
+            do_not_touch: doNotTouch,
+            verify_criteria: verifyCriteria,
+        });
+    }
+    catch (e) {
+        // FAIL-SAFE: do not block the tool if persistence fails
+        console.error("[state] failed to write current_work_order.json:", e);
+    }
+    return {
+        project_id,
+        run_id,
+        work_order: workOrder,
+        paths: {
+            bridge_path: bridgePath,
+            intent_dir: `engines/spec_high/runs/${run_id}/intent`
+        },
+        // MVP: Dummy modules (full implementation uses SSOT versioning)
+        modules: {
+            research: { version: "v1", fingerprint: "mvp", path: "docs/ssot/modules/research" },
+            skills: { version: "v1", fingerprint: "mvp", path: "docs/ssot/modules/skills" },
+            planning: { version: "v1", fingerprint: "mvp", path: "docs/ssot/modules/planning" }
+        },
+        next_action: {
+            tool: "vibe_pm.inspect_code",
+            reason: "구현 후 검수를 요청하세요",
+            when: "after_implementation"
+        },
+        ...(intentWarning ? { warnings: [intentWarning] } : {})
+    };
+}

package/build/mcp/tools/vibe_pm/dashboard.d.ts

@@ -0,0 +1,64 @@
+/**
+ * vibe_pm.dashboard - Worker Dashboard Data
+ *
+ * Part of Phase 19: Manager-Pool Integration
+ * Provides dashboard data for worker monitoring and visualization.
+ */
+import { z } from 'zod';
+import type { DashboardData } from '../../../workers/base/dashboard.js';
+export declare const dashboardInputSchema: z.ZodObject<{
+    /** Project/run ID (optional, auto-generated if omitted) */
+    project_id: z.ZodOptional<z.ZodString>;
+    /** Output format */
+    format: z.ZodDefault<z.ZodEnum<["json", "html", "summary"]>>;
+    /** Include worker details */
+    include_workers: z.ZodDefault<z.ZodBoolean>;
+    /** Include recent tasks */
+    include_tasks: z.ZodDefault<z.ZodBoolean>;
+    /** Include time series data */
+    include_timeseries: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    format: "json" | "html" | "summary";
+    include_workers: boolean;
+    include_tasks: boolean;
+    include_timeseries: boolean;
+    project_id?: string | undefined;
+}, {
+    format?: "json" | "html" | "summary" | undefined;
+    project_id?: string | undefined;
+    include_workers?: boolean | undefined;
+    include_tasks?: boolean | undefined;
+    include_timeseries?: boolean | undefined;
+}>;
+export type DashboardInput = z.infer<typeof dashboardInputSchema>;
+export interface DashboardResult {
+    success: boolean;
+    message: string;
+    /** Full dashboard data (when format is 'json') */
+    data?: DashboardData;
+    /** HTML dashboard (when format is 'html') */
+    html?: string;
+    /** Text summary (when format is 'summary') */
+    summary?: string;
+    /** Pool statistics per worker type */
+    pool_stats?: Record<string, {
+        totalWorkers: number;
+        activeWorkers: number;
+        idleWorkers: number;
+        pendingTasks: number;
+    }>;
+    /** Autoscaling status per worker type */
+    autoscale_status?: Record<string, {
+        enabled: boolean;
+        recentDecisions: number;
+    }>;
+    error?: string;
+}
+/**
+ * Get worker dashboard data
+ *
+ * @param input - Dashboard query parameters
+ * @param basePath - Base path for project (default: cwd)
+ * @returns Dashboard data in requested format
+ */
+export declare function dashboard(input: DashboardInput, basePath?: string): Promise<DashboardResult>;

package/build/mcp/tools/vibe_pm/dashboard.js

@@ -0,0 +1,175 @@
+/**
+ * vibe_pm.dashboard - Worker Dashboard Data
+ *
+ * Part of Phase 19: Manager-Pool Integration
+ * Provides dashboard data for worker monitoring and visualization.
+ */
+import { z } from 'zod';
+import { getWorkerManager } from '../../../workers/index.js';
+// ============================================================================
+// Input Schema
+// ============================================================================
+export const dashboardInputSchema = z.object({
+    /** Project/run ID (optional, auto-generated if omitted) */
+    project_id: z.string().optional(),
+    /** Output format */
+    format: z.enum(['json', 'html', 'summary']).default('summary'),
+    /** Include worker details */
+    include_workers: z.boolean().default(true),
+    /** Include recent tasks */
+    include_tasks: z.boolean().default(true),
+    /** Include time series data */
+    include_timeseries: z.boolean().default(false),
+});
+// ============================================================================
+// Handler
+// ============================================================================
+/**
+ * Get worker dashboard data
+ *
+ * @param input - Dashboard query parameters
+ * @param basePath - Base path for project (default: cwd)
+ * @returns Dashboard data in requested format
+ */
+export async function dashboard(input, basePath = process.cwd()) {
+    try {
+        const manager = getWorkerManager();
+        const dash = manager.getDashboard(input.project_id);
+        const dashData = dash.collect();
+        // Build pool stats
+        const poolStats = {};
+        const stats = manager.getPoolStats(input.project_id);
+        for (const [type, stat] of stats) {
+            poolStats[type] = {
+                totalWorkers: stat.totalWorkers,
+                activeWorkers: stat.activeWorkers,
+                idleWorkers: stat.idleWorkers,
+                pendingTasks: stat.pendingTasks,
+            };
+        }
+        // Build autoscale status
+        const autoscaleStatus = {};
+        const workerTypes = ['fs', 'build', 'browser', 'model', 'search'];
+        for (const type of workerTypes) {
+            const enabled = manager.isAutoscalingEnabled(type, input.project_id);
+            const history = manager.getAutoscaleHistory(type, input.project_id);
+            autoscaleStatus[type] = {
+                enabled,
+                recentDecisions: history.length,
+            };
+        }
+        // Filter data based on include options
+        const filteredData = {
+            ...dashData,
+            workers: input.include_workers ? dashData.workers : [],
+            recentTasks: input.include_tasks ? dashData.recentTasks : [],
+            timeSeries: input.include_timeseries ? dashData.timeSeries : {
+                throughput: [],
+                utilization: [],
+                queueDepth: [],
+            },
+        };
+        // Build result based on format
+        const result = {
+            success: true,
+            message: buildSummaryMessage(dashData),
+            pool_stats: poolStats,
+            autoscale_status: autoscaleStatus,
+        };
+        switch (input.format) {
+            case 'json':
+                result.data = filteredData;
+                break;
+            case 'html':
+                result.html = dash.toHTML();
+                break;
+            case 'summary':
+            default:
+                result.summary = buildDetailedSummary(dashData, poolStats, autoscaleStatus);
+                break;
+        }
+        return result;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            success: false,
+            message: '대시보드 조회에 실패했습니다.',
+            error: errorMessage,
+        };
+    }
+}
+/**
+ * Build summary message
+ */
+function buildSummaryMessage(data) {
+    const { summary } = data;
+    const successPercent = Math.round(summary.successRate * 100);
+    return `Workers: ${summary.activeWorkers} active, ${summary.totalWorkers - summary.activeWorkers} idle | ` +
+        `Tasks: ${summary.completedTasks} completed, ${summary.failedTasks} failed | ` +
+        `Success: ${successPercent}%`;
+}
+/**
+ * Build detailed summary text
+ */
+function buildDetailedSummary(data, poolStats, autoscaleStatus) {
+    const lines = [];
+    const { summary } = data;
+    lines.push('=== Worker Dashboard ===');
+    lines.push('');
+    // Summary stats
+    lines.push('[Summary]');
+    lines.push(`  Workers: ${summary.totalWorkers} total (${summary.activeWorkers} active)`);
+    lines.push(`  Tasks: ${summary.totalTasks} total`);
+    lines.push(`    - Completed: ${summary.completedTasks}`);
+    lines.push(`    - Failed: ${summary.failedTasks}`);
+    lines.push(`  Success Rate: ${Math.round(summary.successRate * 100)}%`);
+    if (summary.avgProcessingTime > 0) {
+        lines.push(`  Avg Processing: ${summary.avgProcessingTime}ms`);
+    }
+    lines.push('');
+    // Pool stats
+    const poolEntries = Object.entries(poolStats);
+    if (poolEntries.length > 0) {
+        lines.push('[Worker Pools]');
+        for (const [type, stat] of poolEntries) {
+            lines.push(`  ${type}: ${stat.totalWorkers} workers (${stat.activeWorkers} active, ${stat.idleWorkers} idle)`);
+            if (stat.pendingTasks > 0) {
+                lines.push(`    Pending tasks: ${stat.pendingTasks}`);
+            }
+        }
+        lines.push('');
+    }
+    // Autoscaling status
+    const enabledAutoscalers = Object.entries(autoscaleStatus).filter(([, s]) => s.enabled);
+    if (enabledAutoscalers.length > 0) {
+        lines.push('[Autoscaling]');
+        for (const [type, status] of enabledAutoscalers) {
+            lines.push(`  ${type}: enabled (${status.recentDecisions} recent decisions)`);
+        }
+        lines.push('');
+    }
+    // Recent workers
+    if (data.workers.length > 0) {
+        lines.push('[Active Workers]');
+        for (const worker of data.workers.slice(0, 5)) {
+            lines.push(`  ${worker.id}: ${worker.status} (${worker.tasksProcessed} tasks)`);
+        }
+        if (data.workers.length > 5) {
+            lines.push(`  ... and ${data.workers.length - 5} more`);
+        }
+        lines.push('');
+    }
+    // Recent tasks
+    if (data.recentTasks.length > 0) {
+        lines.push('[Recent Tasks]');
+        for (const task of data.recentTasks.slice(0, 5)) {
+            const status = task.status === 'success' ? '✓' : '✗';
+            lines.push(`  ${status} ${task.taskId} (${task.workerType}, ${task.processingTime}ms)`);
+        }
+        if (data.recentTasks.length > 5) {
+            lines.push(`  ... and ${data.recentTasks.length - 5} more`);
+        }
+    }
+    return lines.join('\n');
+}

package/build/mcp/tools/vibe_pm/decision-log.d.ts

@@ -0,0 +1,24 @@
+import type { DecisionLogEvent } from "./state-schema.js";
+/**
+ * Append an event to decision_log.v1.jsonl
+ * FAIL-SAFE: Throws on failure, caller should catch
+ */
+export declare function appendDecisionLogEvent(params: {
+    workspaceRoot: string;
+    event: DecisionLogEvent;
+}): Promise<void>;
+/**
+ * Read current work_order_id from state file
+ * Returns null if file doesn't exist or is invalid
+ */
+export declare function readCurrentWorkOrderId(params: {
+    workspaceRoot: string;
+}): Promise<string | null>;
+/**
+ * Read current decision_id from state file
+ * Returns null if file doesn't exist or is invalid
+ */
+export declare function readCurrentDecisionId(params: {
+    workspaceRoot: string;
+}): Promise<string | null>;
+export type { DecisionLogEvent, InspectVerdictEvent, SubmitDecisionEvent, } from "./state-schema.js";

package/build/mcp/tools/vibe_pm/decision-log.js

@@ -0,0 +1,38 @@
+// PR-H: Decision Log unified append utility (SSOT)
+// 통합 decision_log.v1.jsonl append 함수 - 실패해도 워크플로우를 막지 않음
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { readCurrentWorkOrderState, readCurrentDecisionState, } from "./state-store.js";
+const DECISION_LOG_FILENAME = "decision_log.v1.jsonl";
+// ============================================================
+// Main API
+// ============================================================
+/**
+ * Append an event to decision_log.v1.jsonl
+ * FAIL-SAFE: Throws on failure, caller should catch
+ */
+export async function appendDecisionLogEvent(params) {
+    const logPath = path.join(params.workspaceRoot, ".vibe", DECISION_LOG_FILENAME);
+    await fs.mkdir(path.dirname(logPath), { recursive: true });
+    const line = JSON.stringify(params.event);
+    await fs.appendFile(logPath, line + "\n", "utf8");
+}
+// ============================================================
+// Convenience Readers
+// ============================================================
+/**
+ * Read current work_order_id from state file
+ * Returns null if file doesn't exist or is invalid
+ */
+export async function readCurrentWorkOrderId(params) {
+    const state = await readCurrentWorkOrderState(params.workspaceRoot);
+    return state?.work_order_id ?? null;
+}
+/**
+ * Read current decision_id from state file
+ * Returns null if file doesn't exist or is invalid
+ */
+export async function readCurrentDecisionId(params) {
+    const state = await readCurrentDecisionState(params.workspaceRoot);
+    return state?.decision_id ?? null;
+}

package/build/mcp/tools/vibe_pm/diagrams/animator.d.ts

@@ -0,0 +1,27 @@
+import { COLOR_MAPPINGS } from "./constants.js";
+export { COLOR_MAPPINGS };
+export interface AnimatorOptions {
+    includeKeyframes?: boolean;
+    includeHoverEffects?: boolean;
+}
+export declare function injectAnimationStyles(svgContent: string, options?: AnimatorOptions): string;
+export interface AnimateResult {
+    success: boolean;
+    inputPath: string;
+    outputPath: string;
+    error: string | null;
+}
+export declare function animateSvgFile(svgPath: string, outputPath?: string, options?: AnimatorOptions): Promise<AnimateResult>;
+export declare function injectNodeIds(svgContent: string, nodeIdMap: Map<string, string>): string;
+export interface TooltipData {
+    nodeId: string;
+    where?: string;
+    why?: string;
+    next?: string;
+}
+export declare function injectTooltips(svgContent: string, tooltips: TooltipData[]): string;
+export interface AnimationPipelineOptions extends AnimatorOptions {
+    nodeIdMap?: Map<string, string>;
+    tooltips?: TooltipData[];
+}
+export declare function animateSvg(svgContent: string, options?: AnimationPipelineOptions): string;