@stormhwdev/claude-config 1.0.0

package/bin/cli.js

@@ -0,0 +1,310 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+// ─── Colors ────────────────────────────────────────────────────
+const C = {
+  green: (s) => `\x1b[32m${s}\x1b[0m`,
+  yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+  red: (s) => `\x1b[31m${s}\x1b[0m`,
+  cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+  bold: (s) => `\x1b[1m${s}\x1b[0m`,
+  dim: (s) => `\x1b[2m${s}\x1b[0m`,
+};
+
+const info = (msg) => console.log(`${C.green('✓')} ${msg}`);
+const warn = (msg) => console.log(`${C.yellow('!')} ${msg}`);
+const error = (msg) => console.error(`${C.red('✗')} ${msg}`);
+
+// ─── Paths ─────────────────────────────────────────────────────
+const PKG_ROOT = path.resolve(__dirname, '..');
+const CLAUDE_DIR = path.join(process.env.HOME || process.env.USERPROFILE, '.claude');
+
+// Directories to install at user level
+const DIRS = ['agents', 'templates', 'rules'];
+// Files to merge/install at user level
+const MERGE_FILES = ['settings.json'];
+
+// ─── Helpers ───────────────────────────────────────────────────
+
+function ask(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase());
+    });
+  });
+}
+
+function copyDirSync(src, dst) {
+  fs.mkdirSync(dst, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const srcPath = path.join(src, entry.name);
+    const dstPath = path.join(dst, entry.name);
+    if (entry.isDirectory()) {
+      copyDirSync(srcPath, dstPath);
+    } else {
+      fs.copyFileSync(srcPath, dstPath);
+    }
+  }
+}
+
+function filesEqual(a, b) {
+  try {
+    return fs.readFileSync(a).equals(fs.readFileSync(b));
+  } catch {
+    return false;
+  }
+}
+
+function countFiles(dir) {
+  let count = 0;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      count += countFiles(path.join(dir, entry.name));
+    } else {
+      count++;
+    }
+  }
+  return count;
+}
+
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    if (
+      source[key] &&
+      typeof source[key] === 'object' &&
+      !Array.isArray(source[key]) &&
+      target[key] &&
+      typeof target[key] === 'object' &&
+      !Array.isArray(target[key])
+    ) {
+      result[key] = deepMerge(target[key], source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  }
+  return result;
+}
+
+// ─── Commands ──────────────────────────────────────────────────
+
+async function cmdInit(opts) {
+  console.log('');
+  console.log(C.bold('Claude Code 研发规范配置安装'));
+  console.log(C.dim(`源: ${PKG_ROOT}`));
+  console.log(C.dim(`目标: ${CLAUDE_DIR}`));
+  console.log('');
+
+  fs.mkdirSync(CLAUDE_DIR, { recursive: true });
+
+  // 1. Copy directories
+  for (const dir of DIRS) {
+    const src = path.join(PKG_ROOT, dir);
+    const dst = path.join(CLAUDE_DIR, dir);
+
+    if (!fs.existsSync(src)) {
+      warn(`源目录不存在，跳过: ${dir}/`);
+      continue;
+    }
+
+    // If dst is a symlink, remove it first (migrating from symlink-based install)
+    if (fs.existsSync(dst) && fs.lstatSync(dst).isSymbolicLink()) {
+      if (!opts.force) {
+        const answer = await ask(`  ${dir}/ 当前是符号链接，替换为文件副本？[Y/n] `);
+        if (answer === 'n') {
+          warn(`${dir}/ 跳过`);
+          continue;
+        }
+      }
+      fs.unlinkSync(dst);
+    }
+
+    if (fs.existsSync(dst) && !opts.force) {
+      // Check if content is identical
+      const srcCount = countFiles(src);
+      const dstCount = countFiles(dst);
+      if (srcCount === dstCount) {
+        info(`${dir}/ 已是最新 (${srcCount} 个文件)`);
+        // Still overwrite to ensure content matches
+        copyDirSync(src, dst);
+        continue;
+      }
+    }
+
+    copyDirSync(src, dst);
+    info(`${dir}/ 已安装 (${countFiles(src)} 个文件)`);
+  }
+
+  // 2. Merge settings.json
+  for (const file of MERGE_FILES) {
+    const src = path.join(PKG_ROOT, file);
+    const dst = path.join(CLAUDE_DIR, file);
+
+    if (!fs.existsSync(src)) continue;
+
+    // If dst is a symlink, remove it first
+    if (fs.existsSync(dst) && fs.lstatSync(dst).isSymbolicLink()) {
+      fs.unlinkSync(dst);
+    }
+
+    if (fs.existsSync(dst) && !fs.lstatSync(dst).isSymbolicLink()) {
+      try {
+        const existing = JSON.parse(fs.readFileSync(dst, 'utf8'));
+        const incoming = JSON.parse(fs.readFileSync(src, 'utf8'));
+        const merged = deepMerge(existing, incoming);
+
+        if (JSON.stringify(existing) === JSON.stringify(merged)) {
+          info(`${file} 已是最新`);
+        } else {
+          fs.writeFileSync(dst, JSON.stringify(merged, null, 2) + '\n');
+          info(`${file} 已合并更新`);
+        }
+      } catch {
+        // If existing file is malformed, overwrite
+        fs.copyFileSync(src, dst);
+        info(`${file} 已覆盖`);
+      }
+    } else {
+      fs.copyFileSync(src, dst);
+      info(`${file} 已安装`);
+    }
+  }
+
+  console.log('');
+  console.log(C.green('安装完成！'));
+  console.log('');
+  console.log(`使用 ${C.cyan('claude-config apply')} 将 CLAUDE.md 应用到具体项目`);
+  console.log('');
+}
+
+async function cmdApply(opts) {
+  const src = path.join(PKG_ROOT, 'CLAUDE.md.template');
+  const dst = path.join(process.cwd(), 'CLAUDE.md');
+
+  if (!fs.existsSync(src)) {
+    error('CLAUDE.md.template 不存在');
+    process.exit(1);
+  }
+
+  if (fs.existsSync(dst) && !opts.force) {
+    if (filesEqual(src, dst)) {
+      info('CLAUDE.md 已是最新，无需更新');
+      return;
+    }
+
+    const answer = await ask(`当前目录已有 CLAUDE.md，覆盖？[Y/n] `);
+    if (answer === 'n') {
+      warn('已取消');
+      return;
+    }
+  }
+
+  fs.copyFileSync(src, dst);
+  info(`CLAUDE.md 已写入 ${process.cwd()}/CLAUDE.md`);
+}
+
+function cmdHelp() {
+  console.log('');
+  console.log(C.bold('Claude Code 研发规范配置'));
+  console.log('');
+  console.log('命令:');
+  console.log(`  ${C.cyan('init')}     安装/更新用户级配置到 ~/.claude/`);
+  console.log(`  ${C.cyan('apply')}    将 CLAUDE.md 模板应用到当前项目`);
+  console.log(`  ${C.cyan('status')}   查看当前配置状态`);
+  console.log(`  ${C.cyan('help')}     显示帮助信息`);
+  console.log('');
+  console.log('选项:');
+  console.log(`  ${C.cyan('--force')}  跳过确认提示，强制覆盖`);
+  console.log('');
+  console.log('示例:');
+  console.log(`  ${C.dim('# 首次安装')}`);
+  console.log(`  npx @stormhwdev/claude-config init`);
+  console.log('');
+  console.log(`  ${C.dim('# 在项目根目录应用 CLAUDE.md')}`);
+  console.log(`  cd your-project && npx @stormhwdev/claude-config apply`);
+  console.log('');
+  console.log(`  ${C.dim('# 更新到最新版')}`);
+  console.log(`  npx @stormhwdev/claude-config@latest init`);
+  console.log('');
+}
+
+function cmdStatus() {
+  console.log('');
+  console.log(C.bold('配置状态'));
+  console.log('');
+
+  // Check user-level
+  for (const dir of DIRS) {
+    const dst = path.join(CLAUDE_DIR, dir);
+    if (fs.existsSync(dst)) {
+      const isLink = fs.lstatSync(dst).isSymbolicLink();
+      const count = isLink ? '(symlink)' : `${countFiles(dst)} 个文件`;
+      info(`~/.claude/${dir}/  ${C.dim(count)}`);
+    } else {
+      warn(`~/.claude/${dir}/  ${C.dim('未安装')}`);
+    }
+  }
+
+  for (const file of MERGE_FILES) {
+    const dst = path.join(CLAUDE_DIR, file);
+    if (fs.existsSync(dst)) {
+      info(`~/.claude/${file}  ${C.dim('已配置')}`);
+    } else {
+      warn(`~/.claude/${file}  ${C.dim('未安装')}`);
+    }
+  }
+
+  // Check project-level
+  console.log('');
+  const claudeMd = path.join(process.cwd(), 'CLAUDE.md');
+  if (fs.existsSync(claudeMd)) {
+    info(`./CLAUDE.md  ${C.dim('已存在')}`);
+  } else {
+    warn(`./CLAUDE.md  ${C.dim('未配置 (使用 claude-config apply 应用)')}`);
+  }
+
+  console.log('');
+}
+
+// ─── Main ──────────────────────────────────────────────────────
+
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args.find((a) => !a.startsWith('-')) || 'help';
+  const opts = {
+    force: args.includes('--force') || args.includes('-f'),
+  };
+
+  switch (command) {
+    case 'init':
+    case 'install':
+    case 'update':
+      await cmdInit(opts);
+      break;
+    case 'apply':
+      await cmdApply(opts);
+      break;
+    case 'status':
+      cmdStatus();
+      break;
+    case 'help':
+    case '--help':
+    case '-h':
+      cmdHelp();
+      break;
+    default:
+      error(`未知命令: ${command}`);
+      cmdHelp();
+      process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  error(err.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@stormhwdev/claude-config",
+  "version": "1.0.0",
+  "description": "Claude Code 研发规范配置 - 一键安装 agents、rules、templates 到 ~/.claude/",
+  "bin": {
+    "claude-config": "bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "agents/",
+    "rules/",
+    "templates/",
+    "settings.json",
+    "CLAUDE.md.template"
+  ],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "ai",
+    "agent",
+    "config"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": ""
+  }
+}

package/rules/agents.md

@@ -0,0 +1,49 @@
+# Agent Orchestration
+
+## Available Agents
+
+Located in `~/.claude/agents/`:
+
+| Agent | Purpose | When to Use |
+|-------|---------|-------------|
+| planner | Implementation planning | Complex features, refactoring |
+| architect | System design | Architectural decisions |
+| tdd-guide | Test-driven development | New features, bug fixes |
+| code-reviewer | Code review | After writing code |
+| security-reviewer | Security analysis | Before commits |
+| build-error-resolver | Fix build errors | When build fails |
+| e2e-runner | E2E testing | Critical user flows |
+| refactor-cleaner | Dead code cleanup | Code maintenance |
+| doc-updater | Documentation | Updating docs |
+
+## Immediate Agent Usage
+
+No user prompt needed:
+1. Complex feature requests - Use **planner** agent
+2. Code just written/modified - Use **code-reviewer** agent
+3. Bug fix or new feature - Use **tdd-guide** agent
+4. Architectural decision - Use **architect** agent
+
+## Parallel Task Execution
+
+ALWAYS use parallel Task execution for independent operations:
+
+```markdown
+# GOOD: Parallel execution
+Launch 3 agents in parallel:
+1. Agent 1: Security analysis of auth module
+2. Agent 2: Performance review of cache system
+3. Agent 3: Type checking of utilities
+
+# BAD: Sequential when unnecessary
+First agent 1, then agent 2, then agent 3
+```
+
+## Multi-Perspective Analysis
+
+For complex problems, use split role sub-agents:
+- Factual reviewer
+- Senior engineer
+- Security expert
+- Consistency reviewer
+- Redundancy checker

package/rules/coding-style.md

@@ -0,0 +1,26 @@
+# Go Coding Style
+
+> This file extends [common/coding-style.md](../common/coding-style.md) with Go specific content.
+
+## Formatting
+
+- **gofmt** and **goimports** are mandatory — no style debates
+
+## Design Principles
+
+- Accept interfaces, return structs
+- Keep interfaces small (1-3 methods)
+
+## Error Handling
+
+Always wrap errors with context:
+
+```go
+if err != nil {
+    return fmt.Errorf("failed to create user: %w", err)
+}
+```
+
+## Reference
+
+See skill: `golang-patterns` for comprehensive Go idioms and patterns.

package/rules/git-workflow.md

@@ -0,0 +1,45 @@
+# Git Workflow
+
+## Commit Message Format
+
+```
+<type>: <description>
+
+<optional body>
+```
+
+Types: feat, fix, refactor, docs, test, chore, perf, ci
+
+Note: Attribution disabled globally via ~/.claude/settings.json.
+
+## Pull Request Workflow
+
+When creating PRs:
+1. Analyze full commit history (not just latest commit)
+2. Use `git diff [base-branch]...HEAD` to see all changes
+3. Draft comprehensive PR summary
+4. Include test plan with TODOs
+5. Push with `-u` flag if new branch
+
+## Feature Implementation Workflow
+
+1. **Plan First**
+   - Use **planner** agent to create implementation plan
+   - Identify dependencies and risks
+   - Break down into phases
+
+2. **TDD Approach**
+   - Use **tdd-guide** agent
+   - Write tests first (RED)
+   - Implement to pass tests (GREEN)
+   - Refactor (IMPROVE)
+   - Verify 80%+ coverage
+
+3. **Code Review**
+   - Use **code-reviewer** agent immediately after writing code
+   - Address CRITICAL and HIGH issues
+   - Fix MEDIUM issues when possible
+
+4. **Commit & Push**
+   - Detailed commit messages
+   - Follow conventional commits format

package/rules/hooks.md

@@ -0,0 +1,11 @@
+# Go Hooks
+
+> This file extends [common/hooks.md](../common/hooks.md) with Go specific content.
+
+## PostToolUse Hooks
+
+Configure in `~/.claude/settings.json`:
+
+- **gofmt/goimports**: Auto-format `.go` files after edit
+- **go vet**: Run static analysis after editing `.go` files
+- **staticcheck**: Run extended static checks on modified packages

package/rules/patterns.md

@@ -0,0 +1,39 @@
+# Go Patterns
+
+> This file extends [common/patterns.md](../common/patterns.md) with Go specific content.
+
+## Functional Options
+
+```go
+type Option func(*Server)
+
+func WithPort(port int) Option {
+    return func(s *Server) { s.port = port }
+}
+
+func NewServer(opts ...Option) *Server {
+    s := &Server{port: 8080}
+    for _, opt := range opts {
+        opt(s)
+    }
+    return s
+}
+```
+
+## Small Interfaces
+
+Define interfaces where they are used, not where they are implemented.
+
+## Dependency Injection
+
+Use constructor functions to inject dependencies:
+
+```go
+func NewUserService(repo UserRepository, logger Logger) *UserService {
+    return &UserService{repo: repo, logger: logger}
+}
+```
+
+## Reference
+
+See skill: `golang-patterns` for comprehensive Go patterns including concurrency, error handling, and package organization.

package/rules/performance.md

@@ -0,0 +1,55 @@
+# Performance Optimization
+
+## Model Selection Strategy
+
+**Haiku 4.5** (90% of Sonnet capability, 3x cost savings):
+- Lightweight agents with frequent invocation
+- Pair programming and code generation
+- Worker agents in multi-agent systems
+
+**Sonnet 4.5** (Best coding model):
+- Main development work
+- Orchestrating multi-agent workflows
+- Complex coding tasks
+
+**Opus 4.5** (Deepest reasoning):
+- Complex architectural decisions
+- Maximum reasoning requirements
+- Research and analysis tasks
+
+## Context Window Management
+
+Avoid last 20% of context window for:
+- Large-scale refactoring
+- Feature implementation spanning multiple files
+- Debugging complex interactions
+
+Lower context sensitivity tasks:
+- Single-file edits
+- Independent utility creation
+- Documentation updates
+- Simple bug fixes
+
+## Extended Thinking + Plan Mode
+
+Extended thinking is enabled by default, reserving up to 31,999 tokens for internal reasoning.
+
+Control extended thinking via:
+- **Toggle**: Option+T (macOS) / Alt+T (Windows/Linux)
+- **Config**: Set `alwaysThinkingEnabled` in `~/.claude/settings.json`
+- **Budget cap**: `export MAX_THINKING_TOKENS=10000`
+- **Verbose mode**: Ctrl+O to see thinking output
+
+For complex tasks requiring deep reasoning:
+1. Ensure extended thinking is enabled (on by default)
+2. Enable **Plan Mode** for structured approach
+3. Use multiple critique rounds for thorough analysis
+4. Use split role sub-agents for diverse perspectives
+
+## Build Troubleshooting
+
+If build fails:
+1. Use **build-error-resolver** agent
+2. Analyze error messages
+3. Fix incrementally
+4. Verify after each fix

package/rules/security.md

@@ -0,0 +1,28 @@
+# Go Security
+
+> This file extends [common/security.md](../common/security.md) with Go specific content.
+
+## Secret Management
+
+```go
+apiKey := os.Getenv("OPENAI_API_KEY")
+if apiKey == "" {
+    log.Fatal("OPENAI_API_KEY not configured")
+}
+```
+
+## Security Scanning
+
+- Use **gosec** for static security analysis:
+  ```bash
+  gosec ./...
+  ```
+
+## Context & Timeouts
+
+Always use `context.Context` for timeout control:
+
+```go
+ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
+defer cancel()
+```

package/rules/testing.md

@@ -0,0 +1,25 @@
+# Go Testing
+
+> This file extends [common/testing.md](../common/testing.md) with Go specific content.
+
+## Framework
+
+Use the standard `go test` with **table-driven tests**.
+
+## Race Detection
+
+Always run with the `-race` flag:
+
+```bash
+go test -race ./...
+```
+
+## Coverage
+
+```bash
+go test -cover ./...
+```
+
+## Reference
+
+See skill: `golang-testing` for detailed Go testing patterns and helpers.

package/settings.json

@@ -0,0 +1,11 @@
+{
+  "env": {
+    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
+  },
+  "model": "opus",
+  "enabledPlugins": {
+    "everything-claude-code@everything-claude-code": true
+  },
+  "teammateMode": "Split panes",
+  "skipDangerousModePermissionPrompt": true
+}