vibe-commander 0.1.0

package/dist/adapters/cli/commands/set-unit.js

@@ -0,0 +1,90 @@
+/**
+ * set-unit 커맨드 핸들러 — Layer 3 (Adapter)
+ *
+ * 유닛 ID를 받아 계획서 파싱 → 의존성 수집 → 섹션 렌더링 → 커맨드 파일 업데이트
+ * 전체 파이프라인을 실행한다.
+ *
+ * Core 순수 함수들(parseUnitPlan, resolveDepDocs, findDepCommits,
+ * renderSection, updateSection)을 조합하며,
+ * I/O(파일 읽기/쓰기, git 실행)는 이 Adapter에서만 수행.
+ *
+ * @module
+ */
+import { writeFileSync } from 'node:fs';
+import { ok, fail } from '../../../types/index.js';
+import { renderSection } from '../../../core/renderers/section-renderer.js';
+import { updateSection } from '../../../core/renderers/section-updater.js';
+import { resolveCommandContext } from './context-resolver.js';
+import { readCommandsFile } from './io-helpers.js';
+import { writeActiveUnitType } from './state-helpers.js';
+import { isInteractive, promptAllQuestions } from './prompt-helpers.js';
+/**
+ * set-unit 커맨드를 실행한다
+ *
+ * 파이프라인:
+ * 1. 전체 컨텍스트 해석 (resolveCommandContext)
+ * 2. 미결정 페어링 질문 프롬프트 (인터랙티브 모드일 때)
+ * 3. 섹션 렌더링 (renderSection)
+ * 4. 커맨드 파일 업데이트 (updateSection)
+ * 5. 결과 반환
+ *
+ * @param args - 파싱된 CLI 인자 (command === 'set-unit' 보장)
+ * @param projectRoot - 프로젝트 루트 절대 경로
+ * @returns 실행 결과 또는 에러
+ */
+export async function handleSetUnit(args, projectRoot) {
+    if (args.command !== 'set-unit') {
+        return fail('INTERNAL_ERROR', 'handleSetUnit에 잘못된 커맨드가 전달되었습니다');
+    }
+    const { unitId, noPrompt } = args;
+    const requestKeys = 'requestKeys' in args ? args.requestKeys : [];
+    // 1. 전체 컨텍스트 해석 (I/O + 파싱 + 의존성 수집)
+    const resolveResult = resolveCommandContext(unitId, projectRoot, requestKeys);
+    if (!resolveResult.success)
+        return resolveResult;
+    const { context, config, unitTypeKey, unitTypeConfig, planRelPath, warnings } = resolveResult.data;
+    // 2. 미결정 페어링 질문 프롬프트 (인터랙티브 모드)
+    let pairingAnswers = [];
+    const unresolvedCount = context.pairingQuestions.filter((q) => !q.resolved).length;
+    if (unresolvedCount > 0 && isInteractive(noPrompt)) {
+        pairingAnswers = await promptAllQuestions(context.pairingQuestions);
+        context.pairingAnswers = pairingAnswers;
+    }
+    // 3. 섹션 렌더링 (Core 순수 함수)
+    const sectionBody = renderSection(context, unitTypeConfig);
+    // 4. 커맨드 파일 업데이트 (Adapter I/O)
+    let commandsUpdated = false;
+    const cmdFile = readCommandsFile(config, projectRoot);
+    if (cmdFile.success) {
+        const useMarkers = config.commandSections.useMarkers;
+        const markerOptions = useMarkers ? { sectionKey: unitTypeConfig.key } : undefined;
+        const updateResult = updateSection(cmdFile.data.content, unitTypeConfig.commandSection, sectionBody, config.commandSections.separator, markerOptions);
+        if (updateResult.success && updateResult.data.updated) {
+            writeFileSync(cmdFile.data.absPath, updateResult.data.content, 'utf-8');
+            commandsUpdated = true;
+        }
+        else if (updateResult.success && !updateResult.data.updated) {
+            warnings.push(`커맨드 파일에서 '${unitTypeConfig.commandSection}' 섹션을 찾을 수 없습니다`);
+        }
+    }
+    else {
+        warnings.push(`커맨드 파일을 읽을 수 없습니다: ${config.paths.commands}`);
+    }
+    // 5. 활성 유닛 타입 상태 기록 (update-commit 자동 감지용)
+    writeActiveUnitType(projectRoot, unitTypeKey);
+    // 6. 결과 반환
+    return ok({
+        unitId,
+        unitType: unitTypeKey,
+        title: context.unit.title,
+        planPath: planRelPath,
+        depsFound: context.unit.depends.length,
+        docsFound: context.depDocs.reduce((sum, d) => sum + d.found.length, 0),
+        commitsFound: context.depCommits.length,
+        pairingQuestions: context.pairingQuestions,
+        pairingAnswers,
+        commandsUpdated,
+        warnings,
+    });
+}
+//# sourceMappingURL=set-unit.js.map

package/dist/adapters/cli/commands/skill-install.d.ts

@@ -0,0 +1,31 @@
+/**
+ * skill install 커맨드 핸들러 — Layer 3 (Adapter)
+ *
+ * npm 패키지에 번들된 SKILL 파일을 프로젝트의 에이전트 인식 경로에 복사한다.
+ * Cursor(.cursor/skills/), Claude Code(.claude/skills/), Gemini(.gemini/skills/) 지원.
+ *
+ * 파이프라인:
+ * 1. 번들된 SKILL 소스 파일 경로 resolve (import.meta.url 기반)
+ * 2. 각 대상 플랫폼별로 존재 여부 확인
+ * 3. 기존 파일 존재 시 --force 없으면 건너뜀
+ * 4. 디렉토리 생성 + 파일 복사 + 결과 반환
+ *
+ * @module
+ */
+import type { ToolResult } from '../../../types/index.js';
+import type { ParsedArgs } from '../router.js';
+export type Platform = 'cursor' | 'claude' | 'gemini';
+export interface SkillInstallResult {
+    installed: string[];
+    skipped: string[];
+    overwritten: string[];
+}
+/**
+ * skill install 커맨드를 실행한다
+ *
+ * @param args - 파싱된 CLI 인자 (command === 'skill-install' 보장)
+ * @param projectRoot - 프로젝트 루트 절대 경로
+ * @returns 설치 결과 (installed, skipped, overwritten 목록)
+ */
+export declare function handleSkillInstall(args: ParsedArgs, projectRoot: string): ToolResult<SkillInstallResult>;
+//# sourceMappingURL=skill-install.d.ts.map

package/dist/adapters/cli/commands/skill-install.js

@@ -0,0 +1,85 @@
+/**
+ * skill install 커맨드 핸들러 — Layer 3 (Adapter)
+ *
+ * npm 패키지에 번들된 SKILL 파일을 프로젝트의 에이전트 인식 경로에 복사한다.
+ * Cursor(.cursor/skills/), Claude Code(.claude/skills/), Gemini(.gemini/skills/) 지원.
+ *
+ * 파이프라인:
+ * 1. 번들된 SKILL 소스 파일 경로 resolve (import.meta.url 기반)
+ * 2. 각 대상 플랫폼별로 존재 여부 확인
+ * 3. 기존 파일 존재 시 --force 없으면 건너뜀
+ * 4. 디렉토리 생성 + 파일 복사 + 결과 반환
+ *
+ * @module
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ok, fail } from '../../../types/index.js';
+const PLATFORM_CONFIG = {
+    cursor: { sourceDir: 'cursor', targetDir: '.cursor/skills/vibe-commander' },
+    claude: { sourceDir: 'claude', targetDir: '.claude/skills/vibe-commander' },
+    gemini: { sourceDir: 'claude', targetDir: '.gemini/skills/vibe-commander' },
+};
+/**
+ * 번들된 SKILL 파일의 루트 디렉토리를 반환한다
+ *
+ * import.meta.url 기반으로 현재 모듈 위치에서 패키지 루트의 skills/ 디렉토리를 resolve.
+ * src/adapters/cli/commands/ 또는 dist/adapters/cli/commands/ 모두 동일한 깊이.
+ */
+function getSkillsRoot() {
+    const thisDir = dirname(fileURLToPath(import.meta.url));
+    return join(thisDir, '..', '..', '..', '..', 'skills');
+}
+/**
+ * skill install 커맨드를 실행한다
+ *
+ * @param args - 파싱된 CLI 인자 (command === 'skill-install' 보장)
+ * @param projectRoot - 프로젝트 루트 절대 경로
+ * @returns 설치 결과 (installed, skipped, overwritten 목록)
+ */
+export function handleSkillInstall(args, projectRoot) {
+    if (args.command !== 'skill-install') {
+        return fail('INTERNAL_ERROR', 'handleSkillInstall에 잘못된 커맨드가 전달되었습니다');
+    }
+    const skillsRoot = getSkillsRoot();
+    if (!existsSync(skillsRoot)) {
+        return fail('SKILL_SOURCE_NOT_FOUND', 'SKILL 소스 디렉토리를 찾을 수 없습니다', `경로: ${skillsRoot}. npm 패키지가 올바르게 설치되었는지 확인하세요.`);
+    }
+    const result = { installed: [], skipped: [], overwritten: [] };
+    for (const platform of args.targets) {
+        installForPlatform(platform, skillsRoot, projectRoot, args.force, result);
+    }
+    if (result.installed.length === 0 && result.overwritten.length === 0) {
+        if (result.skipped.length > 0) {
+            return ok(result);
+        }
+        return fail('SKILL_INSTALL_FAILED', '설치할 SKILL 파일이 없습니다', '소스 SKILL 파일이 존재하는지 확인하세요.');
+    }
+    return ok(result);
+}
+/**
+ * 단일 플랫폼에 SKILL 파일을 설치한다
+ */
+function installForPlatform(platform, skillsRoot, projectRoot, force, result) {
+    const config = PLATFORM_CONFIG[platform];
+    const sourcePath = join(skillsRoot, config.sourceDir, 'SKILL.md');
+    const targetPath = join(projectRoot, config.targetDir, 'SKILL.md');
+    const displayPath = relative(projectRoot, targetPath).replace(/\\/g, '/');
+    if (!existsSync(sourcePath)) {
+        result.skipped.push(`${platform}: 소스 SKILL 파일 없음`);
+        return;
+    }
+    if (existsSync(targetPath)) {
+        if (!force) {
+            result.skipped.push(`${displayPath} (이미 존재 — --force로 덮어쓰기)`);
+            return;
+        }
+        result.overwritten.push(displayPath);
+    }
+    mkdirSync(dirname(targetPath), { recursive: true });
+    const content = readFileSync(sourcePath, 'utf-8');
+    writeFileSync(targetPath, content, 'utf-8');
+    result.installed.push(displayPath);
+}
+//# sourceMappingURL=skill-install.js.map

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

@@ -0,0 +1,28 @@
+/**
+ * 활성 유닛 상태 추적 헬퍼 — Layer 3 (Adapter)
+ *
+ * set-unit 실행 시 마지막 활성 유닛 타입을 상태 파일에 기록하고,
+ * update-commit 실행 시 이를 읽어 대상 섹션을 결정한다.
+ *
+ * 상태 파일: .vibe-commander.state.json (프로젝트 루트)
+ * 이 파일은 .gitignore에 추가되어 버전 관리에서 제외된다.
+ *
+ * @module
+ */
+/** 상태 파일명 (프로젝트 루트 기준) */
+export declare const STATE_FILENAME = ".vibe-commander.state.json";
+/**
+ * 마지막 활성 유닛 타입을 상태 파일에 기록한다
+ *
+ * @param projectRoot - 프로젝트 루트 절대 경로
+ * @param unitTypeKey - 유닛 타입 키 (예: "implement", "refactor")
+ */
+export declare function writeActiveUnitType(projectRoot: string, unitTypeKey: string): void;
+/**
+ * 마지막 활성 유닛 타입을 상태 파일에서 읽어온다
+ *
+ * @param projectRoot - 프로젝트 루트 절대 경로
+ * @returns 유닛 타입 키 또는 null (파일 없음/파싱 실패 시)
+ */
+export declare function readActiveUnitType(projectRoot: string): string | null;
+//# sourceMappingURL=state-helpers.d.ts.map

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

@@ -0,0 +1,55 @@
+/**
+ * 활성 유닛 상태 추적 헬퍼 — Layer 3 (Adapter)
+ *
+ * set-unit 실행 시 마지막 활성 유닛 타입을 상태 파일에 기록하고,
+ * update-commit 실행 시 이를 읽어 대상 섹션을 결정한다.
+ *
+ * 상태 파일: .vibe-commander.state.json (프로젝트 루트)
+ * 이 파일은 .gitignore에 추가되어 버전 관리에서 제외된다.
+ *
+ * @module
+ */
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+/** 상태 파일명 (프로젝트 루트 기준) */
+export const STATE_FILENAME = '.vibe-commander.state.json';
+/**
+ * 마지막 활성 유닛 타입을 상태 파일에 기록한다
+ *
+ * @param projectRoot - 프로젝트 루트 절대 경로
+ * @param unitTypeKey - 유닛 타입 키 (예: "implement", "refactor")
+ */
+export function writeActiveUnitType(projectRoot, unitTypeKey) {
+    const statePath = join(projectRoot, STATE_FILENAME);
+    const state = { lastActiveUnitType: unitTypeKey };
+    try {
+        writeFileSync(statePath, JSON.stringify(state, null, 2) + '\n', 'utf-8');
+    }
+    catch {
+        // 상태 기록 실패는 무시 (Graceful Degradation)
+    }
+}
+/**
+ * 마지막 활성 유닛 타입을 상태 파일에서 읽어온다
+ *
+ * @param projectRoot - 프로젝트 루트 절대 경로
+ * @returns 유닛 타입 키 또는 null (파일 없음/파싱 실패 시)
+ */
+export function readActiveUnitType(projectRoot) {
+    const statePath = join(projectRoot, STATE_FILENAME);
+    try {
+        const raw = readFileSync(statePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (parsed !== null &&
+            typeof parsed === 'object' &&
+            'lastActiveUnitType' in parsed &&
+            typeof parsed.lastActiveUnitType === 'string') {
+            return parsed.lastActiveUnitType;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=state-helpers.js.map

package/dist/adapters/cli/commands/update-commit.d.ts

@@ -0,0 +1,42 @@
+/**
+ * update-commit 커맨드 핸들러 — Layer 3 (Adapter)
+ *
+ * Commit SHA를 받아 커맨드 파일의 해당 섹션 Commit 라인을 업데이트한다.
+ * replace 모드(값 교체)와 append 모드(콤마 구분 추가)를 지원.
+ *
+ * Core 순수 함수(updateField)를 호출하며,
+ * I/O(파일 읽기/쓰기)는 이 Adapter에서만 수행.
+ *
+ * @module
+ */
+import type { ToolResult } from '../../../types/index.js';
+import type { ParsedArgs } from '../router.js';
+/** update-commit 실행 결과 */
+export interface UpdateCommitResult {
+    sha: string;
+    mode: 'replace' | 'append';
+    section: string;
+    sectionHeader: string;
+    updated: boolean;
+    commitMode: 'auto-head' | 'auto-recent' | 'manual';
+    count?: number;
+    requested?: number;
+}
+/**
+ * update-commit 커맨드를 실행한다
+ *
+ * 파이프라인:
+ * 1. commitMode에 따라 SHA 결정 (auto-head/auto-recent/manual)
+ * 2. 설정 로드 (loadConfig)
+ * 3. 커맨드 파일 읽기
+ * 4. 대상 섹션 결정 (자동 감지 또는 --section)
+ * 5. Commit 필드 업데이트 (updateField)
+ * 6. 파일 쓰기
+ * 7. 결과 반환
+ *
+ * @param args - 파싱된 CLI 인자 (command === 'update-commit' 보장)
+ * @param projectRoot - 프로젝트 루트 절대 경로
+ * @returns 실행 결과 또는 에러
+ */
+export declare function handleUpdateCommit(args: ParsedArgs, projectRoot: string): ToolResult<UpdateCommitResult>;
+//# sourceMappingURL=update-commit.d.ts.map

package/dist/adapters/cli/commands/update-commit.js

@@ -0,0 +1,180 @@
+/**
+ * update-commit 커맨드 핸들러 — Layer 3 (Adapter)
+ *
+ * Commit SHA를 받아 커맨드 파일의 해당 섹션 Commit 라인을 업데이트한다.
+ * replace 모드(값 교체)와 append 모드(콤마 구분 추가)를 지원.
+ *
+ * Core 순수 함수(updateField)를 호출하며,
+ * I/O(파일 읽기/쓰기)는 이 Adapter에서만 수행.
+ *
+ * @module
+ */
+import { writeFileSync } from 'node:fs';
+import { ok, fail } from '../../../types/index.js';
+import { loadConfig } from '../../../config/loader.js';
+import { updateField } from '../../../core/renderers/section-updater.js';
+import { normalizeLineEndings, getHeadingPrefix, isSameLevelHeading, } from '../../../core/parsers/index.js';
+import { findHeaderIndex, getBodyStartIndex, findBodyEndIndex, } from '../../../core/renderers/updater-helpers.js';
+import { readCommandsFile } from './io-helpers.js';
+import { getHeadSha, getRecentShas } from './git-helpers.js';
+import { readActiveUnitType } from './state-helpers.js';
+/**
+ * update-commit 커맨드를 실행한다
+ *
+ * 파이프라인:
+ * 1. commitMode에 따라 SHA 결정 (auto-head/auto-recent/manual)
+ * 2. 설정 로드 (loadConfig)
+ * 3. 커맨드 파일 읽기
+ * 4. 대상 섹션 결정 (자동 감지 또는 --section)
+ * 5. Commit 필드 업데이트 (updateField)
+ * 6. 파일 쓰기
+ * 7. 결과 반환
+ *
+ * @param args - 파싱된 CLI 인자 (command === 'update-commit' 보장)
+ * @param projectRoot - 프로젝트 루트 절대 경로
+ * @returns 실행 결과 또는 에러
+ */
+export function handleUpdateCommit(args, projectRoot) {
+    if (args.command !== 'update-commit') {
+        return fail('INTERNAL_ERROR', 'handleUpdateCommit에 잘못된 커맨드가 전달되었습니다');
+    }
+    const { commitMode, mode, section: sectionKey } = args;
+    // 1. commitMode에 따라 SHA 결정
+    let sha;
+    let actualCount;
+    let requested;
+    switch (commitMode) {
+        case 'auto-head': {
+            const headResult = getHeadSha(projectRoot);
+            if (!headResult.success)
+                return headResult;
+            sha = headResult.data;
+            break;
+        }
+        case 'auto-recent': {
+            const count = args.count ?? 1;
+            const recentResult = getRecentShas(projectRoot, count);
+            if (!recentResult.success)
+                return recentResult;
+            sha = recentResult.data.shas.join(', ');
+            actualCount = recentResult.data.actual;
+            requested = recentResult.data.requested;
+            break;
+        }
+        case 'manual': {
+            sha = args.sha ?? '';
+            if (!sha) {
+                return fail('MISSING_ARGUMENT', "'update-commit' manual 모드에 SHA가 필요합니다");
+            }
+            break;
+        }
+    }
+    // 2. 설정 로드
+    const configResult = loadConfig(projectRoot);
+    if (!configResult.success)
+        return configResult;
+    const config = configResult.data;
+    // 3. 커맨드 파일 읽기 (Adapter I/O)
+    const cmdFile = readCommandsFile(config, projectRoot);
+    if (!cmdFile.success)
+        return cmdFile;
+    const { content: commandsContent, absPath: commandsAbsPath, relPath: commandsRelPath, } = cmdFile.data;
+    // 4. 대상 섹션 결정 (상태 파일 우선 → 자동 감지 fallback)
+    const sectionResult = resolveTargetSection(sectionKey, config, commandsContent, projectRoot);
+    if (!sectionResult.success)
+        return sectionResult;
+    const { sectionHeader, unitTypeKey } = sectionResult.data;
+    // 5. Commit 필드 패턴 생성 (설정 기반)
+    const fieldName = config.commandSections.commitFieldName;
+    const fieldPattern = new RegExp(fieldName);
+    // 6. Commit 필드 업데이트 (Core 순수 함수)
+    const markerOptions = config.commandSections.useMarkers ? { sectionKey: unitTypeKey } : undefined;
+    const updateResult = updateField(commandsContent, sectionHeader, fieldPattern, sha, config.commandSections.separator, mode, markerOptions);
+    if (!updateResult.success) {
+        return updateResult;
+    }
+    if (!updateResult.data.updated) {
+        return fail('FIELD_NOT_FOUND', `'${sectionHeader}' 섹션에서 ${fieldName} 필드를 찾을 수 없습니다`, 'set-unit을 먼저 실행하여 섹션을 초기화하거나, --section 옵션으로 대상 섹션을 지정하세요');
+    }
+    // 7. 파일 쓰기 (Adapter I/O)
+    try {
+        writeFileSync(commandsAbsPath, updateResult.data.content, 'utf-8');
+    }
+    catch {
+        return fail('COMMANDS_WRITE_FAILED', `커맨드 파일을 쓸 수 없습니다: ${commandsRelPath}`, `절대 경로: ${commandsAbsPath}`);
+    }
+    // 8. 결과 반환
+    return ok({
+        sha,
+        mode,
+        section: unitTypeKey,
+        sectionHeader,
+        updated: true,
+        commitMode,
+        ...(actualCount !== undefined && { count: actualCount }),
+        ...(requested !== undefined && { requested }),
+    });
+}
+/**
+ * 대상 섹션을 결정한다.
+ *
+ * 우선순위:
+ * 1. sectionKey가 있으면 해당 유형 사용 (--section 옵션).
+ * 2. 상태 파일에 마지막 활성 유닛 타입이 있고, 해당 섹션이 활성 상태면 사용.
+ * 3. 없으면 commandsContent를 분석하여 활성 유닛이 있는 섹션 탐색 (fallback).
+ * 4. 활성 섹션이 없으면 에러 반환 (PRD §6.3 준수).
+ */
+function resolveTargetSection(sectionKey, config, commandsContent, projectRoot) {
+    // 1. 특정 섹션이 지정된 경우
+    if (sectionKey !== undefined) {
+        const unitType = config.unitTypes.find((t) => t.key === sectionKey);
+        if (!unitType) {
+            return fail('SECTION_NOT_FOUND', `'${sectionKey}' 유닛 유형을 찾을 수 없습니다`, `사용 가능한 유형: ${config.unitTypes.map((t) => t.key).join(', ')}`);
+        }
+        return ok({ sectionHeader: unitType.commandSection, unitTypeKey: unitType.key });
+    }
+    // 2. 상태 파일에서 마지막 활성 유닛 타입 확인 (set-unit이 기록)
+    const lastActiveType = readActiveUnitType(projectRoot);
+    if (lastActiveType !== null) {
+        const stateUnitType = config.unitTypes.find((t) => t.key === lastActiveType);
+        if (stateUnitType &&
+            isActiveSection(commandsContent, stateUnitType, config.commandSections.separator)) {
+            return ok({
+                sectionHeader: stateUnitType.commandSection,
+                unitTypeKey: stateUnitType.key,
+            });
+        }
+    }
+    // 3. Fallback: 활성 유닛 정보가 있는 섹션 순회
+    for (const unitType of config.unitTypes) {
+        if (isActiveSection(commandsContent, unitType, config.commandSections.separator)) {
+            return ok({ sectionHeader: unitType.commandSection, unitTypeKey: unitType.key });
+        }
+    }
+    return fail('NO_ACTIVE_UNIT', '현재 활성화된 유닛을 찾을 수 없습니다', 'vc set-unit <unitId> 명령을 먼저 실행하거나, --section 옵션으로 대상 섹션을 지정하세요');
+}
+/**
+ * 섹션이 활성화되어 있는지(유닛 정보가 채워져 있는지) 확인한다.
+ *
+ * 본문 내에 유닛 ID 패턴에 매칭되는 문자열이 있고, 그 값이 placeholder('-')가 아니면 활성으로 간주.
+ */
+function isActiveSection(content, unitType, separator) {
+    const normalized = normalizeLineEndings(content);
+    const lines = normalized.split('\n');
+    const headerIdx = findHeaderIndex(lines, unitType.commandSection);
+    if (headerIdx === -1)
+        return false;
+    const headingPrefix = getHeadingPrefix(unitType.commandSection);
+    const bodyStartIdx = getBodyStartIndex(lines, headerIdx, separator);
+    const bodyEndIdx = findBodyEndIndex(lines, bodyStartIdx, separator, headingPrefix, isSameLevelHeading);
+    const sectionLines = lines.slice(bodyStartIdx, bodyEndIdx);
+    const sectionContent = sectionLines.join('\n');
+    // 유닛 ID 패턴에서 앵커(^, $) 제거하여 본문 내 검색용 패턴 생성
+    // idPattern은 전체 ID 검증용(^...$)이므로, 섹션 본문 내 포함 검색 시 앵커 제거 필요
+    const searchPattern = unitType.idPattern.replace(/^\^/, '').replace(/\$$/, '');
+    const idRegex = new RegExp(searchPattern, 'm');
+    const match = sectionContent.match(idRegex);
+    // 매칭되는 ID가 있고, 그게 placeholder가 아니면 활성
+    return match !== null && match[0] !== '-';
+}
+//# sourceMappingURL=update-commit.js.map

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

@@ -0,0 +1,40 @@
+/**
+ * validate 커맨드 핸들러 — Layer 3 (Adapter)
+ *
+ * 설정 파일의 스키마 유효성, 참조 경로 존재 여부, ID 패턴 정규식 유효성,
+ * 패턴 간 충돌 여부를 4단계로 종합 검증한다.
+ *
+ * 검증 파이프라인:
+ * 1. 스키마 유효성 — loadConfig()의 Zod 검증 결과
+ * 2. 경로 존재 — commands, roadmap, docRoots 실제 존재 확인
+ * 3. 정규식 유효성 — 각 unitType의 idPattern이 유효한 RegExp인지
+ * 4. 패턴 충돌 — docRoots 내 실제 파일명으로 다중 매칭 시뮬레이션
+ *
+ * @module
+ */
+import type { ToolResult } from '../../../types/index.js';
+import type { ParsedArgs } from '../router.js';
+export interface ValidationItem {
+    category: 'schema' | 'paths' | 'regex' | 'patterns';
+    status: 'pass' | 'warn' | 'error';
+    message: string;
+    details?: string;
+}
+export interface ValidateResult {
+    valid: boolean;
+    errors: number;
+    warnings: number;
+    items: ValidationItem[];
+}
+/**
+ * validate 커맨드를 실행한다
+ *
+ * 4단계 검증 파이프라인을 순차 실행하고 종합 리포트를 반환한다.
+ * 스키마 검증 실패 시 후속 검증을 건너뛰고 즉시 에러 리포트를 반환.
+ *
+ * @param args - 파싱된 CLI 인자 (command === 'validate' 보장)
+ * @param projectRoot - 프로젝트 루트 절대 경로
+ * @returns ValidateResult 또는 에러
+ */
+export declare function handleValidate(args: ParsedArgs, projectRoot: string): ToolResult<ValidateResult>;
+//# sourceMappingURL=validate.d.ts.map