@vibecodetown/mcp-server 1.3.1

package/build/mcp/tools/vibe_pm/mapping/change_map.d.ts

@@ -0,0 +1,12 @@
+import { ChangeMap, ChangedFile, ImportHint, SpecMap } from "./types.js";
+/**
+ * change_map 생성 (스코어링 + 매핑 결과)
+ */
+export declare function buildChangeMap(args: {
+    run_id: string;
+    base?: string;
+    head?: string;
+    spec: SpecMap;
+    changed: ChangedFile[];
+    imports: ImportHint[];
+}): ChangeMap;

package/build/mcp/tools/vibe_pm/mapping/change_map.js

@@ -0,0 +1,154 @@
+import { importHintScore, keywordScore, pathMatches } from "./spec_map.js";
+/**
+ * change_map 생성 (스코어링 + 매핑 결과)
+ */
+export function buildChangeMap(args) {
+    const now = new Date().toISOString();
+    const importMap = new Map(args.imports.map((x) => [x.file, x.imports]));
+    const mapped = [];
+    const unmapped = [];
+    const violations = [];
+    // 1) deny path 체크
+    for (const cf of args.changed) {
+        const deny = args.spec.boundaries.deny_paths ?? [];
+        for (const d of deny) {
+            const prefix = d.path.replace("/**", "").replace("/*", "").replace("*", "");
+            if (cf.file.startsWith(prefix)) {
+                violations.push({
+                    code: "DENY_PATH_TOUCHED",
+                    severity: "BLOCK",
+                    file: cf.file,
+                    detail: `deny_path hit: ${d.path} (${d.reason})`,
+                    evidence: [`path:${cf.file}`],
+                });
+            }
+        }
+    }
+    // 2) 파일별 owner 스코어링
+    for (const cf of args.changed) {
+        // 삭제된 파일은 스킵
+        if (cf.status === "D")
+            continue;
+        const importTargets = importMap.get(cf.file) ?? [];
+        const contentKeywords = [cf.file, ...importTargets].join(" ");
+        const candidates = args.spec.owners.map((o) => {
+            // 스코어 계산
+            const s_path = pathMatches(o, cf.file) ? 1 : 0;
+            const s_kw = keywordScore(o, contentKeywords);
+            const s_imp = importHintScore(o, importTargets);
+            // match order 반영: path가 맞으면 base boost
+            const base = s_path > 0 ? 0.55 : 0.0;
+            const conf = clamp01(base + 0.25 * s_kw + 0.2 * s_imp);
+            const evidence = [];
+            if (s_path > 0)
+                evidence.push(`path_match:${o.paths.join(",")}`);
+            if (s_kw > 0)
+                evidence.push(`keyword_score:${s_kw.toFixed(2)}`);
+            if (s_imp > 0)
+                evidence.push(`import_hint_score:${s_imp.toFixed(2)}`);
+            return {
+                owner_id: o.id,
+                domain_id: o.axis.domain,
+                layer: o.axis.layer,
+                confidence: conf,
+                evidence,
+            };
+        });
+        candidates.sort((a, b) => b.confidence - a.confidence);
+        const best = candidates[0];
+        const second = candidates[1];
+        const mappedMin = args.spec.rules.confidence_thresholds.mapped_min;
+        const suggestMin = args.spec.rules.confidence_thresholds.suggest_min;
+        // suggest_min 미달: unmapped
+        if (!best || best.confidence < suggestMin) {
+            unmapped.push({
+                file: cf.file,
+                reasons: ["no_match_above_suggest_min"],
+                suggested_owners: candidates
+                    .filter((c) => c.confidence >= suggestMin * 0.5) // 절반 이상은 추천
+                    .slice(0, 3)
+                    .map((c) => ({
+                    owner_id: c.owner_id,
+                    domain_id: c.domain_id,
+                    layer: c.layer,
+                    confidence: c.confidence,
+                })),
+            });
+            violations.push({
+                code: "UNMAPPED_CHANGE",
+                severity: "FIX",
+                file: cf.file,
+                detail: `no owner confidence >= ${suggestMin}`,
+                evidence: [`best:${best?.owner_id ?? "none"}:${best?.confidence ?? 0}`],
+            });
+            continue;
+        }
+        // 모호성 체크: best와 second가 너무 가까움
+        if (second &&
+            best.confidence >= mappedMin &&
+            Math.abs(best.confidence - second.confidence) < 0.08) {
+            violations.push({
+                code: "OWNER_AMBIGUOUS",
+                severity: "FIX",
+                file: cf.file,
+                detail: `ambiguous owners: ${best.owner_id}(${best.confidence.toFixed(2)}) vs ${second.owner_id}(${second.confidence.toFixed(2)})`,
+                evidence: [...best.evidence, ...second.evidence],
+            });
+        }
+        // mapped_min 이상: 매핑 확정
+        if (best.confidence >= mappedMin) {
+            mapped.push({
+                file: cf.file,
+                owner_id: best.owner_id,
+                domain_id: best.domain_id,
+                layer: best.layer,
+                confidence: best.confidence,
+                evidence: best.evidence.length ? best.evidence : ["heuristic_match"],
+            });
+        }
+        else {
+            // suggest_min 이상, mapped_min 미달: unmapped
+            unmapped.push({
+                file: cf.file,
+                reasons: [`best_confidence_below_mapped_min:${mappedMin}`],
+                suggested_owners: candidates.slice(0, 3).map((c) => ({
+                    owner_id: c.owner_id,
+                    domain_id: c.domain_id,
+                    layer: c.layer,
+                    confidence: c.confidence,
+                })),
+            });
+            violations.push({
+                code: "UNMAPPED_CHANGE",
+                severity: "FIX",
+                file: cf.file,
+                detail: `best confidence ${best.confidence.toFixed(2)} < mapped_min ${mappedMin}`,
+                evidence: best.evidence,
+            });
+        }
+    }
+    const domainsTouched = uniq(mapped.map((m) => m.domain_id));
+    const layersTouched = uniq(mapped.map((m) => m.layer));
+    return {
+        version: "1.0",
+        run_id: args.run_id,
+        base: args.base,
+        head: args.head,
+        generated_at: now,
+        mapped,
+        unmapped,
+        violations,
+        summary: {
+            mapped_files: mapped.length,
+            unmapped_files: unmapped.length,
+            domains_touched: domainsTouched,
+            layers_touched: layersTouched,
+        },
+    };
+}
+function clamp01(n) {
+    return Math.max(0, Math.min(1, n));
+}
+function uniq(xs) {
+    return Array.from(new Set(xs));
+}

package/build/mcp/tools/vibe_pm/mapping/diff_scan.d.ts

@@ -0,0 +1,31 @@
+import { ChangedFile } from "./types.js";
+/**
+ * git diff로 변경 파일 목록 수집
+ * @deprecated Use scanChangedFilesAsync or scanChangedFilesSmart instead.
+ * Sync operations block the event loop.
+ */
+export declare function scanChangedFiles(baseRef?: string, headRef?: string, cwd?: string): ChangedFile[];
+/**
+ * staged 파일 목록 수집 (commit 전)
+ * @deprecated Use scanStagedFilesAsync or scanStagedFilesSmart instead.
+ * Sync operations block the event loop.
+ */
+export declare function scanStagedFiles(cwd?: string): ChangedFile[];
+/**
+ * Async version of scanChangedFiles (non-blocking)
+ * Recommended for use in async contexts.
+ */
+export declare function scanChangedFilesAsync(baseRef?: string, headRef?: string, cwd?: string): Promise<ChangedFile[]>;
+/**
+ * Async version of scanStagedFiles (non-blocking)
+ * Recommended for use in async contexts.
+ */
+export declare function scanStagedFilesAsync(cwd?: string): Promise<ChangedFile[]>;
+/**
+ * Smart async scan - uses worker if enabled, otherwise async local
+ */
+export declare function scanChangedFilesSmart(baseRef?: string, headRef?: string, cwd?: string, runId?: string): Promise<ChangedFile[]>;
+/**
+ * Smart async staged scan - uses worker if enabled, otherwise async local
+ */
+export declare function scanStagedFilesSmart(cwd?: string, runId?: string): Promise<ChangedFile[]>;

package/build/mcp/tools/vibe_pm/mapping/diff_scan.js

@@ -0,0 +1,156 @@
+// release/mvp_core_clinic/src/mcp/tools/vibe_pm/mapping/diff_scan.ts
+import { spawnSync, spawn } from "child_process";
+import { isMapperWorkerEnabled, diffScanViaWorkerOrFallback, stagedScanViaWorkerOrFallback, } from "../../../../mapper-worker/index.js";
+// ============================================================
+// Common Parsing Logic (extracted to reduce duplication)
+// ============================================================
+/**
+ * Parse git name-status and numstat output into ChangedFile[]
+ */
+function parseGitDiffOutput(nsStdout, numStdout) {
+    const statusMap = new Map();
+    nsStdout
+        .split("\n")
+        .filter(Boolean)
+        .forEach((line) => {
+        const parts = line.split(/\s+/);
+        const s = parts[0];
+        const file = parts.slice(1).join(" ");
+        if (!s || !file)
+            return;
+        statusMap.set(file, s[0]);
+    });
+    const statsMap = new Map();
+    numStdout
+        .split("\n")
+        .filter(Boolean)
+        .forEach((line) => {
+        const [a, d, ...rest] = line.split("\t");
+        const file = rest.join("\t");
+        if (!file)
+            return;
+        statsMap.set(file, {
+            a: parseInt(a || "0", 10) || 0,
+            d: parseInt(d || "0", 10) || 0,
+        });
+    });
+    const files = [];
+    for (const [file, status] of statusMap.entries()) {
+        const st = statsMap.get(file) ?? { a: 0, d: 0 };
+        files.push({
+            file,
+            status,
+            addedLines: st.a,
+            deletedLines: st.d,
+        });
+    }
+    return files;
+}
+// ============================================================
+// Sync Versions (DEPRECATED - use async or smart versions)
+// ============================================================
+/**
+ * git diff로 변경 파일 목록 수집
+ * @deprecated Use scanChangedFilesAsync or scanChangedFilesSmart instead.
+ * Sync operations block the event loop.
+ */
+export function scanChangedFiles(baseRef = "HEAD~1", headRef = "HEAD", cwd) {
+    const opts = { encoding: "utf-8", cwd };
+    const ns = spawnSync("git", ["diff", "--name-status", `${baseRef}..${headRef}`], opts);
+    const num = spawnSync("git", ["diff", "--numstat", `${baseRef}..${headRef}`], opts);
+    return parseGitDiffOutput(ns.stdout || "", num.stdout || "");
+}
+/**
+ * staged 파일 목록 수집 (commit 전)
+ * @deprecated Use scanStagedFilesAsync or scanStagedFilesSmart instead.
+ * Sync operations block the event loop.
+ */
+export function scanStagedFiles(cwd) {
+    const opts = { encoding: "utf-8", cwd };
+    const ns = spawnSync("git", ["diff", "--cached", "--name-status"], opts);
+    const num = spawnSync("git", ["diff", "--cached", "--numstat"], opts);
+    return parseGitDiffOutput(ns.stdout || "", num.stdout || "");
+}
+// ============================================================
+// Async Versions (using spawn instead of spawnSync)
+// ============================================================
+/**
+ * Run git command asynchronously
+ */
+function runGitAsync(args, cwd) {
+    return new Promise((resolve) => {
+        const proc = spawn("git", args, {
+            cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        proc.stdout?.on("data", (data) => {
+            stdout += data.toString();
+        });
+        proc.stderr?.on("data", (data) => {
+            stderr += data.toString();
+        });
+        proc.on("close", (code) => {
+            resolve({ stdout, stderr, code: code ?? 0 });
+        });
+        proc.on("error", (err) => {
+            resolve({ stdout: "", stderr: err.message, code: 1 });
+        });
+    });
+}
+/**
+ * Async version of scanChangedFiles (non-blocking)
+ * Recommended for use in async contexts.
+ */
+export async function scanChangedFilesAsync(baseRef = "HEAD~1", headRef = "HEAD", cwd) {
+    const workDir = cwd ?? process.cwd();
+    const [nsResult, numResult] = await Promise.all([
+        runGitAsync(["diff", "--name-status", `${baseRef}..${headRef}`], workDir),
+        runGitAsync(["diff", "--numstat", `${baseRef}..${headRef}`], workDir),
+    ]);
+    return parseGitDiffOutput(nsResult.stdout, numResult.stdout);
+}
+/**
+ * Async version of scanStagedFiles (non-blocking)
+ * Recommended for use in async contexts.
+ */
+export async function scanStagedFilesAsync(cwd) {
+    const workDir = cwd ?? process.cwd();
+    const [nsResult, numResult] = await Promise.all([
+        runGitAsync(["diff", "--cached", "--name-status"], workDir),
+        runGitAsync(["diff", "--cached", "--numstat"], workDir),
+    ]);
+    return parseGitDiffOutput(nsResult.stdout, numResult.stdout);
+}
+// ============================================================
+// Smart Versions (use worker if available, else async local)
+// ============================================================
+/**
+ * Smart async scan - uses worker if enabled, otherwise async local
+ */
+export async function scanChangedFilesSmart(baseRef = "HEAD~1", headRef = "HEAD", cwd, runId = "default") {
+    const workDir = cwd ?? process.cwd();
+    if (isMapperWorkerEnabled()) {
+        const result = await diffScanViaWorkerOrFallback(workDir, runId, baseRef, headRef, () => scanChangedFiles(baseRef, headRef, workDir));
+        if (result.success && result.data) {
+            return result.data;
+        }
+        throw new Error(result.error ?? "Unknown error");
+    }
+    return scanChangedFilesAsync(baseRef, headRef, workDir);
+}
+/**
+ * Smart async staged scan - uses worker if enabled, otherwise async local
+ */
+export async function scanStagedFilesSmart(cwd, runId = "default") {
+    const workDir = cwd ?? process.cwd();
+    if (isMapperWorkerEnabled()) {
+        const result = await stagedScanViaWorkerOrFallback(workDir, runId, () => scanStagedFiles(workDir));
+        if (result.success && result.data) {
+            return result.data;
+        }
+        throw new Error(result.error ?? "Unknown error");
+    }
+    return scanStagedFilesAsync(workDir);
+}

package/build/mcp/tools/vibe_pm/mapping/gate_judge.d.ts

@@ -0,0 +1,18 @@
+import { ChangeMap, GateDecision, SpecMap, Violation } from "./types.js";
+/**
+ * FIX/BLOCK 판정 + 네비게이션 메시지 생성
+ */
+export declare function judgeMappingGate(args: {
+    run_id: string;
+    spec: SpecMap;
+    changeMap: ChangeMap;
+    changeMapPath: string;
+}): GateDecision;
+/**
+ * violation 목록에서 심각도별 카운트
+ */
+export declare function countViolations(violations: Violation[]): {
+    block: number;
+    fix: number;
+    total: number;
+};

package/build/mcp/tools/vibe_pm/mapping/gate_judge.js

@@ -0,0 +1,101 @@
+/**
+ * FIX/BLOCK 판정 + 네비게이션 메시지 생성
+ */
+export function judgeMappingGate(args) {
+    const v = args.changeMap.violations;
+    const hasBlock = v.some((x) => x.severity === "BLOCK");
+    const hasFix = v.some((x) => x.severity === "FIX");
+    const verdict = hasBlock ? "BLOCK" : hasFix ? "FIX" : "GO";
+    if (verdict === "GO") {
+        return {
+            verdict,
+            title: "MAPPING_GO",
+            summary: "모든 변경이 spec_map에 매핑되었고, 경계 위반이 없습니다.",
+            evidence: {
+                run_id: args.run_id,
+                change_map_path: args.changeMapPath,
+                summary: args.changeMap.summary,
+            },
+            navigation: [],
+            next_actions: [],
+        };
+    }
+    if (verdict === "BLOCK") {
+        const blocks = v.filter((x) => x.severity === "BLOCK");
+        const top = blocks[0];
+        return blockMessage(args.run_id, top, blocks, args.changeMapPath, args.changeMap);
+    }
+    // FIX
+    const fixes = v.filter((x) => x.severity === "FIX");
+    const top = fixes[0];
+    return fixMessage(args.run_id, top, fixes, args.changeMapPath, args.changeMap);
+}
+/**
+ * FIX 메시지 생성
+ */
+function fixMessage(runId, top, all, changeMapPath, cm) {
+    const unmapped = cm.unmapped.map((x) => x.file);
+    const amb = all
+        .filter((x) => x.code === "OWNER_AMBIGUOUS")
+        .map((x) => x.file);
+    return {
+        verdict: "FIX",
+        title: `MAPPING_FIX_REQUIRED: ${top.code}`,
+        summary: `소속(Owner/Domain/Layer) 매핑이 불완전합니다: unmapped=${unmapped.length}, ambiguous=${amb.length}`,
+        evidence: {
+            run_id: runId,
+            change_map_path: changeMapPath,
+            unmapped_files: unmapped,
+            ambiguous_files: amb,
+            violations: all.slice(0, 10),
+            summary: cm.summary,
+        },
+        navigation: [
+            "1) spec_map의 owners 중 하나로 수렴하도록 파일 경로/모듈 위치를 조정",
+            "2) suggested_owners가 있는 unmapped 파일은 제안 도메인으로 이동 또는 기존 모듈로 통합",
+            "3) WORK_ORDER 경계(allow/deny/예외)가 맞는지 확인",
+        ],
+        next_actions: [
+            "Run: vibe_pm.status",
+            "If needed: vibe_pm.create_work_order",
+            "Re-run: vibe_pm.ingress (to regenerate change_map)",
+        ],
+    };
+}
+/**
+ * BLOCK 메시지 생성
+ */
+function blockMessage(runId, top, all, changeMapPath, cm) {
+    return {
+        verdict: "BLOCK",
+        title: `MAPPING_BLOCKED: ${top.code}`,
+        summary: `실행 계약 위반으로 변경이 차단되었습니다: ${top.code}`,
+        evidence: {
+            run_id: runId,
+            change_map_path: changeMapPath,
+            top_violation: top,
+            violations: all.slice(0, 10),
+            summary: cm.summary,
+        },
+        navigation: [
+            "1) 금지 경로/경계 위반 파일을 허용 영역으로 이동하거나 기존 owner 영역으로 통합",
+            "2) 금지 import(경계 침범)는 adapter/port 패턴으로 우회하지 말고 구조적으로 분리",
+            "3) 정말 필요하면 WORK_ORDER에 예외(EX-###) 추가 + 근거 작성 후 재시도",
+        ],
+        next_actions: [
+            "Run: vibe_pm.status",
+            "Then: follow status.next_action",
+            "Re-run: vibe (CI)",
+        ],
+    };
+}
+/**
+ * violation 목록에서 심각도별 카운트
+ */
+export function countViolations(violations) {
+    return {
+        block: violations.filter((v) => v.severity === "BLOCK").length,
+        fix: violations.filter((v) => v.severity === "FIX").length,
+        total: violations.length,
+    };
+}

package/build/mcp/tools/vibe_pm/mapping/import_scan.d.ts

@@ -0,0 +1,9 @@
+import { ImportHint } from "./types.js";
+/**
+ * TypeScript/JavaScript 파일에서 import 힌트 추출
+ */
+export declare function scanImportHints(workspaceRoot: string, files: string[]): ImportHint[];
+/**
+ * import 경로를 절대 경로로 해석 (alias 미지원, 간단 버전)
+ */
+export declare function resolveImportPath(fromFile: string, importTarget: string, workspaceRoot: string): string | null;

package/build/mcp/tools/vibe_pm/mapping/import_scan.js

@@ -0,0 +1,56 @@
+// release/mvp_core_clinic/src/mcp/tools/vibe_pm/mapping/import_scan.ts
+import fs from "fs";
+import path from "path";
+const IMPORT_RE = /^\s*import\s+.*\s+from\s+["'](.+)["'];?/gm;
+const REQUIRE_RE = /require\s*\(\s*["'](.+)["']\s*\)/g;
+/**
+ * TypeScript/JavaScript 파일에서 import 힌트 추출
+ */
+export function scanImportHints(workspaceRoot, files) {
+    const out = [];
+    for (const f of files) {
+        const abs = path.join(workspaceRoot, f);
+        if (!fs.existsSync(abs))
+            continue;
+        // TypeScript/JavaScript 파일만 처리
+        const ext = path.extname(abs).toLowerCase();
+        if (![".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs"].includes(ext)) {
+            continue;
+        }
+        try {
+            const raw = fs.readFileSync(abs, "utf-8");
+            const imports = [];
+            // ES import 추출
+            let m;
+            IMPORT_RE.lastIndex = 0;
+            while ((m = IMPORT_RE.exec(raw)) !== null) {
+                imports.push(m[1]);
+            }
+            // CommonJS require 추출
+            REQUIRE_RE.lastIndex = 0;
+            while ((m = REQUIRE_RE.exec(raw)) !== null) {
+                imports.push(m[1]);
+            }
+            out.push({ file: f, imports });
+        }
+        catch {
+            // 파일 읽기 실패 시 스킵
+            continue;
+        }
+    }
+    return out;
+}
+/**
+ * import 경로를 절대 경로로 해석 (alias 미지원, 간단 버전)
+ */
+export function resolveImportPath(fromFile, importTarget, workspaceRoot) {
+    // 상대 경로인 경우
+    if (importTarget.startsWith(".")) {
+        const dir = path.dirname(path.join(workspaceRoot, fromFile));
+        const resolved = path.resolve(dir, importTarget);
+        const rel = path.relative(workspaceRoot, resolved);
+        return rel.startsWith("..") ? null : rel;
+    }
+    // 패키지 또는 alias는 그대로 반환 (alias 해석은 복잡하므로 스킵)
+    return importTarget;
+}

package/build/mcp/tools/vibe_pm/mapping/index.d.ts

@@ -0,0 +1,8 @@
+export type { Verdict, LayerId, ViolationCode, Violation, SpecOwner, SpecMap, ChangedFile, ImportHint, ChangeMapMapped, ChangeMapUnmapped, ChangeMap, SkeletonMapPatch, GateDecision, } from "./types.js";
+export { loadSpecMap, pathMatches, keywordScore, importHintScore } from "./spec_map.js";
+export { scanChangedFiles, scanStagedFiles, scanChangedFilesAsync, scanStagedFilesAsync, scanChangedFilesSmart, scanStagedFilesSmart, } from "./diff_scan.js";
+export { scanImportHints, resolveImportPath } from "./import_scan.js";
+export { buildChangeMap } from "./change_map.js";
+export { buildSkeletonMapPatch, mergeSkeletonMapPatch } from "./skeleton_patch.js";
+export { judgeMappingGate, countViolations } from "./gate_judge.js";
+export { runMappingPipeline, runMappingPipelineAsync, runMappingPipelineSmart, hasSpecMap, hasChangeMap, loadChangeMap, type MappingPipelineResult, type MappingPipelineOptions, } from "./orchestrator.js";

package/build/mcp/tools/vibe_pm/mapping/index.js

@@ -0,0 +1,10 @@
+// release/mvp_core_clinic/src/mcp/tools/vibe_pm/mapping/index.ts
+// Core functions
+export { loadSpecMap, pathMatches, keywordScore, importHintScore } from "./spec_map.js";
+export { scanChangedFiles, scanStagedFiles, scanChangedFilesAsync, scanStagedFilesAsync, scanChangedFilesSmart, scanStagedFilesSmart, } from "./diff_scan.js";
+export { scanImportHints, resolveImportPath } from "./import_scan.js";
+export { buildChangeMap } from "./change_map.js";
+export { buildSkeletonMapPatch, mergeSkeletonMapPatch } from "./skeleton_patch.js";
+export { judgeMappingGate, countViolations } from "./gate_judge.js";
+// Orchestrator
+export { runMappingPipeline, runMappingPipelineAsync, runMappingPipelineSmart, hasSpecMap, hasChangeMap, loadChangeMap, } from "./orchestrator.js";

package/build/mcp/tools/vibe_pm/mapping/orchestrator.d.ts

@@ -0,0 +1,41 @@
+import { GateDecision, ChangeMap, SkeletonMapPatch } from "./types.js";
+export type MappingPipelineResult = {
+    decision: GateDecision;
+    changeMap: ChangeMap;
+    skeletonPatch: SkeletonMapPatch;
+    changeMapPath: string;
+    skeletonPatchPath: string;
+};
+export type MappingPipelineOptions = {
+    workspaceRoot: string;
+    run_id: string;
+    baseRef?: string;
+    headRef?: string;
+    useStaged?: boolean;
+};
+/**
+ * 매핑 파이프라인 실행 (동기 버전)
+ * @deprecated Use runMappingPipelineAsync or runMappingPipelineSmart instead.
+ * Sync operations block the event loop.
+ */
+export declare function runMappingPipeline(options: MappingPipelineOptions): MappingPipelineResult;
+/**
+ * spec_map 존재 여부 확인
+ */
+export declare function hasSpecMap(workspaceRoot: string): boolean;
+/**
+ * change_map 존재 여부 확인
+ */
+export declare function hasChangeMap(workspaceRoot: string, run_id: string): boolean;
+/**
+ * change_map 로드
+ */
+export declare function loadChangeMap(workspaceRoot: string, run_id: string): ChangeMap | null;
+/**
+ * Async mapping pipeline - uses async git operations and file I/O
+ */
+export declare function runMappingPipelineAsync(options: MappingPipelineOptions): Promise<MappingPipelineResult>;
+/**
+ * Smart mapping pipeline - uses worker if available, otherwise async local
+ */
+export declare function runMappingPipelineSmart(options: MappingPipelineOptions): Promise<MappingPipelineResult>;