vibe-commander 0.1.0

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

@@ -0,0 +1,219 @@
+/**
+ * validate 커맨드 핸들러 — Layer 3 (Adapter)
+ *
+ * 설정 파일의 스키마 유효성, 참조 경로 존재 여부, ID 패턴 정규식 유효성,
+ * 패턴 간 충돌 여부를 4단계로 종합 검증한다.
+ *
+ * 검증 파이프라인:
+ * 1. 스키마 유효성 — loadConfig()의 Zod 검증 결과
+ * 2. 경로 존재 — commands, roadmap, docRoots 실제 존재 확인
+ * 3. 정규식 유효성 — 각 unitType의 idPattern이 유효한 RegExp인지
+ * 4. 패턴 충돌 — docRoots 내 실제 파일명으로 다중 매칭 시뮬레이션
+ *
+ * @module
+ */
+import { existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { ok, fail } from '../../../types/index.js';
+import { loadConfig } from '../../../config/loader.js';
+import { validateRegexes, findPatternConflicts } from '../../../core/resolvers/config-validator.js';
+// ── 공개 API ──
+/**
+ * validate 커맨드를 실행한다
+ *
+ * 4단계 검증 파이프라인을 순차 실행하고 종합 리포트를 반환한다.
+ * 스키마 검증 실패 시 후속 검증을 건너뛰고 즉시 에러 리포트를 반환.
+ *
+ * @param args - 파싱된 CLI 인자 (command === 'validate' 보장)
+ * @param projectRoot - 프로젝트 루트 절대 경로
+ * @returns ValidateResult 또는 에러
+ */
+export function handleValidate(args, projectRoot) {
+    if (args.command !== 'validate') {
+        return fail('INTERNAL_ERROR', 'handleValidate에 잘못된 커맨드가 전달되었습니다');
+    }
+    const items = [];
+    // ── 1단계: 스키마 유효성 검증 ──
+    const configResult = loadConfig(projectRoot);
+    if (!configResult.success) {
+        items.push({
+            category: 'schema',
+            status: 'error',
+            message: '설정 파일 스키마 검증 실패',
+            details: configResult.error.details ?? configResult.error.message,
+        });
+        return ok(compileReport(items));
+    }
+    items.push({
+        category: 'schema',
+        status: 'pass',
+        message: '설정 파일 스키마 검증 통과',
+    });
+    const config = configResult.data;
+    // ── 2단계: 경로 존재 검증 ──
+    validatePaths(config, projectRoot, items);
+    // ── 3단계: 정규식 유효성 + 4단계: 패턴 충돌 검증 ──
+    validateIdPatterns(config, projectRoot, items);
+    return ok(compileReport(items));
+}
+// ── 내부 검증 함수 ──
+/**
+ * 설정에 명시된 경로들의 실제 존재 여부를 검증한다
+ */
+function validatePaths(config, projectRoot, items) {
+    const commandsPath = join(projectRoot, config.paths.commands);
+    if (existsSync(commandsPath)) {
+        items.push({
+            category: 'paths',
+            status: 'pass',
+            message: `commands 파일 존재: ${config.paths.commands}`,
+        });
+    }
+    else {
+        items.push({
+            category: 'paths',
+            status: 'error',
+            message: `commands 파일 미존재: ${config.paths.commands}`,
+            details: `경로: ${commandsPath}`,
+        });
+    }
+    if (config.paths.roadmap !== null) {
+        const roadmapPath = join(projectRoot, config.paths.roadmap);
+        if (existsSync(roadmapPath)) {
+            items.push({
+                category: 'paths',
+                status: 'pass',
+                message: `roadmap 파일 존재: ${config.paths.roadmap}`,
+            });
+        }
+        else {
+            items.push({
+                category: 'paths',
+                status: 'warn',
+                message: `roadmap 파일 미존재: ${config.paths.roadmap}`,
+                details: `경로: ${roadmapPath}`,
+            });
+        }
+    }
+    for (const [role, dir] of Object.entries(config.paths.docRoots)) {
+        const dirPath = join(projectRoot, dir);
+        if (existsSync(dirPath)) {
+            items.push({
+                category: 'paths',
+                status: 'pass',
+                message: `docRoots.${role} 디렉토리 존재: ${dir}`,
+            });
+        }
+        else {
+            items.push({
+                category: 'paths',
+                status: 'warn',
+                message: `docRoots.${role} 디렉토리 미존재: ${dir}`,
+                details: `경로: ${dirPath}`,
+            });
+        }
+    }
+}
+/**
+ * 각 unitType의 idPattern 정규식 유효성과 패턴 간 충돌을 검증한다
+ */
+function validateIdPatterns(config, projectRoot, items) {
+    // 3단계: 정규식 유효성 검증 (Core 레이어 호출)
+    const regexResult = validateRegexes(config.unitTypes);
+    if (!regexResult.success) {
+        items.push({
+            category: 'regex',
+            status: 'error',
+            message: regexResult.error.message,
+            details: regexResult.error.details,
+        });
+        return;
+    }
+    items.push({
+        category: 'regex',
+        status: 'pass',
+        message: '모든 유닛 유형 정규식 유효',
+    });
+    const validRegexes = regexResult.data;
+    // 4단계: 패턴 충돌 검증 (Core 레이어 호출)
+    if (validRegexes.length < 2) {
+        items.push({
+            category: 'patterns',
+            status: 'pass',
+            message: '패턴 충돌 검사: 유효한 패턴이 2개 미만이므로 충돌 불가',
+        });
+        return;
+    }
+    const testIds = collectTestIds(config, projectRoot);
+    if (testIds.length === 0) {
+        items.push({
+            category: 'patterns',
+            status: 'pass',
+            message: '패턴 충돌 검사: 테스트할 파일 없음 (docRoots에 .md 파일 미발견)',
+        });
+        return;
+    }
+    const conflicts = findPatternConflicts(testIds, validRegexes);
+    if (conflicts.length > 0) {
+        for (const conflict of conflicts) {
+            items.push({
+                category: 'patterns',
+                status: 'warn',
+                message: `패턴 충돌: "${conflict.id}" → ${conflict.matchingKeys.join(', ')} 매칭`,
+                details: `unitTypes 배열 순서에 의해 "${conflict.matchingKeys[0] ?? '?'}" 우선 적용`,
+            });
+        }
+    }
+    else {
+        items.push({
+            category: 'patterns',
+            status: 'pass',
+            message: `패턴 충돌 검사 통과: ${String(testIds.length)}개 ID 검증, 충돌 없음`,
+        });
+    }
+}
+/**
+ * docRoots 내 실제 .md 파일명에서 테스트용 ID를 수집한다
+ *
+ * 각 unitType의 planDir에 해당하는 디렉토리에서 .md 파일명을 추출하여
+ * 확장자를 제거한 문자열을 테스트 ID로 사용한다.
+ */
+function collectTestIds(config, projectRoot) {
+    const ids = new Set();
+    const scannedDirs = new Set();
+    for (const ut of config.unitTypes) {
+        const dir = config.paths.docRoots[ut.planDir];
+        if (!dir || scannedDirs.has(dir))
+            continue;
+        scannedDirs.add(dir);
+        const dirPath = join(projectRoot, dir);
+        if (!existsSync(dirPath))
+            continue;
+        try {
+            const files = readdirSync(dirPath);
+            for (const file of files) {
+                if (file.endsWith('.md')) {
+                    ids.add(file.replace(/\.md$/, ''));
+                }
+            }
+        }
+        catch {
+            // 디렉토리 읽기 실패는 무시 (paths 검증에서 이미 처리)
+        }
+    }
+    return [...ids];
+}
+/**
+ * 검증 항목 배열에서 에러/경고 수를 집계하여 최종 리포트를 생성한다
+ */
+function compileReport(items) {
+    const errors = items.filter((i) => i.status === 'error').length;
+    const warnings = items.filter((i) => i.status === 'warn').length;
+    return {
+        valid: errors === 0,
+        errors,
+        warnings,
+        items,
+    };
+}
+//# sourceMappingURL=validate.js.map

package/dist/adapters/cli/formatters-list.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 목록/업데이트 관련 포맷터 — Layer 3 (Adapter)
+ *
+ * list-units, update-commit 커맨드의 실행 결과를 포맷팅한다.
+ *
+ * @module
+ */
+import type { ToolResult, BacklogEntry } from '../../types/index.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;
+}
+/** list-units 실행 결과 */
+export interface ListUnitsResult {
+    total: number;
+    inProgress: BacklogEntry[];
+    ready: BacklogEntry[];
+    blocked: BacklogEntry[];
+    phase?: string;
+}
+/**
+ * update-commit 결과를 콘솔에 포맷팅하여 출력한다
+ */
+export declare function formatUpdateCommit(result: ToolResult<unknown>, json: boolean): void;
+/**
+ * list-units 결과를 콘솔에 포맷팅하여 출력한다
+ */
+export declare function formatListUnits(result: ToolResult<unknown>, json: boolean): void;
+//# sourceMappingURL=formatters-list.d.ts.map

package/dist/adapters/cli/formatters-list.js

@@ -0,0 +1,106 @@
+/**
+ * 목록/업데이트 관련 포맷터 — Layer 3 (Adapter)
+ *
+ * list-units, update-commit 커맨드의 실행 결과를 포맷팅한다.
+ *
+ * @module
+ */
+import { RESET, GREEN, YELLOW, CYAN, DIM, BOLD } from './output.js';
+const COMMIT_MODE_LABELS = {
+    'auto-head': 'HEAD 자동 감지',
+    'auto-recent': '최근 N개 커밋',
+    manual: '수동 지정',
+};
+/**
+ * update-commit 결과를 콘솔에 포맷팅하여 출력한다
+ */
+export function formatUpdateCommit(result, json) {
+    if (!result.success)
+        return;
+    if (json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    const data = result.data;
+    if (!isUpdateCommitResult(data))
+        return;
+    const sourceLabel = COMMIT_MODE_LABELS[data.commitMode] ?? data.commitMode;
+    console.log(`
+${GREEN}✅ 커밋 SHA 업데이트 완료${RESET}
+`);
+    console.log(`${BOLD}🔢 SHA${RESET}: ${CYAN}${data.sha}${RESET}`);
+    console.log(`${BOLD}📑 섹션${RESET}: ${data.sectionHeader} (${data.section})`);
+    console.log(`${BOLD}⚙️  모드${RESET}: ${data.mode} (${sourceLabel})`);
+    if (data.commitMode === 'auto-recent' &&
+        data.requested !== undefined &&
+        data.count !== undefined &&
+        data.count < data.requested) {
+        console.log(`${YELLOW}⚠️  요청: ${String(data.requested)}개, 실제: ${String(data.count)}개 (커밋 수 부족)${RESET}`);
+    }
+    console.log();
+}
+/**
+ * list-units 결과를 콘솔에 포맷팅하여 출력한다
+ */
+export function formatListUnits(result, json) {
+    if (!result.success)
+        return;
+    if (json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    const data = result.data;
+    if (!isListUnitsResult(data))
+        return;
+    const phaseLabel = data.phase ? ` (phase: ${data.phase})` : '';
+    console.log(`
+${BOLD}📋 미완료 유닛 목록${phaseLabel} — 총 ${String(data.total)}개${RESET}
+`);
+    if (data.total === 0) {
+        console.log(`${DIM}  미완료 유닛이 없습니다.${RESET}
+`);
+        return;
+    }
+    if (data.inProgress.length > 0) {
+        console.log(`${YELLOW}🚧 진행중 (${String(data.inProgress.length)}개)${RESET}`);
+        for (const e of data.inProgress) {
+            console.log(`  ${CYAN}${e.unitId}${RESET}  ${e.title.trim()}`);
+        }
+        console.log();
+    }
+    if (data.ready.length > 0) {
+        console.log(`${BOLD}🟢 착수 가능 (${String(data.ready.length)}개)${RESET}`);
+        for (const e of data.ready) {
+            const deps = e.depends.length > 0 ? `  ${DIM}[의존: ${e.depends.join(', ')}]${RESET}` : '';
+            console.log(`  ${CYAN}${e.unitId}${RESET}  ${e.title.trim()}${deps}`);
+        }
+        console.log();
+    }
+    if (data.blocked.length > 0) {
+        console.log(`${BOLD}🔴 차단됨 (${String(data.blocked.length)}개)${RESET}`);
+        for (const e of data.blocked) {
+            const deps = e.depends.length > 0 ? `  ${DIM}[의존: ${e.depends.join(', ')}]${RESET}` : '';
+            console.log(`  ${CYAN}${e.unitId}${RESET}  ${e.title.trim()}${deps}`);
+        }
+        console.log();
+    }
+}
+/** ListUnitsResult 런타임 타입 가드 */
+function isListUnitsResult(data) {
+    return (data !== null &&
+        typeof data === 'object' &&
+        'total' in data &&
+        'inProgress' in data &&
+        'ready' in data &&
+        'blocked' in data);
+}
+/** UpdateCommitResult 런타임 타입 가드 */
+function isUpdateCommitResult(data) {
+    return (data !== null &&
+        typeof data === 'object' &&
+        'sha' in data &&
+        'mode' in data &&
+        'section' in data &&
+        'updated' in data);
+}
+//# sourceMappingURL=formatters-list.js.map

package/dist/adapters/cli/formatters-unit.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 유닛 작업 관련 포맷터 — Layer 3 (Adapter)
+ *
+ * set-unit, context, validate 커맨드의 실행 결과를 포맷팅한다.
+ *
+ * @module
+ */
+import type { ToolResult, PairingQuestion } from '../../types/index.js';
+/** set-unit 실행 result */
+export interface SetUnitResult {
+    unitId: string;
+    unitType: string;
+    title: string;
+    planPath: string;
+    depsFound: number;
+    docsFound: number;
+    commitsFound: number;
+    pairingQuestions: PairingQuestion[];
+    commandsUpdated: boolean;
+    warnings: string[];
+}
+/**
+ * set-unit 결과를 콘솔에 포맷팅하여 출력한다
+ */
+export declare function formatSetUnit(result: ToolResult<unknown>, json: boolean): void;
+/**
+ * context 결과를 콘솔에 포맷팅하여 출력한다
+ */
+export declare function formatContext(result: ToolResult<unknown>, json: boolean): void;
+/**
+ * init 결과를 콘솔에 포맷팅하여 출력한다
+ */
+export declare function formatInit(result: ToolResult<unknown>, json: boolean): void;
+/**
+ * validate 결과를 콘솔에 포맷팅하여 출력한다
+ *
+ * exit code 규칙: 에러 있으면 1, 경고만 있으면 0
+ */
+export declare function formatValidate(result: ToolResult<unknown>, json: boolean): void;
+/**
+ * skill install 결과를 콘솔에 포맷팅하여 출력한다
+ */
+export declare function formatSkillInstall(result: ToolResult<unknown>, json: boolean): void;
+//# sourceMappingURL=formatters-unit.d.ts.map

package/dist/adapters/cli/formatters-unit.js

@@ -0,0 +1,287 @@
+/**
+ * 유닛 작업 관련 포맷터 — Layer 3 (Adapter)
+ *
+ * set-unit, context, validate 커맨드의 실행 결과를 포맷팅한다.
+ *
+ * @module
+ */
+import { RESET, GREEN, YELLOW, CYAN, DIM, BOLD, RED } from './output.js';
+/**
+ * set-unit 결과를 콘솔에 포맷팅하여 출력한다
+ */
+export function formatSetUnit(result, json) {
+    if (!result.success)
+        return;
+    if (json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    const data = result.data;
+    if (!isSetUnitResult(data))
+        return;
+    console.log(`
+${GREEN}✅ 작업 유닛 설정 완료: ${data.unitId}${RESET}
+`);
+    console.log(`${BOLD}📝 제목${RESET}: ${data.title}`);
+    console.log(`${BOLD}📂 유형${RESET}: ${data.unitType}`);
+    console.log(`${BOLD}📄 계획서${RESET}: ${data.planPath}`);
+    console.log(`${BOLD}📝 커맨드 파일${RESET}: ${data.commandsUpdated ? GREEN + '업데이트됨' : RED + '업데이트 실패(섹션 누락)'}${RESET}`);
+    console.log(`
+${BOLD}📊 수집된 컨텍스트${RESET}`);
+    console.log(`  ${DIM}-${RESET} 의존성: ${CYAN}${String(data.depsFound)}${RESET}개`);
+    console.log(`  ${DIM}-${RESET} 문서: ${CYAN}${String(data.docsFound)}${RESET}개`);
+    console.log(`  ${DIM}-${RESET} 커밋: ${CYAN}${String(data.commitsFound)}${RESET}개`);
+    if (data.warnings.length > 0) {
+        console.log(`
+${YELLOW}⚠️  경고 (${String(data.warnings.length)}개)${RESET}`);
+        for (const w of data.warnings) {
+            console.log(`  ${YELLOW}${DIM}-${RESET} ${w}`);
+        }
+    }
+    console.log(`
+${DIM}이제 에이전트에게 '${data.unitId}' 작업을 지시하세요.${RESET}
+`);
+}
+/**
+ * context 결과를 콘솔에 포맷팅하여 출력한다
+ */
+export function formatContext(result, json) {
+    if (!result.success)
+        return;
+    if (json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    const ctx = result.data;
+    if (!isCommandContext(ctx))
+        return;
+    console.log(`
+${GREEN}✅ 유닛 컨텍스트: ${ctx.unit.unitId}${RESET}
+`);
+    console.log(`${BOLD}📝 제목${RESET}: ${ctx.unit.title}`);
+    console.log(`${BOLD}📂 유닛 유형${RESET}: ${ctx.unit.unitType}`);
+    console.log(`${BOLD}📄 계획서${RESET}: ${ctx.unit.planPath}`);
+    if (ctx.unit.depends.length > 0) {
+        console.log(`
+${BOLD}🔗 의존성 (${String(ctx.unit.depends.length)}개)${RESET}`);
+        for (const dep of ctx.unit.depends) {
+            console.log(`  ${DIM}-${RESET} ${CYAN}${dep.unitId}${RESET}  ${dep.description}`);
+        }
+    }
+    if (ctx.depDocs.length > 0) {
+        const totalDocs = ctx.depDocs.reduce((sum, d) => sum + d.found.length, 0);
+        console.log(`
+${BOLD}📚 의존성 문서 (${String(totalDocs)}개)${RESET}`);
+        for (const dd of ctx.depDocs) {
+            for (const doc of dd.found) {
+                console.log(`  ${DIM}-${RESET} [${doc.role}] ${CYAN}${doc.path}${RESET}`);
+            }
+        }
+    }
+    if (ctx.depCommits.length > 0) {
+        console.log(`
+${BOLD}💾 의존성 커밋 (${String(ctx.depCommits.length)}개)${RESET}`);
+        for (const sha of ctx.depCommits) {
+            console.log(`  ${DIM}-${RESET} ${sha}`);
+        }
+    }
+    if (ctx.pairingQuestions.length > 0) {
+        console.log(`
+${BOLD}❓ 페어링 질문 (${String(ctx.pairingQuestions.length)}개)${RESET}`);
+        for (const q of ctx.pairingQuestions) {
+            const marker = q.resolved ? '✅' : '⬜';
+            const decision = q.resolved && q.selectedOption ? ` → ${q.selectedOption}` : '';
+            console.log(`  ${marker} ${q.text}${YELLOW}${decision}${RESET}`);
+        }
+    }
+    if (ctx.specialRequests.length > 0) {
+        console.log(`
+${BOLD}⚡ 특별 요청사항 (${String(ctx.specialRequests.length)}개)${RESET}`);
+        for (const req of ctx.specialRequests) {
+            console.log(`  ${DIM}-${RESET} ${req}`);
+        }
+    }
+    console.log();
+}
+/**
+ * init 결과를 콘솔에 포맷팅하여 출력한다
+ */
+export function formatInit(result, json) {
+    if (!result.success)
+        return;
+    if (json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    const data = result.data;
+    if (!isInitResult(data))
+        return;
+    const action = data.overwritten ? '덮어쓰기' : '생성';
+    const source = data.scanResult ? ' (프로젝트 스캔 기반)' : '';
+    console.log('');
+    console.log(`${GREEN}✅ vibe-commander.config.json ${action} 완료${source}${RESET}`);
+    console.log(`${BOLD}📁 경로${RESET}: ${CYAN}${data.configPath}${RESET}`);
+    if (data.scanResult) {
+        const totalPatternFiles = data.scanResult.idPatterns.reduce((sum, p) => sum + p.matchCount, 0);
+        console.log('');
+        console.log(`${BOLD}📊 스캔 요약${RESET}`);
+        console.log(`  ${DIM}-${RESET} 감지된 패턴: ${CYAN}${String(data.scanResult.idPatterns.length)}${RESET}개 (총 ${String(totalPatternFiles)}개 파일)`);
+        console.log(`  ${DIM}-${RESET} 문서 디렉토리: ${CYAN}${String(data.scanResult.docRoots.length)}${RESET}개`);
+        if (data.scanResult.commandFiles.length > 0) {
+            console.log(`  ${DIM}-${RESET} 커맨드 파일: ${CYAN}${data.scanResult.commandFiles[0]?.filePath ?? ''}${RESET}`);
+        }
+    }
+    console.log('');
+    console.log(`${DIM}다음 명령어로 유닛을 설정하세요:${RESET}`);
+    console.log(`  ${CYAN}vc set-unit <unitId>${RESET}`);
+    console.log('');
+}
+/** InitResult 런타임 타입 가드 */
+function isInitResult(data) {
+    return data !== null && typeof data === 'object' && 'configPath' in data && 'overwritten' in data;
+}
+/** CommandContext 런타임 타입 가드 */
+function isCommandContext(data) {
+    return (data !== null &&
+        typeof data === 'object' &&
+        'unit' in data &&
+        'depDocs' in data &&
+        'depCommits' in data &&
+        'pairingQuestions' in data &&
+        'specialRequests' in data);
+}
+/** SetUnitResult 런타임 타입 가드 */
+function isSetUnitResult(data) {
+    return (data !== null &&
+        typeof data === 'object' &&
+        'unitId' in data &&
+        'title' in data &&
+        'commandsUpdated' in data &&
+        'warnings' in data);
+}
+// ── validate 포맷터 ──
+const CATEGORY_LABELS = {
+    schema: '📋 스키마 유효성',
+    paths: '📂 경로 존재',
+    regex: '🔤 정규식 유효성',
+    patterns: '🔀 패턴 충돌',
+};
+const CATEGORY_ORDER = ['schema', 'paths', 'regex', 'patterns'];
+const STATUS_ICON = {
+    pass: '✅',
+    warn: '⚠️',
+    error: '❌',
+};
+const STATUS_COLOR = {
+    pass: GREEN,
+    warn: YELLOW,
+    error: RED,
+};
+/**
+ * validate 결과를 콘솔에 포맷팅하여 출력한다
+ *
+ * exit code 규칙: 에러 있으면 1, 경고만 있으면 0
+ */
+export function formatValidate(result, json) {
+    if (!result.success)
+        return;
+    const data = result.data;
+    if (!isValidateResult(data))
+        return;
+    if (!data.valid) {
+        process.exitCode = 1;
+    }
+    if (json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    console.log('');
+    if (data.valid) {
+        console.log(`${GREEN}✅ 설정 검증 통과${RESET}`);
+    }
+    else {
+        console.log(`${RED}❌ 설정 검증 실패${RESET}`);
+    }
+    console.log('');
+    for (const cat of CATEGORY_ORDER) {
+        const catItems = data.items.filter((i) => i.category === cat);
+        if (catItems.length === 0)
+            continue;
+        console.log(`${BOLD}${CATEGORY_LABELS[cat]}${RESET}`);
+        for (const item of catItems) {
+            const icon = STATUS_ICON[item.status];
+            const color = STATUS_COLOR[item.status];
+            console.log(`  ${icon} ${color}${item.message}${RESET}`);
+            if (item.details) {
+                console.log(`     ${DIM}${item.details}${RESET}`);
+            }
+        }
+        console.log('');
+    }
+    const passCount = data.items.filter((i) => i.status === 'pass').length;
+    console.log(`${DIM}결과: ${String(passCount)}개 통과, ${String(data.warnings)}개 경고, ${String(data.errors)}개 에러${RESET}`);
+    console.log('');
+}
+/** ValidateResult 런타임 타입 가드 */
+function isValidateResult(data) {
+    return (data !== null &&
+        typeof data === 'object' &&
+        'valid' in data &&
+        'errors' in data &&
+        'warnings' in data &&
+        'items' in data);
+}
+// ── skill install 포맷터 ──
+/**
+ * skill install 결과를 콘솔에 포맷팅하여 출력한다
+ */
+export function formatSkillInstall(result, json) {
+    if (!result.success)
+        return;
+    if (json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    const data = result.data;
+    if (!isSkillInstallResult(data))
+        return;
+    const totalDone = data.installed.length + data.overwritten.length;
+    console.log('');
+    if (totalDone > 0) {
+        console.log(`${GREEN}✅ SKILL 파일 설치 완료${RESET}`);
+    }
+    else {
+        console.log(`${YELLOW}⚠️  설치된 파일 없음${RESET}`);
+    }
+    if (data.installed.length > 0) {
+        console.log('');
+        console.log(`${BOLD}📦 설치됨 (${String(data.installed.length)}개)${RESET}`);
+        for (const p of data.installed) {
+            console.log(`  ${GREEN}+${RESET} ${CYAN}${p}${RESET}`);
+        }
+    }
+    if (data.overwritten.length > 0) {
+        console.log('');
+        console.log(`${BOLD}🔄 덮어씀 (${String(data.overwritten.length)}개)${RESET}`);
+        for (const p of data.overwritten) {
+            console.log(`  ${YELLOW}~${RESET} ${CYAN}${p}${RESET}`);
+        }
+    }
+    if (data.skipped.length > 0) {
+        console.log('');
+        console.log(`${BOLD}⏭️  건너뜀 (${String(data.skipped.length)}개)${RESET}`);
+        for (const s of data.skipped) {
+            console.log(`  ${DIM}-${RESET} ${s}`);
+        }
+    }
+    console.log('');
+}
+/** SkillInstallResult 런타임 타입 가드 */
+function isSkillInstallResult(data) {
+    return (data !== null &&
+        typeof data === 'object' &&
+        'installed' in data &&
+        'skipped' in data &&
+        'overwritten' in data);
+}
+//# sourceMappingURL=formatters-unit.js.map

package/dist/adapters/cli/formatters.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=formatters.d.ts.map