@vibecodetown/mcp-server 2.1.4 → 2.2.1

package/build/tools/vibe_pm/pm_language.js

@@ -1,6 +1,7 @@
 // adapters/mcp-ts/src/tools/vibe_pm/pm_language.ts
 // PM Language transformation utilities
 // Reference: docs/DEV_SPEC/MCP_TOOL_SCHEMA_SPEC.md Section: Status Mapping
+import { applyTermDictionary, resolveLocaleFromText } from "./waiter_mapping.js";
 // ============================================================
 // Signal Level Mapping (Internal → User-facing)
 // ============================================================
@@ -202,21 +203,21 @@ ${verifyList}
  * This is a simplified version - full implementation would parse and restructure
  */
 export function transformAskQueueText(rawText) {
-    let transformed = rawText;
-    // Replace common technical terms with PM-friendly alternatives
-    const replacements = [
-        [/run_id/gi, "프로젝트"],
-        [/bridge/gi, "작업 지시서"],
-        [/schema/gi, "구조"],
-        [/gate/gi, "검토"],
-        [/signal/gi, "상태"],
-        [/FSM/gi, "워크플로우"],
-        [/spec_drift/gi, "범위 변경"],
-        [/decision_card/gi, "결재 안건"],
-        [/clinic_bridge/gi, "검수 기준"]
-    ];
-    for (const [pattern, replacement] of replacements) {
-        transformed = transformed.replace(pattern, replacement);
+    try {
+        const locale = resolveLocaleFromText(rawText);
+        return applyTermDictionary(rawText, locale);
+    }
+    catch {
+        // Best-effort fallback: preserve previous behavior when mapping is unavailable.
+        return rawText
+            .replace(/run_id/gi, "프로젝트")
+            .replace(/bridge/gi, "작업 지시서")
+            .replace(/schema/gi, "구조")
+            .replace(/gate/gi, "검토")
+            .replace(/signal/gi, "상태")
+            .replace(/FSM/gi, "워크플로우")
+            .replace(/spec_drift/gi, "범위 변경")
+            .replace(/decision_card/gi, "결재 안건")
+            .replace(/clinic_bridge/gi, "검수 기준");
     }
-    return transformed;
 }

package/build/tools/vibe_pm/pre_commit_analysis.js

@@ -0,0 +1,292 @@
+// adapters/mcp-ts/src/tools/vibe_pm/pre_commit_analysis.ts
+// Pre-commit analysis: categorize changes and suggest staging strategy
+import { simpleGit } from "simple-git";
+/**
+ * Categorize a file based on its path
+ */
+function categorizeFile(filePath) {
+    const normalized = filePath.replace(/\\/g, "/");
+    // MCP TypeScript
+    if (normalized.includes("adapters/mcp-ts/src/"))
+        return "mcp_source";
+    if (normalized.includes("adapters/mcp-ts/build/"))
+        return "mcp_build";
+    if (normalized.includes("adapters/mcp-ts/test"))
+        return "mcp_test";
+    if (normalized.includes("adapters/mcp-ts/"))
+        return "mcp_other";
+    // Engines (Rust)
+    if (normalized.includes("engines/") && normalized.endsWith(".rs"))
+        return "engine_rust";
+    if (normalized.includes("engines/"))
+        return "engine_other";
+    // Documentation
+    if (normalized.includes("docs/"))
+        return "docs";
+    if (normalized.endsWith(".md"))
+        return "docs";
+    // Python
+    if (normalized.includes("vibecoding_helper/"))
+        return "python_core";
+    if (normalized.endsWith(".py"))
+        return "python";
+    // Config/CI
+    if (normalized.includes(".github/"))
+        return "ci";
+    if (normalized.includes(".vibe/"))
+        return "vibe_config";
+    if (normalized.includes("schemas/"))
+        return "schemas";
+    if (normalized.endsWith(".json") ||
+        normalized.endsWith(".yaml") ||
+        normalized.endsWith(".yml") ||
+        normalized.endsWith(".toml"))
+        return "config";
+    // Generated
+    if (normalized.includes("/generated/"))
+        return "generated";
+    // Tests
+    if (normalized.includes("/test") || normalized.includes("/tests/"))
+        return "tests";
+    // Build artifacts
+    if (normalized.includes("/dist/") ||
+        normalized.includes("/build/") ||
+        normalized.includes("/target/"))
+        return "build_artifacts";
+    // Lock files
+    if (normalized.endsWith("-lock.json") ||
+        normalized.endsWith(".lock") ||
+        normalized.endsWith("-lock.yaml"))
+        return "lock_files";
+    return "other";
+}
+/**
+ * Get human-readable category info
+ */
+function getCategoryInfo(category) {
+    const info = {
+        mcp_source: {
+            name: "MCP 소스 코드",
+            description: "TypeScript MCP 서버 소스 (빌드 후 npm 배포 필요할 수 있음)",
+            suggested: true,
+        },
+        mcp_build: {
+            name: "MCP 빌드 결과물",
+            description: "컴파일된 JavaScript (보통 gitignore됨)",
+            suggested: false,
+        },
+        mcp_test: {
+            name: "MCP 테스트",
+            description: "TypeScript 테스트 파일",
+            suggested: true,
+        },
+        mcp_other: {
+            name: "MCP 기타",
+            description: "MCP 패키지 설정, 스크립트 등",
+            suggested: true,
+        },
+        engine_rust: {
+            name: "Rust 엔진 코드",
+            description: "엔진 소스 (빌드 후 GitHub Release 필요할 수 있음)",
+            suggested: true,
+        },
+        engine_other: {
+            name: "엔진 기타",
+            description: "엔진 설정, 문서 등",
+            suggested: true,
+        },
+        docs: {
+            name: "문서",
+            description: "마크다운 문서, 스펙",
+            suggested: true,
+        },
+        python_core: {
+            name: "Python 코어",
+            description: "vibecoding_helper 모듈",
+            suggested: true,
+        },
+        python: {
+            name: "Python 기타",
+            description: "Python 스크립트, 테스트",
+            suggested: true,
+        },
+        ci: {
+            name: "CI/CD",
+            description: "GitHub Actions 워크플로우",
+            suggested: true,
+        },
+        vibe_config: {
+            name: "Vibe 설정",
+            description: ".vibe/ 로컬 설정 (보통 gitignore됨)",
+            suggested: false,
+        },
+        schemas: {
+            name: "스키마",
+            description: "JSON Schema 정의",
+            suggested: true,
+        },
+        config: {
+            name: "설정 파일",
+            description: "JSON, YAML, TOML 설정",
+            suggested: true,
+        },
+        generated: {
+            name: "생성된 코드",
+            description: "스키마에서 자동 생성된 코드 (재생성 가능)",
+            suggested: false,
+        },
+        tests: {
+            name: "테스트",
+            description: "테스트 파일",
+            suggested: true,
+        },
+        build_artifacts: {
+            name: "빌드 결과물",
+            description: "컴파일된 파일 (보통 gitignore됨)",
+            suggested: false,
+        },
+        lock_files: {
+            name: "Lock 파일",
+            description: "의존성 잠금 파일",
+            suggested: true,
+        },
+        other: {
+            name: "기타",
+            description: "분류되지 않은 파일",
+            suggested: false,
+        },
+    };
+    return info[category] || info.other;
+}
+/**
+ * Analyze git status and categorize changes
+ */
+export async function analyzePreCommit(basePath = process.cwd()) {
+    const git = simpleGit({ baseDir: basePath });
+    const status = await git.status();
+    // Collect all changed files
+    const changes = [];
+    for (const file of status.not_added) {
+        changes.push({ path: file, status: "new", staged: false });
+    }
+    for (const file of status.created) {
+        changes.push({ path: file, status: "new", staged: true });
+    }
+    for (const file of status.modified) {
+        changes.push({ path: file, status: "modified", staged: false });
+    }
+    for (const file of status.staged) {
+        if (!changes.find((c) => c.path === file)) {
+            changes.push({ path: file, status: "modified", staged: true });
+        }
+    }
+    for (const file of status.deleted) {
+        changes.push({ path: file, status: "deleted", staged: false });
+    }
+    for (const file of status.renamed) {
+        changes.push({ path: file.to, status: "renamed", staged: true });
+    }
+    // Group by category
+    const categoryMap = new Map();
+    for (const change of changes) {
+        const cat = categorizeFile(change.path);
+        if (!categoryMap.has(cat)) {
+            categoryMap.set(cat, []);
+        }
+        categoryMap.get(cat).push(change);
+    }
+    // Build categories
+    const categories = [];
+    for (const [cat, files] of categoryMap) {
+        const info = getCategoryInfo(cat);
+        categories.push({
+            name: info.name,
+            description: info.description,
+            files,
+            suggested: info.suggested,
+        });
+    }
+    // Sort: suggested first, then by file count
+    categories.sort((a, b) => {
+        if (a.suggested !== b.suggested)
+            return a.suggested ? -1 : 1;
+        return b.files.length - a.files.length;
+    });
+    // Generate suggestions
+    const suggestions = [];
+    const warnings = [];
+    // Check for MCP source changes
+    const mcpSource = categoryMap.get("mcp_source");
+    if (mcpSource && mcpSource.length > 0) {
+        suggestions.push("MCP 소스 변경됨 → 커밋 후 `vibe_pm.publish_mcp` 실행 권장");
+    }
+    // Check for engine changes
+    const engineRust = categoryMap.get("engine_rust");
+    if (engineRust && engineRust.length > 0) {
+        suggestions.push("Rust 엔진 변경됨 → 커밋 후 엔진 빌드 + GitHub Release 필요할 수 있음");
+    }
+    // Check for vibe config
+    const vibeConfig = categoryMap.get("vibe_config");
+    if (vibeConfig && vibeConfig.length > 0) {
+        warnings.push(".vibe/ 파일은 보통 gitignore됩니다. 의도적 커밋인지 확인하세요.");
+    }
+    // Check for build artifacts
+    const buildArtifacts = categoryMap.get("build_artifacts");
+    if (buildArtifacts && buildArtifacts.length > 0) {
+        warnings.push("빌드 결과물은 보통 gitignore됩니다. 의도적 커밋인지 확인하세요.");
+    }
+    // Check for sensitive patterns
+    for (const change of changes) {
+        const lower = change.path.toLowerCase();
+        if (lower.includes("secret") ||
+            lower.includes("credential") ||
+            lower.includes(".env") ||
+            lower.includes("token")) {
+            warnings.push(`민감한 파일 감지: ${change.path} - 커밋 전 확인 필요`);
+        }
+    }
+    return {
+        categories,
+        total_files: changes.length,
+        suggestions,
+        warnings,
+    };
+}
+/**
+ * Generate a summary for user decision
+ */
+export function formatAnalysisSummary(analysis) {
+    const lines = [];
+    lines.push(`## 변경 파일 분석 (총 ${analysis.total_files}개)\n`);
+    for (const cat of analysis.categories) {
+        const emoji = cat.suggested ? "✅" : "⚠️";
+        lines.push(`### ${emoji} ${cat.name} (${cat.files.length}개)`);
+        lines.push(`> ${cat.description}`);
+        lines.push("");
+        // Show up to 5 files
+        const shown = cat.files.slice(0, 5);
+        for (const f of shown) {
+            const statusIcon = f.staged ? "📦" : "📝";
+            lines.push(`- ${statusIcon} ${f.path}`);
+        }
+        if (cat.files.length > 5) {
+            lines.push(`- ... 외 ${cat.files.length - 5}개`);
+        }
+        lines.push("");
+    }
+    if (analysis.suggestions.length > 0) {
+        lines.push("### 💡 제안");
+        for (const s of analysis.suggestions) {
+            lines.push(`- ${s}`);
+        }
+        lines.push("");
+    }
+    if (analysis.warnings.length > 0) {
+        lines.push("### ⚠️ 경고");
+        for (const w of analysis.warnings) {
+            lines.push(`- ${w}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}

package/build/tools/vibe_pm/publish_mcp.js

@@ -0,0 +1,271 @@
+// adapters/mcp-ts/src/tools/vibe_pm/publish_mcp.ts
+// MCP build and publish workflow
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { spawnSync } from "node:child_process";
+import { getCredentialStore } from "../../auth/credential_store.js";
+/**
+ * Check if MCP source files have changed since last build
+ */
+async function hasSourceChanges(mcpRoot) {
+    const srcDir = path.join(mcpRoot, "src");
+    const buildDir = path.join(mcpRoot, "build");
+    // If no build folder, definitely changed
+    if (!fs.existsSync(buildDir)) {
+        return { changed: true, files: ["build/ not found"] };
+    }
+    // Get build timestamp
+    const buildIndex = path.join(buildDir, "index.js");
+    if (!fs.existsSync(buildIndex)) {
+        return { changed: true, files: ["build/index.js not found"] };
+    }
+    const buildStat = fs.statSync(buildIndex);
+    const buildTime = buildStat.mtime.getTime();
+    // Find source files newer than build
+    const changedFiles = [];
+    function checkDir(dir) {
+        if (!fs.existsSync(dir))
+            return;
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                checkDir(fullPath);
+            }
+            else if (entry.name.endsWith(".ts")) {
+                const stat = fs.statSync(fullPath);
+                if (stat.mtime.getTime() > buildTime) {
+                    changedFiles.push(path.relative(mcpRoot, fullPath));
+                }
+            }
+        }
+    }
+    checkDir(srcDir);
+    return { changed: changedFiles.length > 0, files: changedFiles };
+}
+/**
+ * Run TypeScript build
+ */
+function runBuild(mcpRoot) {
+    try {
+        const result = spawnSync("npm", ["run", "build"], {
+            cwd: mcpRoot,
+            encoding: "utf-8",
+            shell: true,
+            timeout: 120_000, // 2 minutes
+        });
+        if (result.status === 0) {
+            return { success: true, output: result.stdout || "" };
+        }
+        return { success: false, output: result.stderr || result.stdout || "Build failed" };
+    }
+    catch (e) {
+        return { success: false, output: e instanceof Error ? e.message : String(e) };
+    }
+}
+/**
+ * Bump version in package.json
+ */
+function bumpVersion(mcpRoot, type) {
+    try {
+        const result = spawnSync("npm", ["version", type, "--no-git-tag-version"], {
+            cwd: mcpRoot,
+            encoding: "utf-8",
+            shell: true,
+        });
+        if (result.status === 0) {
+            // Read new version from package.json
+            const pkgPath = path.join(mcpRoot, "package.json");
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+            return pkg.version;
+        }
+        throw new Error(result.stderr || "Version bump failed");
+    }
+    catch (e) {
+        throw new Error(`Version bump failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+/**
+ * Run npm publish
+ */
+async function runPublish(mcpRoot, dryRun) {
+    const store = getCredentialStore();
+    const npmToken = await store.getNpmToken();
+    // Set NPM_TOKEN if we have one stored
+    const env = { ...process.env };
+    if (npmToken) {
+        env.NPM_TOKEN = npmToken;
+    }
+    try {
+        const args = ["publish", "--access", "public"];
+        if (dryRun) {
+            args.push("--dry-run");
+        }
+        const result = spawnSync("npm", args, {
+            cwd: mcpRoot,
+            encoding: "utf-8",
+            shell: true,
+            env,
+            timeout: 120_000, // 2 minutes
+        });
+        if (result.status === 0) {
+            return { success: true, output: result.stdout || "" };
+        }
+        return { success: false, output: result.stderr || result.stdout || "Publish failed" };
+    }
+    catch (e) {
+        return { success: false, output: e instanceof Error ? e.message : String(e) };
+    }
+}
+/**
+ * vibe_pm.publish_mcp - Build and publish MCP package
+ *
+ * Workflow:
+ * 1. Check for source changes (skip if no changes unless --force)
+ * 2. Run npm build (tsc)
+ * 3. Optionally bump version
+ * 4. Run npm publish
+ *
+ * PM-friendly description:
+ * MCP 패키지를 빌드하고 npm에 배포합니다.
+ */
+export async function publishMcp(input, basePath = process.cwd()) {
+    const warnings = [];
+    // Find MCP root (adapters/mcp-ts)
+    const mcpRoot = path.join(basePath, "adapters", "mcp-ts");
+    if (!fs.existsSync(path.join(mcpRoot, "package.json"))) {
+        return {
+            success: false,
+            phase: "check",
+            version: "unknown",
+            built: false,
+            published: false,
+            message: "MCP 패키지를 찾을 수 없습니다: adapters/mcp-ts/package.json",
+            warnings,
+        };
+    }
+    // Read current version
+    const pkgPath = path.join(mcpRoot, "package.json");
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+    let version = pkg.version;
+    // Phase 1: Check for changes
+    const { changed, files } = await hasSourceChanges(mcpRoot);
+    if (!changed && !input.force && !input.skip_build) {
+        return {
+            success: true,
+            phase: "check",
+            version,
+            built: false,
+            published: false,
+            message: "소스 변경 없음. 빌드 스킵.",
+            warnings: ["--force로 강제 빌드 가능"],
+        };
+    }
+    // Phase 2: Build
+    let built = false;
+    if (!input.skip_build) {
+        const buildResult = runBuild(mcpRoot);
+        if (!buildResult.success) {
+            return {
+                success: false,
+                phase: "build",
+                version,
+                built: false,
+                published: false,
+                message: `빌드 실패: ${buildResult.output}`,
+                warnings,
+            };
+        }
+        built = true;
+        if (files.length > 0) {
+            warnings.push(`변경된 파일: ${files.slice(0, 5).join(", ")}${files.length > 5 ? ` 외 ${files.length - 5}개` : ""}`);
+        }
+    }
+    // Build only mode
+    if (input.build_only) {
+        return {
+            success: true,
+            phase: "build",
+            version,
+            built,
+            published: false,
+            message: `빌드 완료 (v${version})`,
+            warnings,
+            next_action: {
+                tool: "vibe_pm.publish_mcp",
+                reason: "배포하려면 build_only: false로 다시 실행",
+            },
+        };
+    }
+    // Phase 3: Version bump (optional)
+    if (input.bump) {
+        try {
+            version = bumpVersion(mcpRoot, input.bump);
+            warnings.push(`버전 범프: ${pkg.version} → ${version}`);
+        }
+        catch (e) {
+            return {
+                success: false,
+                phase: "publish",
+                version,
+                built,
+                published: false,
+                message: e instanceof Error ? e.message : String(e),
+                warnings,
+            };
+        }
+    }
+    // Phase 4: Publish
+    const publishResult = await runPublish(mcpRoot, input.dry_run ?? false);
+    if (!publishResult.success) {
+        // Check if it's an auth error
+        if (publishResult.output.includes("ENEEDAUTH") || publishResult.output.includes("401")) {
+            return {
+                success: false,
+                phase: "publish",
+                version,
+                built,
+                published: false,
+                message: "npm 인증 실패. NPM_TOKEN을 설정하거나 npm login을 실행하세요.",
+                warnings: [
+                    "vibe config set npm_token <TOKEN> 으로 토큰 저장 가능",
+                    "또는 NPM_TOKEN 환경변수 설정",
+                ],
+            };
+        }
+        return {
+            success: false,
+            phase: "publish",
+            version,
+            built,
+            published: false,
+            message: `배포 실패: ${publishResult.output}`,
+            warnings,
+        };
+    }
+    const dryRunMsg = input.dry_run ? " (dry-run)" : "";
+    return {
+        success: true,
+        phase: "complete",
+        version,
+        built,
+        published: !input.dry_run,
+        message: `@vibecodetown/mcp-server@${version} 배포 완료${dryRunMsg}`,
+        warnings,
+        next_action: {
+            tool: "vibe_pm.status",
+            reason: "배포 상태 확인",
+        },
+    };
+}
+/**
+ * Quick check if MCP needs rebuild
+ */
+export async function needsMcpBuild(basePath = process.cwd()) {
+    const mcpRoot = path.join(basePath, "adapters", "mcp-ts");
+    if (!fs.existsSync(path.join(mcpRoot, "package.json"))) {
+        return false;
+    }
+    const { changed } = await hasSourceChanges(mcpRoot);
+    return changed;
+}