vibe-commander 0.1.0 → 0.2.0

package/dist/adapters/cli/output.js

@@ -64,6 +64,12 @@ export function printError(result, json) {
         if (result.error.details) {
             console.error(`${DIM}   상세: ${result.error.details}${RESET}`);
         }
+        if (result.error.suggestions && result.error.suggestions.length > 0) {
+            console.error(`${YELLOW}   혹시 이것을 찾으셨나요?${RESET}`);
+            for (const s of result.error.suggestions) {
+                console.error(`${CYAN}     → ${s}${RESET}`);
+            }
+        }
     }
 }
 /**
@@ -85,6 +91,7 @@ ${YELLOW}명령어:${RESET}
   ${CYAN}context${RESET} <unitId>               유닛 컨텍스트 조회 (읽기 전용)
   ${CYAN}validate${RESET}                       설정 파일 검증
   ${CYAN}skill install${RESET}                  SKILL 파일 설치 (Cursor/Claude/Gemini)
+  ${CYAN}schema${RESET} <config|commands|types>  런타임 스키마 조회
 
 ${YELLOW}글로벌 옵션:${RESET}
   ${CYAN}--help${RESET}, ${CYAN}-h${RESET}                    도움말 출력
@@ -95,6 +102,7 @@ ${YELLOW}글로벌 옵션:${RESET}
 ${YELLOW}set-unit 옵션:${RESET}
   ${CYAN}--request${RESET} <key1,key2>             커스텀 특별 요청사항 키 선택 (콤마 구분)
   ${CYAN}--no-prompt${RESET}                       페어링 질문 인터랙티브 프롬프트 비활성화
+  ${CYAN}--dry-run${RESET}                         커맨드 파일 수정 없이 미리보기만 출력
 
 ${YELLOW}update-commit 옵션:${RESET}
   ${CYAN}--mode${RESET} replace|append            값 교체 또는 추가 (기본: replace)
@@ -109,11 +117,17 @@ ${YELLOW}skill install 옵션:${RESET}
   ${CYAN}--gemini${RESET}                           Gemini만 설치 (.gemini/skills/)
   ${CYAN}--force${RESET}                            기존 파일 덮어쓰기
 
+${YELLOW}schema 옵션:${RESET}
+  ${CYAN}--output${RESET} <path>                     결과를 파일로 저장
+  ${CYAN}--json${RESET}                             JSON 형식으로 출력
+
 ${YELLOW}예시:${RESET}
   ${DIM}$ vc validate${RESET}                          ${DIM}# 설정 파일 종합 검증${RESET}
   ${DIM}$ vc init${RESET}
   ${DIM}$ vc init --from-existing${RESET}              ${DIM}# 기존 파일 스캔으로 자동 설정${RESET}
   ${DIM}$ vc set-unit U-013[Mvp]${RESET}
+  ${DIM}$ vc set-unit U-013[Mvp] --dry-run${RESET}            ${DIM}# 커맨드 파일 미수정, 미리보기만${RESET}
+  ${DIM}$ vc set-unit U-013[Mvp] --dry-run --json${RESET}     ${DIM}# 미리보기를 JSON으로 출력${RESET}
   ${DIM}$ vc set-unit U-013[Mvp] --request mcp-nanobanana,mcp-codrag${RESET}
   ${DIM}$ vc update-commit${RESET}                    ${DIM}# HEAD SHA 자동 감지${RESET}
   ${DIM}$ vc update-commit 3${RESET}                   ${DIM}# 최근 3개 커밋 SHA${RESET}
@@ -123,6 +137,10 @@ ${YELLOW}예시:${RESET}
   ${DIM}$ vc skill install${RESET}                    ${DIM}# Cursor + Claude + Gemini 모두 설치${RESET}
   ${DIM}$ vc skill install --cursor${RESET}            ${DIM}# Cursor만 설치${RESET}
   ${DIM}$ vc skill install --force${RESET}             ${DIM}# 기존 파일 덮어쓰기${RESET}
+  ${DIM}$ vc schema config${RESET}                    ${DIM}# 설정 파일 JSON Schema 출력${RESET}
+  ${DIM}$ vc schema commands --json${RESET}            ${DIM}# 커맨드 스키마 JSON 출력${RESET}
+  ${DIM}$ vc schema types${RESET}                      ${DIM}# 프로젝트 유닛 타입 출력${RESET}
+  ${DIM}$ vc schema config --output schema.json${RESET} ${DIM}# JSON Schema를 파일로 저장${RESET}
 
 ${YELLOW}파이프 모드 (에이전트/오케스트레이터 연동):${RESET}
   ${DIM}$ echo '{"unitId":"U-013[Mvp]"}' | vc set-unit --stdin --json${RESET}

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

@@ -14,6 +14,7 @@ export interface SetUnitArgs {
     unitId: string;
     requestKeys: string[];
     noPrompt: boolean;
+    dryRun: boolean;
     json: boolean;
 }
 export interface UpdateCommitArgs {
@@ -52,13 +53,19 @@ export interface SkillInstallArgs {
     force: boolean;
     json: boolean;
 }
+export interface SchemaArgs {
+    command: 'schema';
+    subcommand?: 'config' | 'commands' | 'types';
+    output?: string;
+    json: boolean;
+}
 export interface HelpArgs {
     command: 'help';
 }
 export interface VersionArgs {
     command: 'version';
 }
-export type ParsedArgs = SetUnitArgs | UpdateCommitArgs | ListUnitsArgs | ContextArgs | ValidateArgs | InitArgs | SkillInstallArgs | HelpArgs | VersionArgs;
+export type ParsedArgs = SetUnitArgs | UpdateCommitArgs | ListUnitsArgs | ContextArgs | ValidateArgs | InitArgs | SkillInstallArgs | SchemaArgs | HelpArgs | VersionArgs;
 export type CommandHandler = (args: ParsedArgs, projectRoot: string) => Promise<ToolResult<unknown>> | ToolResult<unknown>;
 /** 커맨드별 커스텀 출력 포맷터 (list-units, context 등에서 사용) */
 export type CommandFormatter = (result: ToolResult<unknown>, json: boolean) => void;

package/dist/adapters/cli/router.js

@@ -50,6 +50,8 @@ export function parseArgs(argv) {
         }
         case 'skill':
             return parseSkillCommand(rest, json);
+        case 'schema':
+            return parseSchemaCommand(rest, json);
         case 'help':
         case '--help':
         case '-h':
@@ -59,7 +61,7 @@ export function parseArgs(argv) {
         case '-v':
             return { success: true, data: { command: 'version' } };
         default:
-            return fail('UNKNOWN_COMMAND', `알 수 없는 명령어: ${subcommand}`, `사용 가능한 명령어: init, set-unit, update-commit, list-units, context, validate, skill`);
+            return fail('UNKNOWN_COMMAND', `알 수 없는 명령어: ${subcommand}`, `사용 가능한 명령어: init, set-unit, update-commit, list-units, context, validate, skill, schema`);
     }
 }
 /**
@@ -80,7 +82,11 @@ function parseSetUnit(args, json) {
             .filter(Boolean)
         : [];
     const noPrompt = hasFlag(args, '--no-prompt');
-    return { success: true, data: { command: 'set-unit', unitId, requestKeys, noPrompt, json } };
+    const dryRun = hasFlag(args, '--dry-run');
+    return {
+        success: true,
+        data: { command: 'set-unit', unitId, requestKeys, noPrompt, dryRun, json },
+    };
 }
 /**
  * update-commit 서브커맨드의 인자를 파싱한다
@@ -170,6 +176,29 @@ function parseSkillCommand(args, json) {
         ];
     return { success: true, data: { command: 'skill-install', targets, force, json } };
 }
+/**
+ * schema 그룹 커맨드의 서브커맨드를 파싱한다
+ *
+ * 지원: schema [config|commands|types] [--output <path>] [--json]
+ * 서브커맨드 미지정 시 도움말 표시를 위해 subcommand 없이 반환
+ */
+function parseSchemaCommand(args, json) {
+    const sub = getPositionalArg(args);
+    const output = getOptionValue(args, '--output');
+    if (!sub) {
+        return {
+            success: true,
+            data: { command: 'schema', json, ...(output !== undefined && { output }) },
+        };
+    }
+    if (sub !== 'config' && sub !== 'commands' && sub !== 'types') {
+        return fail('UNKNOWN_SUBCOMMAND', `알 수 없는 schema 서브커맨드: ${sub}`, '사용 가능한 서브커맨드: config, commands, types');
+    }
+    return {
+        success: true,
+        data: { command: 'schema', subcommand: sub, json, ...(output !== undefined && { output }) },
+    };
+}
 // ── 유틸리티 함수 ──
 /**
  * args에 특정 플래그가 존재하는지 확인
@@ -214,7 +243,7 @@ function getOptionValue(args, option) {
  * 값을 갖는 옵션인지 판별
  */
 function isValueOption(arg) {
-    return ['--mode', '--section', '--phase', '--request'].includes(arg);
+    return ['--mode', '--section', '--phase', '--request', '--output'].includes(arg);
 }
 // ── stdin → ParsedArgs 변환 ──
 /**
@@ -238,7 +267,8 @@ export function parseStdinArgs(subcommand, data, json, rawArgs) {
             const requestKeys = Array.isArray(data.requestKeys)
                 ? data.requestKeys.filter((k) => typeof k === 'string')
                 : [];
-            return ok({ command: 'set-unit', unitId, requestKeys, noPrompt: true, json });
+            const dryRun = rawArgs?.includes('--dry-run') ?? false;
+            return ok({ command: 'set-unit', unitId, requestKeys, noPrompt: true, dryRun, json });
         }
         case 'update-commit': {
             const modeValue = typeof data.mode === 'string' ? data.mode : undefined;
@@ -298,8 +328,21 @@ export function parseStdinArgs(subcommand, data, json, rawArgs) {
                 json,
             });
         }
+        case 'schema': {
+            const sub = typeof data.subcommand === 'string' ? data.subcommand : undefined;
+            if (sub && sub !== 'config' && sub !== 'commands' && sub !== 'types') {
+                return fail('UNKNOWN_SUBCOMMAND', `알 수 없는 schema 서브커맨드: ${sub}`, '사용 가능한 서브커맨드: config, commands, types');
+            }
+            const output = typeof data.output === 'string' ? data.output : undefined;
+            return ok({
+                command: 'schema',
+                ...(sub !== undefined && { subcommand: sub }),
+                json,
+                ...(output !== undefined && { output }),
+            });
+        }
         default:
-            return fail('UNKNOWN_COMMAND', `알 수 없는 명령어: ${subcommand}`, '사용 가능한 명령어: init, set-unit, update-commit, list-units, context, validate, skill');
+            return fail('UNKNOWN_COMMAND', `알 수 없는 명령어: ${subcommand}`, '사용 가능한 명령어: init, set-unit, update-commit, list-units, context, validate, skill, schema');
     }
 }
 // ── 메인 라우터 ──

package/dist/config/schema.d.ts

@@ -3,7 +3,7 @@
  *
  * PRD §5 설정 파일 구조를 Zod 4 스키마로 모델링.
  * 각 서브 스키마는 독립적으로 정의하여 재사용 및 테스트 용이성 확보.
- * 페어링 질문 Q2(Option B) 결정에 따라 snapmit 스타일 기본값 제공.
+ * 범용 기본값을 제공하여 다양한 프로젝트에서 즉시 사용 가능.
  *
  * @module
  */
@@ -202,4 +202,13 @@ export type InferredCommandSectionsConfig = z.infer<typeof commandSectionsSchema
 export type InferredProjectConfig = z.infer<typeof projectConfigSchema>;
 /** 설정 파일명 */
 export declare const CONFIG_FILENAME = "vibe-commander.config.json";
+/**
+ * 프로젝트 설정 스키마를 JSON Schema (Draft 2020-12) 형식으로 반환한다
+ *
+ * Zod 4의 z.toJSONSchema() 내장 기능을 활용하여 변환.
+ * 에이전트가 설정 파일 구조를 런타임에 조회할 수 있도록 한다.
+ *
+ * @returns JSON Schema 호환 객체
+ */
+export declare function getConfigJsonSchema(): Record<string, unknown>;
 //# sourceMappingURL=schema.d.ts.map

package/dist/config/schema.js

@@ -3,7 +3,7 @@
  *
  * PRD §5 설정 파일 구조를 Zod 4 스키마로 모델링.
  * 각 서브 스키마는 독립적으로 정의하여 재사용 및 테스트 용이성 확보.
- * 페어링 질문 Q2(Option B) 결정에 따라 snapmit 스타일 기본값 제공.
+ * 범용 기본값을 제공하여 다양한 프로젝트에서 즉시 사용 가능.
  *
  * @module
  */
@@ -12,14 +12,14 @@ import { z } from 'zod';
 /** 기본 경로 설정 스키마 */
 export const pathsSchema = z.object({
     /** 커맨드 파일 경로 (프로젝트 루트 기준) */
-    commands: z.string().default('vibe/commands.md'),
+    commands: z.string().default('commands.md'),
     /** 로드맵 파일 경로. null이면 list-units 비활성화 */
-    roadmap: z.string().nullable().default('vibe/roadmap.md'),
+    roadmap: z.string().nullable().default('roadmap.md'),
     /** 역할별 문서 루트 디렉토리 (키: 역할명, 값: 상대 경로) */
     docRoots: z.record(z.string(), z.string()).default({
-        plan: 'vibe/unit-plans',
-        result: 'vibe/unit-results',
-        runbook: 'vibe/unit-runbooks',
+        plan: 'unit-plans',
+        result: 'unit-results',
+        runbook: 'unit-runbooks',
     }),
     /** 리팩토링 서브유닛 디렉토리. null이면 서브유닛 미사용 */
     refactorSubDir: z.string().nullable().default(null),
@@ -183,4 +183,15 @@ export const projectConfigSchema = z.object({
 });
 /** 설정 파일명 */
 export const CONFIG_FILENAME = 'vibe-commander.config.json';
+/**
+ * 프로젝트 설정 스키마를 JSON Schema (Draft 2020-12) 형식으로 반환한다
+ *
+ * Zod 4의 z.toJSONSchema() 내장 기능을 활용하여 변환.
+ * 에이전트가 설정 파일 구조를 런타임에 조회할 수 있도록 한다.
+ *
+ * @returns JSON Schema 호환 객체
+ */
+export function getConfigJsonSchema() {
+    return z.toJSONSchema(projectConfigSchema);
+}
 //# sourceMappingURL=schema.js.map

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

@@ -12,4 +12,6 @@ export { updateSection, updateField } from './section-updater.js';
 export type { UpdateResult, MarkerOptions } from './section-updater.js';
 export { createBeginMarker, createEndMarker, findMarkerRange, isValidSectionKey, wrapWithMarkers, stripMarkers, } from './marker-utils.js';
 export type { MarkerRange } from './marker-utils.js';
+export { COMMAND_REGISTRY, SCHEMA_SUBCOMMANDS, renderCommandsSchema, renderTypesSchema, } from './schema-renderer.js';
+export type { ArgSchema, FlagSchema, CommandSchema, TypeSchemaEntry, SchemaSubcommandInfo, SchemaResult, } from './schema-renderer.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/renderers/index.js

@@ -15,4 +15,6 @@ export { renderSection } from './section-renderer.js';
 export { updateSection, updateField } from './section-updater.js';
 // 마커 유틸리티
 export { createBeginMarker, createEndMarker, findMarkerRange, isValidSectionKey, wrapWithMarkers, stripMarkers, } from './marker-utils.js';
+// 스키마 렌더러
+export { COMMAND_REGISTRY, SCHEMA_SUBCOMMANDS, renderCommandsSchema, renderTypesSchema, } from './schema-renderer.js';
 //# sourceMappingURL=index.js.map

package/dist/core/renderers/schema-renderer.d.ts

@@ -0,0 +1,92 @@
+/**
+ * 스키마 렌더러 — Layer 1 (Core)
+ *
+ * CLI 커맨드 메타데이터와 유닛 타입 정보를 구조화된 형식으로 렌더링한다.
+ * 에이전트가 런타임에 CLI 스키마를 조회하여 문서 없이도 CLI를 활용할 수 있게 지원.
+ * 순수 함수만 포함 — I/O 없음.
+ *
+ * @module
+ */
+import type { UnitTypeConfig } from '../../types/index.js';
+/** CLI 커맨드 인자 스키마 */
+export interface ArgSchema {
+    name: string;
+    required: boolean;
+    description: string;
+}
+/** CLI 커맨드 플래그 스키마 */
+export interface FlagSchema {
+    name: string;
+    alias?: string;
+    type: 'boolean' | 'string';
+    description: string;
+}
+/** CLI 커맨드 스키마 */
+export interface CommandSchema {
+    name: string;
+    description: string;
+    args: ArgSchema[];
+    flags: FlagSchema[];
+}
+/** 유닛 타입 스키마 출력 항목 */
+export interface TypeSchemaEntry {
+    key: string;
+    displayName?: string;
+    idPattern: string;
+    planDir: string;
+    commandSection: string;
+    collectDeps: boolean;
+    headerTemplate: string;
+}
+/** schema 서브커맨드 정보 */
+export interface SchemaSubcommandInfo {
+    name: string;
+    description: string;
+}
+/** schema 커맨드 결과 (discriminated union) */
+export type SchemaResult = {
+    subcommand: 'help';
+    availableSubcommands: SchemaSubcommandInfo[];
+    usage: string;
+} | {
+    subcommand: 'config';
+    schema: Record<string, unknown>;
+    outputPath?: string;
+} | {
+    subcommand: 'commands';
+    globalFlags: FlagSchema[];
+    commands: CommandSchema[];
+    outputPath?: string;
+} | {
+    subcommand: 'types';
+    types: TypeSchemaEntry[];
+    outputPath?: string;
+};
+/**
+ * 모든 CLI 커맨드의 메타데이터 레지스트리.
+ * 새 커맨드 추가 시 이 배열도 함께 업데이트해야 한다.
+ */
+export declare const COMMAND_REGISTRY: CommandSchema[];
+/** schema 서브커맨드 도움말 정보 */
+export declare const SCHEMA_SUBCOMMANDS: SchemaSubcommandInfo[];
+/**
+ * 커맨드 메타데이터를 구조화된 형태로 렌더링한다
+ *
+ * 글로벌 플래그와 커맨드별 메타데이터를 결합하여 반환.
+ * 에이전트가 사용 가능한 모든 커맨드와 옵션을 파악할 수 있도록 한다.
+ */
+export declare function renderCommandsSchema(): {
+    globalFlags: FlagSchema[];
+    commands: CommandSchema[];
+};
+/**
+ * 유닛 타입 정보를 구조화된 형태로 렌더링한다
+ *
+ * ProjectConfig의 unitTypes 배열을 TypeSchemaEntry로 변환.
+ * 에이전트가 유효한 유닛 ID 패턴과 프로젝트 구조를 파악할 수 있도록 한다.
+ *
+ * @param unitTypes - 프로젝트 설정의 unitTypes 배열
+ * @returns 구조화된 타입 스키마 배열
+ */
+export declare function renderTypesSchema(unitTypes: UnitTypeConfig[]): TypeSchemaEntry[];
+//# sourceMappingURL=schema-renderer.d.ts.map

package/dist/core/renderers/schema-renderer.js

@@ -0,0 +1,162 @@
+/**
+ * 스키마 렌더러 — Layer 1 (Core)
+ *
+ * CLI 커맨드 메타데이터와 유닛 타입 정보를 구조화된 형식으로 렌더링한다.
+ * 에이전트가 런타임에 CLI 스키마를 조회하여 문서 없이도 CLI를 활용할 수 있게 지원.
+ * 순수 함수만 포함 — I/O 없음.
+ *
+ * @module
+ */
+// ── 커맨드 레지스트리 (정적 메타데이터) ──
+const GLOBAL_FLAGS = [
+    { name: '--help', alias: '-h', type: 'boolean', description: '도움말 출력' },
+    { name: '--version', alias: '-v', type: 'boolean', description: '버전 출력' },
+    { name: '--json', type: 'boolean', description: 'JSON 형식으로 출력 (ToolResult 구조)' },
+    { name: '--stdin', type: 'boolean', description: 'stdin에서 JSON 입력 읽기' },
+];
+/**
+ * 모든 CLI 커맨드의 메타데이터 레지스트리.
+ * 새 커맨드 추가 시 이 배열도 함께 업데이트해야 한다.
+ */
+export const COMMAND_REGISTRY = [
+    {
+        name: 'init',
+        description: '프로젝트 초기화 (설정 파일 생성)',
+        args: [],
+        flags: [
+            {
+                name: '--from-existing',
+                type: 'boolean',
+                description: '기존 파일 스캔으로 ID 패턴/디렉토리 자동 감지',
+            },
+            { name: '--force', type: 'boolean', description: '기존 설정 파일 덮어쓰기' },
+            { name: '--json', type: 'boolean', description: 'JSON 형식으로 출력' },
+            { name: '--stdin', type: 'boolean', description: 'stdin에서 JSON 입력 읽기' },
+        ],
+    },
+    {
+        name: 'set-unit',
+        description: '현재 작업 유닛 설정 (커맨드 파일 섹션 자동 구성)',
+        args: [{ name: 'unitId', required: true, description: '설정할 유닛 ID (예: U-001[Mvp])' }],
+        flags: [
+            {
+                name: '--request',
+                type: 'string',
+                description: '커스텀 특별 요청사항 키 선택 (콤마 구분)',
+            },
+            {
+                name: '--no-prompt',
+                type: 'boolean',
+                description: '페어링 질문 인터랙티브 프롬프트 비활성화',
+            },
+            { name: '--dry-run', type: 'boolean', description: '커맨드 파일 수정 없이 미리보기만 출력' },
+            { name: '--json', type: 'boolean', description: 'JSON 형식으로 출력' },
+            { name: '--stdin', type: 'boolean', description: 'stdin에서 JSON 입력 읽기' },
+        ],
+    },
+    {
+        name: 'update-commit',
+        description: '커밋 SHA 업데이트 (인자 없음=HEAD, 숫자=최근 N개)',
+        args: [
+            { name: 'sha|N', required: false, description: 'SHA 해시 또는 최근 커밋 수 (생략 시 HEAD)' },
+        ],
+        flags: [
+            {
+                name: '--mode',
+                type: 'string',
+                description: '값 교체(replace) 또는 추가(append) (기본: replace)',
+            },
+            { name: '--section', type: 'string', description: '대상 섹션 지정 (미지정 시 자동 감지)' },
+            { name: '--json', type: 'boolean', description: 'JSON 형식으로 출력' },
+            { name: '--stdin', type: 'boolean', description: 'stdin에서 JSON 입력 읽기' },
+        ],
+    },
+    {
+        name: 'list-units',
+        description: '미완료 유닛 목록 조회',
+        args: [],
+        flags: [
+            { name: '--phase', type: 'string', description: '특정 Phase로 필터링 (예: Mvp, Mmp)' },
+            { name: '--json', type: 'boolean', description: 'JSON 형식으로 출력' },
+            { name: '--stdin', type: 'boolean', description: 'stdin에서 JSON 입력 읽기' },
+        ],
+    },
+    {
+        name: 'context',
+        description: '유닛 컨텍스트 조회 (읽기 전용)',
+        args: [{ name: 'unitId', required: true, description: '조회할 유닛 ID (예: U-001[Mvp])' }],
+        flags: [
+            { name: '--json', type: 'boolean', description: 'JSON 형식으로 출력' },
+            { name: '--stdin', type: 'boolean', description: 'stdin에서 JSON 입력 읽기' },
+        ],
+    },
+    {
+        name: 'validate',
+        description: '설정 파일 종합 검증 (스키마/경로/정규식/패턴충돌)',
+        args: [],
+        flags: [{ name: '--json', type: 'boolean', description: 'JSON 형식으로 출력' }],
+    },
+    {
+        name: 'skill install',
+        description: 'SKILL 파일 설치 (Cursor/Claude Code/Gemini)',
+        args: [],
+        flags: [
+            { name: '--cursor', type: 'boolean', description: 'Cursor만 설치 (.cursor/skills/)' },
+            { name: '--claude', type: 'boolean', description: 'Claude Code만 설치 (.claude/skills/)' },
+            { name: '--gemini', type: 'boolean', description: 'Gemini만 설치 (.gemini/skills/)' },
+            { name: '--force', type: 'boolean', description: '기존 파일 덮어쓰기' },
+            { name: '--json', type: 'boolean', description: 'JSON 형식으로 출력' },
+        ],
+    },
+    {
+        name: 'schema',
+        description: '런타임 스키마 조회 (config/commands/types)',
+        args: [
+            { name: 'subcommand', required: false, description: '조회 대상 (config, commands, types)' },
+        ],
+        flags: [
+            { name: '--output', type: 'string', description: '결과를 파일로 저장할 경로' },
+            { name: '--json', type: 'boolean', description: 'JSON 형식으로 출력' },
+        ],
+    },
+];
+/** schema 서브커맨드 도움말 정보 */
+export const SCHEMA_SUBCOMMANDS = [
+    { name: 'config', description: '설정 파일(vibe-commander.config.json) JSON Schema 출력' },
+    { name: 'commands', description: '사용 가능한 커맨드 목록 + 파라미터 + 플래그 출력' },
+    { name: 'types', description: '현재 프로젝트의 유닛 유형 목록 + ID 패턴 출력' },
+];
+// ── 공개 API ──
+/**
+ * 커맨드 메타데이터를 구조화된 형태로 렌더링한다
+ *
+ * 글로벌 플래그와 커맨드별 메타데이터를 결합하여 반환.
+ * 에이전트가 사용 가능한 모든 커맨드와 옵션을 파악할 수 있도록 한다.
+ */
+export function renderCommandsSchema() {
+    return {
+        globalFlags: GLOBAL_FLAGS,
+        commands: COMMAND_REGISTRY,
+    };
+}
+/**
+ * 유닛 타입 정보를 구조화된 형태로 렌더링한다
+ *
+ * ProjectConfig의 unitTypes 배열을 TypeSchemaEntry로 변환.
+ * 에이전트가 유효한 유닛 ID 패턴과 프로젝트 구조를 파악할 수 있도록 한다.
+ *
+ * @param unitTypes - 프로젝트 설정의 unitTypes 배열
+ * @returns 구조화된 타입 스키마 배열
+ */
+export function renderTypesSchema(unitTypes) {
+    return unitTypes.map((ut) => ({
+        key: ut.key,
+        ...(ut.displayName !== undefined && { displayName: ut.displayName }),
+        idPattern: ut.idPattern,
+        planDir: ut.planDir,
+        commandSection: ut.commandSection,
+        collectDeps: ut.collectDeps,
+        headerTemplate: ut.headerTemplate,
+    }));
+}
+//# sourceMappingURL=schema-renderer.js.map

package/dist/core/validators/input-validator.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 입력 검증 순수 함수 — Layer 1 (Core)
+ *
+ * 에이전트 환각(hallucination) 방어를 위한 입력 검증 유틸리티.
+ * 제어 문자, URL 인코딩, 경로 순회, 쿼리 파라미터 등 위험한 입력을 거부하고,
+ * 유사 유닛 ID를 레벤슈타인 거리 기반으로 제안한다.
+ *
+ * I/O 없는 순수 함수만 포함 (Core Layer 1 규칙 준수).
+ *
+ * @module
+ */
+/** 입력 검증 결과 */
+export interface ValidationResult {
+    valid: boolean;
+    error?: string;
+    suggestions?: string[];
+}
+/**
+ * 유닛 ID의 안전성과 형식을 검증한다
+ *
+ * 검증 순서:
+ * 1. 빈 값 체크
+ * 2. 제어 문자 (ASCII < 0x20) 거부
+ * 3. URL 인코딩 (% 포함) 거부
+ * 4. 경로 순회 (../, ..\) 거부
+ * 5. 쿼리 파라미터 (?, #) 거부
+ * 6. knownIds 제공 시 매칭 실패하면 유사 ID 제안
+ *
+ * @param id - 검증할 유닛 ID
+ * @param knownIds - 알려진 유닛 ID 목록 (fuzzy match에 사용, 선택)
+ * @returns 검증 결과
+ */
+export declare function validateUnitId(id: string, knownIds?: string[]): ValidationResult;
+/**
+ * Git SHA의 형식을 검증한다
+ *
+ * 유효한 SHA 형식: 7~40자리 16진수 문자열
+ *
+ * @param sha - 검증할 SHA 문자열
+ * @returns 검증 결과
+ */
+export declare function validateSha(sha: string): ValidationResult;
+/**
+ * 경로 문자열의 안전성을 검증한다
+ *
+ * @param pathStr - 검증할 경로 문자열
+ * @returns 검증 결과
+ */
+export declare function validatePath(pathStr: string): ValidationResult;
+//# sourceMappingURL=input-validator.d.ts.map