vibe-commander 0.1.0

package/dist/adapters/cli/router.js

@@ -0,0 +1,419 @@
+/**
+ * CLI 서브커맨드 라우터 — Layer 3 (Adapter)
+ *
+ * process.argv를 직접 파싱하여 4개 서브커맨드(set-unit, update-commit,
+ * list-units, context)로 라우팅한다. Commander.js 등 외부 의존성 없이
+ * 자체 arg 파싱을 구현 (RULE-003, 페어링 Q1 Option B 채택).
+ *
+ * @module
+ */
+import { ok, fail } from '../../types/index.js';
+import { printHelp, printVersion, printUnknownCommand, printMissingArg, printSuccess, printError, } from './output.js';
+import { readStdin, parseStdinJson } from '../pipe/stdin-reader.js';
+// ── arg 파싱 ──
+/**
+ * process.argv로부터 서브커맨드와 인자/옵션을 파싱한다
+ *
+ * argv[0] = node, argv[1] = script, argv[2] = subcommand 형태.
+ * 글로벌 플래그(--help, --version)는 서브커맨드보다 우선 처리.
+ *
+ * @param argv - process.argv 배열
+ * @returns 파싱된 커맨드 인자 또는 에러
+ */
+export function parseArgs(argv) {
+    const args = argv.slice(2);
+    // 글로벌 플래그 우선 처리
+    if (args.length === 0 || hasFlag(args, '--help') || hasFlag(args, '-h')) {
+        return { success: true, data: { command: 'help' } };
+    }
+    if (hasFlag(args, '--version') || hasFlag(args, '-v')) {
+        return { success: true, data: { command: 'version' } };
+    }
+    const subcommand = args[0] ?? '';
+    const rest = args.slice(1);
+    const json = hasFlag(rest, '--json');
+    switch (subcommand) {
+        case 'set-unit':
+            return parseSetUnit(rest, json);
+        case 'update-commit':
+            return parseUpdateCommit(rest, json);
+        case 'list-units':
+            return parseListUnits(rest, json);
+        case 'context':
+            return parseContext(rest, json);
+        case 'validate':
+            return { success: true, data: { command: 'validate', json } };
+        case 'init': {
+            const fromExisting = hasFlag(rest, '--from-existing');
+            const force = hasFlag(rest, '--force');
+            return { success: true, data: { command: 'init', json, fromExisting, force } };
+        }
+        case 'skill':
+            return parseSkillCommand(rest, json);
+        case 'help':
+        case '--help':
+        case '-h':
+            return { success: true, data: { command: 'help' } };
+        case 'version':
+        case '--version':
+        case '-v':
+            return { success: true, data: { command: 'version' } };
+        default:
+            return fail('UNKNOWN_COMMAND', `알 수 없는 명령어: ${subcommand}`, `사용 가능한 명령어: init, set-unit, update-commit, list-units, context, validate, skill`);
+    }
+}
+/**
+ * set-unit 서브커맨드의 인자를 파싱한다
+ *
+ * 필수: <unitId> — 위치 인자 (첫 번째 non-flag 인자)
+ */
+function parseSetUnit(args, json) {
+    const unitId = getPositionalArg(args);
+    if (!unitId) {
+        return fail('MISSING_ARGUMENT', "'set-unit' 명령어에 <unitId> 인자가 필요합니다", '사용법: vc set-unit <unitId> [--request key1,key2] [--no-prompt]');
+    }
+    const requestRaw = getOptionValue(args, '--request');
+    const requestKeys = requestRaw
+        ? requestRaw
+            .split(',')
+            .map((k) => k.trim())
+            .filter(Boolean)
+        : [];
+    const noPrompt = hasFlag(args, '--no-prompt');
+    return { success: true, data: { command: 'set-unit', unitId, requestKeys, noPrompt, json } };
+}
+/**
+ * update-commit 서브커맨드의 인자를 파싱한다
+ *
+ * 인자 분기:
+ * - 없음 → auto-head (HEAD SHA 자동 감지)
+ * - 순수 숫자 → auto-recent (최근 N개 SHA)
+ * - 그 외 → manual (기존 SHA 직접 지정)
+ *
+ * 선택: --mode replace|append (기본: replace)
+ * 선택: --section <sectionName>
+ */
+function parseUpdateCommit(args, json) {
+    const positional = getPositionalArg(args);
+    const modeValue = getOptionValue(args, '--mode');
+    const mode = modeValue === 'append' ? 'append' : 'replace';
+    const section = getOptionValue(args, '--section');
+    const base = {
+        command: 'update-commit',
+        mode,
+        ...(section !== undefined && { section }),
+        json,
+    };
+    if (!positional) {
+        return { success: true, data: { ...base, commitMode: 'auto-head' } };
+    }
+    if (/^\d+$/.test(positional)) {
+        return {
+            success: true,
+            data: { ...base, commitMode: 'auto-recent', count: parseInt(positional, 10) },
+        };
+    }
+    return { success: true, data: { ...base, commitMode: 'manual', sha: positional } };
+}
+/**
+ * list-units 서브커맨드의 인자를 파싱한다
+ *
+ * 선택: --phase <phaseName>
+ */
+function parseListUnits(args, json) {
+    const phase = getOptionValue(args, '--phase');
+    return {
+        success: true,
+        data: {
+            command: 'list-units',
+            ...(phase !== undefined && { phase }),
+            json,
+        },
+    };
+}
+/**
+ * context 서브커맨드의 인자를 파싱한다
+ *
+ * 필수: <unitId> — 위치 인자
+ */
+function parseContext(args, json) {
+    const unitId = getPositionalArg(args);
+    if (!unitId) {
+        return fail('MISSING_ARGUMENT', "'context' 명령어에 <unitId> 인자가 필요합니다", '사용법: vc context <unitId> [--json]');
+    }
+    return { success: true, data: { command: 'context', unitId, json } };
+}
+/**
+ * skill 그룹 커맨드의 서브커맨드를 파싱한다
+ *
+ * 현재 지원: skill install [--cursor] [--claude] [--gemini] [--force]
+ * 플랫폼 플래그 미지정 시 Cursor + Claude + Gemini 모두 설치
+ */
+function parseSkillCommand(args, json) {
+    const sub = getPositionalArg(args);
+    if (!sub) {
+        return fail('MISSING_SUBCOMMAND', "'skill' 명령어에 서브커맨드가 필요합니다", '사용법: vc skill install [--cursor] [--claude] [--gemini] [--force]');
+    }
+    if (sub !== 'install') {
+        return fail('UNKNOWN_SUBCOMMAND', `알 수 없는 skill 서브커맨드: ${sub}`, '사용법: vc skill install [--cursor] [--claude] [--gemini] [--force]');
+    }
+    const cursor = hasFlag(args, '--cursor');
+    const claude = hasFlag(args, '--claude');
+    const gemini = hasFlag(args, '--gemini');
+    const force = hasFlag(args, '--force');
+    const targets = !cursor && !claude && !gemini
+        ? ['cursor', 'claude', 'gemini']
+        : [
+            ...(cursor ? ['cursor'] : []),
+            ...(claude ? ['claude'] : []),
+            ...(gemini ? ['gemini'] : []),
+        ];
+    return { success: true, data: { command: 'skill-install', targets, force, json } };
+}
+// ── 유틸리티 함수 ──
+/**
+ * args에 특정 플래그가 존재하는지 확인
+ */
+function hasFlag(args, flag) {
+    return args.includes(flag);
+}
+/**
+ * 첫 번째 non-flag 위치 인자를 추출
+ *
+ * --로 시작하지 않는 첫 번째 인자를 반환.
+ * 옵션 값으로 사용되는 인자를 건너뛰기 위해 --option value 패턴을 인식.
+ */
+function getPositionalArg(args) {
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === undefined)
+            continue;
+        // 플래그는 건너뜀
+        if (arg.startsWith('--')) {
+            // 값을 갖는 옵션이면 다음 인자도 건너뜀
+            if (isValueOption(arg)) {
+                i++;
+            }
+            continue;
+        }
+        return arg;
+    }
+    return undefined;
+}
+/**
+ * 특정 옵션의 값을 추출 (--option value 패턴)
+ */
+function getOptionValue(args, option) {
+    const idx = args.indexOf(option);
+    if (idx === -1 || idx + 1 >= args.length) {
+        return undefined;
+    }
+    return args[idx + 1];
+}
+/**
+ * 값을 갖는 옵션인지 판별
+ */
+function isValueOption(arg) {
+    return ['--mode', '--section', '--phase', '--request'].includes(arg);
+}
+// ── stdin → ParsedArgs 변환 ──
+/**
+ * stdin JSON 데이터로부터 ParsedArgs를 생성한다
+ *
+ * 서브커맨드는 argv에서 결정되고, 인자/옵션은 stdin JSON에서 추출.
+ * --stdin은 --no-prompt를 암시한다 (stdin이 JSON 데이터에 사용되므로 인터랙티브 불가).
+ *
+ * @param subcommand - argv에서 추출한 서브커맨드 이름
+ * @param data - stdin에서 파싱한 JSON 객체
+ * @param json - --json 플래그 여부
+ * @returns ParsedArgs 또는 에러
+ */
+export function parseStdinArgs(subcommand, data, json, rawArgs) {
+    switch (subcommand) {
+        case 'set-unit': {
+            const unitId = typeof data.unitId === 'string' ? data.unitId : undefined;
+            if (!unitId) {
+                return fail('STDIN_MISSING_FIELD', 'stdin JSON에 "unitId" (string) 필드가 필요합니다', '예시: {"unitId": "U-001[Mvp]"}');
+            }
+            const requestKeys = Array.isArray(data.requestKeys)
+                ? data.requestKeys.filter((k) => typeof k === 'string')
+                : [];
+            return ok({ command: 'set-unit', unitId, requestKeys, noPrompt: true, json });
+        }
+        case 'update-commit': {
+            const modeValue = typeof data.mode === 'string' ? data.mode : undefined;
+            const mode = modeValue === 'append' ? 'append' : 'replace';
+            const section = typeof data.section === 'string' ? data.section : undefined;
+            const base = {
+                command: 'update-commit',
+                mode,
+                ...(section !== undefined && { section }),
+                json,
+            };
+            if (typeof data.sha === 'string') {
+                return ok({ ...base, commitMode: 'manual', sha: data.sha });
+            }
+            if (typeof data.count === 'number' && Number.isInteger(data.count) && data.count > 0) {
+                return ok({ ...base, commitMode: 'auto-recent', count: data.count });
+            }
+            return ok({ ...base, commitMode: 'auto-head' });
+        }
+        case 'list-units': {
+            const phase = typeof data.phase === 'string' ? data.phase : undefined;
+            return ok({
+                command: 'list-units',
+                ...(phase !== undefined && { phase }),
+                json,
+            });
+        }
+        case 'context': {
+            const unitId = typeof data.unitId === 'string' ? data.unitId : undefined;
+            if (!unitId) {
+                return fail('STDIN_MISSING_FIELD', 'stdin JSON에 "unitId" (string) 필드가 필요합니다', '예시: {"unitId": "U-001[Mvp]"}');
+            }
+            return ok({ command: 'context', unitId, json });
+        }
+        case 'validate':
+            return ok({ command: 'validate', json });
+        case 'init':
+            return ok({
+                command: 'init',
+                json,
+                stdinData: data,
+                fromExisting: rawArgs?.includes('--from-existing') ?? false,
+                force: rawArgs?.includes('--force') ?? false,
+            });
+        case 'skill': {
+            if (!rawArgs?.includes('install')) {
+                return fail('UNKNOWN_COMMAND', 'skill 서브커맨드가 필요합니다', '사용법: vc skill install --stdin --json');
+            }
+            const stdinTargets = Array.isArray(data.targets)
+                ? data.targets.filter((t) => t === 'cursor' || t === 'claude' || t === 'gemini')
+                : [];
+            const targets = stdinTargets.length > 0 ? stdinTargets : ['cursor', 'claude', 'gemini'];
+            return ok({
+                command: 'skill-install',
+                targets,
+                force: rawArgs.includes('--force'),
+                json,
+            });
+        }
+        default:
+            return fail('UNKNOWN_COMMAND', `알 수 없는 명령어: ${subcommand}`, '사용 가능한 명령어: init, set-unit, update-commit, list-units, context, validate, skill');
+    }
+}
+// ── 메인 라우터 ──
+/**
+ * CLI 라우터 메인 실행 함수
+ *
+ * process.argv를 파싱하고, 해당 서브커맨드의 핸들러를 호출하여 결과를 출력한다.
+ * 커맨드별 커스텀 포맷터가 등록되어 있으면 기본 출력 대신 포맷터를 사용.
+ *
+ * @param argv - process.argv
+ * @param projectRoot - 프로젝트 루트 경로
+ * @param handlers - 서브커맨드별 핸들러 맵 (선택, 미제공 시 stub 사용)
+ * @param formatters - 서브커맨드별 커스텀 출력 포맷터 (선택)
+ */
+export async function route(argv, projectRoot, handlers, formatters) {
+    const rawArgs = argv.slice(2);
+    const hasJsonFlag = rawArgs.includes('--json');
+    const hasStdinFlag = rawArgs.includes('--stdin');
+    let parseResult;
+    if (hasStdinFlag) {
+        // ── stdin 모드: argv에서 서브커맨드, stdin에서 인자 ──
+        const subcommand = rawArgs.find((a) => !a.startsWith('--'));
+        if (!subcommand) {
+            emitError(fail('MISSING_COMMAND', '--stdin 모드에서 서브커맨드가 필요합니다', '사용법: vc <command> --stdin [--json]'), hasJsonFlag);
+            return;
+        }
+        if (['help', '--help', '-h'].includes(subcommand)) {
+            printHelp();
+            return;
+        }
+        if (['version', '--version', '-v'].includes(subcommand)) {
+            printVersion();
+            return;
+        }
+        const stdinRaw = await readStdin();
+        const stdinResult = parseStdinJson(stdinRaw);
+        if (!stdinResult.success) {
+            emitError(stdinResult, hasJsonFlag);
+            return;
+        }
+        parseResult = parseStdinArgs(subcommand, stdinResult.data, hasJsonFlag, rawArgs);
+    }
+    else {
+        // ── 일반 모드: argv에서 모든 인자 ──
+        parseResult = parseArgs(argv);
+    }
+    // 파싱 실패
+    if (!parseResult.success) {
+        if (hasJsonFlag) {
+            printError(parseResult, true);
+        }
+        else if (parseResult.error.code === 'UNKNOWN_COMMAND') {
+            const cmd = argv[2] ?? '';
+            printUnknownCommand(cmd);
+        }
+        else if (parseResult.error.code === 'MISSING_ARGUMENT') {
+            const cmd = argv[2] ?? '';
+            const argName = extractArgName(parseResult.error.details ?? '');
+            printMissingArg(cmd, argName);
+        }
+        else {
+            printError(parseResult, false);
+        }
+        process.exitCode = 1;
+        return;
+    }
+    const parsed = parseResult.data;
+    // 글로벌 커맨드 처리
+    if (parsed.command === 'help') {
+        printHelp();
+        return;
+    }
+    if (parsed.command === 'version') {
+        printVersion();
+        return;
+    }
+    // 서브커맨드 핸들러 조회
+    const handler = handlers?.[parsed.command] ?? stubHandler;
+    const json = 'json' in parsed ? parsed.json : false;
+    const formatter = formatters?.[parsed.command];
+    const result = await handler(parsed, projectRoot);
+    if (result.success) {
+        if (formatter) {
+            formatter(result, json);
+        }
+        else {
+            printSuccess(result, json);
+        }
+    }
+    else {
+        printError(result, json);
+        process.exitCode = 1;
+    }
+}
+/**
+ * 에러를 출력하고 프로세스 종료 코드를 설정한다
+ */
+function emitError(result, json) {
+    printError(result, json);
+    process.exitCode = 1;
+}
+/**
+ * 스텁 핸들러 — 후속 유닛에서 교체될 임시 핸들러
+ *
+ * 해당 커맨드가 아직 구현되지 않았음을 알린다.
+ */
+function stubHandler(args) {
+    return fail('NOT_IMPLEMENTED', `'${args.command}' 명령어는 아직 구현되지 않았습니다`, '후속 유닛(U-014 ~ U-016)에서 구현 예정');
+}
+/**
+ * 에러 상세 메시지에서 인자 이름을 추출
+ */
+function extractArgName(details) {
+    const match = details.match(/<(\w+)>/);
+    return match?.[1] ?? 'arg';
+}
+//# sourceMappingURL=router.js.map

package/dist/adapters/cli/scanner.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 프로젝트 파일 스캐너 — Layer 3 (Adapter)
+ *
+ * 기존 프로젝트의 파일/디렉토리를 자동 스캔하여 ID 패턴, 경로 구조,
+ * 커맨드 파일 섹션 헤더를 감지하고 설정 초안 데이터를 생성한다.
+ *
+ * `vc init --from-existing` 커맨드에서 사용.
+ *
+ * @module
+ */
+import type { ScanResult } from '../../types/index.js';
+/**
+ * 프로젝트 루트를 스캔하여 ID 패턴, 문서 디렉토리, 커맨드 파일을 감지한다
+ *
+ * @param projectRoot - 프로젝트 루트 절대 경로
+ * @returns 스캔 결과
+ */
+export declare function scanProject(projectRoot: string): ScanResult;
+//# sourceMappingURL=scanner.d.ts.map

package/dist/adapters/cli/scanner.js

@@ -0,0 +1,227 @@
+/**
+ * 프로젝트 파일 스캐너 — Layer 3 (Adapter)
+ *
+ * 기존 프로젝트의 파일/디렉토리를 자동 스캔하여 ID 패턴, 경로 구조,
+ * 커맨드 파일 섹션 헤더를 감지하고 설정 초안 데이터를 생성한다.
+ *
+ * `vc init --from-existing` 커맨드에서 사용.
+ *
+ * @module
+ */
+import { readdirSync, readFileSync } from 'node:fs';
+import { join, relative, basename, dirname, extname } from 'node:path';
+// ── 상수 ──
+const EXCLUDED_DIRS = new Set([
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    'coverage',
+    '.cache',
+    '.next',
+    '.nuxt',
+    '.svelte-kit',
+    '.turbo',
+    '.vercel',
+    'out',
+    '__pycache__',
+]);
+const MAX_DEPTH = 6;
+/**
+ * 프로젝트 루트를 스캔하여 ID 패턴, 문서 디렉토리, 커맨드 파일을 감지한다
+ *
+ * @param projectRoot - 프로젝트 루트 절대 경로
+ * @returns 스캔 결과
+ */
+export function scanProject(projectRoot) {
+    const mdFiles = collectMdFiles(projectRoot, projectRoot, 0);
+    const idPatterns = detectIdPatterns(mdFiles);
+    const docRoots = detectDocRoots(mdFiles);
+    const commandFiles = detectCommandFiles(mdFiles, projectRoot);
+    const roadmapCandidates = detectRoadmapCandidates(mdFiles);
+    const suggestedIdPattern = buildCombinedPattern(idPatterns);
+    return {
+        totalMdFiles: mdFiles.length,
+        idPatterns,
+        docRoots,
+        commandFiles,
+        roadmapCandidates,
+        suggestedIdPattern,
+    };
+}
+// ── 파일 수집 ──
+function collectMdFiles(root, dir, depth) {
+    if (depth > MAX_DEPTH)
+        return [];
+    const results = [];
+    try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                if (!EXCLUDED_DIRS.has(entry.name) && !entry.name.startsWith('.')) {
+                    results.push(...collectMdFiles(root, join(dir, entry.name), depth + 1));
+                }
+            }
+            else if (entry.isFile() && extname(entry.name).toLowerCase() === '.md') {
+                const relPath = relative(root, join(dir, entry.name)).replace(/\\/g, '/');
+                results.push(relPath);
+            }
+        }
+    }
+    catch {
+        // 읽기 권한 없는 디렉토리 건너뜀
+    }
+    return results;
+}
+function detectIdPatterns(mdFiles) {
+    const prefixGroups = new Map();
+    for (const file of mdFiles) {
+        const name = basename(file, '.md');
+        // [우선순위 1] PREFIX-NNN[Tag] (예: U-001[Mvp], RU-001[Mmp])
+        const tagMatch = name.match(/^([A-Z][A-Z0-9]*)-\d+\[/);
+        if (tagMatch?.[1]) {
+            upsertGroup(prefixGroups, tagMatch[1], name, true, false);
+            continue;
+        }
+        // [우선순위 2] PREFIX-WORD-NNN (예: CP-MVP-01)
+        const compoundMatch = name.match(/^([A-Z][A-Z0-9]*)-[A-Z][A-Z0-9]*-\d+/);
+        if (compoundMatch?.[1]) {
+            upsertGroup(prefixGroups, compoundMatch[1], name, false, true);
+            continue;
+        }
+        // [우선순위 3] PREFIX-NNN (예: TASK-001)
+        const basicMatch = name.match(/^([A-Z][A-Z0-9]*)-\d+/);
+        if (basicMatch?.[1]) {
+            upsertGroup(prefixGroups, basicMatch[1], name, false, false);
+        }
+    }
+    const patterns = [];
+    for (const [prefix, group] of prefixGroups) {
+        let regex;
+        let displayLabel;
+        if (group.isCompound) {
+            regex = `${prefix}-`;
+            displayLabel = `${prefix}-*-NN`;
+        }
+        else {
+            regex = `${prefix}-\\d+`;
+            displayLabel = group.hasTag ? `${prefix}-NNN[*]` : `${prefix}-NNN`;
+        }
+        patterns.push({
+            prefix,
+            regex: `^${regex}`,
+            displayLabel,
+            matchCount: group.names.length,
+            examples: group.names.slice(0, 3),
+        });
+    }
+    patterns.sort((a, b) => b.matchCount - a.matchCount);
+    return patterns;
+}
+function upsertGroup(groups, prefix, name, hasTag, isCompound) {
+    const existing = groups.get(prefix);
+    if (existing) {
+        existing.names.push(name);
+        if (hasTag)
+            existing.hasTag = true;
+        if (isCompound)
+            existing.isCompound = true;
+    }
+    else {
+        groups.set(prefix, { names: [name], hasTag, isCompound });
+    }
+}
+// ── 문서 디렉토리 감지 ──
+const ROLE_KEYWORDS = {
+    plan: ['plan', 'plans', 'unit-plan', 'unit-plans'],
+    result: ['result', 'results', 'unit-result', 'unit-results', 'report', 'reports'],
+    runbook: ['runbook', 'runbooks', 'unit-runbook', 'unit-runbooks'],
+};
+function detectDocRoots(mdFiles) {
+    const dirCounts = new Map();
+    for (const file of mdFiles) {
+        const dir = dirname(file);
+        if (dir === '.')
+            continue;
+        dirCounts.set(dir, (dirCounts.get(dir) ?? 0) + 1);
+    }
+    const docRoots = [];
+    for (const [dir, count] of dirCounts) {
+        const dirBasename = basename(dir).toLowerCase();
+        let role = 'other';
+        for (const [r, keywords] of Object.entries(ROLE_KEYWORDS)) {
+            if (keywords.includes(dirBasename)) {
+                role = r;
+                break;
+            }
+        }
+        if (count >= 2 || role !== 'other') {
+            docRoots.push({ role, dirPath: dir, fileCount: count });
+        }
+    }
+    const roleOrder = { plan: 0, result: 1, runbook: 2, other: 3 };
+    docRoots.sort((a, b) => {
+        const orderDiff = (roleOrder[a.role] ?? 3) - (roleOrder[b.role] ?? 3);
+        if (orderDiff !== 0)
+            return orderDiff;
+        return b.fileCount - a.fileCount;
+    });
+    return docRoots;
+}
+// ── 커맨드 파일 감지 ──
+const COMMAND_FILE_INDICATORS = ['command', 'commands', 'task', 'tasks'];
+function detectCommandFiles(mdFiles, projectRoot) {
+    const candidates = [];
+    for (const file of mdFiles) {
+        const name = basename(file, '.md').toLowerCase();
+        if (!COMMAND_FILE_INDICATORS.some((ind) => name.includes(ind)))
+            continue;
+        try {
+            const content = readFileSync(join(projectRoot, file), 'utf-8');
+            const sections = extractHeaders(content);
+            const separatorMatch = content.match(/^(-{10,}|={10,})$/m);
+            if (sections.length > 0) {
+                candidates.push({
+                    filePath: file,
+                    sections,
+                    hasSeparator: separatorMatch !== null,
+                    separatorSample: separatorMatch?.[1] ?? null,
+                });
+            }
+        }
+        catch {
+            // 읽기 실패한 파일 건너뜀
+        }
+    }
+    return candidates;
+}
+function extractHeaders(content) {
+    const lines = content.split('\n');
+    const headers = [];
+    for (const line of lines) {
+        const match = line.match(/^(#{1,3})\s+(.+)/);
+        if (match?.[1] && match[2]) {
+            headers.push(`${'#'.repeat(match[1].length)} ${match[2].trim()}`);
+        }
+    }
+    return headers;
+}
+// ── 로드맵 감지 ──
+function detectRoadmapCandidates(mdFiles) {
+    return mdFiles.filter((file) => {
+        const name = basename(file, '.md').toLowerCase();
+        return name === 'roadmap' || name.includes('roadmap');
+    });
+}
+// ── 통합 ID 패턴 생성 ──
+function buildCombinedPattern(patterns) {
+    if (patterns.length === 0)
+        return null;
+    if (patterns.length === 1) {
+        const first = patterns[0];
+        return first ? `${first.regex}.*` : null;
+    }
+    const parts = patterns.map((p) => p.regex.replace(/^\^/, ''));
+    return `^(${parts.join('|')}).*`;
+}
+//# sourceMappingURL=scanner.js.map

package/dist/adapters/pipe/stdin-reader.d.ts

@@ -0,0 +1,23 @@
+/**
+ * stdin JSON 리더 — Layer 3 (Adapter)
+ *
+ * stdin에서 전체 입력을 버퍼링하고 JSON으로 파싱한다.
+ * 에이전트/오케스트레이터의 파이프 연동을 위한 입력 어댑터.
+ *
+ * @module
+ */
+import type { ToolResult } from '../../types/index.js';
+/**
+ * stdin에서 전체 데이터를 읽는다
+ *
+ * stdin stream을 EOF까지 버퍼링하여 문자열로 반환.
+ * TTY(터미널 직접 실행)인 경우 빈 문자열 반환.
+ */
+export declare function readStdin(): Promise<string>;
+/**
+ * stdin 문자열을 JSON 객체로 파싱한다
+ *
+ * 빈 입력, 비-객체, 파싱 오류를 구조화된 ToolResult로 반환.
+ */
+export declare function parseStdinJson(raw: string): ToolResult<Record<string, unknown>>;
+//# sourceMappingURL=stdin-reader.d.ts.map