vibe-commander 0.1.0

package/dist/core/parsers/dependency-extractor.d.ts

@@ -0,0 +1,64 @@
+/**
+ * 의존성 추출기 — Layer 1 순수 함수
+ *
+ * 계획서 마크다운에서 의존 유닛 정보를 추출한다.
+ * `dependsSource` 설정에 따라 section, frontmatter, metadata-table 소스를 지원하고,
+ * Fallback 체인으로 부분 실패에 대응한다.
+ *
+ * Fallback 체인: 설정 소스 → 메타데이터 테이블 → 본문 정규식 스캔
+ *
+ * PRD §8.1 계획서 파싱:
+ *   dependsSource: "section" → dependsSectionName 헤더 아래 **유닛ID** / [유닛ID] 수집
+ *   dependsSource: "frontmatter" → YAML frontmatter의 depends 배열
+ *   dependsSource: "metadata-table" → 메타데이터 테이블의 dependsField 값
+ *
+ * @module
+ */
+import type { DepInfo, PlanParsingConfig, ToolResult } from '../../types/index.js';
+import type { ParsedDependencyResult } from './dep-line-parser.js';
+/**
+ * 계획서에서 의존 유닛 정보를 추출한다
+ *
+ * `dependsSource` 설정값에 따라 추출 전략을 선택하고,
+ * 실패 시 Fallback 체인으로 다음 전략을 자동 시도한다.
+ *
+ * Fallback 순서:
+ * 1. 설정된 소스 (planParsing.dependsSource)
+ * 2. 메타데이터 테이블 스캔 (설정 소스가 metadata-table이 아닌 경우)
+ * 3. 본문 정규식 전체 스캔 (idPattern이 있을 때만)
+ *
+ * @param content - 계획서 마크다운 전체 내용
+ * @param config - 계획서 파싱 설정 (dependsSource, dependsSectionName, metadataTable)
+ * @param idPattern - 유닛 ID 매칭 정규식 패턴 (선택). 섹션 내 ID 필터링과 본문 스캔에 사용
+ * @returns 추출된 의존 유닛 정보 배열을 포함한 ToolResult. 의존성이 없으면 빈 배열(success: true)
+ *
+ * @example
+ * ```typescript
+ * const content = '## 이전 작업에서 가져올 것\n- **U-002[Mvp]**: 공유 타입';
+ * const config: PlanParsingConfig = {
+ *   titleSource: 'h1',
+ *   dependsSource: 'section',
+ *   dependsSectionName: '이전 작업에서 가져올 것',
+ *   pairingQuestionSection: '페어링 질문',
+ *   metadataTable: { idField: 'Unit ID', phaseField: 'Phase', dependsField: '의존성' },
+ * };
+ * const result = extractDependencies(content, config, 'U-\\d+(?:\\[.*?\\])?');
+ * if (result.success) {
+ *   // result.data → [{ unitId: 'U-002[Mvp]', description: '공유 타입' }]
+ * }
+ * ```
+ */
+export declare function extractDependencies(content: string, config: PlanParsingConfig, idPattern?: string): ToolResult<DepInfo[]>;
+/**
+ * 계획서에서 의존 유닛 정보와 비유닛 컨텍스트 항목을 함께 추출한다
+ *
+ * `extractDependencies`와 동일한 Fallback 체인을 적용하되,
+ * 섹션 소스에서 발견된 비유닛 컨텍스트 항목(contextNotes)도 함께 반환한다.
+ *
+ * @param content - 계획서 마크다운 전체 내용
+ * @param config - 계획서 파싱 설정
+ * @param idPattern - 유닛 ID 매칭 정규식 패턴 (선택)
+ * @returns 유닛 의존성과 비유닛 컨텍스트 항목을 포함한 ToolResult
+ */
+export declare function extractDependenciesWithNotes(content: string, config: PlanParsingConfig, idPattern?: string): ToolResult<ParsedDependencyResult>;
+//# sourceMappingURL=dependency-extractor.d.ts.map

package/dist/core/parsers/dependency-extractor.js

@@ -0,0 +1,193 @@
+/**
+ * 의존성 추출기 — Layer 1 순수 함수
+ *
+ * 계획서 마크다운에서 의존 유닛 정보를 추출한다.
+ * `dependsSource` 설정에 따라 section, frontmatter, metadata-table 소스를 지원하고,
+ * Fallback 체인으로 부분 실패에 대응한다.
+ *
+ * Fallback 체인: 설정 소스 → 메타데이터 테이블 → 본문 정규식 스캔
+ *
+ * PRD §8.1 계획서 파싱:
+ *   dependsSource: "section" → dependsSectionName 헤더 아래 **유닛ID** / [유닛ID] 수집
+ *   dependsSource: "frontmatter" → YAML frontmatter의 depends 배열
+ *   dependsSource: "metadata-table" → 메타데이터 테이블의 dependsField 값
+ *
+ * @module
+ */
+import { ok } from '../../types/index.js';
+import { parseMetadataTable } from './metadata-parser.js';
+import { FRONTMATTER_RE, findSectionLines, deduplicateBy, normalizeLineEndings, isNoneDependency, } from './md-utils.js';
+import { parseDependencyLines } from './dep-line-parser.js';
+/**
+ * 계획서에서 의존 유닛 정보를 추출한다
+ *
+ * `dependsSource` 설정값에 따라 추출 전략을 선택하고,
+ * 실패 시 Fallback 체인으로 다음 전략을 자동 시도한다.
+ *
+ * Fallback 순서:
+ * 1. 설정된 소스 (planParsing.dependsSource)
+ * 2. 메타데이터 테이블 스캔 (설정 소스가 metadata-table이 아닌 경우)
+ * 3. 본문 정규식 전체 스캔 (idPattern이 있을 때만)
+ *
+ * @param content - 계획서 마크다운 전체 내용
+ * @param config - 계획서 파싱 설정 (dependsSource, dependsSectionName, metadataTable)
+ * @param idPattern - 유닛 ID 매칭 정규식 패턴 (선택). 섹션 내 ID 필터링과 본문 스캔에 사용
+ * @returns 추출된 의존 유닛 정보 배열을 포함한 ToolResult. 의존성이 없으면 빈 배열(success: true)
+ *
+ * @example
+ * ```typescript
+ * const content = '## 이전 작업에서 가져올 것\n- **U-002[Mvp]**: 공유 타입';
+ * const config: PlanParsingConfig = {
+ *   titleSource: 'h1',
+ *   dependsSource: 'section',
+ *   dependsSectionName: '이전 작업에서 가져올 것',
+ *   pairingQuestionSection: '페어링 질문',
+ *   metadataTable: { idField: 'Unit ID', phaseField: 'Phase', dependsField: '의존성' },
+ * };
+ * const result = extractDependencies(content, config, 'U-\\d+(?:\\[.*?\\])?');
+ * if (result.success) {
+ *   // result.data → [{ unitId: 'U-002[Mvp]', description: '공유 타입' }]
+ * }
+ * ```
+ */
+export function extractDependencies(content, config, idPattern) {
+    const result = extractDependenciesWithNotes(content, config, idPattern);
+    if (!result.success)
+        return result;
+    return ok(result.data.deps);
+}
+/**
+ * 계획서에서 의존 유닛 정보와 비유닛 컨텍스트 항목을 함께 추출한다
+ *
+ * `extractDependencies`와 동일한 Fallback 체인을 적용하되,
+ * 섹션 소스에서 발견된 비유닛 컨텍스트 항목(contextNotes)도 함께 반환한다.
+ *
+ * @param content - 계획서 마크다운 전체 내용
+ * @param config - 계획서 파싱 설정
+ * @param idPattern - 유닛 ID 매칭 정규식 패턴 (선택)
+ * @returns 유닛 의존성과 비유닛 컨텍스트 항목을 포함한 ToolResult
+ */
+export function extractDependenciesWithNotes(content, config, idPattern) {
+    const normalized = normalizeLineEndings(content);
+    // 1. 설정된 소스로 시도
+    const primary = extractBySource(normalized, config, idPattern);
+    if (primary.deps.length > 0) {
+        return ok({
+            deps: deduplicateBy(primary.deps, (d) => d.unitId),
+            contextNotes: primary.contextNotes,
+        });
+    }
+    // 2. Fallback: 메타데이터 테이블 (설정 소스가 metadata-table이면 이미 시도했으므로 건너뜀)
+    if (config.dependsSource !== 'metadata-table') {
+        const fromTableResult = parseMetadataTable(normalized, config.metadataTable);
+        const fromTable = fromTableResult.success
+            ? fromTableResult.data.depends.map((unitId) => ({ unitId, description: '' }))
+            : [];
+        if (fromTable.length > 0) {
+            return ok({
+                deps: deduplicateBy(fromTable, (d) => d.unitId),
+                contextNotes: primary.contextNotes,
+            });
+        }
+    }
+    // 3. Fallback: 본문 정규식 스캔 (idPattern이 있을 때만)
+    if (idPattern) {
+        const fromScan = extractFromBodyScan(normalized, idPattern);
+        if (fromScan.length > 0) {
+            return ok({
+                deps: deduplicateBy(fromScan, (d) => d.unitId),
+                contextNotes: primary.contextNotes,
+            });
+        }
+    }
+    return ok({ deps: [], contextNotes: primary.contextNotes });
+}
+// ── 소스별 추출 전략 ──
+/**
+ * 설정된 소스에 따라 적절한 추출 전략을 선택한다
+ */
+function extractBySource(content, config, idPattern) {
+    switch (config.dependsSource) {
+        case 'section':
+            return config.dependsSectionName
+                ? extractFromSection(content, config.dependsSectionName, idPattern)
+                : { deps: [], contextNotes: [] };
+        case 'frontmatter':
+            return { deps: extractFromFrontmatter(content), contextNotes: [] };
+        case 'metadata-table':
+            return { deps: extractFromMetadataTable(content, config.metadataTable), contextNotes: [] };
+        default:
+            return { deps: [], contextNotes: [] };
+    }
+}
+/** 섹션 기반으로 의존성과 비유닛 컨텍스트 항목을 추출한다 */
+function extractFromSection(content, sectionName, idPattern) {
+    const sectionLines = findSectionLines(content, sectionName, { allowBoldMarker: true });
+    if (sectionLines.length === 0)
+        return { deps: [], contextNotes: [] };
+    return parseDependencyLines(sectionLines, idPattern);
+}
+/** YAML frontmatter의 depends 필드에서 의존성을 추출한다 (배열/콤마/단일값) */
+function extractFromFrontmatter(content) {
+    const fmMatch = content.match(FRONTMATTER_RE);
+    if (!fmMatch?.[1])
+        return [];
+    const fmContent = fmMatch[1];
+    const lines = fmContent.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // depends: ... 패턴 매칭 (대소문자 무시)
+        const kvMatch = trimmed.match(/^depends\s*:\s*(.+)$/i);
+        if (!kvMatch?.[1])
+            continue;
+        let value = kvMatch[1].trim();
+        // YAML 인라인 배열 형식: [U-117, U-116]
+        if (value.startsWith('[') && value.endsWith(']')) {
+            value = value.slice(1, -1);
+        }
+        // 따옴표 제거 (YAML 문자열)
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        return value
+            .split(',')
+            .map((s) => s.trim())
+            .filter((s) => !isNoneDependency(s))
+            .map((unitId) => ({
+            unitId,
+            description: '',
+        }));
+    }
+    return [];
+}
+/** 메타데이터 테이블에서 의존성을 추출한다 */
+function extractFromMetadataTable(content, tableConfig) {
+    const tableResult = parseMetadataTable(content, tableConfig);
+    if (!tableResult.success)
+        return [];
+    return tableResult.data.depends.map((unitId) => ({
+        unitId,
+        description: '',
+    }));
+}
+/** 본문 전체에서 ID 패턴으로 의존성을 스캔한다 (Fallback 최후 수단) */
+function extractFromBodyScan(content, idPattern) {
+    try {
+        const regex = new RegExp(idPattern, 'g');
+        const matches = content.match(regex);
+        if (!matches)
+            return [];
+        // 중복 제거
+        const unique = [...new Set(matches)];
+        return unique.map((unitId) => ({
+            unitId,
+            description: '',
+        }));
+    }
+    catch {
+        // 잘못된 정규식 — 빈 배열 반환 (Graceful Degradation)
+        return [];
+    }
+}
+//# sourceMappingURL=dependency-extractor.js.map

package/dist/core/parsers/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Core 파서 — 공개 API barrel export
+ *
+ * 계획서/백로그 마크다운 파싱 함수의 진입점.
+ * 내부 구현 상세는 노출하지 않는다.
+ *
+ * @module
+ */
+export { parseUnitPlan } from './plan-parser.js';
+export type { ParseUnitPlanResult } from './plan-parser.js';
+export { parseBacklog } from './backlog-parser.js';
+export { extractTitle } from './title-extractor.js';
+export { parseMetadataTable } from './metadata-parser.js';
+export type { MetadataTableResult } from './metadata-parser.js';
+export { extractDependencies, extractDependenciesWithNotes } from './dependency-extractor.js';
+export type { ParsedDependencyResult } from './dep-line-parser.js';
+export { extractPairingQuestions } from './pairing-question-extractor.js';
+export { findSectionLines, escapeRegex, safeRegex, normalizeLineEndings, stripCR, getHeadingPrefix, isSameLevelHeading, deduplicateBy, FRONTMATTER_RE, HEADING_RE, } from './md-utils.js';
+export type { FindSectionOptions } from './md-utils.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/parsers/index.js

@@ -0,0 +1,20 @@
+/**
+ * Core 파서 — 공개 API barrel export
+ *
+ * 계획서/백로그 마크다운 파싱 함수의 진입점.
+ * 내부 구현 상세는 노출하지 않는다.
+ *
+ * @module
+ */
+// 통합 파서 (메인 엔트리포인트)
+export { parseUnitPlan } from './plan-parser.js';
+// 백로그 파서
+export { parseBacklog } from './backlog-parser.js';
+// 개별 추출기 (필요 시 단독 사용)
+export { extractTitle } from './title-extractor.js';
+export { parseMetadataTable } from './metadata-parser.js';
+export { extractDependencies, extractDependenciesWithNotes } from './dependency-extractor.js';
+export { extractPairingQuestions } from './pairing-question-extractor.js';
+// 공통 유틸 (다른 Core 모듈에서 사용)
+export { findSectionLines, escapeRegex, safeRegex, normalizeLineEndings, stripCR, getHeadingPrefix, isSameLevelHeading, deduplicateBy, FRONTMATTER_RE, HEADING_RE, } from './md-utils.js';
+//# sourceMappingURL=index.js.map

package/dist/core/parsers/md-utils.d.ts

@@ -0,0 +1,81 @@
+/**
+ * 마크다운 파싱 공통 유틸리티 — Layer 1 순수 함수
+ *
+ * 여러 파서에서 공유하는 정규식 상수와 헬퍼 함수 모음.
+ * 섹션 탐색, 정규식 유틸, 라인 처리 등.
+ *
+ * @module
+ */
+/** Frontmatter 블록 패턴: ---로 감싸진 YAML 영역 */
+export declare const FRONTMATTER_RE: RegExp;
+/** 마크다운 헤딩 패턴: # ~ ###### 레벨 */
+export declare const HEADING_RE: RegExp;
+/** 볼드 마커 패턴: **섹션명** (콜론/대시 허용) */
+export declare const BOLD_MARKER_RE: RegExp;
+/**
+ * 섹션 탐색 옵션
+ */
+export interface FindSectionOptions {
+    /** 볼드 마커(**섹션명**) 시작도 허용 (기본: false) */
+    allowBoldMarker?: boolean;
+}
+/**
+ * 섹션명에 해당하는 콘텐츠 라인들을 추출한다
+ *
+ * 헤딩(##, ### 등)에서 sectionName을 포함하는 섹션을 찾고,
+ * 동일/상위 레벨의 다음 헤딩까지의 라인을 수집한다.
+ *
+ * @param content - 마크다운 전체 내용
+ * @param sectionName - 찾을 섹션명 (includes 매칭)
+ * @param options - 탐색 옵션 (볼드 마커 허용 등)
+ * @returns 섹션 내 라인 배열
+ */
+export declare function findSectionLines(content: string, sectionName: string, options?: FindSectionOptions): string[];
+/**
+ * 정규식 특수문자를 이스케이프한다
+ */
+export declare function escapeRegex(str: string): string;
+/**
+ * 정규식 문자열을 안전하게 RegExp로 변환한다
+ */
+export declare function safeRegex(pattern: string): RegExp | null;
+/**
+ * 콘텐츠의 줄바꿈을 LF로 정규화한다
+ *
+ * Windows CRLF(\r\n)를 LF(\n)로 변환.
+ * 각 파서의 진입점에서 한 번 호출하면 내부 로직에서 \r 걱정 불필요.
+ * \r\n이 없으면 원본 그대로 반환하여 성능 영향 최소화.
+ */
+export declare function normalizeLineEndings(content: string): string;
+/**
+ * 라인 끝의 캐리지 리턴(\r)을 제거한다
+ */
+export declare function stripCR(line: string): string;
+/**
+ * 섹션 헤더의 헤딩 레벨 프리픽스를 추출한다
+ *
+ * @example
+ * getHeadingPrefix('# 유닛 구현')   // → '#'
+ * getHeadingPrefix('## 작업 백로그') // → '##'
+ * getHeadingPrefix('plain text')    // → null
+ */
+export declare function getHeadingPrefix(sectionHeader: string): string | null;
+/**
+ * 라인이 주어진 헤딩과 동급인지 확인한다
+ *
+ * 헤딩 레벨이 동일한 경우만 true.
+ * 예: headingPrefix='#'일 때 '# foo' → true, '## foo' → false
+ */
+export declare function isSameLevelHeading(line: string, headingPrefix: string | null): boolean;
+/**
+ * 값이 "의존성 없음"을 나타내는지 판단한다
+ *
+ * 대소문자 무관으로 "None", "-", 빈 문자열 등을 인식.
+ * 모든 파서에서 재사용하여 일관된 None 필터링 보장.
+ */
+export declare function isNoneDependency(value: string): boolean;
+/**
+ * 배열에서 키 기준 중복을 제거한다 (첫 등장 유지)
+ */
+export declare function deduplicateBy<T>(items: T[], keyFn: (item: T) => string): T[];
+//# sourceMappingURL=md-utils.d.ts.map

package/dist/core/parsers/md-utils.js

@@ -0,0 +1,144 @@
+/**
+ * 마크다운 파싱 공통 유틸리티 — Layer 1 순수 함수
+ *
+ * 여러 파서에서 공유하는 정규식 상수와 헬퍼 함수 모음.
+ * 섹션 탐색, 정규식 유틸, 라인 처리 등.
+ *
+ * @module
+ */
+/** Frontmatter 블록 패턴: ---로 감싸진 YAML 영역 */
+export const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---/;
+/** 마크다운 헤딩 패턴: # ~ ###### 레벨 */
+export const HEADING_RE = /^(#{1,6})\s+(.+)$/;
+/** 볼드 마커 패턴: **섹션명** (콜론/대시 허용) */
+export const BOLD_MARKER_RE = /^\*\*[^*]+\*\*\s*[:\-—]?\s*$/;
+/**
+ * 섹션명에 해당하는 콘텐츠 라인들을 추출한다
+ *
+ * 헤딩(##, ### 등)에서 sectionName을 포함하는 섹션을 찾고,
+ * 동일/상위 레벨의 다음 헤딩까지의 라인을 수집한다.
+ *
+ * @param content - 마크다운 전체 내용
+ * @param sectionName - 찾을 섹션명 (includes 매칭)
+ * @param options - 탐색 옵션 (볼드 마커 허용 등)
+ * @returns 섹션 내 라인 배열
+ */
+export function findSectionLines(content, sectionName, options = {}) {
+    const { allowBoldMarker = false } = options;
+    const lines = content.split('\n');
+    let inSection = false;
+    let sectionHeadingLevel = 0;
+    const result = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        const headingMatch = trimmed.match(HEADING_RE);
+        if (inSection) {
+            if (headingMatch) {
+                const level = (headingMatch[1] ?? '').length;
+                if (sectionHeadingLevel > 0 && level <= sectionHeadingLevel)
+                    break;
+                if (sectionHeadingLevel === 0)
+                    break;
+            }
+            if (allowBoldMarker && sectionHeadingLevel === 0 && BOLD_MARKER_RE.test(trimmed)) {
+                break;
+            }
+            result.push(line);
+        }
+        else {
+            if (headingMatch?.[2]?.includes(sectionName)) {
+                inSection = true;
+                sectionHeadingLevel = (headingMatch[1] ?? '').length;
+                continue;
+            }
+            if (allowBoldMarker && trimmed.includes(`**${sectionName}**`)) {
+                inSection = true;
+                sectionHeadingLevel = 0;
+                continue;
+            }
+        }
+    }
+    return result;
+}
+/**
+ * 정규식 특수문자를 이스케이프한다
+ */
+export function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * 정규식 문자열을 안전하게 RegExp로 변환한다
+ */
+export function safeRegex(pattern) {
+    try {
+        return new RegExp(pattern);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 콘텐츠의 줄바꿈을 LF로 정규화한다
+ *
+ * Windows CRLF(\r\n)를 LF(\n)로 변환.
+ * 각 파서의 진입점에서 한 번 호출하면 내부 로직에서 \r 걱정 불필요.
+ * \r\n이 없으면 원본 그대로 반환하여 성능 영향 최소화.
+ */
+export function normalizeLineEndings(content) {
+    return content.includes('\r') ? content.replace(/\r\n/g, '\n') : content;
+}
+/**
+ * 라인 끝의 캐리지 리턴(\r)을 제거한다
+ */
+export function stripCR(line) {
+    return line.endsWith('\r') ? line.slice(0, -1) : line;
+}
+/**
+ * 섹션 헤더의 헤딩 레벨 프리픽스를 추출한다
+ *
+ * @example
+ * getHeadingPrefix('# 유닛 구현')   // → '#'
+ * getHeadingPrefix('## 작업 백로그') // → '##'
+ * getHeadingPrefix('plain text')    // → null
+ */
+export function getHeadingPrefix(sectionHeader) {
+    const match = sectionHeader.trim().match(/^(#{1,6})\s/);
+    return match?.[1] ?? null;
+}
+/**
+ * 라인이 주어진 헤딩과 동급인지 확인한다
+ *
+ * 헤딩 레벨이 동일한 경우만 true.
+ * 예: headingPrefix='#'일 때 '# foo' → true, '## foo' → false
+ */
+export function isSameLevelHeading(line, headingPrefix) {
+    if (!headingPrefix)
+        return false;
+    const trimmed = stripCR(line).trim();
+    // 동일 레벨: prefix + 공백으로 시작하되, 더 깊은 레벨(prefix + #)은 제외
+    return trimmed.startsWith(headingPrefix + ' ') && !trimmed.startsWith(headingPrefix + '#');
+}
+/**
+ * 값이 "의존성 없음"을 나타내는지 판단한다
+ *
+ * 대소문자 무관으로 "None", "-", 빈 문자열 등을 인식.
+ * 모든 파서에서 재사용하여 일관된 None 필터링 보장.
+ */
+export function isNoneDependency(value) {
+    const normalized = value.trim().toLowerCase();
+    return normalized === '' || normalized === 'none' || normalized === '-' || normalized === '없음';
+}
+/**
+ * 배열에서 키 기준 중복을 제거한다 (첫 등장 유지)
+ */
+export function deduplicateBy(items, keyFn) {
+    const seen = new Set();
+    return items.filter((item) => {
+        const key = keyFn(item);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+//# sourceMappingURL=md-utils.js.map

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

@@ -0,0 +1,49 @@
+/**
+ * 메타데이터 테이블 파서 — Layer 1 순수 함수
+ *
+ * 계획서 마크다운의 메타데이터 테이블(2-column key-value)에서
+ * 유닛 메타정보를 추출한다.
+ *
+ * 설정의 `metadataTable` 필드명으로 시맨틱 키(unitId, phase, depends)에 매핑.
+ * 테이블이 없으면 모든 필드가 null인 결과 반환 (Graceful Degradation).
+ *
+ * @module
+ */
+import type { MetadataTableConfig, ToolResult } from '../../types/index.js';
+/**
+ * 메타데이터 테이블 파싱 결과
+ *
+ * 설정 필드명으로 매핑된 시맨틱 키와 원본 key-value 맵을 제공.
+ */
+export interface MetadataTableResult {
+    /** Unit ID (tableConfig.idField 키로 찾은 값) */
+    unitId?: string;
+    /** Phase (tableConfig.phaseField 키로 찾은 값) */
+    phase?: string;
+    /** 의존성 ID 목록 (tableConfig.dependsField 키로 찾은 값을 콤마로 분리) */
+    depends: string[];
+    /** 원본 key-value 맵 (테이블의 모든 항목) */
+    raw: Record<string, string>;
+}
+/**
+ * 마크다운 2-column 테이블에서 메타데이터를 파싱한다
+ *
+ * 첫 번째 2-column 테이블을 찾아 key-value 쌍으로 추출하고,
+ * 설정의 필드명으로 시맨틱 키(unitId, phase, depends)에 매핑한다.
+ *
+ * @param content - 마크다운 전체 내용
+ * @param tableConfig - 메타데이터 테이블 필드명 매핑 설정
+ * @returns 파싱된 메타데이터 결과를 포함한 ToolResult
+ *
+ * @example
+ * ```typescript
+ * const content = '| 항목 | 내용 |\n|---|---|\n| Unit ID | U-005 |\n| Phase | MVP |';
+ * const config = { idField: 'Unit ID', phaseField: 'Phase', dependsField: '의존성' };
+ * const result = parseMetadataTable(content, config);
+ * if (result.success) {
+ *   // result.data.unitId === 'U-005'
+ * }
+ * ```
+ */
+export declare function parseMetadataTable(content: string, tableConfig: MetadataTableConfig): ToolResult<MetadataTableResult>;
+//# sourceMappingURL=metadata-parser.d.ts.map