vibe-commander 0.1.0 → 0.1.1

package/AGENTS.md

@@ -0,0 +1,94 @@
+# AGENTS.md — vibe-commander for AI Agents
+
+> This file is automatically included in the npm package.
+> AI agents should read this file at the start of a conversation to understand how to use the `vc` CLI.
+
+## Quick Reference
+
+```
+vc init                          # Initialize project (create config)
+vc init --from-existing          # Auto-detect from existing files
+vc set-unit <unitId>             # Set current working unit
+vc set-unit <unitId> --dry-run   # Preview without modifying files
+vc update-commit [sha|N]         # Update commit SHA (no arg=HEAD, number=recent N)
+vc list-units [--phase Mvp]      # List incomplete units
+vc context <unitId> --json       # Read-only context query
+vc validate                      # Validate config
+vc skill install                 # Install SKILL files for agents
+vc schema [config|commands|types] # Introspect CLI schema
+```
+
+## Invariant Rules for Agents
+
+1. **Always `--dry-run` first**: Before any mutating command (`set-unit`), run with `--dry-run` to preview changes. Only proceed if the preview looks correct.
+2. **Always use `--json`**: Parse structured output instead of human-readable text. All commands support `--json` flag.
+3. **Validate inputs**: Unit IDs follow project-specific patterns (e.g., `U-001[Mvp]`, `RU-010[Mmp]`). Do not fabricate IDs — use `vc list-units --json` to discover valid IDs.
+4. **Check exit codes**: `0` = success, `1` = error, `2` = usage error. Non-zero exit always has a JSON error on stderr when `--json` is used.
+5. **Use `--stdin` for pipe mode**: Pass JSON arguments via stdin for automation: `echo '{"unitId":"U-001[Mvp]"}' | vc set-unit --stdin --json`
+
+## Safe Workflow Example
+
+```bash
+# 1. Discover available units
+vc list-units --json
+
+# 2. Preview what set-unit will do (no file changes)
+vc set-unit U-013[Mvp] --dry-run --json
+
+# 3. Apply changes only after confirming preview
+vc set-unit U-013[Mvp] --json
+
+# 4. Update commit SHA after making changes
+vc update-commit --json
+```
+
+## Config File
+
+- Location: `vibe-commander.config.json` in project root
+- Validate with: `vc validate --json`
+- The config defines unit ID patterns, document paths, and command sections
+
+## Error Handling
+
+All errors follow the `ToolResult` structure:
+
+```json
+{
+  "success": false,
+  "error": {
+    "code": "UNIT_TYPE_NOT_FOUND",
+    "message": "유닛 ID에 매칭되는 유형을 찾을 수 없습니다: U-116",
+    "details": "등록된 유형: implement, refactor, checkpoint",
+    "suggestions": ["U-116[Mmp]", "U-115[Mmp]"]
+  }
+}
+```
+
+When an invalid unit ID is provided, the `suggestions` field contains similar valid IDs based on fuzzy matching.
+
+## Input Safety
+
+The CLI rejects dangerous input patterns:
+- Path traversal: `../`, `..\\`
+- Control characters: ASCII < 0x20
+- URL encoding: `%2e`, `%2F`, etc.
+- Query parameters: `?`, `#`
+
+## Schema Discovery
+
+The `vc schema` command provides machine-readable information about the CLI and project configuration. Use this to dynamically discover capabilities:
+
+- `vc schema config --json`: Returns the JSON Schema for `vibe-commander.config.json`.
+- `vc schema commands --json`: Returns all available commands, their descriptions, arguments, and flags.
+- `vc schema types --json`: Returns the list of `unitTypes` and their ID regex patterns for the current project.
+- Use the `--output <path>` flag to save the schema to a file for repeated use.
+
+## SKILL Files
+
+After installing with `vc skill install`, SKILL files provide detailed CLI usage guides in:
+- `.cursor/skills/vibe-commander/SKILL.md` (Cursor)
+- `.claude/skills/vibe-commander/SKILL.md` (Claude Code)
+
+## Architecture Note
+
+vibe-commander uses **SKILL files + CLI**, not MCP servers. There is no MCP endpoint to connect to. Interact exclusively through the `vc` CLI binary.

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

@@ -11,7 +11,9 @@
  * @module
  */
 import { fail } from '../../../types/index.js';
+import { validateUnitId } from '../../../core/validators/input-validator.js';
 import { resolveCommandContext } from './context-resolver.js';
+import { enrichWithSuggestions } from './io-helpers.js';
 /**
  * context 커맨드를 실행한다
  *
@@ -27,10 +29,16 @@ export function handleContext(args, projectRoot) {
         return fail('INTERNAL_ERROR', 'handleContext에 잘못된 커맨드가 전달되었습니다');
     }
     const { unitId } = args;
+    // 0. 입력 안전성 검증 (제어 문자, 경로 순회, URL 인코딩 등)
+    const safetyCheck = validateUnitId(unitId);
+    if (!safetyCheck.valid) {
+        return fail('INVALID_INPUT', safetyCheck.error ?? '입력 검증 실패');
+    }
     // 1. 전체 컨텍스트 해석 (I/O + 파싱 + 의존성 수집)
     const resolveResult = resolveCommandContext(unitId, projectRoot);
-    if (!resolveResult.success)
-        return resolveResult;
+    if (!resolveResult.success) {
+        return enrichWithSuggestions(resolveResult, unitId, projectRoot);
+    }
     return {
         success: true,
         data: resolveResult.data.context,

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

@@ -42,4 +42,23 @@ export interface BuildSpecialRequestsResult {
  * 존재하지 않는 키는 warnings에 추가하고 나머지는 정상 처리 (Graceful Degradation)
  */
 export declare function buildSpecialRequests(config: ProjectConfig, unitTypeKey: string, requestKeys?: string[]): BuildSpecialRequestsResult;
+/**
+ * 프로젝트의 계획서 디렉토리에서 알려진 유닛 ID 목록을 스캔한다
+ *
+ * docRoots의 plan 디렉토리에서 .md 파일명을 수집하여 유닛 ID로 반환.
+ * Graceful Degradation: 설정 로드 실패, 디렉토리 미존재 시 빈 배열 반환.
+ */
+export declare function scanKnownUnitIds(projectRoot: string): string[];
+/**
+ * 유닛 ID 매칭/탐색 실패 시 fuzzy match 제안을 첨부한다
+ *
+ * UNIT_TYPE_NOT_FOUND 또는 PLAN_NOT_FOUND 에러에 대해
+ * 프로젝트의 알려진 유닛 ID를 스캔하여 유사 ID를 제안.
+ *
+ * @param result - 원본 실패 결과
+ * @param unitId - 잘못된 유닛 ID
+ * @param projectRoot - 프로젝트 루트 경로
+ * @returns 제안이 추가된 실패 결과
+ */
+export declare function enrichWithSuggestions(result: ToolResult<never>, unitId: string, projectRoot: string): ToolResult<never>;
 //# sourceMappingURL=io-helpers.d.ts.map

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

@@ -10,6 +10,8 @@ import { readFileSync, existsSync, readdirSync } from 'node:fs';
 import { execSync } from 'node:child_process';
 import { join } from 'node:path';
 import { ok, fail } from '../../../types/index.js';
+import { validateUnitId } from '../../../core/validators/input-validator.js';
+import { loadConfig } from '../../../config/loader.js';
 import { findDepCommits } from '../../../core/resolvers/dep-commit-resolver.js';
 import { filterCommitsByChangedFiles } from '../../../core/resolvers/commit-filter.js';
 import { getChangedFiles } from './git-helpers.js';
@@ -134,6 +136,69 @@ export function buildSpecialRequests(config, unitTypeKey, requestKeys) {
     }
     return { requests, warnings };
 }
+/**
+ * 프로젝트의 계획서 디렉토리에서 알려진 유닛 ID 목록을 스캔한다
+ *
+ * docRoots의 plan 디렉토리에서 .md 파일명을 수집하여 유닛 ID로 반환.
+ * Graceful Degradation: 설정 로드 실패, 디렉토리 미존재 시 빈 배열 반환.
+ */
+export function scanKnownUnitIds(projectRoot) {
+    try {
+        const configResult = loadConfig(projectRoot);
+        if (!configResult.success)
+            return [];
+        const config = configResult.data;
+        const ids = [];
+        for (const unitType of config.unitTypes) {
+            const planDirKey = unitType.planDir;
+            const planDir = config.paths.docRoots[planDirKey];
+            if (!planDir)
+                continue;
+            const dirPath = join(projectRoot, planDir);
+            if (!existsSync(dirPath))
+                continue;
+            const files = readdirSync(dirPath);
+            for (const file of files) {
+                if (file.endsWith('.md')) {
+                    ids.push(file.slice(0, -3));
+                }
+            }
+        }
+        return [...new Set(ids)];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * 유닛 ID 매칭/탐색 실패 시 fuzzy match 제안을 첨부한다
+ *
+ * UNIT_TYPE_NOT_FOUND 또는 PLAN_NOT_FOUND 에러에 대해
+ * 프로젝트의 알려진 유닛 ID를 스캔하여 유사 ID를 제안.
+ *
+ * @param result - 원본 실패 결과
+ * @param unitId - 잘못된 유닛 ID
+ * @param projectRoot - 프로젝트 루트 경로
+ * @returns 제안이 추가된 실패 결과
+ */
+export function enrichWithSuggestions(result, unitId, projectRoot) {
+    if (result.success)
+        return result;
+    const enrichable = ['UNIT_TYPE_NOT_FOUND', 'PLAN_NOT_FOUND'];
+    if (!enrichable.includes(result.error.code))
+        return result;
+    const knownIds = scanKnownUnitIds(projectRoot);
+    if (knownIds.length === 0)
+        return result;
+    const fuzzyResult = validateUnitId(unitId, knownIds);
+    if (fuzzyResult.suggestions && fuzzyResult.suggestions.length > 0) {
+        return {
+            success: false,
+            error: { ...result.error, suggestions: fuzzyResult.suggestions },
+        };
+    }
+    return result;
+}
 /**
  * 간단한 glob 패턴(* 와일드카드)을 정규식으로 변환
  */

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

@@ -0,0 +1,28 @@
+/**
+ * schema 커맨드 핸들러 — Layer 3 (Adapter)
+ *
+ * CLI 스키마를 런타임에 조회할 수 있게 하여, 에이전트가
+ * SKILL 파일이나 문서 없이도 CLI를 자율적으로 활용할 수 있도록 한다.
+ *
+ * 하위 커맨드:
+ * - config: 설정 파일(vibe-commander.config.json) JSON Schema 출력
+ * - commands: 사용 가능한 커맨드 목록 + 파라미터 + 플래그
+ * - types: 현재 프로젝트의 unitTypes 목록 + ID 패턴
+ *
+ * @module
+ */
+import type { ToolResult } from '../../../types/index.js';
+import type { ParsedArgs } from '../router.js';
+import { type SchemaResult } from '../../../core/renderers/schema-renderer.js';
+/**
+ * schema 커맨드를 실행한다
+ *
+ * 하위 커맨드에 따라 설정 스키마, 커맨드 목록, 유닛 타입 정보를 반환.
+ * --output 옵션이 지정되면 결과를 파일로 저장한다.
+ *
+ * @param args - 파싱된 CLI 인자 (command === 'schema' 보장)
+ * @param projectRoot - 프로젝트 루트 절대 경로
+ * @returns SchemaResult 또는 에러
+ */
+export declare function handleSchema(args: ParsedArgs, projectRoot: string): ToolResult<SchemaResult>;
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1,106 @@
+/**
+ * schema 커맨드 핸들러 — Layer 3 (Adapter)
+ *
+ * CLI 스키마를 런타임에 조회할 수 있게 하여, 에이전트가
+ * SKILL 파일이나 문서 없이도 CLI를 자율적으로 활용할 수 있도록 한다.
+ *
+ * 하위 커맨드:
+ * - config: 설정 파일(vibe-commander.config.json) JSON Schema 출력
+ * - commands: 사용 가능한 커맨드 목록 + 파라미터 + 플래그
+ * - types: 현재 프로젝트의 unitTypes 목록 + ID 패턴
+ *
+ * @module
+ */
+import { writeFileSync, mkdirSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { ok, fail } from '../../../types/index.js';
+import { loadConfig } from '../../../config/loader.js';
+import { getConfigJsonSchema } from '../../../config/schema.js';
+import { renderCommandsSchema, renderTypesSchema, SCHEMA_SUBCOMMANDS, } from '../../../core/renderers/schema-renderer.js';
+import { validatePath } from '../../../core/validators/input-validator.js';
+/**
+ * schema 커맨드를 실행한다
+ *
+ * 하위 커맨드에 따라 설정 스키마, 커맨드 목록, 유닛 타입 정보를 반환.
+ * --output 옵션이 지정되면 결과를 파일로 저장한다.
+ *
+ * @param args - 파싱된 CLI 인자 (command === 'schema' 보장)
+ * @param projectRoot - 프로젝트 루트 절대 경로
+ * @returns SchemaResult 또는 에러
+ */
+export function handleSchema(args, projectRoot) {
+    if (args.command !== 'schema') {
+        return fail('INTERNAL_ERROR', 'handleSchema에 잘못된 커맨드가 전달되었습니다');
+    }
+    const { subcommand, output } = args;
+    if (!subcommand) {
+        return ok({
+            subcommand: 'help',
+            availableSubcommands: SCHEMA_SUBCOMMANDS,
+            usage: 'vc schema <config|commands|types> [--output <path>] [--json]',
+        });
+    }
+    let result;
+    switch (subcommand) {
+        case 'config': {
+            const schema = getConfigJsonSchema();
+            result = { subcommand: 'config', schema };
+            break;
+        }
+        case 'commands': {
+            const commandsData = renderCommandsSchema();
+            result = {
+                subcommand: 'commands',
+                globalFlags: commandsData.globalFlags,
+                commands: commandsData.commands,
+            };
+            break;
+        }
+        case 'types': {
+            const configResult = loadConfig(projectRoot);
+            if (!configResult.success) {
+                return fail('CONFIG_NOT_FOUND', '설정 파일을 로드할 수 없습니다', `프로젝트 루트에 vibe-commander.config.json이 필요합니다. 'vc init'으로 생성하세요.\n${configResult.error.message}`);
+            }
+            const types = renderTypesSchema(configResult.data.unitTypes);
+            result = { subcommand: 'types', types };
+            break;
+        }
+        default:
+            return fail('UNKNOWN_SUBCOMMAND', `알 수 없는 schema 서브커맨드: ${String(subcommand)}`, '사용 가능한 서브커맨드: config, commands, types');
+    }
+    if (output) {
+        const pathCheck = validatePath(output);
+        if (!pathCheck.valid) {
+            return fail('INVALID_OUTPUT_PATH', pathCheck.error ?? '출력 경로가 유효하지 않습니다');
+        }
+        const outputPath = resolve(projectRoot, output);
+        const contentToWrite = extractContent(result);
+        try {
+            mkdirSync(dirname(outputPath), { recursive: true });
+            writeFileSync(outputPath, JSON.stringify(contentToWrite, null, 2) + '\n', 'utf-8');
+            result = { ...result, outputPath };
+        }
+        catch (err) {
+            return fail('OUTPUT_WRITE_ERROR', `결과를 파일에 저장할 수 없습니다: ${output}`, err instanceof Error ? err.message : String(err));
+        }
+    }
+    return ok(result);
+}
+/**
+ * SchemaResult에서 파일 저장용 콘텐츠만 추출한다
+ *
+ * config → JSON Schema 객체, commands → 커맨드 메타데이터, types → 타입 배열
+ */
+function extractContent(result) {
+    switch (result.subcommand) {
+        case 'config':
+            return result.schema;
+        case 'commands':
+            return { globalFlags: result.globalFlags, commands: result.commands };
+        case 'types':
+            return result.types;
+        default:
+            return result;
+    }
+}
+//# sourceMappingURL=schema.js.map

package/dist/adapters/cli/commands/set-unit.d.ts

@@ -25,6 +25,8 @@ export interface SetUnitResult {
     pairingAnswers: PairingAnswer[];
     commandsUpdated: boolean;
     warnings: string[];
+    dryRun?: boolean;
+    preview?: string;
 }
 /**
  * set-unit 커맨드를 실행한다

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

@@ -12,10 +12,11 @@
  */
 import { writeFileSync } from 'node:fs';
 import { ok, fail } from '../../../types/index.js';
+import { validateUnitId } from '../../../core/validators/input-validator.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 { readCommandsFile, enrichWithSuggestions } from './io-helpers.js';
 import { writeActiveUnitType } from './state-helpers.js';
 import { isInteractive, promptAllQuestions } from './prompt-helpers.js';
 /**
@@ -36,42 +37,50 @@ export async function handleSetUnit(args, projectRoot) {
     if (args.command !== 'set-unit') {
         return fail('INTERNAL_ERROR', 'handleSetUnit에 잘못된 커맨드가 전달되었습니다');
     }
-    const { unitId, noPrompt } = args;
+    const { unitId, noPrompt, dryRun } = args;
     const requestKeys = 'requestKeys' in args ? args.requestKeys : [];
+    // 0. 입력 안전성 검증 (제어 문자, 경로 순회, URL 인코딩 등)
+    const safetyCheck = validateUnitId(unitId);
+    if (!safetyCheck.valid) {
+        return fail('INVALID_INPUT', safetyCheck.error ?? '입력 검증 실패');
+    }
     // 1. 전체 컨텍스트 해석 (I/O + 파싱 + 의존성 수집)
     const resolveResult = resolveCommandContext(unitId, projectRoot, requestKeys);
-    if (!resolveResult.success)
-        return resolveResult;
+    if (!resolveResult.success) {
+        return enrichWithSuggestions(resolveResult, unitId, projectRoot);
+    }
     const { context, config, unitTypeKey, unitTypeConfig, planRelPath, warnings } = resolveResult.data;
-    // 2. 미결정 페어링 질문 프롬프트 (인터랙티브 모드)
+    // 2. 미결정 페어링 질문 프롬프트 (인터랙티브 모드, dry-run 시 건너뜀)
     let pairingAnswers = [];
     const unresolvedCount = context.pairingQuestions.filter((q) => !q.resolved).length;
-    if (unresolvedCount > 0 && isInteractive(noPrompt)) {
+    if (unresolvedCount > 0 && !dryRun && isInteractive(noPrompt)) {
         pairingAnswers = await promptAllQuestions(context.pairingQuestions);
         context.pairingAnswers = pairingAnswers;
     }
     // 3. 섹션 렌더링 (Core 순수 함수)
     const sectionBody = renderSection(context, unitTypeConfig);
-    // 4. 커맨드 파일 업데이트 (Adapter I/O)
+    // 4. 커맨드 파일 업데이트 (Adapter I/O) — dry-run 시 건너뜀
     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;
+    if (!dryRun) {
+        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 if (updateResult.success && !updateResult.data.updated) {
-            warnings.push(`커맨드 파일에서 '${unitTypeConfig.commandSection}' 섹션을 찾을 수 없습니다`);
+        else {
+            warnings.push(`커맨드 파일을 읽을 수 없습니다: ${config.paths.commands}`);
         }
+        // 5. 활성 유닛 타입 상태 기록 (update-commit 자동 감지용)
+        writeActiveUnitType(projectRoot, unitTypeKey);
     }
-    else {
-        warnings.push(`커맨드 파일을 읽을 수 없습니다: ${config.paths.commands}`);
-    }
-    // 5. 활성 유닛 타입 상태 기록 (update-commit 자동 감지용)
-    writeActiveUnitType(projectRoot, unitTypeKey);
     // 6. 결과 반환
     return ok({
         unitId,
@@ -85,6 +94,7 @@ export async function handleSetUnit(args, projectRoot) {
         pairingAnswers,
         commandsUpdated,
         warnings,
+        ...(dryRun && { dryRun: true, preview: sectionBody }),
     });
 }
 //# sourceMappingURL=set-unit.js.map

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

@@ -11,6 +11,7 @@
  */
 import { writeFileSync } from 'node:fs';
 import { ok, fail } from '../../../types/index.js';
+import { validateSha } from '../../../core/validators/input-validator.js';
 import { loadConfig } from '../../../config/loader.js';
 import { updateField } from '../../../core/renderers/section-updater.js';
 import { normalizeLineEndings, getHeadingPrefix, isSameLevelHeading, } from '../../../core/parsers/index.js';
@@ -66,6 +67,10 @@ export function handleUpdateCommit(args, projectRoot) {
             if (!sha) {
                 return fail('MISSING_ARGUMENT', "'update-commit' manual 모드에 SHA가 필요합니다");
             }
+            const shaCheck = validateSha(sha);
+            if (!shaCheck.valid) {
+                return fail('INVALID_INPUT', shaCheck.error ?? '입력 검증 실패');
+            }
             break;
         }
     }

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

@@ -41,4 +41,8 @@ export declare function formatValidate(result: ToolResult<unknown>, json: boolea
  * skill install 결과를 콘솔에 포맷팅하여 출력한다
  */
 export declare function formatSkillInstall(result: ToolResult<unknown>, json: boolean): void;
+/**
+ * schema 결과를 콘솔에 포맷팅하여 출력한다
+ */
+export declare function formatSchema(result: ToolResult<unknown>, json: boolean): void;
 //# sourceMappingURL=formatters-unit.d.ts.map

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

@@ -284,4 +284,97 @@ function isSkillInstallResult(data) {
         'skipped' in data &&
         'overwritten' in data);
 }
+// ── schema 포맷터 ──
+/**
+ * schema 결과를 콘솔에 포맷팅하여 출력한다
+ */
+export function formatSchema(result, json) {
+    if (!result.success)
+        return;
+    if (json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    const data = result.data;
+    if (!isSchemaResult(data))
+        return;
+    if ('outputPath' in data && data.outputPath) {
+        console.log(`\n${GREEN}✅ 스키마가 파일에 저장되었습니다: ${CYAN}${data.outputPath}${RESET}\n`);
+        return;
+    }
+    switch (data.subcommand) {
+        case 'help':
+            formatSchemaHelp(data);
+            break;
+        case 'config':
+            console.log(JSON.stringify(data.schema, null, 2));
+            break;
+        case 'commands':
+            formatSchemaCommands(data);
+            break;
+        case 'types':
+            formatSchemaTypes(data);
+            break;
+    }
+}
+function formatSchemaHelp(data) {
+    console.log('');
+    console.log(`${BOLD}vc schema${RESET} — 런타임 스키마 조회`);
+    console.log('');
+    console.log(`${YELLOW}사용 가능한 서브커맨드:${RESET}`);
+    for (const sub of data.availableSubcommands) {
+        console.log(`  ${CYAN}${sub.name}${RESET}       ${sub.description}`);
+    }
+    console.log('');
+    console.log(`${YELLOW}사용법:${RESET} ${data.usage}`);
+    console.log('');
+}
+function formatSchemaCommands(data) {
+    console.log('');
+    console.log(`${BOLD}📋 vibe-commander CLI 스키마${RESET}`);
+    console.log('');
+    console.log(`${YELLOW}글로벌 옵션:${RESET}`);
+    for (const flag of data.globalFlags) {
+        const alias = flag.alias ? `, ${CYAN}${flag.alias}${RESET}` : '';
+        console.log(`  ${CYAN}${flag.name}${RESET}${alias}  ${DIM}${flag.description}${RESET}`);
+    }
+    console.log('');
+    console.log(`${YELLOW}명령어 (${String(data.commands.length)}개):${RESET}`);
+    for (const cmd of data.commands) {
+        const argStr = cmd.args.map((a) => (a.required ? `<${a.name}>` : `[${a.name}]`)).join(' ');
+        const nameWithArgs = argStr ? `${cmd.name} ${argStr}` : cmd.name;
+        console.log(`  ${CYAN}${nameWithArgs}${RESET}`);
+        console.log(`    ${cmd.description}`);
+        if (cmd.args.length > 0) {
+            for (const arg of cmd.args) {
+                const req = arg.required ? `${RED}필수${RESET}` : `${DIM}선택${RESET}`;
+                console.log(`    ${DIM}인자:${RESET} ${arg.name} (${req}) — ${arg.description}`);
+            }
+        }
+        if (cmd.flags.length > 0) {
+            const flagNames = cmd.flags.map((f) => f.name).join(', ');
+            console.log(`    ${DIM}플래그:${RESET} ${flagNames}`);
+        }
+        console.log('');
+    }
+}
+function formatSchemaTypes(data) {
+    console.log('');
+    console.log(`${BOLD}📋 프로젝트 유닛 타입 (${String(data.types.length)}개)${RESET}`);
+    console.log('');
+    for (const t of data.types) {
+        const displayName = t.displayName ? ` (${t.displayName})` : '';
+        console.log(`  ${CYAN}${BOLD}${t.key}${RESET}${displayName}`);
+        console.log(`    ${DIM}ID 패턴:${RESET}      ${t.idPattern}`);
+        console.log(`    ${DIM}계획서:${RESET}        ${t.planDir}`);
+        console.log(`    ${DIM}커맨드 섹션:${RESET}   ${t.commandSection}`);
+        console.log(`    ${DIM}의존성 수집:${RESET}   ${t.collectDeps ? GREEN + '✅' : RED + '❌'}${RESET}`);
+        console.log(`    ${DIM}헤더 템플릿:${RESET}   ${t.headerTemplate}`);
+        console.log('');
+    }
+}
+/** SchemaResult 런타임 타입 가드 */
+function isSchemaResult(data) {
+    return data !== null && typeof data === 'object' && 'subcommand' in data;
+}
 //# sourceMappingURL=formatters-unit.js.map

package/dist/adapters/cli/index.js

@@ -22,7 +22,8 @@ import { handleContext } from './commands/context.js';
 import { handleInit } from './commands/init.js';
 import { handleValidate } from './commands/validate.js';
 import { handleSkillInstall } from './commands/skill-install.js';
-import { formatContext, formatSetUnit, formatInit, formatValidate, formatSkillInstall, } from './formatters-unit.js';
+import { handleSchema } from './commands/schema.js';
+import { formatContext, formatSetUnit, formatInit, formatValidate, formatSkillInstall, formatSchema, } from './formatters-unit.js';
 import { formatListUnits, formatUpdateCommit } from './formatters-list.js';
 const handlers = {
     init: handleInit,
@@ -32,6 +33,7 @@ const handlers = {
     context: handleContext,
     validate: handleValidate,
     'skill-install': handleSkillInstall,
+    schema: handleSchema,
 };
 const formatters = {
     init: formatInit,
@@ -41,6 +43,7 @@ const formatters = {
     context: formatContext,
     validate: formatValidate,
     'skill-install': formatSkillInstall,
+    schema: formatSchema,
 };
 /**
  * CLI 메인 실행 함수