vibe-commander 0.1.0

package/dist/config/schema.js

@@ -0,0 +1,186 @@
+/**
+ * Zod 4 스키마 정의 — vibe-commander.config.json
+ *
+ * PRD §5 설정 파일 구조를 Zod 4 스키마로 모델링.
+ * 각 서브 스키마는 독립적으로 정의하여 재사용 및 테스트 용이성 확보.
+ * 페어링 질문 Q2(Option B) 결정에 따라 snapmit 스타일 기본값 제공.
+ *
+ * @module
+ */
+import { z } from 'zod';
+// ── 경로 관련 ──
+/** 기본 경로 설정 스키마 */
+export const pathsSchema = z.object({
+    /** 커맨드 파일 경로 (프로젝트 루트 기준) */
+    commands: z.string().default('vibe/commands.md'),
+    /** 로드맵 파일 경로. null이면 list-units 비활성화 */
+    roadmap: z.string().nullable().default('vibe/roadmap.md'),
+    /** 역할별 문서 루트 디렉토리 (키: 역할명, 값: 상대 경로) */
+    docRoots: z.record(z.string(), z.string()).default({
+        plan: 'vibe/unit-plans',
+        result: 'vibe/unit-results',
+        runbook: 'vibe/unit-runbooks',
+    }),
+    /** 리팩토링 서브유닛 디렉토리. null이면 서브유닛 미사용 */
+    refactorSubDir: z.string().nullable().default(null),
+});
+// ── 유닛 유형 ──
+/** 유닛 유형 정의 스키마 */
+export const unitTypeSchema = z.object({
+    /** 유형 키 (예: "implement", "refactor") */
+    key: z.string(),
+    /** 표시 이름 (예: "유닛 구현"). 미제공 시 key 값 활용 */
+    displayName: z.string().optional(),
+    /** 유닛 ID 매칭 정규식 패턴 (예: "^(U-\\d+|CP-).*") */
+    idPattern: z.string().refine((val) => {
+        try {
+            new RegExp(val);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }, { message: '유효한 정규식 문자열이어야 합니다' }),
+    /** 계획서 디렉토리 (paths.docRoots 키 참조) */
+    planDir: z.string(),
+    /** 커맨드 파일 내 대상 섹션 헤더 (예: "# 유닛 구현") */
+    commandSection: z.string(),
+    /** 의존성 수집 여부 */
+    collectDeps: z.boolean(),
+    /** 섹션 헤더 템플릿. {{unitId}}, {{title}} 등 변수 치환 지원 */
+    headerTemplate: z.string(),
+});
+// ── 문서 탐색 ──
+/** 개별 문서 역할의 탐색 규칙 스키마 */
+export const docDiscoveryRuleSchema = z.object({
+    /** 파일 탐색 패턴 (예: "{{unitId}}.md") */
+    pattern: z.string(),
+    /** glob 패턴 사용 여부 (기본: false) */
+    glob: z.boolean().optional().default(false),
+});
+/** 문서 탐색 설정 스키마 (역할별 규칙 맵) */
+export const docDiscoverySchema = z.record(z.string(), docDiscoveryRuleSchema);
+// ── 계획서 파싱 ──
+/** 메타데이터 테이블 파싱 설정 스키마 */
+export const metadataTableSchema = z.object({
+    /** ID 필드명 */
+    idField: z.string().default('Unit ID'),
+    /** Phase 필드명 */
+    phaseField: z.string().default('Phase'),
+    /** 의존성 필드명 */
+    dependsField: z.string().default('의존성'),
+});
+/** 계획서 파싱 설정 스키마 */
+export const planParsingSchema = z.object({
+    /** 제목 추출 소스 ("h1" | "frontmatter:title") */
+    titleSource: z.enum(['h1', 'frontmatter:title']).default('h1'),
+    /** 의존성 추출 소스 ("section" | "frontmatter" | "metadata-table") */
+    dependsSource: z.enum(['section', 'frontmatter', 'metadata-table']).default('section'),
+    /** 의존성 섹션 헤더명. null이면 섹션 기반 추출 비활성화 */
+    dependsSectionName: z.string().nullable().default('이전 작업에서 가져올 것'),
+    /** 페어링 질문 섹션 헤더명 */
+    pairingQuestionSection: z.string().default('페어링 질문'),
+    /** 메타데이터 테이블 파싱 설정 */
+    metadataTable: metadataTableSchema.prefault({}),
+});
+// ── 백로그 파싱 ──
+/** 상태 표시 매핑 스키마 */
+export const statusMapSchema = z.object({
+    /** 대기 상태 표시 */
+    ready: z.string().default('⏸️'),
+    /** 진행중 상태 표시 */
+    inProgress: z.string().default('🚧'),
+    /** 완료 상태 표시 */
+    completed: z.string().default('✅'),
+    /** 차단 상태 표시 */
+    blocked: z.string().default('❌'),
+});
+/** 백로그(로드맵) 파싱 설정 스키마 */
+export const backlogParsingSchema = z.object({
+    /** 백로그 섹션 시작 헤더 */
+    sectionHeader: z.string().default('## 작업 백로그'),
+    /** 백로그 항목 매칭 정규식 (named group 지원) */
+    entryPattern: z
+        .string()
+        .default('ID=\\[(?<id>.+?)\\]\\((?<path>[^)]+)\\)\\s*\\|\\s*(?<title>[^|]+)\\|\\s*Depends=(?<deps>[^|]*)\\|\\s*(?<status>.+)'),
+    /** 완료된 유닛 섹션 헤더 */
+    completedSection: z.string().default('### 완료'),
+    /** 상태 문자열 ↔ 내부 상태 키 매핑 */
+    statusMap: statusMapSchema.prefault({}),
+});
+// ── 커밋 탐색 ──
+/** 커밋 탐색 설정 스키마 */
+export const commitSearchSchema = z.object({
+    /** 탐색 전략 ("git-log-grep" | "conventional-commit" | "disabled") */
+    strategy: z.string().default('git-log-grep'),
+    /** grep에 사용할 ID 변환 방식 (예: "shortId") */
+    extractId: z.string().default('shortId'),
+    /** 최대 결과 수 */
+    maxResults: z.number().default(5),
+    /**
+     * 제외할 경로 glob 패턴 목록.
+     * 변경 파일이 모두 이 패턴에 매칭되는 커밋은 필터링됨 (문서 전용 커밋 제거).
+     * 기본값 [] → 필터 미적용
+     */
+    excludePaths: z.array(z.string()).default([]),
+    /**
+     * 필수 포함 경로 glob 패턴 목록.
+     * 변경 파일 중 하나라도 이 패턴에 매칭되어야 통과 (소스 코드 커밋만 허용).
+     * 기본값 [] → 필터 미적용
+     */
+    requirePaths: z.array(z.string()).default([]),
+});
+// ── 커맨드 파일 섹션 ──
+/** 커맨드 파일 섹션 설정 스키마 */
+export const commandSectionsSchema = z.object({
+    /** 섹션 구분자 문자열 */
+    separator: z.string().default('---------------------------------------------------'),
+    /** 다른 섹션 보존 여부 */
+    preserveOtherSections: z.boolean().default(true),
+    /** Commit SHA를 기록할 필드 키워드 (기본: "Commit") */
+    commitFieldName: z.string().default('Commit'),
+    /**
+     * HTML 주석 마커 사용 여부.
+     * true이면 섹션 경계에 `<!-- vc:begin:{key} -->` / `<!-- vc:end:{key} -->` 마커를 삽입하고,
+     * 섹션 탐색 시 마커를 우선 사용한다 (Fallback으로 기존 헤더 기반 탐색).
+     * 기본값 false로 기존 프로젝트 하위 호환 보장.
+     */
+    useMarkers: z.boolean().default(false),
+});
+// ── 최상위 설정 ──
+/** 기본 문서 탐색 설정 */
+export const DEFAULT_DOC_DISCOVERY = {
+    plan: { pattern: '{{unitId}}.md', glob: false },
+    result: { pattern: '{{unitId}}.md', glob: false },
+    runbook: { pattern: '{{shortId}}-*-runbook.md', glob: true },
+};
+/** 프로젝트 설정 스키마 (vibe-commander.config.json) */
+export const projectConfigSchema = z.object({
+    /** JSON Schema URL (IDE 자동완성용) */
+    $schema: z.string().optional(),
+    /** 설정 파일 버전 (현재 1 고정) */
+    version: z.literal(1),
+    /** 기본 경로 설정 */
+    paths: pathsSchema.prefault({}),
+    /** 유닛 유형 정의 배열 (순서 = ID 매칭 우선순위, 최소 1개 필수) */
+    unitTypes: z.array(unitTypeSchema).min(1),
+    /** 문서 탐색 규칙 (역할별) */
+    docDiscovery: docDiscoverySchema.default(DEFAULT_DOC_DISCOVERY),
+    /** 계획서 파싱 규칙 */
+    planParsing: planParsingSchema.prefault({}),
+    /** 백로그(로드맵) 파싱 규칙 */
+    backlogParsing: backlogParsingSchema.prefault({}),
+    /** 커밋 탐색 설정 */
+    commitSearch: commitSearchSchema.prefault({}),
+    /** 커맨드 파일 섹션 설정 */
+    commandSections: commandSectionsSchema.prefault({}),
+    /** 기본 특별 요청사항 목록 */
+    defaultSpecialRequests: z.array(z.string()).default([]),
+    /** 유닛 유형별 추가 특별 요청사항 (키: unitType.key) */
+    specialRequestsByType: z.record(z.string(), z.array(z.string())).default({}),
+    /** 키 기반 선택적 특별 요청사항 (--request 옵션용, 키: 사용자 정의 식별자, 값: 텍스트) */
+    customRequests: z.record(z.string(), z.string()).default({}),
+});
+/** 설정 파일명 */
+export const CONFIG_FILENAME = 'vibe-commander.config.json';
+//# sourceMappingURL=schema.js.map

package/dist/core/parsers/backlog-parser.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 백로그(로드맵) 파서 — Layer 1 순수 함수
+ *
+ * 로드맵 파일의 작업 백로그 섹션을 파싱하여
+ * 유닛 목록, 상태, 의존성을 추출한다.
+ * `list-units` 커맨드의 데이터 소스.
+ *
+ * @module
+ */
+import type { BacklogParsingConfig } from '../../types/index.js';
+import type { BacklogEntry, ToolResult } from '../../types/index.js';
+/**
+ * 로드맵 백로그 섹션을 파싱하여 유닛 목록을 반환한다
+ *
+ * 1. 백로그 섹션 탐색 (sectionHeader 기반)
+ * 2. 완료 섹션 분리 (completedSection 기반)
+ * 3. 활성 항목 파싱 (entryPattern + statusMap)
+ * 4. 의존성 충족 계산 (ready ↔ blocked 분류)
+ *
+ * @param content - 로드맵 파일 전체 내용
+ * @param config - 백로그 파싱 설정 (entryPattern, statusMap 등)
+ * @returns 파싱된 BacklogEntry 배열 (활성 + 완료)
+ */
+export declare function parseBacklog(content: string, config: BacklogParsingConfig): ToolResult<BacklogEntry[]>;
+//# sourceMappingURL=backlog-parser.d.ts.map

package/dist/core/parsers/backlog-parser.js

@@ -0,0 +1,255 @@
+/**
+ * 백로그(로드맵) 파서 — Layer 1 순수 함수
+ *
+ * 로드맵 파일의 작업 백로그 섹션을 파싱하여
+ * 유닛 목록, 상태, 의존성을 추출한다.
+ * `list-units` 커맨드의 데이터 소스.
+ *
+ * @module
+ */
+import { ok, fail } from '../../types/index.js';
+import { normalizeLineEndings, safeRegex, getHeadingPrefix, HEADING_RE, isNoneDependency, } from './md-utils.js';
+/**
+ * 완료 섹션의 마크다운 링크에서 ID/경로/제목을 추출하는 패턴
+ *
+ * 형식: - ✅ [ID](path) | 제목 (날짜)
+ * 비탐욕(.+?)으로 ID 캡처하여 [Phase] 접미사가 있는 ID 지원
+ */
+const COMPLETED_LINK_RE = /\[(?<id>.+?)\]\((?<path>[^)]+)\)(?:\s*\|\s*(?<title>.+))?/;
+/**
+ * 로드맵 백로그 섹션을 파싱하여 유닛 목록을 반환한다
+ *
+ * 1. 백로그 섹션 탐색 (sectionHeader 기반)
+ * 2. 완료 섹션 분리 (completedSection 기반)
+ * 3. 활성 항목 파싱 (entryPattern + statusMap)
+ * 4. 의존성 충족 계산 (ready ↔ blocked 분류)
+ *
+ * @param content - 로드맵 파일 전체 내용
+ * @param config - 백로그 파싱 설정 (entryPattern, statusMap 등)
+ * @returns 파싱된 BacklogEntry 배열 (활성 + 완료)
+ */
+export function parseBacklog(content, config) {
+    const normalized = normalizeLineEndings(content);
+    // 1. entryPattern을 RegExp로 안전하게 변환
+    const entryRegex = safeRegex(config.entryPattern);
+    if (!entryRegex) {
+        return fail('INVALID_ENTRY_PATTERN', `백로그 항목 패턴이 유효하지 않습니다: ${config.entryPattern}`);
+    }
+    // 2. 백로그 섹션 탐색
+    const sectionLines = findBacklogSection(normalized, config.sectionHeader);
+    if (sectionLines === null) {
+        return fail('BACKLOG_SECTION_NOT_FOUND', `백로그 섹션을 찾을 수 없습니다: ${config.sectionHeader}`);
+    }
+    // 3. 완료 섹션 분리
+    const { activeLines, completedLines } = splitByCompletedSection(sectionLines, config.completedSection);
+    // 4. 완료 ID 세트 구축 (의존성 충족 판단용)
+    const completedIds = extractCompletedIds(completedLines);
+    // 5. 활성 항목 파싱
+    const activeEntries = parseActiveEntries(activeLines, entryRegex, config.statusMap);
+    // 6. 활성 항목 중 completed 상태인 것도 completedIds에 추가
+    for (const entry of activeEntries) {
+        if (entry.status === 'completed') {
+            completedIds.add(entry.unitId);
+        }
+    }
+    // 7. 완료 섹션 항목 파싱 (BacklogEntry로 변환)
+    const completedEntries = parseCompletedSectionEntries(completedLines);
+    // 8. completedIds 확장: shortId도 포함 (의존성 매칭용)
+    const expandedCompletedIds = expandWithShortIds(completedIds);
+    // 9. 의존성 충족 계산 (ready ↔ blocked 분류)
+    const resolvedEntries = resolveDependencies(activeEntries, expandedCompletedIds);
+    return ok([...resolvedEntries, ...completedEntries]);
+}
+// ── 내부 헬퍼 함수 ──────────────────────────────────────
+/**
+ * 백로그 섹션의 라인들을 추출한다
+ *
+ * sectionHeader와 정확히 일치하는 헤딩을 찾고,
+ * 동일/상위 레벨의 다음 헤딩까지의 라인을 수집한다.
+ *
+ * @returns 섹션 라인 배열, 섹션 미발견 시 null
+ */
+function findBacklogSection(content, sectionHeader) {
+    const lines = content.split('\n');
+    const trimmedHeader = sectionHeader.trim();
+    const headingPrefix = getHeadingPrefix(trimmedHeader);
+    const sectionLevel = headingPrefix ? headingPrefix.length : 0;
+    let inSection = false;
+    const result = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!inSection) {
+            if (trimmed === trimmedHeader) {
+                inSection = true;
+                continue;
+            }
+        }
+        else {
+            // 동일/상위 레벨 헤딩이면 섹션 종료
+            const headingMatch = trimmed.match(HEADING_RE);
+            if (headingMatch && sectionLevel > 0) {
+                const level = (headingMatch[1] ?? '').length;
+                if (level <= sectionLevel) {
+                    break;
+                }
+            }
+            result.push(line);
+        }
+    }
+    return inSection ? result : null;
+}
+/**
+ * 섹션 라인을 완료 섹션 기준으로 분리한다
+ *
+ * completedSectionHeader 이전 라인은 activeLines,
+ * 이후 라인은 completedLines로 분리.
+ */
+function splitByCompletedSection(sectionLines, completedSectionHeader) {
+    const trimmedHeader = completedSectionHeader.trim();
+    const completedIdx = sectionLines.findIndex((line) => line.trim() === trimmedHeader);
+    if (completedIdx === -1) {
+        return { activeLines: sectionLines, completedLines: [] };
+    }
+    return {
+        activeLines: sectionLines.slice(0, completedIdx),
+        completedLines: sectionLines.slice(completedIdx + 1),
+    };
+}
+/**
+ * 완료 섹션 라인에서 유닛 ID를 추출한다
+ *
+ * 마크다운 링크 `[ID](path)` 형태에서 ID 추출.
+ */
+function extractCompletedIds(lines) {
+    const ids = new Set();
+    for (const line of lines) {
+        const match = line.match(COMPLETED_LINK_RE);
+        if (match?.groups?.id) {
+            ids.add(match.groups.id.trim());
+        }
+    }
+    return ids;
+}
+/**
+ * 활성 백로그 항목을 entryPattern으로 파싱한다
+ *
+ * Named groups: id, path, title, deps, status
+ */
+function parseActiveEntries(lines, entryRegex, statusMap) {
+    const reverseMap = buildReverseStatusMap(statusMap);
+    const entries = [];
+    for (const line of lines) {
+        const match = line.match(entryRegex);
+        if (!match?.groups)
+            continue;
+        const { id, path, title, deps, status } = match.groups;
+        if (!id || !title || status === undefined)
+            continue;
+        entries.push({
+            unitId: id.trim(),
+            title: title.trim(),
+            depends: parseDependsList(deps ?? ''),
+            status: resolveStatus(status.trim(), reverseMap),
+            path: (path ?? '').trim(),
+        });
+    }
+    return entries;
+}
+/**
+ * 완료 섹션의 항목을 BacklogEntry로 파싱한다
+ *
+ * 완료 섹션은 entryPattern과 다른 형식이므로 별도 파싱.
+ * 형식: - ✅ [ID](path) | 제목 (날짜)
+ */
+function parseCompletedSectionEntries(lines) {
+    const entries = [];
+    for (const line of lines) {
+        const match = line.match(COMPLETED_LINK_RE);
+        if (!match?.groups?.id)
+            continue;
+        entries.push({
+            unitId: match.groups.id.trim(),
+            title: (match.groups.title ?? '').trim(),
+            depends: [],
+            status: 'completed',
+            path: (match.groups.path ?? '').trim(),
+        });
+    }
+    return entries;
+}
+/**
+ * 상태 이모지 → BacklogStatus 역방향 맵을 구축한다
+ *
+ * statusMap: { ready: '⏸️', inProgress: '🚧', completed: '✅', blocked: '❌' }
+ * → Map { '⏸️' → 'ready', '🚧' → 'inProgress', ... }
+ */
+function buildReverseStatusMap(statusMap) {
+    const map = new Map();
+    for (const [key, emoji] of Object.entries(statusMap)) {
+        map.set(emoji.trim(), key);
+    }
+    return map;
+}
+/**
+ * 상태 문자열을 BacklogStatus로 변환한다
+ *
+ * 역방향 맵에 없는 경우 기본값 'ready' 반환.
+ */
+function resolveStatus(statusStr, reverseMap) {
+    return reverseMap.get(statusStr.trim()) ?? 'ready';
+}
+/**
+ * 쉼표로 구분된 의존성 문자열을 파싱한다
+ *
+ * "U-008,U-009,U-010" → ["U-008", "U-009", "U-010"]
+ * 빈 문자열 → []
+ */
+function parseDependsList(deps) {
+    return deps
+        .split(',')
+        .map((d) => d.trim())
+        .filter((d) => Boolean(d) && !isNoneDependency(d));
+}
+/**
+ * 완료 ID 세트에 shortId 변형을 추가한다
+ *
+ * 의존성 필드가 shortId(예: "U-002")로 기재되고
+ * 완료 ID가 fullId(예: "U-002[Mvp]")인 경우의 매칭을 위해
+ * [Phase] 접미사를 제거한 shortId도 세트에 추가한다.
+ */
+function expandWithShortIds(ids) {
+    const expanded = new Set(ids);
+    for (const id of ids) {
+        const shortId = id.replace(/\[.*?\]$/, '');
+        if (shortId !== id) {
+            expanded.add(shortId);
+        }
+    }
+    return expanded;
+}
+/**
+ * 의존성 충족 여부를 계산하여 ready/blocked를 분류한다
+ *
+ * - completed, inProgress 상태는 변경하지 않음
+ * - 의존성이 없거나 모두 충족되면 ready
+ * - 미충족 의존성이 있으면 blocked
+ */
+function resolveDependencies(entries, completedIds) {
+    return entries.map((entry) => {
+        // completed, inProgress는 그대로 유지
+        if (entry.status === 'completed' || entry.status === 'inProgress') {
+            return entry;
+        }
+        // 의존성이 없으면 ready 유지
+        if (entry.depends.length === 0) {
+            return { ...entry, status: 'ready' };
+        }
+        // 모든 의존성이 완료되었는지 확인
+        const allDepsCompleted = entry.depends.every((dep) => completedIds.has(dep));
+        return {
+            ...entry,
+            status: (allDepsCompleted ? 'ready' : 'blocked'),
+        };
+    });
+}
+//# sourceMappingURL=backlog-parser.js.map

package/dist/core/parsers/dep-line-parser.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 의존성 라인 파서 — Layer 1 순수 함수
+ *
+ * 마크다운 리스트 항목에서 의존 유닛 정보(ID, 설명, artifacts)를 파싱한다.
+ * dependency-extractor.ts에서 섹션 내 라인들을 받아 구조화된 DepInfo로 변환.
+ *
+ * @module
+ */
+import type { DepInfo } from '../../types/index.js';
+/**
+ * 의존성 라인 파싱 결과
+ *
+ * 유닛 기반 의존성(`deps`)과 비유닛 컨텍스트 항목(`contextNotes`)을 분리하여 반환.
+ */
+export interface ParsedDependencyResult {
+    /** 유닛 ID가 있는 의존성 항목 */
+    deps: DepInfo[];
+    /** 유닛 ID가 없는 비유닛 컨텍스트 항목 (SKILL 참조, 기존 코드 패턴 등) */
+    contextNotes: string[];
+}
+/**
+ * 섹션 내 리스트 항목에서 의존성 정보를 파싱한다
+ *
+ * 각 최상위 리스트 항목(`- `)에서:
+ * 1. `**ID**` 또는 `[ID](url)` 패턴으로 유닛 ID 추출
+ * 2. idPattern이 있으면 필터링
+ * 3. 설명 텍스트 추출
+ * 4. 하위 항목(`  - `)에서 artifacts 추출
+ * 5. 유닛 ID가 없는 라인은 contextNotes로 수집
+ *
+ * @param lines - 섹션 내 라인 배열
+ * @param idPattern - 유닛 ID 필터링 패턴 (선택)
+ * @returns 유닛 의존성과 비유닛 컨텍스트 항목
+ */
+export declare function parseDependencyLines(lines: string[], idPattern?: string): ParsedDependencyResult;
+//# sourceMappingURL=dep-line-parser.d.ts.map

package/dist/core/parsers/dep-line-parser.js

@@ -0,0 +1,176 @@
+/**
+ * 의존성 라인 파서 — Layer 1 순수 함수
+ *
+ * 마크다운 리스트 항목에서 의존 유닛 정보(ID, 설명, artifacts)를 파싱한다.
+ * dependency-extractor.ts에서 섹션 내 라인들을 받아 구조화된 DepInfo로 변환.
+ *
+ * @module
+ */
+import { escapeRegex, safeRegex, isNoneDependency } from './md-utils.js';
+/**
+ * 섹션 내 리스트 항목에서 의존성 정보를 파싱한다
+ *
+ * 각 최상위 리스트 항목(`- `)에서:
+ * 1. `**ID**` 또는 `[ID](url)` 패턴으로 유닛 ID 추출
+ * 2. idPattern이 있으면 필터링
+ * 3. 설명 텍스트 추출
+ * 4. 하위 항목(`  - `)에서 artifacts 추출
+ * 5. 유닛 ID가 없는 라인은 contextNotes로 수집
+ *
+ * @param lines - 섹션 내 라인 배열
+ * @param idPattern - 유닛 ID 필터링 패턴 (선택)
+ * @returns 유닛 의존성과 비유닛 컨텍스트 항목
+ */
+export function parseDependencyLines(lines, idPattern) {
+    const deps = [];
+    const contextNotes = [];
+    let currentUnitId = '';
+    let currentDescription = '';
+    let currentArtifacts;
+    let hasCurrent = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed === '')
+            continue;
+        // 최상위 리스트 항목 판별: `- ` 또는 `* `로 시작하고, 들여쓰기 없음
+        const isTopLevelItem = /^[-*]\s/.test(trimmed) && !/^\s{2,}/.test(line);
+        if (isTopLevelItem) {
+            // 이전 dep 저장
+            if (hasCurrent) {
+                deps.push({
+                    unitId: currentUnitId,
+                    description: currentDescription,
+                    artifacts: currentArtifacts,
+                });
+            }
+            // 새 dep 파싱
+            const parsed = extractDepFromLine(trimmed, idPattern);
+            if (parsed) {
+                currentUnitId = parsed.unitId;
+                currentDescription = parsed.description;
+                currentArtifacts = parsed.artifacts;
+                hasCurrent = true;
+            }
+            else {
+                // 비유닛 컨텍스트 항목: 리스트 마커 제거 후 수집
+                const noteText = trimmed.replace(/^[-*]\s+/, '').trim();
+                if (noteText) {
+                    const firstToken = noteText.split(/[\s(,]/)[0] ?? '';
+                    if (!isNoneDependency(firstToken)) {
+                        contextNotes.push(noteText);
+                    }
+                }
+                hasCurrent = false;
+            }
+        }
+        else if (hasCurrent && /^\s{2,}/.test(line)) {
+            // 하위 항목 → artifacts에 추가
+            const artifactText = extractArtifactText(trimmed);
+            if (artifactText) {
+                currentArtifacts =
+                    currentArtifacts !== undefined ? `${currentArtifacts}; ${artifactText}` : artifactText;
+            }
+        }
+    }
+    // 마지막 dep 저장
+    if (hasCurrent) {
+        deps.push({
+            unitId: currentUnitId,
+            description: currentDescription,
+            artifacts: currentArtifacts,
+        });
+    }
+    return { deps, contextNotes };
+}
+/**
+ * 한 라인에서 의존 유닛 정보를 추출한다
+ *
+ * 추출 우선순위:
+ * 1. 링크 텍스트 `[ID](url)` — 더 구체적 (문서 링크 포함)
+ * 2. 볼드 텍스트 `**ID**` — 일반적인 의존성 표기
+ *
+ * idPattern이 제공되면 추출된 후보를 필터링하여 실제 유닛 ID만 선별.
+ *
+ * @param line - 리스트 항목 라인 (리스트 마커 제거 전)
+ * @param idPattern - 유닛 ID 필터링 패턴 (선택)
+ * @returns 추출된 DepInfo 또는 null
+ */
+function extractDepFromLine(line, idPattern) {
+    // 리스트 마커 제거
+    const content = line.replace(/^[-*]\s+/, '');
+    // 후보 ID 수집 (링크 우선, 볼드 후순위)
+    const candidates = [];
+    // 링크 텍스트: [ID](url) — 중첩 괄호 1레벨 지원 (예: [U-002[Mvp]])
+    const linkRegex = /\[((?:[^[\]]*(?:\[[^\]]*\])?[^[\]]*)*)\]\([^)]*\)/g;
+    let match;
+    while ((match = linkRegex.exec(content)) !== null) {
+        if (match[1])
+            candidates.push({ id: match[1].trim(), source: 'link' });
+    }
+    // 볼드 텍스트: **ID**
+    const boldRegex = /\*\*([^*]+)\*\*/g;
+    while ((match = boldRegex.exec(content)) !== null) {
+        if (match[1])
+            candidates.push({ id: match[1].trim(), source: 'bold' });
+    }
+    if (candidates.length === 0)
+        return null;
+    // idPattern으로 필터링
+    const idRegex = idPattern ? safeRegex(idPattern) : null;
+    const validCandidate = idRegex ? candidates.find((c) => idRegex.test(c.id)) : candidates[0];
+    if (!validCandidate)
+        return null;
+    const unitId = validCandidate.id;
+    if (isNoneDependency(unitId))
+        return null;
+    // 설명 추출: ID 참조 이후의 텍스트에서 구분자 제거
+    const description = extractDescription(content, unitId, validCandidate.source);
+    return { unitId, description };
+}
+/**
+ * ID 참조 이후의 설명 텍스트를 추출한다
+ *
+ * 볼드 `**ID**` 또는 링크 `[ID](url)` 이후의 텍스트에서
+ * 구분자(`:`, `—`, `-`)를 제거하고 정리.
+ *
+ * @param content - 리스트 항목 내용 (마커 제거 후)
+ * @param unitId - 추출된 유닛 ID
+ * @param source - ID가 추출된 소스 ('link' | 'bold')
+ * @returns 설명 문자열 (없으면 빈 문자열)
+ */
+function extractDescription(content, unitId, source) {
+    const escapedId = escapeRegex(unitId);
+    let afterPattern;
+    if (source === 'link') {
+        afterPattern = new RegExp(`\\[${escapedId}\\]\\([^)]*\\)\\s*(.*)`);
+    }
+    else {
+        afterPattern = new RegExp(`\\*\\*${escapedId}\\*\\*\\s*(.*)`);
+    }
+    const afterMatch = content.match(afterPattern);
+    if (!afterMatch?.[1])
+        return '';
+    // 구분자 제거: 시작 부분의 :, —, -, | 등
+    return afterMatch[1].replace(/^[:\-—|]+\s*/, '').trim();
+}
+/**
+ * 하위 항목에서 artifact 텍스트를 추출한다
+ *
+ * `- 결과물: ...` 형식의 하위 항목에서 결과물 설명을 추출.
+ * 결과물 접두사가 없으면 일반 하위 항목 텍스트를 반환.
+ *
+ * @param line - 하위 항목 라인 (트리밍 완료)
+ * @returns artifact 텍스트 또는 undefined
+ */
+function extractArtifactText(line) {
+    const content = line.replace(/^[-*]\s+/, '');
+    if (content === '')
+        return undefined;
+    // "결과물:" 접두사가 있으면 그 뒤의 텍스트
+    const artifactMatch = content.match(/^결과물\s*:\s*(.+)/);
+    if (artifactMatch?.[1])
+        return artifactMatch[1].trim();
+    // 일반 하위 항목 텍스트
+    return content;
+}
+//# sourceMappingURL=dep-line-parser.js.map