vibe-commander 0.1.0

package/dist/core/resolvers/commit-filter.js

@@ -0,0 +1,95 @@
+/**
+ * 커밋 교차 검증 필터 — Layer 1 순수 함수
+ *
+ * `git diff-tree`로 수집된 변경 파일 목록을 기반으로,
+ * excludePaths/requirePaths glob 패턴에 따라 커밋을 필터링한다.
+ *
+ * **순수 함수**: child_process, fs 등 I/O 모듈을 사용하지 않음.
+ * 변경 파일 수집은 Adapter(Layer 3)의 책임이며,
+ * 이 함수는 이미 수집된 목록을 받아 필터링만 담당한다.
+ *
+ * **Q2 결정 (Option C — 독립 적용)**:
+ * excludePaths와 requirePaths를 독립 필터로 순차 적용.
+ * - excludePaths 필터: 변경 파일이 모두 exclude 패턴에 매칭되면 제거 (문서 전용 커밋)
+ * - requirePaths 필터: 변경 파일 중 require 패턴에 하나도 매칭 안 되면 제거
+ * - 두 필터가 모두 빈 배열이면 기존 동작 유지
+ *
+ * @module
+ */
+/**
+ * 변경 파일 목록을 기반으로 커밋을 필터링한다
+ *
+ * excludePaths와 requirePaths를 독립 필터로 순차 적용 (Option C).
+ * 두 필터가 모두 빈 배열이면 모든 커밋 통과 (Graceful Degradation).
+ *
+ * @param commits - 변경 파일 목록이 포함된 커밋 배열
+ * @param options - 필터 옵션 (excludePaths, requirePaths)
+ * @returns 필터를 통과한 커밋 배열
+ *
+ * @example
+ * ```typescript
+ * const commits = [
+ *   { sha: 'abc1234', changedFiles: ['src/core/parser.ts', 'vibe/unit-plans/U-001.md'] },
+ *   { sha: 'def5678', changedFiles: ['vibe/unit-plans/U-001.md'] },
+ * ];
+ * const filtered = filterCommitsByChangedFiles(commits, {
+ *   excludePaths: ['vibe/**'],
+ * });
+ * // filtered → [{ sha: 'abc1234', changedFiles: [...] }]
+ * // def5678 제거: 변경 파일이 모두 vibe/** 패턴에 매칭됨
+ * ```
+ */
+export function filterCommitsByChangedFiles(commits, options = {}) {
+    const { excludePaths = [], requirePaths = [] } = options;
+    if (excludePaths.length === 0 && requirePaths.length === 0) {
+        return commits;
+    }
+    let result = commits;
+    // excludePaths 필터: 변경 파일이 모두 exclude 패턴에 매칭되면 제거
+    if (excludePaths.length > 0) {
+        result = result.filter((commit) => {
+            if (commit.changedFiles.length === 0)
+                return true;
+            // 모든 파일이 exclude 패턴 중 하나에 매칭되면 필터링 (false = 제거)
+            return !commit.changedFiles.every((file) => excludePaths.some((pattern) => matchesGlobPattern(file, pattern)));
+        });
+    }
+    // requirePaths 필터: 변경 파일 중 하나도 require 패턴에 매칭 안 되면 제거
+    if (requirePaths.length > 0) {
+        result = result.filter((commit) => {
+            if (commit.changedFiles.length === 0)
+                return false;
+            return commit.changedFiles.some((file) => requirePaths.some((pattern) => matchesGlobPattern(file, pattern)));
+        });
+    }
+    return result;
+}
+// ── 내부 헬퍼 ──
+/**
+ * 파일 경로가 glob 패턴에 매칭되는지 검사한다
+ *
+ * 지원하는 와일드카드:
+ * - `**` — 모든 경로 세그먼트 매칭 (슬래시 포함)
+ * - `*`  — 단일 경로 세그먼트 매칭 (슬래시 미포함)
+ *
+ * 예시:
+ * - `src/**` → `src/core/foo.ts` ✅, `docs/foo.ts` ❌
+ * - `**\/*.md` → `vibe/unit-plans/U-001.md` ✅, `src/core/foo.ts` ❌
+ * - `src/*.ts` → `src/foo.ts` ✅, `src/core/foo.ts` ❌
+ *
+ * @param filePath - 검사할 파일 경로 (프로젝트 루트 기준 상대 경로)
+ * @param pattern - glob 패턴
+ * @returns 매칭 여부
+ */
+export function matchesGlobPattern(filePath, pattern) {
+    const DOUBLE_STAR = '__DOUBLE_STAR__';
+    // 정규식 특수문자 이스케이프 (*와 ** 는 이후 단계에서 처리)
+    const regexStr = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&') // regex 특수문자 이스케이프
+        .replace(/\*\*/g, DOUBLE_STAR) // ** 임시 치환
+        .replace(/\*/g, '[^/]*') // * → 슬래시 미포함 임의 문자
+        .replace(new RegExp(`${DOUBLE_STAR}/`, 'g'), '(.*\\/)?') // **/ → 선택적 경로 접두사
+        .replace(new RegExp(DOUBLE_STAR, 'g'), '.*'); // 남은 ** → 임의 문자 (슬래시 포함)
+    return new RegExp(`^${regexStr}$`).test(filePath);
+}
+//# sourceMappingURL=commit-filter.js.map

package/dist/core/resolvers/config-generator.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 프로젝트 설정 생성 로직 — Layer 1 (Core / Pure Functions)
+ *
+ * 수집된 답변이나 스캔 결과를 바탕으로 ProjectConfig 객체를 생성한다.
+ * 이 모듈은 I/O를 수행하지 않으며, 데이터 구조 변환 및 기본값 관리를 담당한다.
+ *
+ * @module
+ */
+import type { ScanResult, InitAnswers } from '../../types/index.js';
+export declare const DEFAULT_COMMANDS_PATH = "vibe/commands.md";
+export declare const DEFAULT_ROADMAP_PATH = "vibe/roadmap.md";
+export declare const DEFAULT_PLAN_DIR = "vibe/unit-plans";
+export declare const DEFAULT_RESULT_DIR = "vibe/unit-results";
+export declare const DEFAULT_ID_PATTERN = "^(U-\\d+|CP-).*";
+export declare const DEFAULT_COMMAND_SECTION = "# \uC720\uB2DB \uAD6C\uD604";
+export declare const DEFAULT_HEADER_TEMPLATE = "### \uD604\uC7AC \uAD6C\uD604 \uC720\uB2DB: {{title}}\n- \uD604\uC7AC \uAD6C\uD604 \uC720\uB2DB \uAC1C\uBC1C \uACC4\uD68D\uC11C: @{{planPath}}\n- \uD604\uC7AC \uAD6C\uD604 Commit(\uBCC0\uACBD\uC810 \uD655\uC778\uD558\uC5EC \uB9E5\uB77D\uC73C\uB85C \uC0AC\uC6A9): -";
+/**
+ * 외부 주입 데이터(stdin 등)에서 InitAnswers를 추출한다
+ */
+export declare function extractStdinAnswers(data: Record<string, unknown>): InitAnswers;
+/**
+ * 스캔 결과로부터 InitAnswers를 생성한다 (오버라이드 적용 가능)
+ */
+export declare function buildAnswersFromScan(scanResult: ScanResult, overrides?: Record<string, unknown>): InitAnswers;
+/**
+ * InitAnswers → 설정 JSON 객체 구성 (최소 필드)
+ *
+ * 이 함수는 Zod 스키마에 정의된 기본값들을 제외한 핵심 필드만으로 객체를 구성합니다.
+ * 최종 결과는 Zod로 검증하거나 기존 설정과 병합하는 용도로 사용됩니다.
+ */
+export declare function buildConfigObject(answers: InitAnswers): Record<string, unknown>;
+//# sourceMappingURL=config-generator.d.ts.map

package/dist/core/resolvers/config-generator.js

@@ -0,0 +1,112 @@
+/**
+ * 프로젝트 설정 생성 로직 — Layer 1 (Core / Pure Functions)
+ *
+ * 수집된 답변이나 스캔 결과를 바탕으로 ProjectConfig 객체를 생성한다.
+ * 이 모듈은 I/O를 수행하지 않으며, 데이터 구조 변환 및 기본값 관리를 담당한다.
+ *
+ * @module
+ */
+// ── 기본값 상수 ──
+export const DEFAULT_COMMANDS_PATH = 'vibe/commands.md';
+export const DEFAULT_ROADMAP_PATH = 'vibe/roadmap.md';
+export const DEFAULT_PLAN_DIR = 'vibe/unit-plans';
+export const DEFAULT_RESULT_DIR = 'vibe/unit-results';
+export const DEFAULT_ID_PATTERN = '^(U-\\d+|CP-).*';
+export const DEFAULT_COMMAND_SECTION = '# 유닛 구현';
+export const DEFAULT_HEADER_TEMPLATE = '### 현재 구현 유닛: {{title}}\n- 현재 구현 유닛 개발 계획서: @{{planPath}}\n- 현재 구현 Commit(변경점 확인하여 맥락으로 사용): -';
+/**
+ * Record<string, unknown> 오버라이드를 InitAnswers 기본값에 적용한다
+ */
+function applyOverrides(defaults, overrides) {
+    return {
+        commandsPath: typeof overrides['commandsPath'] === 'string'
+            ? overrides['commandsPath']
+            : defaults.commandsPath,
+        roadmapPath: typeof overrides['roadmapPath'] === 'string'
+            ? overrides['roadmapPath']
+            : overrides['roadmapPath'] === null
+                ? null
+                : defaults.roadmapPath,
+        planDir: typeof overrides['planDir'] === 'string' ? overrides['planDir'] : defaults.planDir,
+        resultDir: typeof overrides['resultDir'] === 'string' ? overrides['resultDir'] : defaults.resultDir,
+        runbookDir: typeof overrides['runbookDir'] === 'string' ? overrides['runbookDir'] : defaults.runbookDir,
+        idPattern: typeof overrides['idPattern'] === 'string' ? overrides['idPattern'] : defaults.idPattern,
+        commandSection: typeof overrides['commandSection'] === 'string'
+            ? overrides['commandSection']
+            : defaults.commandSection,
+    };
+}
+/**
+ * 외부 주입 데이터(stdin 등)에서 InitAnswers를 추출한다
+ */
+export function extractStdinAnswers(data) {
+    const defaults = {
+        commandsPath: DEFAULT_COMMANDS_PATH,
+        roadmapPath: DEFAULT_ROADMAP_PATH,
+        planDir: DEFAULT_PLAN_DIR,
+        resultDir: DEFAULT_RESULT_DIR,
+        runbookDir: null,
+        idPattern: DEFAULT_ID_PATTERN,
+        commandSection: DEFAULT_COMMAND_SECTION,
+    };
+    return applyOverrides(defaults, data);
+}
+/**
+ * 스캔 결과로부터 InitAnswers를 생성한다 (오버라이드 적용 가능)
+ */
+export function buildAnswersFromScan(scanResult, overrides) {
+    const planRoot = scanResult.docRoots.find((d) => d.role === 'plan');
+    const resultRoot = scanResult.docRoots.find((d) => d.role === 'result');
+    const runbookRoot = scanResult.docRoots.find((d) => d.role === 'runbook');
+    const commandFile = scanResult.commandFiles[0];
+    const roadmap = scanResult.roadmapCandidates[0] ?? null;
+    const bestSection = commandFile?.sections.find((s) => s.startsWith('# ') || s.startsWith('## '));
+    const defaults = {
+        commandsPath: commandFile?.filePath ?? DEFAULT_COMMANDS_PATH,
+        roadmapPath: roadmap ?? DEFAULT_ROADMAP_PATH,
+        planDir: planRoot?.dirPath ?? DEFAULT_PLAN_DIR,
+        resultDir: resultRoot?.dirPath ?? DEFAULT_RESULT_DIR,
+        runbookDir: runbookRoot?.dirPath ?? null,
+        idPattern: scanResult.suggestedIdPattern ?? DEFAULT_ID_PATTERN,
+        commandSection: bestSection ?? DEFAULT_COMMAND_SECTION,
+    };
+    if (!overrides)
+        return defaults;
+    return applyOverrides(defaults, overrides);
+}
+/**
+ * InitAnswers → 설정 JSON 객체 구성 (최소 필드)
+ *
+ * 이 함수는 Zod 스키마에 정의된 기본값들을 제외한 핵심 필드만으로 객체를 구성합니다.
+ * 최종 결과는 Zod로 검증하거나 기존 설정과 병합하는 용도로 사용됩니다.
+ */
+export function buildConfigObject(answers) {
+    const docRoots = {
+        plan: answers.planDir,
+        result: answers.resultDir,
+    };
+    if (answers.runbookDir) {
+        docRoots['runbook'] = answers.runbookDir;
+    }
+    return {
+        $schema: 'https://vibe-commander/config-schema.json',
+        version: 1,
+        paths: {
+            commands: answers.commandsPath,
+            roadmap: answers.roadmapPath,
+            docRoots,
+        },
+        unitTypes: [
+            {
+                key: 'implement',
+                displayName: '유닛 구현',
+                idPattern: answers.idPattern,
+                planDir: 'plan',
+                commandSection: answers.commandSection,
+                collectDeps: true,
+                headerTemplate: DEFAULT_HEADER_TEMPLATE,
+            },
+        ],
+    };
+}
+//# sourceMappingURL=config-generator.js.map

package/dist/core/resolvers/config-merger.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 설정 병합 유틸리티 — Layer 1 (Core)
+ *
+ * 기존 설정(existing)에 스캔 결과(scanned)를 병합하여
+ * 커스텀 필드를 보존하면서 감지된 경로/패턴을 반영한다.
+ *
+ * 순수 함수: JSON in → JSON out, I/O 없음.
+ *
+ * 병합 전략:
+ * - `$schema`, `version`: 스캔 결과 우선
+ * - `paths`: 스캔 결과 우선 반영 (갱신), 없는 키 추가
+ * - `unitTypes`: 기존 배열 유지 + key 또는 idPattern이 새로운 항목만 추가
+ * - 기타 필드: 기존 값 보존 (커스텀 설정 보호)
+ *
+ * @module
+ */
+/**
+ * 기존 설정에 스캔 결과를 병합한다
+ *
+ * @param existing - 기존 설정 파일의 파싱된 JSON 객체
+ * @param scanned - 스캔 결과로 생성된 최소 설정 객체
+ * @returns 병합된 설정 객체
+ */
+export declare function mergeConfigs(existing: Record<string, unknown>, scanned: Record<string, unknown>): Record<string, unknown>;
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+//# sourceMappingURL=config-merger.d.ts.map

package/dist/core/resolvers/config-merger.js

@@ -0,0 +1,89 @@
+/**
+ * 설정 병합 유틸리티 — Layer 1 (Core)
+ *
+ * 기존 설정(existing)에 스캔 결과(scanned)를 병합하여
+ * 커스텀 필드를 보존하면서 감지된 경로/패턴을 반영한다.
+ *
+ * 순수 함수: JSON in → JSON out, I/O 없음.
+ *
+ * 병합 전략:
+ * - `$schema`, `version`: 스캔 결과 우선
+ * - `paths`: 스캔 결과 우선 반영 (갱신), 없는 키 추가
+ * - `unitTypes`: 기존 배열 유지 + key 또는 idPattern이 새로운 항목만 추가
+ * - 기타 필드: 기존 값 보존 (커스텀 설정 보호)
+ *
+ * @module
+ */
+/**
+ * 기존 설정에 스캔 결과를 병합한다
+ *
+ * @param existing - 기존 설정 파일의 파싱된 JSON 객체
+ * @param scanned - 스캔 결과로 생성된 최소 설정 객체
+ * @returns 병합된 설정 객체
+ */
+export function mergeConfigs(existing, scanned) {
+    const merged = { ...existing };
+    if (scanned['$schema'] !== undefined)
+        merged['$schema'] = scanned['$schema'];
+    if (scanned['version'] !== undefined)
+        merged['version'] = scanned['version'];
+    if (isPlainObject(scanned['paths'])) {
+        merged['paths'] = mergePaths(isPlainObject(existing['paths']) ? existing['paths'] : {}, scanned['paths']);
+    }
+    if (Array.isArray(scanned['unitTypes'])) {
+        merged['unitTypes'] = mergeUnitTypes(Array.isArray(existing['unitTypes'])
+            ? existing['unitTypes']
+            : [], scanned['unitTypes']);
+    }
+    return merged;
+}
+/**
+ * paths 병합: 스캔 결과 우선 반영 (갱신), 없는 키 추가.
+ * docRoots는 키별 병합 (기존 키 보존).
+ */
+function mergePaths(existing, scanned) {
+    const merged = { ...existing };
+    for (const key of Object.keys(scanned)) {
+        if (key === 'docRoots')
+            continue;
+        // 스캔 결과를 우선하여 갱신하거나 추가함
+        merged[key] = scanned[key];
+    }
+    if (isPlainObject(scanned['docRoots'])) {
+        const existingDocRoots = isPlainObject(existing['docRoots']) ? existing['docRoots'] : {};
+        const mergedDocRoots = { ...existingDocRoots };
+        for (const key of Object.keys(scanned['docRoots'])) {
+            // 스캔 결과에 있는 docRoots 키는 무조건 반영 (갱신 또는 추가)
+            mergedDocRoots[key] = scanned['docRoots'][key];
+        }
+        merged['docRoots'] = mergedDocRoots;
+    }
+    return merged;
+}
+/**
+ * unitTypes 병합: 기존 배열 유지 + key 또는 idPattern 필드로 중복 판단.
+ * idPattern이 유효한(비어있지 않은 문자열) 항목만 추가함.
+ */
+function mergeUnitTypes(existing, scanned) {
+    const merged = [...existing];
+    const existingKeys = new Set(existing.map((t) => (typeof t['key'] === 'string' ? t['key'] : '')).filter(Boolean));
+    const existingPatterns = new Set(existing.map((t) => (typeof t['idPattern'] === 'string' ? t['idPattern'] : '')).filter(Boolean));
+    for (const scannedType of scanned) {
+        const scannedKey = typeof scannedType['key'] === 'string' ? scannedType['key'] : '';
+        const scannedPattern = typeof scannedType['idPattern'] === 'string' ? scannedType['idPattern'] : '';
+        // 유효성 검사: key와 idPattern이 필수
+        if (!scannedKey || !scannedPattern)
+            continue;
+        // 중복 검사: key 또는 idPattern이 이미 존재하면 건너뜀
+        if (existingKeys.has(scannedKey) || existingPatterns.has(scannedPattern))
+            continue;
+        merged.push(scannedType);
+        existingKeys.add(scannedKey);
+        existingPatterns.add(scannedPattern);
+    }
+    return merged;
+}
+export function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=config-merger.js.map

package/dist/core/resolvers/config-validator.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 설정 검증 Core 로직 — Layer 1 (Core)
+ *
+ * 정규식 유효성 검사 및 패턴 충돌 감지 등 I/O가 없는 순수 함수들로 구성된다.
+ *
+ * @module
+ */
+import type { ToolResult } from '../../types/index.js';
+export interface ValidPattern {
+    key: string;
+    regex: RegExp;
+}
+export interface PatternConflict {
+    id: string;
+    matchingKeys: string[];
+}
+/**
+ * 단일 정규식 문자열의 유효성을 검증한다
+ *
+ * @param pattern - 정규식 문자열
+ * @returns 유효한 정규식이면 true, 그렇지 않으면 false
+ */
+export declare function isValidRegex(pattern: string): boolean;
+/**
+ * 설정된 ID 패턴들이 유효한 정규식인지 검사한다
+ *
+ * @param patterns - 유닛 유형별 패턴 정보
+ * @returns 유효한 정규식 객체 목록 또는 에러
+ */
+export declare function validateRegexes(patterns: {
+    key: string;
+    idPattern: string;
+}[]): ToolResult<ValidPattern[]>;
+/**
+ * 주어진 ID 목록에 대해 여러 패턴이 동시에 매칭되는 충돌 케이스를 찾는다
+ *
+ * @param ids - docRoots에서 수집된 실제 ID 목록
+ * @param validRegexes - 유효성이 검증된 정규식 목록
+ * @returns 충돌이 발생한 ID와 매칭된 유형 키 목록
+ */
+export declare function findPatternConflicts(ids: string[], validRegexes: ValidPattern[]): PatternConflict[];
+//# sourceMappingURL=config-validator.d.ts.map

package/dist/core/resolvers/config-validator.js

@@ -0,0 +1,61 @@
+/**
+ * 설정 검증 Core 로직 — Layer 1 (Core)
+ *
+ * 정규식 유효성 검사 및 패턴 충돌 감지 등 I/O가 없는 순수 함수들로 구성된다.
+ *
+ * @module
+ */
+import { ok, fail } from '../../types/index.js';
+/**
+ * 단일 정규식 문자열의 유효성을 검증한다
+ *
+ * @param pattern - 정규식 문자열
+ * @returns 유효한 정규식이면 true, 그렇지 않으면 false
+ */
+export function isValidRegex(pattern) {
+    try {
+        new RegExp(pattern);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 설정된 ID 패턴들이 유효한 정규식인지 검사한다
+ *
+ * @param patterns - 유닛 유형별 패턴 정보
+ * @returns 유효한 정규식 객체 목록 또는 에러
+ */
+export function validateRegexes(patterns) {
+    const validRegexes = [];
+    for (const { key, idPattern } of patterns) {
+        try {
+            const regex = new RegExp(idPattern);
+            validRegexes.push({ key, regex });
+        }
+        catch (err) {
+            const detail = err instanceof Error ? err.message : String(err);
+            return fail('INVALID_REGEX', `유닛 유형 "${key}"의 정규식이 유효하지 않습니다: ${idPattern}`, detail);
+        }
+    }
+    return ok(validRegexes);
+}
+/**
+ * 주어진 ID 목록에 대해 여러 패턴이 동시에 매칭되는 충돌 케이스를 찾는다
+ *
+ * @param ids - docRoots에서 수집된 실제 ID 목록
+ * @param validRegexes - 유효성이 검증된 정규식 목록
+ * @returns 충돌이 발생한 ID와 매칭된 유형 키 목록
+ */
+export function findPatternConflicts(ids, validRegexes) {
+    const conflicts = [];
+    for (const id of ids) {
+        const matchingKeys = validRegexes.filter((r) => r.regex.test(id)).map((r) => r.key);
+        if (matchingKeys.length > 1) {
+            conflicts.push({ id, matchingKeys });
+        }
+    }
+    return conflicts;
+}
+//# sourceMappingURL=config-validator.js.map

package/dist/core/resolvers/dep-commit-resolver.d.ts

@@ -0,0 +1,63 @@
+/**
+ * 의존성 커밋 해석기 — Layer 1 순수 함수
+ *
+ * `git log --oneline` 출력 텍스트에서
+ * 의존 유닛 관련 커밋 SHA를 추출한다.
+ *
+ * **순수 함수**: child_process, fs 등 I/O 모듈을 사용하지 않음.
+ * git 명령 실행은 Adapter(Layer 3)의 책임이며,
+ * 이 함수는 텍스트 파싱만 담당한다.
+ *
+ * PRD §5 commitSearch 설정:
+ *   strategy: "git-log-grep" | "conventional-commit" | "disabled"
+ *   extractId: "shortId" | "bareId" | "unitId" (검색어 변환 방식)
+ *   maxResults: 최대 결과 수
+ *
+ * @module
+ */
+import type { CommitSearchConfig, ToolResult } from '../../types/index.js';
+/**
+ * 개별 커밋 정보
+ *
+ * git log 한 줄에서 파싱된 SHA와 메시지.
+ */
+export interface CommitEntry {
+    /** 커밋 SHA (7자 이상의 축약 또는 전체 SHA) */
+    sha: string;
+    /** 커밋 메시지 (한 줄) */
+    message: string;
+}
+/**
+ * git log 출력에서 의존 유닛 관련 커밋을 추출한다
+ *
+ * 각 depId에서 검색어를 추출(config.extractId 설정 기반)하고,
+ * git log 출력의 각 줄에서 검색어가 포함된 커밋의 SHA를 수집한다.
+ *
+ * **Graceful Degradation**:
+ * - config.strategy가 "disabled"이면 빈 배열 반환 (정상)
+ * - depIds가 빈 배열이면 빈 배열 반환 (정상)
+ * - 매칭되는 커밋이 없으면 빈 배열 반환 (정상)
+ * - gitLogOutput이 빈 문자열이면 빈 배열 반환 (정상)
+ *
+ * git log --oneline 형식 기대:
+ *   `abc1234 feat(core): U-005[Mvp] 제목 추출기`
+ *   `def5678 fix: U-006 의존성 추출 버그 수정`
+ *
+ * @param depIds - 의존 유닛 ID 목록 (검색 대상)
+ * @param gitLogOutput - `git log --oneline` 출력 텍스트
+ * @param config - 커밋 탐색 설정 (strategy, extractId, maxResults)
+ * @returns 추출된 커밋 SHA 목록을 포함한 ToolResult
+ *
+ * @example
+ * ```typescript
+ * const depIds = ['U-005[Mvp]', 'U-006[Mvp]'];
+ * const gitLog = 'abc1234 feat: U-005 제목 추출기\ndef5678 fix: U-006 의존성';
+ * const config = { strategy: 'git-log-grep', extractId: 'shortId', maxResults: 5 };
+ * const result = findDepCommits(depIds, gitLog, config);
+ * if (result.success) {
+ *   // result.data → ['abc1234', 'def5678']
+ * }
+ * ```
+ */
+export declare function findDepCommits(depIds: string[], gitLogOutput: string, config: CommitSearchConfig): ToolResult<CommitEntry[]>;
+//# sourceMappingURL=dep-commit-resolver.d.ts.map

package/dist/core/resolvers/dep-commit-resolver.js

@@ -0,0 +1,158 @@
+/**
+ * 의존성 커밋 해석기 — Layer 1 순수 함수
+ *
+ * `git log --oneline` 출력 텍스트에서
+ * 의존 유닛 관련 커밋 SHA를 추출한다.
+ *
+ * **순수 함수**: child_process, fs 등 I/O 모듈을 사용하지 않음.
+ * git 명령 실행은 Adapter(Layer 3)의 책임이며,
+ * 이 함수는 텍스트 파싱만 담당한다.
+ *
+ * PRD §5 commitSearch 설정:
+ *   strategy: "git-log-grep" | "conventional-commit" | "disabled"
+ *   extractId: "shortId" | "bareId" | "unitId" (검색어 변환 방식)
+ *   maxResults: 최대 결과 수
+ *
+ * @module
+ */
+import { ok } from '../../types/index.js';
+import { toShortId, toBareId } from '../renderers/interpolate.js';
+import { deduplicateBy, normalizeLineEndings } from '../parsers/md-utils.js';
+/**
+ * git log 출력에서 의존 유닛 관련 커밋을 추출한다
+ *
+ * 각 depId에서 검색어를 추출(config.extractId 설정 기반)하고,
+ * git log 출력의 각 줄에서 검색어가 포함된 커밋의 SHA를 수집한다.
+ *
+ * **Graceful Degradation**:
+ * - config.strategy가 "disabled"이면 빈 배열 반환 (정상)
+ * - depIds가 빈 배열이면 빈 배열 반환 (정상)
+ * - 매칭되는 커밋이 없으면 빈 배열 반환 (정상)
+ * - gitLogOutput이 빈 문자열이면 빈 배열 반환 (정상)
+ *
+ * git log --oneline 형식 기대:
+ *   `abc1234 feat(core): U-005[Mvp] 제목 추출기`
+ *   `def5678 fix: U-006 의존성 추출 버그 수정`
+ *
+ * @param depIds - 의존 유닛 ID 목록 (검색 대상)
+ * @param gitLogOutput - `git log --oneline` 출력 텍스트
+ * @param config - 커밋 탐색 설정 (strategy, extractId, maxResults)
+ * @returns 추출된 커밋 SHA 목록을 포함한 ToolResult
+ *
+ * @example
+ * ```typescript
+ * const depIds = ['U-005[Mvp]', 'U-006[Mvp]'];
+ * const gitLog = 'abc1234 feat: U-005 제목 추출기\ndef5678 fix: U-006 의존성';
+ * const config = { strategy: 'git-log-grep', extractId: 'shortId', maxResults: 5 };
+ * const result = findDepCommits(depIds, gitLog, config);
+ * if (result.success) {
+ *   // result.data → ['abc1234', 'def5678']
+ * }
+ * ```
+ */
+export function findDepCommits(depIds, gitLogOutput, config) {
+    // disabled 전략이면 빈 결과 반환
+    if (config.strategy === 'disabled')
+        return ok([]);
+    // 빈 입력 처리
+    if (depIds.length === 0 || gitLogOutput.trim() === '')
+        return ok([]);
+    const normalizedLog = normalizeLineEndings(gitLogOutput);
+    // 1. 각 depId에서 검색어 추출
+    const searchTerms = buildSearchTerms(depIds, config.extractId);
+    if (searchTerms.length === 0)
+        return ok([]);
+    // 2. git log 출력 파싱
+    const allCommits = parseGitLogOutput(normalizedLog);
+    if (allCommits.length === 0)
+        return ok([]);
+    // 3. 검색어로 커밋 필터링
+    const matched = filterCommitsByTerms(allCommits, searchTerms);
+    // 4. 중복 제거 + maxResults 제한
+    const deduplicated = deduplicateBy(matched, (c) => c.sha);
+    const limited = deduplicated.slice(0, config.maxResults);
+    return ok(limited);
+}
+// ── 내부 헬퍼 ──
+/**
+ * depIds에서 검색어 목록을 생성한다
+ *
+ * config.extractId 설정에 따라 ID 변환:
+ * - "shortId": phase 제거 (U-005[Mvp] → U-005)
+ * - "bareId": 숫자만 (U-005[Mvp] → 005)
+ * - "unitId" 또는 기타: 원본 그대로
+ *
+ * @param depIds - 의존 유닛 ID 목록
+ * @param extractId - ID 변환 방식
+ * @returns 검색어 목록 (중복 제거)
+ */
+function buildSearchTerms(depIds, extractId) {
+    const terms = new Set();
+    for (const depId of depIds) {
+        let term;
+        switch (extractId) {
+            case 'shortId':
+                term = toShortId(depId);
+                break;
+            case 'bareId':
+                term = toBareId(depId);
+                break;
+            default:
+                // "unitId" 또는 알 수 없는 값 → 원본 사용
+                term = depId;
+                break;
+        }
+        if (term !== '')
+            terms.add(term);
+    }
+    return [...terms];
+}
+/**
+ * git log --oneline 출력을 파싱한다
+ *
+ * 각 줄에서 SHA(7자 이상 hex)와 메시지를 분리.
+ * 빈 줄, 파싱 불가 줄은 건너뛴다.
+ *
+ * 느슨한 정규식으로 다양한 git log 형식에 대응:
+ * - `abc1234 feat: 메시지`
+ * - `abc1234567890 메시지`
+ * - `abc1234 (HEAD -> main) 메시지`
+ *
+ * @param output - git log 출력 텍스트
+ * @returns CommitEntry 배열
+ */
+function parseGitLogOutput(output) {
+    const lines = output.split('\n');
+    const commits = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed === '')
+            continue;
+        // SHA: 7자 이상의 hex 문자열 (줄 시작)
+        const match = trimmed.match(/^([0-9a-f]{7,40})\s+(.+)$/i);
+        if (match?.[1] && match[2]) {
+            commits.push({
+                sha: match[1],
+                message: match[2],
+            });
+        }
+    }
+    return commits;
+}
+/**
+ * 검색어가 포함된 커밋을 필터링한다
+ *
+ * 대소문자 무시로 검색하여 유연하게 매칭.
+ *
+ * @param commits - 전체 커밋 목록
+ * @param searchTerms - 검색어 목록
+ * @returns 매칭된 커밋 목록
+ */
+function filterCommitsByTerms(commits, searchTerms) {
+    const lowerTerms = searchTerms.map((t) => t.toLowerCase());
+    return commits.filter((commit) => {
+        const lowerMessage = commit.message.toLowerCase();
+        return lowerTerms.some((term) => lowerMessage.includes(term));
+    });
+}
+//# sourceMappingURL=dep-commit-resolver.js.map