vibe-commander 0.1.0

package/dist/adapters/cli/commands/init.d.ts

@@ -0,0 +1,25 @@
+/**
+ * init 커맨드 핸들러 — Layer 3 (Adapter)
+ *
+ * 대화형 질문을 통해 프로젝트 설정 파일(vibe-commander.config.json)을 생성한다.
+ * 모드 분기(대화형/stdin/from-existing)를 담당하는 진입점 파일.
+ *
+ * 파이프라인:
+ * 1. 기존 설정 파일 존재 확인 → 덮어쓰기 확인
+ * 2. 대화형 질문으로 최소 설정 정보 수집
+ * 3. 수집된 정보 → ProjectConfig 구조 구성
+ * 4. Zod 스키마 검증 → JSON 직렬화 → 파일 쓰기
+ *
+ * @module
+ */
+import type { ToolResult, InitResult } from '../../../types/index.js';
+import type { ParsedArgs } from '../router.js';
+/**
+ * init 커맨드를 실행한다
+ *
+ * @param args - 파싱된 CLI 인자 (command === 'init' 보장)
+ * @param projectRoot - 프로젝트 루트 절대 경로
+ * @returns 실행 결과 또는 에러
+ */
+export declare function handleInit(args: ParsedArgs, projectRoot: string): Promise<ToolResult<InitResult>>;
+//# sourceMappingURL=init.d.ts.map

package/dist/adapters/cli/commands/init.js

@@ -0,0 +1,73 @@
+/**
+ * init 커맨드 핸들러 — Layer 3 (Adapter)
+ *
+ * 대화형 질문을 통해 프로젝트 설정 파일(vibe-commander.config.json)을 생성한다.
+ * 모드 분기(대화형/stdin/from-existing)를 담당하는 진입점 파일.
+ *
+ * 파이프라인:
+ * 1. 기존 설정 파일 존재 확인 → 덮어쓰기 확인
+ * 2. 대화형 질문으로 최소 설정 정보 수집
+ * 3. 수집된 정보 → ProjectConfig 구조 구성
+ * 4. Zod 스키마 검증 → JSON 직렬화 → 파일 쓰기
+ *
+ * @module
+ */
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { fail } from '../../../types/index.js';
+import { CONFIG_FILENAME } from '../../../config/schema.js';
+import { scanProject } from '../scanner.js';
+import { handleInteractive, handleFromExistingInteractive } from './init-interactive.js';
+import { extractStdinAnswers, buildAnswersFromScan, buildAndWriteConfig, readExistingConfig, } from './init-helpers.js';
+/**
+ * init 커맨드를 실행한다
+ *
+ * @param args - 파싱된 CLI 인자 (command === 'init' 보장)
+ * @param projectRoot - 프로젝트 루트 절대 경로
+ * @returns 실행 결과 또는 에러
+ */
+export async function handleInit(args, projectRoot) {
+    if (args.command !== 'init') {
+        return fail('INTERNAL_ERROR', 'handleInit에 잘못된 커맨드가 전달되었습니다');
+    }
+    const configPath = join(projectRoot, CONFIG_FILENAME);
+    const alreadyExists = existsSync(configPath);
+    if (args.fromExisting) {
+        return handleFromExisting(args, projectRoot, configPath, alreadyExists);
+    }
+    if (args.stdinData) {
+        const answers = extractStdinAnswers(args.stdinData);
+        return buildAndWriteConfig(answers, configPath, alreadyExists);
+    }
+    if (!process.stdin.isTTY) {
+        return fail('NOT_INTERACTIVE', '대화형 모드는 TTY 환경에서만 사용 가능합니다', '--stdin 옵션으로 JSON 입력을 사용하세요: echo \'{"commandsPath":"..."}\'  | vc init --stdin');
+    }
+    return handleInteractive(configPath, alreadyExists);
+}
+/**
+ * --from-existing 모드 — 프로젝트를 스캔하여 패턴을 감지하고 설정을 생성한다
+ *
+ * 기존 config가 존재하면:
+ * - stdin/비TTY: --force 없으면 병합 모드 기본 적용
+ * - TTY: 병합/덮어쓰기/취소 3지선다 프롬프트
+ */
+async function handleFromExisting(args, projectRoot, configPath, alreadyExists) {
+    const scanResult = scanProject(projectRoot);
+    if (scanResult.idPatterns.length === 0) {
+        return fail('SCAN_NO_PATTERNS', 'ID 패턴을 감지하지 못했습니다', `${String(scanResult.totalMdFiles)}개 .md 파일을 스캔했지만 ID 패턴이 발견되지 않았습니다. 'vc init'으로 수동 설정을 시도하세요.`);
+    }
+    const existingConfig = alreadyExists ? readExistingConfig(configPath) : null;
+    const force = args.force;
+    if (args.stdinData) {
+        const answers = buildAnswersFromScan(scanResult, args.stdinData);
+        const mergeWith = !force && existingConfig ? existingConfig : undefined;
+        return buildAndWriteConfig(answers, configPath, alreadyExists, scanResult, mergeWith);
+    }
+    if (!process.stdin.isTTY) {
+        const answers = buildAnswersFromScan(scanResult);
+        const mergeWith = !force && existingConfig ? existingConfig : undefined;
+        return buildAndWriteConfig(answers, configPath, alreadyExists, scanResult, mergeWith);
+    }
+    return handleFromExistingInteractive(scanResult, configPath, alreadyExists, existingConfig);
+}
+//# sourceMappingURL=init.js.map

package/dist/adapters/cli/commands/io-helpers.d.ts

@@ -0,0 +1,45 @@
+/**
+ * CLI 공통 I/O 헬퍼 — Layer 3 (Adapter)
+ *
+ * 커맨드 파일 읽기, 의존 문서 파일 확인, Git 커밋 수집 등
+ * CLI 커맨드 핸들러에서 공통으로 사용하는 I/O 래퍼를 제공한다.
+ *
+ * @module
+ */
+import type { ToolResult, DepDocs, ProjectConfig, CommitSearchConfig } from '../../../types/index.js';
+import type { DepDocPattern } from '../../../core/resolvers/dep-doc-resolver.js';
+/**
+ * 커맨드 파일을 읽어 반환한다
+ */
+export declare function readCommandsFile(config: ProjectConfig, projectRoot: string): ToolResult<{
+    content: string;
+    absPath: string;
+    relPath: string;
+}>;
+/**
+ * DepDocPattern[]에서 실제 존재하는 파일만 필터링하여 DepDocs[]로 변환
+ */
+export declare function resolveActualDocs(patterns: DepDocPattern[], projectRoot: string): DepDocs[];
+/**
+ * Git 로그에서 의존 유닛 관련 커밋 SHA를 수집하고 교차 검증 필터를 적용한다
+ *
+ * 1. `git log --pretty=oneline`으로 커밋 메시지 검색 (findDepCommits)
+ * 2. excludePaths/requirePaths 설정이 있으면 각 SHA의 변경 파일을 조회 (getChangedFiles)
+ * 3. filterCommitsByChangedFiles로 필터링 (Option C: 독립 순차 적용)
+ *
+ * excludePaths/requirePaths가 모두 빈 배열이면 git diff-tree 호출을 건너뜀 (기존 동작 유지).
+ */
+export declare function collectGitCommits(depIds: string[], commitSearch: CommitSearchConfig, projectRoot: string): string[];
+/** buildSpecialRequests 반환 타입 */
+export interface BuildSpecialRequestsResult {
+    requests: string[];
+    warnings: string[];
+}
+/**
+ * 기본 + 유닛 유형별 + 커스텀 키 선택 특별 요청사항을 합산
+ *
+ * 병합 순서: defaultSpecialRequests → specialRequestsByType[key] → customRequests[선택된 키들]
+ * 존재하지 않는 키는 warnings에 추가하고 나머지는 정상 처리 (Graceful Degradation)
+ */
+export declare function buildSpecialRequests(config: ProjectConfig, unitTypeKey: string, requestKeys?: string[]): BuildSpecialRequestsResult;
+//# sourceMappingURL=io-helpers.d.ts.map

package/dist/adapters/cli/commands/io-helpers.js

@@ -0,0 +1,144 @@
+/**
+ * CLI 공통 I/O 헬퍼 — Layer 3 (Adapter)
+ *
+ * 커맨드 파일 읽기, 의존 문서 파일 확인, Git 커밋 수집 등
+ * CLI 커맨드 핸들러에서 공통으로 사용하는 I/O 래퍼를 제공한다.
+ *
+ * @module
+ */
+import { readFileSync, existsSync, readdirSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+import { join } from 'node:path';
+import { ok, fail } from '../../../types/index.js';
+import { findDepCommits } from '../../../core/resolvers/dep-commit-resolver.js';
+import { filterCommitsByChangedFiles } from '../../../core/resolvers/commit-filter.js';
+import { getChangedFiles } from './git-helpers.js';
+/**
+ * 커맨드 파일을 읽어 반환한다
+ */
+export function readCommandsFile(config, projectRoot) {
+    const relPath = config.paths.commands;
+    const absPath = join(projectRoot, relPath);
+    try {
+        const content = readFileSync(absPath, 'utf-8');
+        return ok({ content, absPath, relPath });
+    }
+    catch {
+        return fail('COMMANDS_NOT_FOUND', `커맨드 파일을 찾을 수 없습니다: ${relPath}`, `절대 경로: ${absPath}`);
+    }
+}
+/**
+ * DepDocPattern[]에서 실제 존재하는 파일만 필터링하여 DepDocs[]로 변환
+ */
+export function resolveActualDocs(patterns, projectRoot) {
+    const result = [];
+    for (const pattern of patterns) {
+        const found = [];
+        for (const loc of pattern.locations) {
+            if (loc.glob) {
+                const dirPath = join(projectRoot, loc.dir);
+                try {
+                    if (existsSync(dirPath)) {
+                        const files = readdirSync(dirPath);
+                        const regex = globToRegex(loc.filePattern);
+                        for (const file of files) {
+                            if (regex.test(file)) {
+                                found.push({ role: loc.role, path: `${loc.dir}/${file}` });
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // 디렉토리 읽기 실패 시 무시
+                }
+            }
+            else {
+                const fullPath = join(projectRoot, loc.fullPattern);
+                if (existsSync(fullPath)) {
+                    found.push({ role: loc.role, path: loc.fullPattern });
+                }
+            }
+        }
+        result.push({ unitId: pattern.unitId, found });
+    }
+    return result;
+}
+/**
+ * Git 로그에서 의존 유닛 관련 커밋 SHA를 수집하고 교차 검증 필터를 적용한다
+ *
+ * 1. `git log --pretty=oneline`으로 커밋 메시지 검색 (findDepCommits)
+ * 2. excludePaths/requirePaths 설정이 있으면 각 SHA의 변경 파일을 조회 (getChangedFiles)
+ * 3. filterCommitsByChangedFiles로 필터링 (Option C: 독립 순차 적용)
+ *
+ * excludePaths/requirePaths가 모두 빈 배열이면 git diff-tree 호출을 건너뜀 (기존 동작 유지).
+ */
+export function collectGitCommits(depIds, commitSearch, projectRoot) {
+    if (commitSearch.strategy === 'disabled')
+        return [];
+    try {
+        const output = execSync('git log --pretty=oneline -200', {
+            cwd: projectRoot,
+            encoding: 'utf-8',
+            timeout: 10000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const result = findDepCommits(depIds, output, commitSearch);
+        if (!result.success)
+            return [];
+        const shas = result.data.map((c) => c.sha);
+        // excludePaths/requirePaths 모두 빈 배열이면 필터 건너뜀 (기존 동작 유지)
+        const needsFilter = commitSearch.excludePaths.length > 0 || commitSearch.requirePaths.length > 0;
+        if (!needsFilter)
+            return shas;
+        // 교차 검증: 각 SHA에 대해 변경 파일 수집
+        const commitsWithFiles = shas.map((sha) => {
+            const filesResult = getChangedFiles(projectRoot, sha);
+            return {
+                sha,
+                changedFiles: filesResult.success ? filesResult.data : [],
+            };
+        });
+        // 필터링 적용 (Option C — 독립 순차)
+        const filtered = filterCommitsByChangedFiles(commitsWithFiles, {
+            excludePaths: commitSearch.excludePaths,
+            requirePaths: commitSearch.requirePaths,
+        });
+        return filtered.map((c) => c.sha);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * 기본 + 유닛 유형별 + 커스텀 키 선택 특별 요청사항을 합산
+ *
+ * 병합 순서: defaultSpecialRequests → specialRequestsByType[key] → customRequests[선택된 키들]
+ * 존재하지 않는 키는 warnings에 추가하고 나머지는 정상 처리 (Graceful Degradation)
+ */
+export function buildSpecialRequests(config, unitTypeKey, requestKeys) {
+    const defaults = config.defaultSpecialRequests;
+    const typeSpecific = config.specialRequestsByType[unitTypeKey] ?? [];
+    const requests = [...defaults, ...typeSpecific];
+    const warnings = [];
+    if (requestKeys && requestKeys.length > 0) {
+        const customRequests = config.customRequests;
+        for (const key of requestKeys) {
+            const value = customRequests[key];
+            if (value !== undefined) {
+                requests.push(value);
+            }
+            else {
+                warnings.push(`커스텀 요청사항 키 '${key}'를 찾을 수 없습니다 (무시됨)`);
+            }
+        }
+    }
+    return { requests, warnings };
+}
+/**
+ * 간단한 glob 패턴(* 와일드카드)을 정규식으로 변환
+ */
+function globToRegex(pattern) {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*');
+    return new RegExp(`^${escaped}$`);
+}
+//# sourceMappingURL=io-helpers.js.map

package/dist/adapters/cli/commands/list-units.d.ts

@@ -0,0 +1,39 @@
+/**
+ * list-units 커맨드 핸들러 — Layer 3 (Adapter)
+ *
+ * 로드맵 백로그를 파싱하여 미완료 유닛 목록을
+ * ready/inProgress/blocked로 분류하여 출력한다.
+ *
+ * Core 순수 함수(parseBacklog)를 호출하며,
+ * I/O(파일 읽기)는 이 Adapter에서만 수행.
+ *
+ * @module
+ */
+import type { ToolResult, BacklogEntry } from '../../../types/index.js';
+import type { ParsedArgs } from '../router.js';
+/** list-units 실행 결과 */
+export interface ListUnitsResult {
+    total: number;
+    inProgress: BacklogEntry[];
+    ready: BacklogEntry[];
+    blocked: BacklogEntry[];
+    phase?: string;
+}
+/**
+ * list-units 커맨드를 실행한다
+ *
+ * 파이프라인:
+ * 1. 설정 로드 (loadConfig)
+ * 2. 로드맵 경로 확인 — null이면 에러 반환
+ * 3. 로드맵 파일 읽기 (Adapter I/O)
+ * 4. 백로그 파싱 (parseBacklog)
+ * 5. completed 제외, phase 필터링
+ * 6. 상태별 분류 (inProgress/ready/blocked)
+ * 7. 결과 반환
+ *
+ * @param args - 파싱된 CLI 인자 (command === 'list-units' 보장)
+ * @param projectRoot - 프로젝트 루트 절대 경로
+ * @returns 실행 결과 또는 에러
+ */
+export declare function handleListUnits(args: ParsedArgs, projectRoot: string): ToolResult<ListUnitsResult>;
+//# sourceMappingURL=list-units.d.ts.map

package/dist/adapters/cli/commands/list-units.js

@@ -0,0 +1,92 @@
+/**
+ * list-units 커맨드 핸들러 — Layer 3 (Adapter)
+ *
+ * 로드맵 백로그를 파싱하여 미완료 유닛 목록을
+ * ready/inProgress/blocked로 분류하여 출력한다.
+ *
+ * Core 순수 함수(parseBacklog)를 호출하며,
+ * I/O(파일 읽기)는 이 Adapter에서만 수행.
+ *
+ * @module
+ */
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ok, fail } from '../../../types/index.js';
+import { loadConfig } from '../../../config/loader.js';
+import { parseBacklog } from '../../../core/parsers/backlog-parser.js';
+/**
+ * list-units 커맨드를 실행한다
+ *
+ * 파이프라인:
+ * 1. 설정 로드 (loadConfig)
+ * 2. 로드맵 경로 확인 — null이면 에러 반환
+ * 3. 로드맵 파일 읽기 (Adapter I/O)
+ * 4. 백로그 파싱 (parseBacklog)
+ * 5. completed 제외, phase 필터링
+ * 6. 상태별 분류 (inProgress/ready/blocked)
+ * 7. 결과 반환
+ *
+ * @param args - 파싱된 CLI 인자 (command === 'list-units' 보장)
+ * @param projectRoot - 프로젝트 루트 절대 경로
+ * @returns 실행 결과 또는 에러
+ */
+export function handleListUnits(args, projectRoot) {
+    if (args.command !== 'list-units') {
+        return fail('INTERNAL_ERROR', 'handleListUnits에 잘못된 커맨드가 전달되었습니다');
+    }
+    const { phase } = args;
+    // 1. 설정 로드
+    const configResult = loadConfig(projectRoot);
+    if (!configResult.success)
+        return configResult;
+    const config = configResult.data;
+    // 2. 로드맵 경로 확인
+    if (!config.paths.roadmap) {
+        return fail('ROADMAP_NOT_CONFIGURED', '로드맵 파일이 설정되지 않았습니다', 'vibe-commander.config.json의 paths.roadmap을 설정하세요');
+    }
+    // 3. 로드맵 파일 읽기 (Adapter I/O)
+    const roadmapAbsPath = join(projectRoot, config.paths.roadmap);
+    let roadmapContent;
+    try {
+        roadmapContent = readFileSync(roadmapAbsPath, 'utf-8');
+    }
+    catch {
+        return fail('ROADMAP_NOT_FOUND', `로드맵 파일을 찾을 수 없습니다: ${config.paths.roadmap}`, `절대 경로: ${roadmapAbsPath}`);
+    }
+    // 4. 백로그 파싱 (Core 순수 함수)
+    const parseResult = parseBacklog(roadmapContent, config.backlogParsing);
+    if (!parseResult.success)
+        return parseResult;
+    // 5. 활성 항목만 필터 (completed 제외)
+    let entries = parseResult.data.filter((e) => e.status !== 'completed');
+    // 6. phase 필터링 (대소문자 무시)
+    if (phase) {
+        const normalizedPhase = phase.toLowerCase();
+        entries = entries.filter((e) => {
+            const entryPhase = extractPhase(e.unitId);
+            return entryPhase !== null && entryPhase.toLowerCase() === normalizedPhase;
+        });
+    }
+    // 7. 상태별 분류
+    const inProgress = entries.filter((e) => e.status === 'inProgress');
+    const ready = entries.filter((e) => e.status === 'ready');
+    const blocked = entries.filter((e) => e.status === 'blocked');
+    return ok({
+        total: entries.length,
+        inProgress,
+        ready,
+        blocked,
+        ...(phase !== undefined && { phase }),
+    });
+}
+/**
+ * 유닛 ID에서 phase 태그를 추출한다
+ *
+ * "U-016[Mvp]" → "Mvp"
+ * "CP-MVP-03" → null
+ */
+function extractPhase(unitId) {
+    const match = unitId.match(/\[([^\]]+)\]$/);
+    return match?.[1] ?? null;
+}
+//# sourceMappingURL=list-units.js.map

package/dist/adapters/cli/commands/prompt-helpers.d.ts

@@ -0,0 +1,36 @@
+/**
+ * CLI 인터랙티브 프롬프트 유틸리티 — Layer 3 (Adapter)
+ *
+ * 페어링 질문의 미결정 항목을 CLI에서 즉석으로 답변받는 기능을 제공한다.
+ * Node.js 내장 readline/promises 모듈을 사용하여 외부 의존성 추가 없음
+ * (RULE-003 준수).
+ *
+ * readline 인터페이스는 사용 후 반드시 close()하여 이벤트 루프를 정리한다.
+ *
+ * @module
+ */
+import type { PairingQuestion, PairingAnswer } from '../../../types/index.js';
+/**
+ * 현재 환경이 인터랙티브 프롬프트를 지원하는지 판별한다
+ *
+ * 다음 조건 중 하나라도 해당되면 비대화형으로 판정:
+ * - `--no-prompt` 플래그가 활성화됨
+ * - stdin이 TTY가 아님 (파이프, CI 환경 등)
+ *
+ * @param noPrompt - CLI `--no-prompt` 옵션 값
+ * @returns 대화형 프롬프트 가능 여부
+ */
+export declare function isInteractive(noPrompt: boolean): boolean;
+/**
+ * 미결정 페어링 질문들에 대해 CLI 프롬프트를 실행한다
+ *
+ * 미결정(resolved=false) 질문만 추출하여 순서대로 프롬프트를 표시한다.
+ * - 옵션이 있는 질문: 번호 선택 프롬프트
+ * - 옵션이 없는 질문: 자유 텍스트 입력
+ * - 각 질문마다 건너뛰기(Skip) 가능
+ *
+ * @param questions - 전체 페어링 질문 목록 (resolved/unresolved 모두)
+ * @returns 사용자가 답변한 PairingAnswer 배열 (건너뛴 질문은 제외)
+ */
+export declare function promptAllQuestions(questions: PairingQuestion[]): Promise<PairingAnswer[]>;
+//# sourceMappingURL=prompt-helpers.d.ts.map

package/dist/adapters/cli/commands/prompt-helpers.js

@@ -0,0 +1,113 @@
+/**
+ * CLI 인터랙티브 프롬프트 유틸리티 — Layer 3 (Adapter)
+ *
+ * 페어링 질문의 미결정 항목을 CLI에서 즉석으로 답변받는 기능을 제공한다.
+ * Node.js 내장 readline/promises 모듈을 사용하여 외부 의존성 추가 없음
+ * (RULE-003 준수).
+ *
+ * readline 인터페이스는 사용 후 반드시 close()하여 이벤트 루프를 정리한다.
+ *
+ * @module
+ */
+import { createInterface } from 'node:readline/promises';
+import { stdin, stdout } from 'node:process';
+import { CYAN, YELLOW, GREEN, DIM, RESET, BOLD } from '../output.js';
+/**
+ * 현재 환경이 인터랙티브 프롬프트를 지원하는지 판별한다
+ *
+ * 다음 조건 중 하나라도 해당되면 비대화형으로 판정:
+ * - `--no-prompt` 플래그가 활성화됨
+ * - stdin이 TTY가 아님 (파이프, CI 환경 등)
+ *
+ * @param noPrompt - CLI `--no-prompt` 옵션 값
+ * @returns 대화형 프롬프트 가능 여부
+ */
+export function isInteractive(noPrompt) {
+    if (noPrompt)
+        return false;
+    return process.stdin.isTTY;
+}
+/**
+ * 미결정 페어링 질문들에 대해 CLI 프롬프트를 실행한다
+ *
+ * 미결정(resolved=false) 질문만 추출하여 순서대로 프롬프트를 표시한다.
+ * - 옵션이 있는 질문: 번호 선택 프롬프트
+ * - 옵션이 없는 질문: 자유 텍스트 입력
+ * - 각 질문마다 건너뛰기(Skip) 가능
+ *
+ * @param questions - 전체 페어링 질문 목록 (resolved/unresolved 모두)
+ * @returns 사용자가 답변한 PairingAnswer 배열 (건너뛴 질문은 제외)
+ */
+export async function promptAllQuestions(questions) {
+    const unresolved = questions.filter((q) => !q.resolved);
+    if (unresolved.length === 0)
+        return [];
+    console.log('');
+    console.log(`${BOLD}🔍 미결정 페어링 질문이 ${String(unresolved.length)}개 발견되었습니다.${RESET}`);
+    const rl = createInterface({ input: stdin, output: stdout });
+    const answers = [];
+    try {
+        for (const question of unresolved) {
+            const answer = await promptSingleQuestion(rl, question);
+            if (answer)
+                answers.push(answer);
+        }
+    }
+    catch {
+        // Ctrl+C 또는 스트림 종료 시 수집된 답변까지만 반환
+    }
+    finally {
+        rl.close();
+    }
+    if (answers.length > 0) {
+        console.log('');
+        console.log(`${GREEN}✅ ${String(answers.length)}개 질문에 답변 완료${RESET}`);
+    }
+    return answers;
+}
+/**
+ * 단일 페어링 질문에 대한 프롬프트를 실행한다
+ *
+ * @param rl - readline 인터페이스 (외부에서 생성, 수명 관리)
+ * @param question - 프롬프트할 페어링 질문
+ * @returns 답변 또는 null (건너뛰기)
+ */
+async function promptSingleQuestion(rl, question) {
+    const options = question.options ?? [];
+    console.log('');
+    console.log(`${BOLD}❓ ${question.id}${RESET}: ${question.text}`);
+    if (options.length > 0) {
+        return promptWithOptions(rl, question.id, options);
+    }
+    return promptFreeText(rl, question.id);
+}
+/**
+ * 옵션 선택 프롬프트 (번호 입력)
+ */
+async function promptWithOptions(rl, questionId, options) {
+    for (let i = 0; i < options.length; i++) {
+        console.log(`  ${CYAN}[${String(i + 1)}]${RESET} ${options[i] ?? ''}`);
+    }
+    console.log(`  ${DIM}[S] 건너뛰기${RESET}`);
+    const answer = await rl.question(`${YELLOW}선택: ${RESET}`);
+    const trimmed = answer.trim().toLowerCase();
+    if (trimmed === 's' || trimmed === '')
+        return null;
+    const idx = parseInt(trimmed, 10) - 1;
+    if (idx >= 0 && idx < options.length) {
+        return { questionId, selectedOption: options[idx] };
+    }
+    console.log(`${DIM}유효하지 않은 선택입니다. 건너뜁니다.${RESET}`);
+    return null;
+}
+/**
+ * 자유 텍스트 입력 프롬프트
+ */
+async function promptFreeText(rl, questionId) {
+    const answer = await rl.question(`${YELLOW}답변 입력 (건너뛰려면 Enter): ${RESET}`);
+    const trimmed = answer.trim();
+    if (trimmed === '')
+        return null;
+    return { questionId, freeText: trimmed };
+}
+//# sourceMappingURL=prompt-helpers.js.map

package/dist/adapters/cli/commands/set-unit.d.ts

@@ -0,0 +1,44 @@
+/**
+ * set-unit 커맨드 핸들러 — Layer 3 (Adapter)
+ *
+ * 유닛 ID를 받아 계획서 파싱 → 의존성 수집 → 섹션 렌더링 → 커맨드 파일 업데이트
+ * 전체 파이프라인을 실행한다.
+ *
+ * Core 순수 함수들(parseUnitPlan, resolveDepDocs, findDepCommits,
+ * renderSection, updateSection)을 조합하며,
+ * I/O(파일 읽기/쓰기, git 실행)는 이 Adapter에서만 수행.
+ *
+ * @module
+ */
+import type { ToolResult, PairingQuestion, PairingAnswer } from '../../../types/index.js';
+import type { ParsedArgs } from '../router.js';
+/** set-unit 실행 결과 */
+export interface SetUnitResult {
+    unitId: string;
+    unitType: string;
+    title: string;
+    planPath: string;
+    depsFound: number;
+    docsFound: number;
+    commitsFound: number;
+    pairingQuestions: PairingQuestion[];
+    pairingAnswers: PairingAnswer[];
+    commandsUpdated: boolean;
+    warnings: string[];
+}
+/**
+ * set-unit 커맨드를 실행한다
+ *
+ * 파이프라인:
+ * 1. 전체 컨텍스트 해석 (resolveCommandContext)
+ * 2. 미결정 페어링 질문 프롬프트 (인터랙티브 모드일 때)
+ * 3. 섹션 렌더링 (renderSection)
+ * 4. 커맨드 파일 업데이트 (updateSection)
+ * 5. 결과 반환
+ *
+ * @param args - 파싱된 CLI 인자 (command === 'set-unit' 보장)
+ * @param projectRoot - 프로젝트 루트 절대 경로
+ * @returns 실행 결과 또는 에러
+ */
+export declare function handleSetUnit(args: ParsedArgs, projectRoot: string): Promise<ToolResult<SetUnitResult>>;
+//# sourceMappingURL=set-unit.d.ts.map