@vibecodetown/mcp-server 1.3.1

package/build/mcp/tools/vibe_pm/dirty-scan.js

@@ -0,0 +1,242 @@
+// MVP Core - Dirty Scan
+// S0/S1/S2 level delta scanning for change detection
+//
+// 설계 원칙:
+// - S0: 최소 인덱스 (빠름, 안전) - 파일 수 + 최상위 mtime + lockfile 해시
+// - S1: 표준 (기본) - S0 + src/docs/package.json mtime
+// - S2: 확장 (느림) - S1 + repo_map 해시 비교
+import * as fs from "node:fs";
+import * as fsPromises from "node:fs/promises";
+import * as path from "node:path";
+import * as crypto from "node:crypto";
+// ============================================================
+// Main Scan Function
+// ============================================================
+/**
+ * Run delta scan to detect changes
+ *
+ * @param basePath Workspace root path
+ * @param level Scan level (S0=fast, S1=standard, S2=extended)
+ * @param previousSnapshot Optional previous snapshot to compare against
+ */
+export async function runDeltaScan(basePath, level = "S1", previousSnapshot) {
+    const startTime = Date.now();
+    const reasons = [];
+    let isDirty = false;
+    // Get current snapshot
+    const currentSnapshot = await createSnapshot(basePath, level);
+    // Compare with previous snapshot
+    if (previousSnapshot) {
+        // Check file count
+        if (currentSnapshot.file_count !== previousSnapshot.file_count) {
+            isDirty = true;
+            reasons.push({
+                code: "file_count_changed",
+                detail: `파일 수: ${previousSnapshot.file_count} → ${currentSnapshot.file_count}`,
+            });
+        }
+        // Check lockfile hash
+        if (currentSnapshot.lockfile_hash !== previousSnapshot.lockfile_hash) {
+            isDirty = true;
+            reasons.push({
+                code: "lockfile_changed",
+                detail: "Lockfile이 변경되었습니다",
+            });
+        }
+        // Check root mtime (for S0+)
+        if (currentSnapshot.root_mtime !== previousSnapshot.root_mtime) {
+            isDirty = true;
+            reasons.push({
+                code: "mtime_changed",
+                detail: "루트 디렉토리 mtime 변경",
+            });
+        }
+        // Check src mtime (for S1+)
+        if (level !== "S0" && currentSnapshot.src_mtime !== previousSnapshot.src_mtime) {
+            isDirty = true;
+            reasons.push({
+                code: "mtime_changed",
+                detail: "src 디렉토리 mtime 변경",
+            });
+        }
+        // Check package.json mtime (for S1+)
+        if (level !== "S0" && currentSnapshot.package_json_mtime !== previousSnapshot.package_json_mtime) {
+            isDirty = true;
+            reasons.push({
+                code: "config_changed",
+                detail: "package.json 변경",
+            });
+        }
+        // Check docs mtime (for S2)
+        if (level === "S2" && currentSnapshot.docs_mtime !== previousSnapshot.docs_mtime) {
+            isDirty = true;
+            reasons.push({
+                code: "mtime_changed",
+                detail: "docs 디렉토리 mtime 변경",
+            });
+        }
+    }
+    // Determine confidence based on scan level
+    const confidence = level === "S0" ? "low" : level === "S1" ? "medium" : "high";
+    return {
+        is_dirty: isDirty,
+        confidence,
+        reasons,
+        scan_level: level,
+        scanned_at: new Date().toISOString(),
+        duration_ms: Date.now() - startTime,
+        stats: {
+            file_count: currentSnapshot.file_count,
+            dir_count: currentSnapshot.dir_count,
+            lockfile_hash: currentSnapshot.lockfile_hash,
+            src_mtime: currentSnapshot.src_mtime,
+            package_json_mtime: currentSnapshot.package_json_mtime,
+        },
+    };
+}
+// ============================================================
+// Snapshot Functions
+// ============================================================
+/**
+ * Create a snapshot of the current state
+ */
+export async function createSnapshot(basePath, level = "S1") {
+    const snapshot = {
+        format_version: "scan.snapshot.v1",
+        created_at: new Date().toISOString(),
+        scan_level: level,
+        file_count: 0,
+        dir_count: 0,
+        root_mtime: 0,
+    };
+    try {
+        // Get root stats
+        const rootStats = await fsPromises.stat(basePath);
+        snapshot.root_mtime = rootStats.mtimeMs;
+        // Count files and directories
+        const entries = await fsPromises.readdir(basePath, { withFileTypes: true });
+        snapshot.file_count = entries.filter(e => e.isFile()).length;
+        snapshot.dir_count = entries.filter(e => e.isDirectory()).length;
+        // Get lockfile hash
+        snapshot.lockfile_hash = await getLockfileHash(basePath);
+        // S1+ checks
+        if (level !== "S0") {
+            // Check src directory
+            const srcPath = path.join(basePath, "src");
+            if (fs.existsSync(srcPath)) {
+                const srcStats = await fsPromises.stat(srcPath);
+                snapshot.src_mtime = srcStats.mtimeMs;
+            }
+            // Check package.json
+            const pkgPath = path.join(basePath, "package.json");
+            if (fs.existsSync(pkgPath)) {
+                const pkgStats = await fsPromises.stat(pkgPath);
+                snapshot.package_json_mtime = pkgStats.mtimeMs;
+            }
+        }
+        // S2 checks
+        if (level === "S2") {
+            // Check docs directory
+            const docsPath = path.join(basePath, "docs");
+            if (fs.existsSync(docsPath)) {
+                const docsStats = await fsPromises.stat(docsPath);
+                snapshot.docs_mtime = docsStats.mtimeMs;
+            }
+        }
+    }
+    catch {
+        // Continue with partial snapshot
+    }
+    return snapshot;
+}
+/**
+ * Save snapshot to file
+ */
+export async function saveSnapshot(basePath, snapshot) {
+    const snapshotDir = path.join(basePath, ".vibe", "observer");
+    await fsPromises.mkdir(snapshotDir, { recursive: true });
+    // NOTE:
+    // - saveSnapshot()가 최초 실행될 때 .vibe/observer 디렉토리 생성으로 basePath mtime이 변할 수 있다.
+    // - snapshot의 root_mtime을 "저장 시점" 기준으로 보정해 quickDirtyCheck가 즉시 dirty로 오판하지 않게 한다.
+    try {
+        const rootStats = await fsPromises.stat(basePath);
+        snapshot.root_mtime = rootStats.mtimeMs;
+    }
+    catch {
+        // ignore
+    }
+    const snapshotPath = path.join(snapshotDir, "last_snapshot.json");
+    await fsPromises.writeFile(snapshotPath, JSON.stringify(snapshot, null, 2) + "\n", "utf-8");
+    return snapshotPath;
+}
+/**
+ * Load snapshot from file
+ */
+export async function loadSnapshot(basePath) {
+    const snapshotPath = path.join(basePath, ".vibe", "observer", "last_snapshot.json");
+    try {
+        if (fs.existsSync(snapshotPath)) {
+            const content = await fsPromises.readFile(snapshotPath, "utf-8");
+            return JSON.parse(content);
+        }
+    }
+    catch {
+        // Return null if snapshot doesn't exist or is invalid
+    }
+    return null;
+}
+// ============================================================
+// Helper Functions
+// ============================================================
+/**
+ * Get hash of lockfile(s)
+ */
+async function getLockfileHash(basePath) {
+    const lockfiles = [
+        "package-lock.json",
+        "yarn.lock",
+        "pnpm-lock.yaml",
+        "bun.lockb",
+    ];
+    for (const lockfile of lockfiles) {
+        const lockPath = path.join(basePath, lockfile);
+        if (fs.existsSync(lockPath)) {
+            try {
+                const content = await fsPromises.readFile(lockPath);
+                const hash = crypto.createHash("sha256");
+                hash.update(content);
+                return hash.digest("hex").slice(0, 16);
+            }
+            catch {
+                // Continue to next lockfile
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Get quick dirty check without full scan
+ * Useful for fast polling
+ */
+export async function quickDirtyCheck(basePath) {
+    const previousSnapshot = await loadSnapshot(basePath);
+    if (!previousSnapshot) {
+        return true; // No previous snapshot = assume dirty
+    }
+    try {
+        // Quick check: root mtime and file count only
+        const rootStats = await fsPromises.stat(basePath);
+        if (rootStats.mtimeMs !== previousSnapshot.root_mtime) {
+            return true;
+        }
+        const entries = await fsPromises.readdir(basePath, { withFileTypes: true });
+        const fileCount = entries.filter(e => e.isFile()).length;
+        if (fileCount !== previousSnapshot.file_count) {
+            return true;
+        }
+        return false;
+    }
+    catch {
+        return true; // Error = assume dirty
+    }
+}

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

@@ -0,0 +1,17 @@
+export interface DocsStructureResult {
+    ok: boolean;
+    created: boolean;
+    docsRoot: string;
+    structure: {
+        active: boolean;
+        reference: boolean;
+        archived: boolean;
+        index: boolean;
+        claude: boolean;
+    };
+    createdPaths?: string[];
+}
+export declare function getDocsDir(workspaceRoot: string): string;
+export declare function checkDocsStructure(workspaceRoot: string): DocsStructureResult;
+export declare function createDocsStructure(workspaceRoot: string): DocsStructureResult;
+export declare function ensureDocsStructure(workspaceRoot: string): DocsStructureResult;

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

@@ -0,0 +1,148 @@
+// Docs structure guard + auto-init
+//
+// 모든 vibe_pm 도구 시작 시 호출되어:
+// 1. docs/ 구조가 있는지 확인
+// 2. 없으면 자동 생성 (rewind)
+import * as fs from "node:fs";
+import * as path from "node:path";
+const DOCS_FOLDERS = [
+    "active",
+    "reference",
+    "reference/ssot",
+    "reference/product-spec",
+    "reference/contracts",
+    "archived",
+    "archived/legacy",
+    "archived/topics",
+];
+function getIndexTemplate() {
+    const date = new Date().toISOString().split("T")[0];
+    return `# Docs Index
+
+> 생성일: ${date}
+> 구조: active / reference / archived
+
+---
+
+## Active (현재 작업)
+
+| 폴더 | 설명 | 상태 |
+|------|------|:----:|
+| (없음) | - | - |
+
+---
+
+## Reference (영구 참조)
+
+### SSOT (운영 규약)
+| 파일 | 용도 |
+|------|------|
+| (없음) | - |
+
+### Product Spec (제품 정의)
+| 파일 | 용도 |
+|------|------|
+| (없음) | - |
+
+### Contracts (계약/인터페이스)
+| 파일 | 용도 |
+|------|------|
+| (없음) | - |
+
+---
+
+## Archived (완료/폐기)
+
+| 폴더 | 설명 |
+|------|------|
+| [legacy/](archived/legacy/) | 오래된 문서 |
+| [topics/](archived/topics/) | 비활성 주제 |
+`;
+}
+const CLAUDE_TEMPLATE = `# Docs — AI 에이전트 운영 규칙
+
+## 폴더 구조 (SSOT)
+
+\`\`\`
+docs/
+├── active/              # 현재 진행 중인 작업
+├── reference/           # 영구 참조 SSOT
+│   ├── ssot/           # 운영 규약
+│   ├── product-spec/   # 제품 정의
+│   └── contracts/      # 계약/인터페이스
+├── archived/            # 완료/폐기된 문서
+│   ├── legacy/         # 오래된 문서
+│   └── topics/         # 비활성 주제
+└── INDEX.md            # 전체 인덱스
+\`\`\`
+
+## 핵심 규칙
+
+### 새 문서 작성 시
+- 진행 중인 작업 → \`active/<topic>/\`
+- SSOT/정책 → \`reference/<category>/\`
+- 완료된 작업 → \`archived/<period>/\`
+
+### 작업 완료 시
+\`\`\`bash
+mv active/<topic> archived/YYYY-MM/<topic>
+\`\`\`
+
+### 금지 사항
+- ❌ 날짜 폴더 직접 생성 (예: docs/0203/)
+- ❌ 루트에 임시 문서 생성
+- ❌ archived/ 문서 수정
+`;
+export function getDocsDir(workspaceRoot) {
+    return path.join(workspaceRoot, "docs");
+}
+export function checkDocsStructure(workspaceRoot) {
+    const docsRoot = getDocsDir(workspaceRoot);
+    const structure = {
+        active: fs.existsSync(path.join(docsRoot, "active")),
+        reference: fs.existsSync(path.join(docsRoot, "reference")),
+        archived: fs.existsSync(path.join(docsRoot, "archived")),
+        index: fs.existsSync(path.join(docsRoot, "INDEX.md")),
+        claude: fs.existsSync(path.join(docsRoot, "CLAUDE.md")),
+    };
+    const ok = structure.active && structure.reference && structure.archived;
+    return { ok, created: false, docsRoot, structure };
+}
+export function createDocsStructure(workspaceRoot) {
+    const docsRoot = getDocsDir(workspaceRoot);
+    const createdPaths = [];
+    for (const folder of DOCS_FOLDERS) {
+        const folderPath = path.join(docsRoot, folder);
+        if (!fs.existsSync(folderPath)) {
+            fs.mkdirSync(folderPath, { recursive: true });
+            createdPaths.push(folder);
+            const gitkeep = path.join(folderPath, ".gitkeep");
+            if (!fs.existsSync(gitkeep)) {
+                fs.writeFileSync(gitkeep, "");
+            }
+        }
+    }
+    const indexPath = path.join(docsRoot, "INDEX.md");
+    if (!fs.existsSync(indexPath)) {
+        fs.writeFileSync(indexPath, getIndexTemplate());
+        createdPaths.push("INDEX.md");
+    }
+    const claudePath = path.join(docsRoot, "CLAUDE.md");
+    if (!fs.existsSync(claudePath)) {
+        fs.writeFileSync(claudePath, CLAUDE_TEMPLATE);
+        createdPaths.push("CLAUDE.md");
+    }
+    return {
+        ok: true,
+        created: createdPaths.length > 0,
+        docsRoot,
+        structure: { active: true, reference: true, archived: true, index: true, claude: true },
+        createdPaths,
+    };
+}
+export function ensureDocsStructure(workspaceRoot) {
+    const check = checkDocsStructure(workspaceRoot);
+    if (check.ok)
+        return check;
+    return createDocsStructure(workspaceRoot);
+}

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

@@ -0,0 +1,65 @@
+import { z } from "zod";
+export declare const DoctorInputSchema: z.ZodObject<{
+    auto_fix: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    auto_fix: boolean;
+}, {
+    auto_fix?: boolean | undefined;
+}>;
+export type DoctorInput = z.infer<typeof DoctorInputSchema>;
+export interface EngineStatus {
+    name: string;
+    status: "정상" | "업데이트 필요" | "설치 필요" | "손상됨";
+    version: string;
+    currentVersion: string | null;
+}
+export interface PythonCliStatus {
+    status: "정상" | "오류";
+    message: string;
+    pythonpath_detected: string | null;
+}
+export interface HelperStatus {
+    status: "정상" | "비활성" | "설치 필요" | "오류";
+    mode: string;
+    source?: string;
+    path?: string;
+    message: string;
+}
+export interface ObserverStatus {
+    status: "활성" | "비활성";
+    mode: "off" | "soft" | "watch";
+    hooks_enabled: boolean;
+    env_flags: {
+        VIBE_OBSERVER: string | undefined;
+        VIBE_OBSERVER_WATCH: string | undefined;
+        VIBE_AUTONOMY: string | undefined;
+    };
+    message: string;
+}
+export interface DoctorOutput {
+    status: "OK" | "FIXED" | "NEEDS_ATTENTION" | "ERROR";
+    summary: string;
+    contracts?: {
+        version: string;
+        bundle_sha256: string;
+        schema_count: number;
+    };
+    engines: EngineStatus[];
+    helper?: HelperStatus;
+    observer?: ObserverStatus;
+    python_cli?: PythonCliStatus;
+    actions_taken?: string[];
+    next_action: {
+        type: "NONE" | "MANUAL_FIX" | "CONTACT_SUPPORT" | "INSTALL_HELPER";
+        message: string;
+    };
+}
+/**
+ * vibe_pm.doctor - Installation health check (MVP)
+ *
+ * Checks:
+ * - Engine binaries (spec-high, clinic)
+ * - (Self-contained) helper availability
+ * - Contract schema versions
+ */
+export declare function doctor(input: DoctorInput): Promise<DoctorOutput>;