jun-claude-code 0.0.11 → 0.0.12

package/README.md

@@ -1,140 +1,161 @@
 # 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 15종. 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 문서 관리 |
+| `context-generator` | Context 자동 생성 |
+| `project-task-manager` | GitHub Project 태스크 관리 |
 
-### 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 운영 스킬 |
+| `ContextGeneration` | Context 자동 생성 스킬 |
 
-### Hooks (`.claude/hooks/`)
+### Hooks (`templates/global/hooks/`)
 
-- 워크플로우 순서 강제 프로토콜
-- Skill/Agent 평가 프로토콜
+| Hook | 설명 |
+|------|------|
+| `workflow-enforced.sh` | 워크플로우 순서 강제 프로토콜 |
+| `skill-forced.sh` | Skill/Agent 평가 프로토콜 |
+| `task-loader.sh` | GitHub Project 태스크 조회 |
 
-## 커스터마이징
+### Workflow
 
-설치 후 `~/.claude/` 디렉토리에서 필요에 맞게 수정하세요.
+Planning -> Validation -> Implementation -> Review 순서의 작업 워크플로우와 Context 절약 원칙(Subagent 위임 규칙)을 정의합니다.
 
-```
-~/.claude/
-├── CLAUDE.md          # 작업 가이드
-├── agents/            # Agent 정의 수정/추가
-├── skills/            # Skill 가이드 수정/추가
-├── hooks/             # 자동 실행 스크립트
-└── context/           # 프로젝트별 Context (직접 추가)
+## 설치
+
+```bash
+# npx로 바로 실행
+npx jun-claude-code
+
+# 또는 전역 설치
+npm install -g jun-claude-code
 ```
 
-### 프로젝트별 설정
+## 사용법
 
-프로젝트 루트에 `.claude/` 폴더를 만들어 프로젝트별 설정을 추가할 수 있습니다.
+### 기본 명령어: 설정 복사
 
+`templates/global` 설정 파일을 `~/.claude`로 복사합니다.
+
+```bash
+jun-claude-code
 ```
-your-project/
-├── .claude/
-│   ├── context/       # 프로젝트 아키텍처, 도메인 지식
-│   └── skills/        # 프로젝트 전용 스킬
-└── CLAUDE.md          # 프로젝트 설명
-```
 
-### 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/context/
+├── codebase/
+│   └── INDEX.md                   # 코드베이스 모듈 참조 목록
+└── business/
+    └── INDEX.md                   # 비즈니스 도메인 참조 목록
+```
 
-```bash
-gh auth refresh -s read:project,project
+> `CLAUDE_CODE_OAUTH_TOKEN`를 GitHub repository secrets에 추가해야 합니다.
+
+## 프로젝트 구조
+
+```
+templates/
+├── global/                # ~/.claude/에 설치되는 전역 설정
+│   ├── CLAUDE.md          # 작업 가이드 (워크플로우, Context 절약 원칙)
+│   ├── agents/            # Subagent 정의 (15종)
+│   ├── skills/            # 스킬 가이드 (코딩, Git, BE, FE 등)
+│   ├── hooks/             # 자동 실행 스크립트 (워크플로우 강제, 스킬 평가)
+│   └── settings.json      # Claude Code 전역 설정
+└── project/               # 프로젝트 .claude/에 설치되는 프로젝트별 설정
+    ├── agents/            # project-task-manager Agent
+    ├── 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

@@ -36,6 +36,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const copy_1 = require("./copy");
+const init_context_1 = require("./init-context");
 const program = new commander_1.Command();
 program
     .name('jun-claude-code')
@@ -78,4 +79,21 @@ 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.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,121 @@
+"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. .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'));
+    }
+    // 3. .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'));
+    }
+    // 4. 안내 메시지
+    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/package.json

@@ -1,12 +1,12 @@
 {
   "name": "jun-claude-code",
-  "version": "0.0.11",
+  "version": "0.0.12",
   "description": "Claude Code configuration template - copy .claude settings to your project",
   "main": "dist/index.js",
   "bin": "dist/cli.js",
   "files": [
     "dist",
-    ".claude"
+    "templates"
   ],
   "scripts": {
     "build": "tsc",

package/templates/global/agents/context-generator.md

@@ -0,0 +1,66 @@
+---
+name: context-generator
+description: GitHub Action에서 PR diff 기반으로 .claude/context/ 문서를 자동 생성/업데이트 (CI 전용)
+keywords: [context, PR, diff, codebase, business, 문서생성]
+model: sonnet
+color: green
+---
+
+# Context Generator Agent
+
+PR의 변경 내용을 분석하여 `.claude/context/` 하위에 codebase/business 문서를 자동 생성하고 업데이트합니다.
+
+## 실행 조건
+
+- GitHub Action에서 PR 이벤트로 트리거
+- `anthropics/claude-code-action@v1`을 통해 실행
+
+## 프로세스
+
+### 1. Diff 수집
+
+```bash
+git diff HEAD~1 --name-only
+```
+
+변경된 파일 목록을 수집합니다.
+
+### 2. 모듈 매핑
+
+변경된 파일을 모듈 단위로 그룹화합니다.
+- `src/cli.ts` → `cli` 모듈
+- `src/copy.ts` → `copy-logic` 모듈
+- `.claude/agents/*.md` → `agents` 모듈
+
+### 3. 기존 Context 확인
+
+`.claude/context/codebase/`와 `.claude/context/business/`에서 기존 문서를 확인합니다.
+- 기존 문서가 있으면 → 업데이트
+- 기존 문서가 없으면 → 새로 생성
+
+### 4. Codebase Context 생성
+
+[ContextGeneration Skill](../../skills/ContextGeneration/SKILL.md)의 Codebase 규칙에 따라:
+- 모듈별 `.md` 파일 생성/업데이트
+- 파일 경로와 함수명만 참조 (원본 코드 포함 금지)
+- `codebase/INDEX.md` 업데이트
+
+### 5. Business Context 생성
+
+[ContextGeneration Skill](../../skills/ContextGeneration/SKILL.md)의 Business 규칙에 따라:
+- 기술 용어를 비즈니스 관점으로 변환
+- 도메인별 `.md` 파일 생성/업데이트
+- `business/INDEX.md` 업데이트
+
+### 6. 커밋
+
+```bash
+git add .claude/context/
+git commit -m "docs: update context for PR changes"
+```
+
+## 제약사항
+
+- `.claude/context/**` 경로 변경은 무시 (무한루프 방지)
+- 변경된 파일과 관련된 context만 업데이트 (전체 재생성 금지)
+- 원본 소스 코드를 context 문서에 포함하지 않음

package/{.claude → templates/global}/agents/context-manager.md

@@ -1,6 +1,6 @@
 ---
 name: context-manager
-description: .claude 문서의 파일 구조/포맷 최적화 시 호출. 큰 파일을 INDEX.md + 상세파일로 분리, 중복 제거, 테이블 압축으로 토큰 절약. (스펙 내용의 논리적 정합성 검증은 director 담당)
+description: 기존 .claude/context/ 문서의 구조 최적화 시 호출. 큰 파일을 INDEX.md + 상세파일로 분리, 중복 제거, 테이블 압축으로 토큰 절약 (수동 호출, 스펙 정합성 검증은 director 담당)
 keywords: [Context관리, 문서정리, 파일분리, 토큰최적화, 구조개선, 문서품질]
 model: sonnet
 color: green

package/{.claude → templates/global}/agents/explore.md

@@ -1,6 +1,6 @@
 ---
 name: explore
-description: 파일 위치/코드 검색이 필요할 때 호출. Glob/Grep으로 빠른 탐색, 파일 구조 파악. Main Context 오염 없이 결과만 반환.
+description: 파일 위치/코드 검색이 필요할 때 호출. Glob/Grep으로 빠른 탐색, 파일 구조 파악.
 keywords: [탐색, 검색, 파일찾기, 패턴매칭, 구조파악, Glob, Grep, 빠른검색]
 model: haiku
 color: gray

package/{.claude → templates/global}/agents/simple-code-writer.md

@@ -1,6 +1,6 @@
 ---
 name: simple-code-writer
-description: 1-2개 파일의 간단한 코드 수정 시 호출. Main Agent 대신 단순 수정, 설정 변경, 오타 수정 등을 수행.
+description: lint/build 오류, 오타, 설정값 등 간단한 코드 수정 시 호출. 단순 수정, 설정 변경, 오타 수정 수행.
 keywords: [간단수정, 단순수정, 설정변경, 오타수정, 1-2파일, 소규모수정]
 model: haiku
 color: cyan

package/{.claude → templates/global}/hooks/skill-forced.sh

@@ -25,18 +25,8 @@ Main Agent의 Context Window는 제한적입니다.
 
 ### 🚨 필수 위임 작업 (Main Agent 직접 수행 금지)
 
-| 작업 유형 | 사용할 Agent | 이유 |
-|----------|-------------|------|
-| 코드베이스 탐색/검색 | explore | 파일 내용이 Main Context에 쌓이지 않음 |
-| 여러 파일 읽기 | explore / context-collector | 탐색 결과만 요약해서 받음 |
-| 패턴/구조 파악 | context-collector | 분석 결과만 받음 |
-| 복잡한 계획 수립 | task-planner | 계획 결과만 받음 |
-| 영향 분석 | impact-analyzer | 분석 결과만 받음 |
-| 코드 리뷰 | code-reviewer | 리뷰 결과만 받음 |
-| 테스트/빌드 검증 | qa-tester | 검증 결과만 받음 |
-| 단순 수정 (lint/build 오류, 오타, 설정값) | simple-code-writer | Main이 직접 수정하지 않음 |
-| 여러 파일 코드 작성 | code-writer / designer | 구현 결과만 받음 |
-| Git 작업 | git-manager | 커밋/PR 결과만 받음 |
+아래 PART 2의 "사용 가능한 Agents" 목록에서 각 Agent의 description을 확인하고,
+작업에 적합한 Agent에 위임하세요. 각 Agent의 description에 위임 이유가 포함되어 있습니다.
 
 ### ❌ 절대 금지 (Main Agent에서 직접 수행 금지)
 

package/templates/global/skills/ContextGeneration/SKILL.md

@@ -0,0 +1,152 @@
+---
+name: ContextGeneration
+description: PR 변경 내용을 분석하여 .claude/context/ 문서를 자동 생성하는 규칙
+keywords: [context, codebase, business, PR, 자동생성, 문서화]
+estimated_tokens: ~800
+---
+
+# Context 자동 생성 규칙
+
+PR 변경 내용을 분석하여 `.claude/context/` 하위에 codebase/business 문서를 자동 생성합니다.
+
+## Context 디렉토리 구조
+
+```
+.claude/context/
+├── codebase/
+│   ├── INDEX.md          # 모듈 목록 + 경로
+│   └── <module-name>.md  # 모듈별 구현 참조
+└── business/
+    ├── INDEX.md          # 프로젝트 개요 + 도메인 목록
+    └── <domain-area>.md  # 비즈니스 레벨 요약
+```
+
+## Codebase Context 규칙
+
+### 파일명
+- **kebab-case** 사용 (예: `cli.md`, `copy-logic.md`, `auth-middleware.md`)
+- 모듈/기능 단위로 분리
+
+### 필수 섹션
+
+```markdown
+---
+name: <모듈명>
+description: <한 줄 설명>
+keywords: [관련, 키워드]
+---
+
+# <모듈명>
+
+<2-3문장 개요>
+
+## 파일 구조
+
+| 파일 | 역할 | 핵심 함수/클래스 |
+|------|------|-----------------|
+| src/example.ts | 메인 로직 | mainFunction(), HelperClass |
+
+## 핵심 흐름
+
+1. <진입점> → <처리> → <결과>
+2. ...
+
+## 관련 Business Context
+
+- [<도메인명>](../business/<domain>.md)
+```
+
+### 금지사항
+
+- **원본 코드 포함 절대 금지** (코드 블록으로 소스 코드를 복사하지 않음)
+- 파일 경로와 함수/클래스명만 참조
+- 파일 참조 형식: `| src/copy.ts | 파일 복사 메인 로직 | mergeSettingsJson() |`
+
+## Business Context 규칙
+
+### 파일명
+- **비즈니스 도메인 기준** (예: `configuration-management.md`, `user-authentication.md`)
+- 기술 용어 금지 (예: `settings-json-merge.md` ❌ → `configuration-management.md` ✅)
+
+### 필수 섹션
+
+```markdown
+---
+name: <도메인명>
+description: <비즈니스 관점 한 줄 설명>
+keywords: [비즈니스, 키워드]
+---
+
+# <도메인명>
+
+## 목적
+
+<이 기능이 사용자에게 제공하는 가치>
+
+## 핵심 기능
+
+| 기능 | 설명 | 사용자 관점 |
+|------|------|------------|
+| 설정 복사 | 템플릿 설정을 사용자 환경에 적용 | 초기 설정 자동화 |
+
+## 사용자 흐름
+
+1. 사용자가 <동작> → <결과>
+2. ...
+
+## 관련 Codebase Context
+
+- [<모듈명>](../codebase/<module>.md)
+```
+
+### 변환 규칙
+- Codebase의 기술 용어를 비즈니스 관점으로 변환
+  - `mergeSettingsJson()` → "기존 설정을 보존하면서 새 설정 적용"
+  - `copyClaudeFiles()` → "템플릿 설정을 사용자 환경에 배포"
+
+## INDEX.md 작성 규칙
+
+### codebase/INDEX.md
+
+```markdown
+---
+name: Codebase Index
+description: 코드베이스 모듈 참조 목록
+---
+
+# Codebase Context Index
+
+## 모듈 목록
+
+| 모듈 | 설명 | 문서 |
+|------|------|------|
+| CLI | 커맨드라인 인터페이스 | [cli.md](./cli.md) |
+```
+
+### business/INDEX.md
+
+```markdown
+---
+name: Business Index
+description: 비즈니스 도메인 참조 목록
+---
+
+# Business Context Index
+
+## 프로젝트 개요
+
+<프로젝트가 해결하는 문제와 대상 사용자 1-2문장>
+
+## 도메인 목록
+
+| 도메인 | 설명 | 문서 |
+|--------|------|------|
+| 설정 관리 | 사용자 설정 배포 및 관리 | [configuration-management.md](./configuration-management.md) |
+```
+
+## 증분 업데이트 원칙
+
+- PR에서 변경된 파일만 해당하는 context 문서를 업데이트
+- 전체 재생성 금지 -- 기존 문서의 변경되지 않은 부분은 유지
+- 새 모듈이 추가되면 INDEX.md에 행 추가
+- 모듈이 삭제되면 INDEX.md에서 해당 행 제거 및 문서 파일 삭제

package/templates/project/workflows/context-gen.yml

@@ -0,0 +1,52 @@
+name: Context Auto-Generation
+
+on:
+  pull_request:
+    types: [opened, synchronize]
+    paths-ignore:
+      - '.claude/context/**'
+
+permissions:
+  contents: write
+  pull-requests: write
+  id-token: write
+
+jobs:
+  generate-context:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout PR branch
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ github.head_ref }}
+          fetch-depth: 0
+
+      - name: Generate context documents
+        uses: anthropics/claude-code-action@v1
+        with:
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+          prompt: |
+            당신은 context-generator 에이전트입니다.
+            .claude/agents/context-generator.md의 에이전트 정의와
+            .claude/skills/ContextGeneration/SKILL.md의 스킬 가이드를 읽고 정확히 따르세요.
+
+            PR diff를 분석하고 .claude/context/ 아래에 컨텍스트 문서를 생성/업데이트하세요.
+
+            단계:
+            1. `git diff HEAD~1 --name-only`을 실행하여 변경된 파일 목록 가져오기
+            2. 변경된 각 모듈에 대해 .claude/context/codebase/<module>.md 생성 또는 업데이트
+            3. 영향을 받는 각 비즈니스 도메인에 대해 .claude/context/business/<domain>.md 생성 또는 업데이트
+            4. 두 디렉토리의 INDEX.md 파일 업데이트
+            5. "docs: update context for PR changes" 메시지로 변경사항 커밋
+
+            중요사항:
+            - 컨텍스트 문서에 소스 코드를 포함하지 말고, 파일 경로와 함수 이름만 포함하세요
+            - 실제로 변경된 파일에 대해서만 컨텍스트 업데이트
+            - ContextGeneration 스킬에 명시된 정확한 형식 따르기
+
+      - name: Commit and push context changes
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add .claude/context/
+          git diff --staged --quiet || (git commit -m "docs: context 문서 자동 업데이트" && git push)