jun-claude-code 0.0.11 → 0.0.13

package/README.md

@@ -1,140 +1,179 @@
 # jun-claude-code
 
-Claude Code 설정 템플릿 CLI입니다. 미리 정의된 `.claude` 설정을 `~/.claude`로 복사하여 새 프로젝트에서 빠르게 Claude Code 환경을 구축할 수 있습니다.
+Claude Code 설정 템플릿 CLI. 미리 정의된 Agents, Skills, Hooks, Workflow를 프로젝트에 설치하여 Claude Code 환경을 빠르게 구축합니다.
 
-## 설치
-
-```bash
-# npx로 바로 실행
-npx jun-claude-code
-
-# 또는 전역 설치
-npm install -g jun-claude-code
-```
-
-## 사용법
-
-```bash
-# 기본 실행 (기존 파일이 있으면 덮어쓰기 확인)
-jun-claude-code
-
-# 미리보기 (실제 복사 없이 복사될 파일 목록 확인)
-jun-claude-code --dry-run
+## 포함 내용
 
-# 강제 덮어쓰기 (확인 없이 모든 파일 복사)
-jun-claude-code --force
-```
-
-## 포함된 설정
+### Agents (`templates/global/agents/`)
 
-### Agents (`.claude/agents/`)
+작업별 전문 Subagent 13종. Main Agent의 Context Window를 절약하면서 각 작업을 위임합니다.
 
-| Agent | 설명 |
+| Agent | 역할 |
 |-------|------|
-| `explore` | 빠른 코드베이스 탐색 |
+| `explore` | 코드베이스 탐색 |
 | `task-planner` | 작업 계획 수립 |
-| `code-writer` | 코드 작성 |
+| `code-writer` | 코드 작성 (Opus) |
+| `simple-code-writer` | 단순 수정 (Haiku) |
 | `code-reviewer` | 셀프 코드 리뷰 |
-| `git-manager` | Git 작업 (커밋, PR) |
+| `git-manager` | Git 커밋/PR |
 | `impact-analyzer` | 사이드이펙트 분석 |
 | `qa-tester` | 테스트/빌드 검증 |
 | `architect` | 아키텍처 설계 |
 | `designer` | UI/UX 스타일링 |
+| `director` | 작업 총괄 디렉터 |
 | `context-collector` | Context 수집 |
 | `context-manager` | Context 문서 관리 |
 
-### Skills (`.claude/skills/`)
+### Skills (`templates/global/skills/`)
 
 | Skill | 설명 |
 |-------|------|
 | `Coding` | 공통 코딩 원칙 (SRP, 응집도, 가독성) |
-| `Git` | Git 커밋/PR 규칙 |
+| `Git` | Git 커밋/PR 규칙, PR 리뷰, 피드백 적용 |
 | `Backend` | 백엔드 개발 원칙 (레이어, TypeORM) |
+| `React` | React 개발 (TanStack Router, React Hook Form, Tailwind) |
+| `Documentation` | .claude 문서 작성 가이드 |
+| `Director` | 디렉터 Agent 운영 스킬 |
 
-### Hooks (`.claude/hooks/`)
+### Hooks (`templates/global/hooks/`)
 
-- 워크플로우 순서 강제 프로토콜
-- Skill/Agent 평가 프로토콜
+| Hook | 설명 |
+|------|------|
+| `workflow-enforced.sh` | 워크플로우 순서 강제 프로토콜 |
+| `skill-forced.sh` | Skill/Agent 평가 프로토콜 |
 
-## 커스터마이징
+### Project Agents (`templates/project/agents/`)
 
-설치 후 `~/.claude/` 디렉토리에서 필요에 맞게 수정하세요.
+프로젝트 `.claude/`에 설치되는 프로젝트별 Agent.
 
-```
-~/.claude/
-├── CLAUDE.md          # 작업 가이드
-├── agents/            # Agent 정의 수정/추가
-├── skills/            # Skill 가이드 수정/추가
-├── hooks/             # 자동 실행 스크립트
-└── context/           # 프로젝트별 Context (직접 추가)
-```
+| Agent | 역할 |
+|-------|------|
+| `project-task-manager` | GitHub Project 태스크 관리 |
+| `context-generator` | Context 자동 생성 |
 
-### 프로젝트별 설정
+### Project Skills (`templates/project/skills/`)
 
-프로젝트 루트에 `.claude/` 폴더를 만들어 프로젝트별 설정을 추가할 수 있습니다.
+| Skill | 설명 |
+|-------|------|
+| `ContextGeneration` | Context 자동 생성 스킬 |
 
+### Workflow
+
+Planning -> Validation -> Implementation -> Review 순서의 작업 워크플로우와 Context 절약 원칙(Subagent 위임 규칙)을 정의합니다.
+
+## 설치
+
+```bash
+# npx로 바로 실행
+npx jun-claude-code
+
+# 또는 전역 설치
+npm install -g jun-claude-code
 ```
-your-project/
-├── .claude/
-│   ├── context/       # 프로젝트 아키텍처, 도메인 지식
-│   └── skills/        # 프로젝트 전용 스킬
-└── CLAUDE.md          # 프로젝트 설명
+
+## 사용법
+
+### 기본 명령어: 설정 복사
+
+`templates/global` 설정 파일을 `~/.claude`로 복사합니다.
+
+```bash
+jun-claude-code
 ```
 
-### GitHub Project 연동
+| 옵션 | 설명 |
+|------|------|
+| `--dry-run`, `-d` | 실제 복사 없이 복사될 파일 목록만 확인 |
+| `--force`, `-f` | 확인 없이 모든 파일 덮어쓰기 |
 
-`init-project` 커맨드로 GitHub Project 태스크 관리를 프로젝트에 연동할 수 있습니다.
+### `init-project`: GitHub Project 연동
+
+프로젝트 디렉토리에서 GitHub Project 태스크 관리를 설정합니다.
 
 ```bash
-# 프로젝트 루트에서 실행
 jun-claude-code init-project
 ```
 
-실행하면 다음을 인터랙티브로 설정합니다:
-
-1. **GitHub Owner** (org 또는 user)
-2. **Project Number**
-3. **Repository** (owner/repo 형식)
+인터랙티브로 다음을 설정합니다:
+- GitHub Owner (org 또는 user)
+- Project Number
+- Repository (owner/repo 형식)
 
-설정 완료 후 프로젝트에 생성되는 파일:
+설정 후 생성되는 파일:
 
 ```
-your-project/
-├── .claude/
-│   ├── project.env                    # GitHub Project 설정 (GITHUB_PROJECT_OWNER 등)
-│   ├── settings.json                  # StartSession hook (세션 시작 시 태스크 표시)
-│   ├── hooks/
-│   │   └── task-loader.sh             # 태스크 조회 스크립트
-│   └── agents/
-│       └── project-task-manager.md    # 태스크 관리 Agent
+.claude/
+├── project.env                    # GitHub Project 환경변수
+├── settings.json                  # StartSession hook 설정
+├── hooks/
+│   └── task-loader.sh             # 태스크 조회 스크립트
+└── agents/
+    └── project-task-manager.md    # 태스크 관리 Agent
 ```
 
-#### 수동 설정
+> `read:project` 스코프 필요: `gh auth refresh -s read:project,project`
+
+### `init-context`: Context 자동 생성 설정
 
-`init-project` 대신 직접 `.claude/project.env`를 생성할 수도 있습니다:
+GitHub Actions를 통한 Context 문서 자동 생성을 설정합니다.
 
 ```bash
-# .claude/project.env
-GITHUB_PROJECT_OWNER=your-org
-GITHUB_PROJECT_NUMBER=1
-GITHUB_PROJECT_REPO=your-org/your-repo
+jun-claude-code init-context
 ```
 
-#### 필요 권한
+설정 후 생성되는 파일:
 
-GitHub Project 접근에 `read:project` 스코프가 필요합니다:
+```
+.github/workflows/
+└── context-gen.yml                # Context 생성 GitHub Actions 워크플로우
+
+.claude/
+├── agents/
+│   └── context-generator.md       # Context 자동 생성 Agent
+├── skills/
+│   └── ContextGeneration/
+│       └── SKILL.md               # Context 자동 생성 Skill
+└── context/
+    ├── codebase/
+    │   └── INDEX.md               # 코드베이스 모듈 참조 목록
+    └── business/
+        └── INDEX.md               # 비즈니스 도메인 참조 목록
+```
+
+> `CLAUDE_CODE_OAUTH_TOKEN`를 GitHub repository secrets에 추가해야 합니다.
+
+## 프로젝트 구조
 
-```bash
-gh auth refresh -s read:project,project
 ```
+templates/
+├── global/                # ~/.claude/에 설치되는 전역 설정
+│   ├── CLAUDE.md          # 작업 가이드 (워크플로우, Context 절약 원칙)
+│   ├── agents/            # Subagent 정의 (13종)
+│   ├── skills/            # 스킬 가이드 (코딩, Git, BE, FE 등)
+│   ├── hooks/             # 자동 실행 스크립트 (워크플로우 강제, 스킬 평가)
+│   └── settings.json      # Claude Code 전역 설정
+└── project/               # 프로젝트 .claude/에 설치되는 프로젝트별 설정
+    ├── agents/            # project-task-manager, context-generator Agent
+    ├── skills/            # ContextGeneration Skill
+    ├── hooks/             # task-loader Hook
+    ├── workflows/         # context-gen Workflow
+    └── project.env.example
+```
+
+## 커스터마이징
 
-## 핵심 원칙
+설치 후 `~/.claude/`에서 필요에 맞게 수정할 수 있습니다. 프로젝트별로는 프로젝트 루트에 `.claude/`를 만들어 설정을 추가합니다.
 
-이 템플릿의 핵심 원칙:
+```
+your-project/
+├── .claude/
+│   ├── context/           # 프로젝트 아키텍처, 도메인 지식
+│   └── skills/            # 프로젝트 전용 스킬
+└── CLAUDE.md              # 프로젝트 설명
+```
 
-1. **Context 절약**: Main Agent의 Context Window 보존을 위해 Subagent에 작업 위임
-2. **워크플로우 준수**: Planning → Validation → Implementation → Review
-3. **Git 작업 위임**: 모든 Git 작업은 `git-manager` Agent 사용
+- **context/**: 프로젝트의 사실/배경 정보 (아키텍처, 도메인 모델, API 스펙 등)
+- **skills/**: 프로젝트 고유의 작업 절차 (배포 방법, 테스트 규칙 등)
 
 ## License
 

package/dist/cli.js

@@ -33,9 +33,15 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
 const copy_1 = require("./copy");
+const init_context_1 = require("./init-context");
+const validate_1 = require("./validate");
 const program = new commander_1.Command();
 program
     .name('jun-claude-code')
@@ -78,4 +84,38 @@ program
         process.exit(1);
     }
 });
+program
+    .command('init-context')
+    .description('Setup context auto-generation with GitHub Actions')
+    .action(async () => {
+    try {
+        await (0, init_context_1.initContext)();
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error('Error:', error.message);
+        }
+        else {
+            console.error('An unexpected error occurred');
+        }
+        process.exit(1);
+    }
+});
+program
+    .command('validate')
+    .description('Validate template directory structure')
+    .action(async () => {
+    try {
+        await (0, validate_1.validateTemplates)();
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.error(chalk_1.default.red('Validation failed:'), error.message);
+        }
+        else {
+            console.error(chalk_1.default.red('Validation failed'));
+        }
+        process.exit(1);
+    }
+});
 program.parse();

package/dist/copy.js

@@ -93,12 +93,12 @@ function copyFile(src, dest) {
     fs.copyFileSync(src, dest);
 }
 /**
- * Get the source .claude directory path (from package installation)
+ * Get the source templates/global directory path (from package installation)
  */
-function getSourceClaudeDir() {
+function getSourceGlobalDir() {
     // When installed as npm package, __dirname is in dist/
-    // .claude folder is at package root (sibling to dist/)
-    return path.resolve(__dirname, '..', '.claude');
+    // templates/global folder is at package root
+    return path.resolve(__dirname, '..', 'templates', 'global');
 }
 /**
  * Get the destination .claude directory path (user's home)
@@ -110,26 +110,100 @@ function getDestClaudeDir() {
     }
     return path.join(homeDir, '.claude');
 }
+/**
+ * Merge settings.json from source into destination.
+ * Hooks are merged per event key; duplicate hook entries (by deep equality) are skipped.
+ * Non-hook keys are shallow-merged (source wins for new keys, dest preserved for existing).
+ */
+function mergeSettingsJson(sourceDir, destDir) {
+    const sourcePath = path.join(sourceDir, 'settings.json');
+    const destPath = path.join(destDir, 'settings.json');
+    if (!fs.existsSync(sourcePath)) {
+        return;
+    }
+    let sourceSettings;
+    try {
+        sourceSettings = JSON.parse(fs.readFileSync(sourcePath, 'utf-8'));
+    }
+    catch {
+        console.log(chalk_1.default.yellow('  Warning: Could not parse source settings.json, skipping merge.'));
+        return;
+    }
+    let destSettings = {};
+    if (fs.existsSync(destPath)) {
+        try {
+            destSettings = JSON.parse(fs.readFileSync(destPath, 'utf-8'));
+        }
+        catch {
+            console.log(chalk_1.default.yellow('  Warning: Could not parse destination settings.json, creating fresh.'));
+            destSettings = {};
+        }
+    }
+    // Merge top-level keys (source fills in missing keys, dest's existing keys preserved)
+    for (const key of Object.keys(sourceSettings)) {
+        if (key === 'hooks') {
+            continue; // hooks are merged separately below
+        }
+        if (!(key in destSettings)) {
+            destSettings[key] = sourceSettings[key];
+        }
+    }
+    // Merge hooks
+    const sourceHooks = sourceSettings.hooks || {};
+    if (!destSettings.hooks) {
+        destSettings.hooks = {};
+    }
+    const destHooks = destSettings.hooks;
+    for (const event of Object.keys(sourceHooks)) {
+        const sourceEntries = sourceHooks[event] || [];
+        if (!destHooks[event]) {
+            destHooks[event] = [];
+        }
+        const destEntries = destHooks[event];
+        // Extract a command-based key from a hook entry for duplicate detection.
+        // Type 1: { type: "command", command: "..." } → returns "type:command"
+        // Type 2: { hooks: [{ type: "command", command: "..." }, ...] } → returns sorted "type:command" joined
+        const getHookKey = (entry) => {
+            if (entry.hooks && Array.isArray(entry.hooks)) {
+                return entry.hooks
+                    .map((h) => `${h.type || ''}:${h.command || ''}`)
+                    .sort()
+                    .join('\n');
+            }
+            return `${entry.type || ''}:${entry.command || ''}`;
+        };
+        // Build a Set of command keys from existing entries for fast duplicate detection
+        const existingKeys = new Set(destEntries.map((entry) => getHookKey(entry)));
+        for (const entry of sourceEntries) {
+            const key = getHookKey(entry);
+            if (!existingKeys.has(key)) {
+                destEntries.push(entry);
+                existingKeys.add(key);
+            }
+        }
+    }
+    ensureDir(destDir);
+    fs.writeFileSync(destPath, JSON.stringify(destSettings, null, 2) + '\n', 'utf-8');
+    console.log(`  ${chalk_1.default.blue('[merged]')} settings.json`);
+}
 /**
  * Copy .claude files to user's home directory
  */
 async function copyClaudeFiles(options = {}) {
     const { dryRun = false, force = false } = options;
-    const sourceDir = getSourceClaudeDir();
+    const sourceDir = getSourceGlobalDir();
     const destDir = getDestClaudeDir();
     console.log(chalk_1.default.blue('Source:'), sourceDir);
     console.log(chalk_1.default.blue('Destination:'), destDir);
     console.log();
     // Check if source exists
     if (!fs.existsSync(sourceDir)) {
-        console.error(chalk_1.default.red('Error:'), 'Source .claude directory not found');
+        console.error(chalk_1.default.red('Error:'), 'Source templates/global directory not found');
         process.exit(1);
     }
-    // Files to exclude from global copy (project-specific files)
+    // Files to exclude from global copy (merge-handled separately)
     const EXCLUDE_FROM_GLOBAL = [
-        'hooks/task-loader.sh',
-        'agents/project-task-manager.md',
-        'project.env.example',
+        'settings.json',
     ];
     // Get all files to copy
     const allFiles = getAllFiles(sourceDir);
@@ -137,7 +211,7 @@ async function copyClaudeFiles(options = {}) {
         return !EXCLUDE_FROM_GLOBAL.includes(file);
     });
     if (files.length === 0) {
-        console.log(chalk_1.default.yellow('No files found in .claude directory'));
+        console.log(chalk_1.default.yellow('No files found in templates/global directory'));
         return;
     }
     console.log(chalk_1.default.cyan(`Found ${files.length} files to copy:`));
@@ -152,6 +226,11 @@ async function copyClaudeFiles(options = {}) {
             const status = exists ? chalk_1.default.yellow('[overwrite]') : chalk_1.default.green('[new]');
             console.log(`  ${status} ${file}`);
         }
+        // settings.json merge indicator
+        const sourceSettingsExists = fs.existsSync(path.join(sourceDir, 'settings.json'));
+        if (sourceSettingsExists) {
+            console.log(`  ${chalk_1.default.blue('[merge]')} settings.json`);
+        }
         console.log();
         console.log(chalk_1.default.yellow('No files were copied (dry run mode)'));
         return;
@@ -177,6 +256,8 @@ async function copyClaudeFiles(options = {}) {
         console.log(`  ${status} ${file}`);
         copiedCount++;
     }
+    // Merge settings.json (hooks are merged, not overwritten)
+    mergeSettingsJson(sourceDir, destDir);
     console.log();
     console.log(chalk_1.default.green(`Done! Copied ${copiedCount} files, skipped ${skippedCount} files.`));
 }

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export { copyClaudeFiles, CopyOptions } from './copy';
 export { initProject } from './init-project';
+export { initContext } from './init-context';

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initProject = exports.copyClaudeFiles = void 0;
+exports.initContext = exports.initProject = exports.copyClaudeFiles = void 0;
 var copy_1 = require("./copy");
 Object.defineProperty(exports, "copyClaudeFiles", { enumerable: true, get: function () { return copy_1.copyClaudeFiles; } });
 var init_project_1 = require("./init-project");
 Object.defineProperty(exports, "initProject", { enumerable: true, get: function () { return init_project_1.initProject; } });
+var init_context_1 = require("./init-context");
+Object.defineProperty(exports, "initContext", { enumerable: true, get: function () { return init_context_1.initContext; } });

package/dist/init-context.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Initialize context auto-generation with GitHub Actions
+ */
+export declare function initContext(): Promise<void>;

package/dist/init-context.js

@@ -0,0 +1,143 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initContext = initContext;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Get the templates/project directory path (from package installation)
+ */
+function getTemplatesDir() {
+    return path.resolve(__dirname, '..', 'templates', 'project');
+}
+/**
+ * Initialize context auto-generation with GitHub Actions
+ */
+async function initContext() {
+    const cwd = process.cwd();
+    console.log(chalk_1.default.bold('\n📄 Initializing Context Auto-Generation...\n'));
+    // 1. templates/project/workflows/context-gen.yml → .github/workflows/context-gen.yml 복사
+    const templateSrc = path.join(getTemplatesDir(), 'workflows', 'context-gen.yml');
+    const workflowDest = path.join(cwd, '.github', 'workflows', 'context-gen.yml');
+    fs.mkdirSync(path.dirname(workflowDest), { recursive: true });
+    if (fs.existsSync(workflowDest)) {
+        console.log(chalk_1.default.yellow('  ⚠ .github/workflows/context-gen.yml already exists, skipping'));
+    }
+    else {
+        fs.copyFileSync(templateSrc, workflowDest);
+        console.log(chalk_1.default.green('  ✓ Created .github/workflows/context-gen.yml'));
+    }
+    // 2. context-generator Agent 복사
+    const agentSrc = path.join(getTemplatesDir(), 'agents', 'context-generator.md');
+    const agentDest = path.join(cwd, '.claude', 'agents', 'context-generator.md');
+    fs.mkdirSync(path.dirname(agentDest), { recursive: true });
+    if (fs.existsSync(agentDest)) {
+        console.log(chalk_1.default.yellow('  ⚠ .claude/agents/context-generator.md already exists, skipping'));
+    }
+    else {
+        fs.copyFileSync(agentSrc, agentDest);
+        console.log(chalk_1.default.green('  ✓ Created .claude/agents/context-generator.md'));
+    }
+    // 3. ContextGeneration Skill 복사
+    const skillSrc = path.join(getTemplatesDir(), 'skills', 'ContextGeneration', 'SKILL.md');
+    const skillDest = path.join(cwd, '.claude', 'skills', 'ContextGeneration', 'SKILL.md');
+    fs.mkdirSync(path.dirname(skillDest), { recursive: true });
+    if (fs.existsSync(skillDest)) {
+        console.log(chalk_1.default.yellow('  ⚠ .claude/skills/ContextGeneration/SKILL.md already exists, skipping'));
+    }
+    else {
+        fs.copyFileSync(skillSrc, skillDest);
+        console.log(chalk_1.default.green('  ✓ Created .claude/skills/ContextGeneration/SKILL.md'));
+    }
+    // 4. .claude/context/codebase/ 디렉토리 + stub INDEX.md
+    const codebaseDirPath = path.join(cwd, '.claude', 'context', 'codebase');
+    const codebaseIndex = path.join(codebaseDirPath, 'INDEX.md');
+    fs.mkdirSync(codebaseDirPath, { recursive: true });
+    if (fs.existsSync(codebaseIndex)) {
+        console.log(chalk_1.default.yellow('  ⚠ .claude/context/codebase/INDEX.md already exists, skipping'));
+    }
+    else {
+        fs.writeFileSync(codebaseIndex, `---
+name: Codebase Index
+description: 코드베이스 모듈 참조 목록
+---
+
+# Codebase Context Index
+
+## 모듈 목록
+
+| 모듈 | 설명 | 문서 |
+|------|------|------|
+`);
+        console.log(chalk_1.default.green('  ✓ Created .claude/context/codebase/INDEX.md'));
+    }
+    // 5. .claude/context/business/ 디렉토리 + stub INDEX.md
+    const businessDirPath = path.join(cwd, '.claude', 'context', 'business');
+    const businessIndex = path.join(businessDirPath, 'INDEX.md');
+    fs.mkdirSync(businessDirPath, { recursive: true });
+    if (fs.existsSync(businessIndex)) {
+        console.log(chalk_1.default.yellow('  ⚠ .claude/context/business/INDEX.md already exists, skipping'));
+    }
+    else {
+        fs.writeFileSync(businessIndex, `---
+name: Business Index
+description: 비즈니스 도메인 참조 목록
+---
+
+# Business Context Index
+
+## 프로젝트 개요
+
+<!-- 프로젝트가 해결하는 문제와 대상 사용자를 작성하세요 -->
+
+## 도메인 목록
+
+| 도메인 | 설명 | 문서 |
+|--------|------|------|
+`);
+        console.log(chalk_1.default.green('  ✓ Created .claude/context/business/INDEX.md'));
+    }
+    // 6. 안내 메시지
+    console.log(chalk_1.default.bold('\n✅ Context auto-generation setup complete!\n'));
+    console.log(chalk_1.default.cyan('Next steps:'));
+    console.log(chalk_1.default.cyan('  1. Add CLAUDE_CODE_OAUTH_TOKEN to your repository secrets'));
+    console.log(chalk_1.default.cyan('     → Settings > Secrets and variables > Actions > New repository secret'));
+    console.log(chalk_1.default.cyan('  2. Create a PR to trigger context auto-generation'));
+    console.log('');
+}

package/dist/init-project.js

@@ -57,10 +57,10 @@ function askQuestion(question) {
     });
 }
 /**
- * Get the source .claude directory path (from package installation)
+ * Get the source templates/project directory path (from package installation)
  */
-function getSourceClaudeDir() {
-    return path.resolve(__dirname, '..', '.claude');
+function getSourceProjectDir() {
+    return path.resolve(__dirname, '..', 'templates', 'project');
 }
 /**
  * Get the project .claude directory path (current working directory)
@@ -101,7 +101,7 @@ function createProjectEnv(destDir, config) {
  * Copy a project-specific file from package source to project directory
  */
 function copyProjectFile(srcRelative, destDir) {
-    const srcPath = path.join(getSourceClaudeDir(), srcRelative);
+    const srcPath = path.join(getSourceProjectDir(), srcRelative);
     const destPath = path.join(destDir, srcRelative);
     if (!fs.existsSync(srcPath)) {
         console.log(chalk_1.default.yellow(`  ⚠ 소스 파일 없음: ${srcRelative}`));

package/dist/validate.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Validate template directory structure
+ */
+export declare function validateTemplates(): Promise<void>;