Delegate CLAUDE.md to claude /init, add anti-reinvention rules

CLAUDE.md generation:
- Delegates to `claude /init` (headless) instead of custom generation
- Appends ROBOCO context via `<roboco>` tags
- Fallback to template if /init fails or doesn't produce file
- Verifies file existence after /init before declaring success

Anti-reinvention:
- CLAUDE.md: added Anti-Reinvention Rule section
- PRD: added "How" column to all setup domain tables
- Removed unused prompt utils (select, input) — Agent SDK handles dialogue
- Fixed all lint warnings (unused imports/params)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: serithemage

CLAUDE.md

@@ -67,3 +67,19 @@ src/
 - `init` = first-time setup with interview, `install` = team member applies existing config
 - `doctor` checks ROBOCO CLI itself, `status` checks target repo setup
 - No `lint` command — static validation of vibe coding "correctness" is impractical
+- CLAUDE.md generation delegates to `claude /init`, not custom implementation
+
+## Anti-Reinvention Rule
+
+Before implementing any feature, check if it already exists in:
+1. **Claude Code built-in** — `/init`, `/compact`, `/review`, built-in tools (Read, Write, Glob, Grep, Bash)
+2. **Claude Code SDK / Agent SDK** — `query()`, hooks, permissions, MCP
+3. **OMC** — agents, skills, workflows (ralph, autopilot, ultrawork)
+4. **npm ecosystem** — established packages for common tasks
+
+If existing functionality covers 80%+ of the need, **wrap/delegate** instead of reimplementing.
+Concrete examples:
+- CLAUDE.md generation → `claude /init` (headless) + `<roboco>` tag append
+- AI conversation → `@anthropic-ai/claude-agent-sdk` `query()`, not raw API
+- MCP server install → `claude mcp add`, not custom installer
+- Git hooks → `husky`, not custom scripts

docs/PRD.md

@@ -37,33 +37,33 @@ npx roboco init [path]
 
 ### 4.1 Claude Code 환경 (필수)
 
-| 산출물 | 설명 |
-|--------|------|
-| `CLAUDE.md` | 리포 특성에 맞는 AI 맞춤 컨텍스트 문서 (커뮤니티 표준 구조 적용) |
-| `.claude/` | settings, commands, skills 디렉토리 구성 |
-| Claude Code Hooks | `.claude/settings.json`에 스택별 hooks 템플릿 자동 생성 (lint/format/typecheck 자동화) |
-| MCP 서버 설정 | 필요한 MCP 서버 자동 구성 |
-| oh-my-claudecode (OMC) | 통째 설치 (dependency) |
+| 산출물 | 설명 | How (구현 방법론) |
+|--------|------|-----------------|
+| `CLAUDE.md` | 리포 특성에 맞는 AI 맞춤 컨텍스트 문서 | `claude /init` (headless)로 생성 → `<roboco>` 태그로 ROBOCO 컨텍스트 append. 직접 생성 금지 |
+| `.claude/settings.json` | 권한, hooks 설정 | JSON 직접 생성 (ROBOCO 고유 스키마) |
+| Claude Code Hooks | 스택별 lint/format 자동화 | 스택 감지 결과 기반으로 hooks 템플릿 렌더링 (TS→prettier, Py→black, Go→gofmt) |
+| MCP 서버 설정 | 필요한 MCP 서버 자동 구성 | `claude mcp add` CLI 위임. 직접 설정 파일 쓰기 금지 |
+| oh-my-claudecode (OMC) | 멀티에이전트 오케스트레이션 | `claude plugin install` CLI 위임 |
 
 ### 4.2 프로세스 문서 (선택)
 
-| 산출물 | 설명 |
-|--------|------|
-| 바이브 코딩 5단계 템플릿 | 의도전달 → 요건정의 → 조사 → 계획 → 구현 |
-| OpenSpec | 프로세스 문서화 프레임워크 |
+| 산출물 | 설명 | How |
+|--------|------|-----|
+| 바이브 코딩 5단계 템플릿 | 의도전달 → 요건정의 → 조사 → 계획 → 구현 | 정적 마크다운 템플릿 복사 (ROBOCO 고유 콘텐츠) |
+| OpenSpec | 프로세스 문서화 프레임워크 | openspec CLI/config 위임 |
 
 각 단계별로 문서를 남기고 언제든지 원하는 단계부터 다시 시작할 수 있어야 한다.
 
 ### 4.3 CI/CD 파이프라인 (선택)
 
-| 산출물 | 설명 |
-|--------|------|
-| pre-commit hooks | 바이브 코딩 규칙 강제 |
-| GitHub Actions 워크플로우 | CI에서 규칙 검증 자동화 |
+| 산출물 | 설명 | How |
+|--------|------|-----|
+| pre-commit hooks | 바이브 코딩 규칙 강제 | `husky` 위임. `.husky/pre-commit` 생성, 직접 .git/hooks 조작 금지 |
+| GitHub Actions 워크플로우 | CI에서 규칙 검증 자동화 | 정적 YAML 템플릿 복사 (ROBOCO 고유 워크플로우) |
 
 ### 4.4 스택 분석 및 최적화 (자동)
 
-- 리포의 기술 스택 자동 감지
+- 리포의 기술 스택 자동 감지 (ROBOCO 고유 기능 — package.json, pyproject.toml, go.mod 등 파싱)
 - 언어 비의존 공통 설정 기반으로 스택별 최적화된 설정 제공
 
 ## 5. 명령어

src/commands/add.ts

@@ -1,7 +1,7 @@
 import { resolve } from 'node:path';
 import ora from 'ora';
 import { fileExists, readJson, writeJson } from '../utils/fs.js';
-import { installTools, printInstallReport } from '../core/installer.js';
+import { installTools } from '../core/installer.js';
 import { logger } from '../utils/logger.js';
 import type { RobocoConfig, ToolSelection } from '../types/index.js';
 

src/commands/audit.ts

@@ -52,7 +52,7 @@ export async function auditCommand(options: AuditOptions): Promise<void> {
 
 async function auditClaudeEnv(
   targetPath: string,
-  analysis: ReturnType<typeof analyze> extends Promise<infer T> ? T : never,
+  _analysis: ReturnType<typeof analyze> extends Promise<infer T> ? T : never,
 ): Promise<AuditCategory> {
   const cat: AuditCategory = {
     name: 'Claude Code Environment',

src/core/generator.ts

@@ -1,6 +1,7 @@
 import { join } from 'node:path';
+import { execa } from 'execa';
 import type { AnalysisResult, InterviewResult, RobocoConfig } from '../types/index.js';
-import { ensureDir, fileExists, writeText } from '../utils/fs.js';
+import { ensureDir, fileExists, writeText, readText } from '../utils/fs.js';
 import { logger } from '../utils/logger.js';
 
 interface FileOperation {
@@ -17,7 +18,12 @@ export async function generate(
   const files: FileOperation[] = [];
 
   // Claude Code Environment (required)
-  files.push(...generateClaudeEnv(targetPath, analysis, interviewResult));
+  // Step 1: Run claude /init to generate base CLAUDE.md
+  await runClaudeInit(targetPath);
+  // Step 2: Append ROBOCO context + generate settings/hooks
+  await appendRobocoContext(targetPath, analysis, interviewResult);
+  // Step 3: Generate .claude/settings.json and hooks
+  files.push(...generateClaudeSettings(targetPath, analysis));
 
   // Process Documents (optional)
   if (interviewResult.setupDomains.processDocs) {
@@ -51,50 +57,84 @@ function relative(base: string, full: string): string {
   return full.startsWith(base) ? full.slice(base.length + 1) : full;
 }
 
-function generateClaudeEnv(
-  targetPath: string,
-  analysis: AnalysisResult,
-  _interviewResult: InterviewResult,
-): FileOperation[] {
-  const files: FileOperation[] = [];
-  const projectName = analysis.git.repoName ?? 'My Project';
-  const stackList =
-    [...analysis.stack.languages, ...analysis.stack.frameworks].join(', ') || 'Not detected';
-
-  files.push({
-    path: join(targetPath, 'CLAUDE.md'),
-    content: `# ${projectName}
+async function runClaudeInit(targetPath: string): Promise<void> {
+  const claudeMdPath = join(targetPath, 'CLAUDE.md');
+  if (await fileExists(claudeMdPath)) {
+    logger.info('CLAUDE.md already exists — skipping claude /init');
+    return;
+  }
 
-## Project Overview
-<!-- Describe your project here -->
+  try {
+    await execa('claude', ['/init'], {
+      cwd: targetPath,
+      timeout: 30000,
+      env: { ...process.env, CLAUDE_CODE_HEADLESS: '1' },
+      stdin: 'ignore',
+    });
+    // Verify claude /init actually created the file
+    if (await fileExists(claudeMdPath)) {
+      logger.success('CLAUDE.md generated via claude /init');
+      return;
+    }
+  } catch {
+    // Fall through to template generation
+  }
 
-## Tech Stack
-${stackList}
+  logger.warn('claude /init did not produce CLAUDE.md — generating template');
+  const { basename } = await import('node:path');
+  await writeText(
+    claudeMdPath,
+    `# ${basename(targetPath)}\n\n## Project Overview\n\nDescribe your project here.\n`,
+  );
+}
 
-## Development Commands
-\`\`\`bash
-# Build
-# Test
-# Lint
-\`\`\`
+async function appendRobocoContext(
+  targetPath: string,
+  analysis: AnalysisResult,
+  interviewResult: InterviewResult,
+): Promise<void> {
+  const claudeMdPath = join(targetPath, 'CLAUDE.md');
+  if (!(await fileExists(claudeMdPath))) return;
+
+  const existing = await readText(claudeMdPath);
+  if (existing.includes('<roboco>')) {
+    logger.info('ROBOCO context already present in CLAUDE.md — skipping');
+    return;
+  }
 
-## Coding Conventions
-<!-- Add your coding conventions here -->
+  const tools = Object.entries(interviewResult.tools)
+    .filter(([, v]) => v)
+    .map(([k]) => k)
+    .join(', ');
 
+  const robocoBlock = `
+<roboco>
 ## Vibe Coding Process
-This project follows the 5-stage vibe coding process:
+
+This project uses ROBOCO for AI-native development with the 5-stage vibe coding process:
 1. **Intent** — Communicate what you want to build
 2. **Requirements** — Define requirements through deep interview
 3. **Research** — Investigate approaches and tools
 4. **Plan** — Create an implementation plan
 5. **Implement** — Build with AI assistance
 
-## Non-Goals
-<!-- List things explicitly out of scope -->
-`,
-    description: 'CLAUDE.md',
-  });
+Each stage produces documents in \`docs/vibe-coding/\`. You can restart from any stage.
+
+## ROBOCO Configuration
+
+- **Stack**: ${[...analysis.stack.languages, ...analysis.stack.frameworks].join(', ') || 'Not detected'}
+- **Tools**: ${tools}
+- **Config**: \`.roboco/config.json\`
+
+Run \`roboco status\` to check setup, \`roboco audit\` for maturity scoring.
+</roboco>
+`;
+
+  await writeText(claudeMdPath, existing.trimEnd() + '\n' + robocoBlock);
+  logger.success('ROBOCO context appended to CLAUDE.md');
+}
 
+function generateClaudeSettings(targetPath: string, analysis: AnalysisResult): FileOperation[] {
   const hooks = generateHooksForStack(analysis.stack.languages);
   const settings = {
     permissions: {
@@ -114,13 +154,13 @@ This project follows the 5-stage vibe coding process:
     ...(Object.keys(hooks).length > 0 ? { hooks } : {}),
   };
 
-  files.push({
-    path: join(targetPath, '.claude', 'settings.json'),
-    content: JSON.stringify(settings, null, 2) + '\n',
-    description: '.claude/settings.json',
-  });
-
-  return files;
+  return [
+    {
+      path: join(targetPath, '.claude', 'settings.json'),
+      content: JSON.stringify(settings, null, 2) + '\n',
+      description: '.claude/settings.json',
+    },
+  ];
 }
 
 function generateHooksForStack(languages: string[]): Record<string, unknown> {

src/utils/prompt.ts

@@ -16,25 +16,3 @@ export async function confirm(message: string, defaultYes = true): Promise<boole
     });
   });
 }
-
-export async function select(message: string, choices: string[]): Promise<number> {
-  const rl = createRl();
-  const list = choices.map((c, i) => `  ${i + 1}) ${c}`).join('\n');
-  return new Promise((resolve) => {
-    rl.question(`${message}\n${list}\n> `, (answer: string) => {
-      rl.close();
-      const idx = parseInt(answer.trim(), 10) - 1;
-      resolve(idx >= 0 && idx < choices.length ? idx : 0);
-    });
-  });
-}
-
-export async function input(message: string): Promise<string> {
-  const rl = createRl();
-  return new Promise((resolve) => {
-    rl.question(`${message} `, (answer: string) => {
-      rl.close();
-      resolve(answer.trim());
-    });
-  });
-}

tests/integration/init-pipeline.test.ts

@@ -8,6 +8,11 @@ import { interview } from '../../src/core/interviewer.js';
 import { generate } from '../../src/core/generator.js';
 import { fileExists } from '../../src/utils/fs.js';
 
+// Pre-create CLAUDE.md to skip `claude /init` in tests
+async function seedClaudeMd(dir: string, name: string): Promise<void> {
+  await writeFile(join(dir, 'CLAUDE.md'), `# ${name}\n\n## Overview\nTest project.\n`);
+}
+
 describe('init pipeline (analyze → interview → generate)', () => {
   let tempDir: string;
 
@@ -24,43 +29,39 @@ describe('init pipeline (analyze → interview → generate)', () => {
     );
     await writeFile(join(tempDir, 'tsconfig.json'), '{}');
     await mkdir(join(tempDir, 'src'));
+    await seedClaudeMd(tempDir, 'test-project');
   });
 
   afterEach(async () => {
     await rm(tempDir, { recursive: true, force: true });
   });
 
   it('full pipeline produces valid ROBOCO setup', async () => {
-    // Step 1: Analyze
     const analysis = await analyze(tempDir);
     expect(analysis.stack.languages).toContain('TypeScript');
     expect(analysis.stack.frameworks).toContain('React');
     expect(analysis.git.isRepo).toBe(true);
 
-    // Step 2: Interview (auto)
     const result = await interview(analysis, { auto: true });
     expect(result.tools.omc).toBe(true);
     expect(result.setupDomains.claudeEnv).toBe(true);
 
-    // Step 3: Generate
     const created = await generate(tempDir, analysis, result);
     expect(created.length).toBeGreaterThan(0);
 
-    // Verify artifacts
     expect(await fileExists(join(tempDir, 'CLAUDE.md'))).toBe(true);
     expect(await fileExists(join(tempDir, '.claude', 'settings.json'))).toBe(true);
     expect(await fileExists(join(tempDir, '.roboco', 'config.json'))).toBe(true);
 
-    // Verify CLAUDE.md contains project info
     const claudeMd = await readFile(join(tempDir, 'CLAUDE.md'), 'utf-8');
+    expect(claudeMd).toContain('test-project');
+    expect(claudeMd).toContain('<roboco>');
     expect(claudeMd).toContain('TypeScript');
 
-    // Verify settings.json has TypeScript hooks
     const settings = JSON.parse(await readFile(join(tempDir, '.claude', 'settings.json'), 'utf-8'));
     expect(settings.permissions).toBeDefined();
     expect(settings.hooks).toBeDefined();
 
-    // Verify config is valid
     const config = JSON.parse(await readFile(join(tempDir, '.roboco', 'config.json'), 'utf-8'));
     expect(config.version).toBe('0.1.0');
     expect(config.analysis.stack.languages).toContain('TypeScript');
@@ -69,24 +70,20 @@ describe('init pipeline (analyze → interview → generate)', () => {
   it('pipeline with full options generates all artifacts', async () => {
     const analysis = await analyze(tempDir);
     const result = await interview(analysis, { auto: true });
-    // Auto mode enables processDocs + cicd for git repos
     expect(result.setupDomains.processDocs).toBe(true);
     expect(result.setupDomains.cicd).toBe(true);
 
     await generate(tempDir, analysis, result);
 
-    // Process docs
     expect(await fileExists(join(tempDir, 'docs', 'vibe-coding', '01-intent.md'))).toBe(true);
     expect(await fileExists(join(tempDir, 'docs', 'vibe-coding', '05-implement.md'))).toBe(true);
-
-    // CI/CD
     expect(await fileExists(join(tempDir, '.github', 'workflows', 'vibe-coding-check.yml'))).toBe(
       true,
     );
+    expect(await fileExists(join(tempDir, '.husky', 'pre-commit'))).toBe(true);
   });
 
   it('pipeline handles Python project correctly', async () => {
-    // Replace with Python project
     await rm(join(tempDir, 'package.json'));
     await rm(join(tempDir, 'tsconfig.json'));
     await writeFile(join(tempDir, 'requirements.txt'), 'flask\ndjango\n');
@@ -102,14 +99,13 @@ describe('init pipeline (analyze → interview → generate)', () => {
     expect(JSON.stringify(settings.hooks)).toContain('black');
   });
 
-  it('pipeline preserves existing CLAUDE.md', async () => {
-    await writeFile(join(tempDir, 'CLAUDE.md'), '# Existing content\nDo not overwrite');
-
+  it('pipeline preserves existing CLAUDE.md and appends roboco context', async () => {
     const analysis = await analyze(tempDir);
     const result = await interview(analysis, { auto: true });
     await generate(tempDir, analysis, result);
 
     const content = await readFile(join(tempDir, 'CLAUDE.md'), 'utf-8');
-    expect(content).toContain('Existing content');
+    expect(content).toContain('test-project');
+    expect(content).toContain('<roboco>');
   });
 });