Claude Bootstrap

一个为 Claude Code 设计的、带有明确立场的项目初始化系统。默认采用代理团队模式，严格遵循 TDD 流程，支持多引擎代码评审，并将安全性置于首位。

瓶颈已从代码生成转移到代码理解。 AI 能够生成无限量的代码，但人类仍然需要对这些代码进行审查、理解和维护。Claude Bootstrap 提供了一系列约束机制，确保 AI 生成的代码简洁、安全且可验证。

v3.3.1 新增功能： Mnemos 两层后压缩任务恢复——当 Claude Code 的压缩功能触发、崩溃或未运行时，也能保证上下文的完整恢复。类型化内存图（目标永不被驱逐）、四维疲劳监测，以及跨会话的检查点与恢复功能。iCPG 意图增强型代码属性图——追踪代码存在的原因，检测偏差，避免重复工作。

核心理念

┌────────────────────────────────────────────────────────────────┐
│  通过停止钩子实现 TDD 循环                                      │
│  ─────────────────────────────────────────────────────────────│
│  停止钩子会在每次 Claude 回应后运行测试。                      │
│  如果测试失败，反馈会自动回传给 Claude，直到测试全部通过。    │
│  这是真正的 Claude Code 基础设施——无需任何插件。              │
├────────────────────────────────────────────────────────────────┤
│  测试先行，始终如此                                           │
│  ─────────────────────────────────────────────────────────────│
│  功能开发流程：编写测试 → 观察测试失败 → 实现功能 → 通过测试   │
│  Bug 修复流程：发现测试缺失 → 编写失败的测试 → 修复 → 通过测试  │
│  没有经过失败测试的代码不会被部署。                            │
├────────────────────────────────────────────────────────────────┤
│  简洁性是目标                                        │
│  ─────────────────────────────────────────────────────────────│
│  每个函数不超过 20 行 │ 每个文件不超过 200 行 │ 参数最多 3 个     │
│  通过 .claude/rules/ 中的 frontmatter 路径强制执行。            │
├────────────────────────────────────────────────────────────────┤
│  默认安全                                            │
│  ─────────────────────────────────────────────────────────────│
│  代码中不包含任何敏感信息 │ 对 .env 文件实施权限拒绝规则     │
│  依赖项扫描 │ 提交前钩子 │ CI 强制执行       │
├────────────────────────────────────────────────────────────────┤
│  默认使用代理团队                                    │
│  ─────────────────────────────────────────────────────────────│
│  每个项目都以协调一致的 AI 代理团队形式运行。                  │
│  代理定义使用规范的 frontmatter：工具、模型、                   │
│  最大轮次、努力程度、禁止使用的工具等。                        │
├────────────────────────────────────────────────────────────────┤
│  条件规则                                            │
│  ─────────────────────────────────────────────────────────────│
│  .claude/rules/ 中的规则会根据文件路径激活。                    │
│  React 规则仅在编辑 .tsx 文件时加载。                           │
│  Python 规则仅在编辑 .py 文件时加载。                           │
│  这样可以节省 token，减少噪音，提供更精准的指导。              │
└────────────────────────────────────────────────────────────────┘

快速入门

# 克隆并安装（可克隆到任意位置）
git clone https://github.com/alinaqi/claude-bootstrap.git
cd claude-bootstrap && ./install.sh

# 在任意项目目录下
claude
> /initialize-project

Claude 将执行以下操作：

1. 验证工具 - 检查 gh、vercel、supabase 的 CLI 是否可用
2. 提问 - 选择编程语言、框架、是否以 AI 优先、数据库类型、图分析级别等
3. 设置仓库 - 创建或连接 GitHub 仓库
4. 创建结构 - 包括技能、规则、配置、安全措施、CI/CD、规格说明和待办事项
5. 复制 settings.json - 预配置的权限和停止钩子
6. 生成 CLAUDE.md - 包含用于模块化技能的 @include 指令
7. 生成 CLAUDE.local.md - 用于开发者私有覆盖的模板
8. 启动代理团队 - 部署团队负责人 + 质量控制 + 安全 + 评审 + 合并 + 功能代理

TDD 循环的工作原理（停止钩子）

无需插件，也无假命令。 当 Claude 完成一次响应时，Claude Code 的停止钩子会运行一段脚本。如果脚本退出码为 2，则会将 stderr 反馈给 Claude，并继续对话。

┌─────────────────────────────────────────────────────────────┐
│  1. 用户说：“在注册功能中添加邮箱验证”                       │
│  2. Claude 编写测试用例及实现代码                             │
│  3. Claude 完成响应                                            │
│  4. 停止钩子运行：npm test && npm run lint                     │
│  5a. 所有测试通过（退出码 0）→ 完成！                          │
│  5b. 测试失败（退出码 2）→ stderr 被反馈给 Claude             │
│  6. Claude 发现问题，修复后再次完成响应                         │
│  7. 停止钩子再次运行 → 重复此过程，直到所有测试通过为止        │
└─────────────────────────────────────────────────────────────┘

配置位于 .claude/settings.json 中：

{
  "hooks": {
    "Stop": [{
      "hooks": [{
        "type": "command",
        "command": "scripts/tdd-loop-check.sh",
        "timeout": 60,
        "statusMessage": "正在运行测试..."
      }]
    }]
  }
}

tdd-loop-check.sh 脚本会运行测试、代码风格检查和类型检查。它还会记录迭代次数（最多 25 次），并区分代码错误（循环）和环境错误（停止）。

@include 指令

CLAUDE.md 使用 @include 指令来模块化加载技能：

# CLAUDE.md
@.claude/skills/base/SKILL.md
@.claude/skills/iterative-development/SKILL.md
@.claude/skills/security/SKILL.md

这些内容会在加载时由 Claude Code 解析——内容会被递归内联（最大深度 5，内置循环检测）。这意味着技能实际上会成为提示的一部分，而不仅仅是作为文本列出。

条件规则

.claude/rules/ 中的规则使用 YAML frontmatter 的 paths: 字段，仅在编辑相关文件时才会生效：

# .claude/rules/react.md
---
paths: ["src/components/**", "**/*.tsx"]
---
优先使用带 hooks 的函数式组件...

# .claude/rules/python.md
---
paths: ["**/*.py"]
---
使用类型注解、pytest 和 ruff...

包含的规则：

规则	激活条件
quality-gates.md	始终（无 paths: 过滤）
tdd-workflow.md	始终
security.md	始终
react.md	编辑 .tsx/.jsx 文件
typescript.md	编辑 .ts/.tsx 文件
python.md	编辑 .py 文件
nodejs-backend.md	编辑 api/routes/server 文件

更智能的压缩（PreCompact 钩子）

Claude Code 内置的压缩机制会在上下文使用率达到约 83% 时触发，并使用一个通用的 9 段模板将所有内容总结为 20,000 个 token。然而，它并不了解你的项目真正关心的内容。

PreCompact 钩子通过向总结器注入项目特定的保留优先级来解决这一问题：

┌─────────────────────────────────────────────────────────────┐
│  内置压缩：                                       │
│  “总结本次对话” → 通用摘要            │
├─────────────────────────────────────────────────────────────┤
│  使用 PreCompact 钩子：                                      │
│  “请总结，但要逐字保留所有模式决策、精确的错误信息、API 合同细节，   │
│   并按名称引用这些关键决策，同时附上当前的 Git 状态以便包含在内” → 项目感知的总结     │
└─────────────────────────────────────────────────────────────┘

该钩子会自动检测：

• 项目类型（TypeScript/Next.js、Python/FastAPI、Flutter 等）
• 模式文件（Drizzle、Prisma、SQLAlchemy）→ 告知总结器保留模式相关的讨论
• API 目录→ 告知总结器保留端点路径和合同内容
• CLAUDE.md 中的关键决策→ 告知总结器按名称引用这些决策
• Git 状态→ 注入分支、未提交的更改以及暂存文件

在正常使用过程中无额外开销，仅在压缩真正触发时才会运行。

Mnemos — 任务范围内的内存生命周期

Claude Code 的内置压缩具有损耗性且不可靠。它有时不会触发，/compact 和 /clear 命令也可能失败（尤其是在多智能体执行中），而崩溃或重启则会导致所有上下文丢失。Mnemos 提供了持久化到磁盘的结构化状态，能够抵御所有这些故障模式。

┌─────────────────────────────────────────────────────────────┐
│  默认 Claude Code          与  使用 Mnemos               │
├─────────────────────────────────────────────────────────────┤
│  盲目等待至 83.5%               持续进行四维监控│
│  突然强制压缩           分阶段触发：40→60→75→83%   │
│  统一总结            类型化：目标永远不会被清除  │
│  无跨会话记忆          自动检查点与恢复    │
│  崩溃 = 完全丢失上下文       崩溃 = 从磁盘恢复  │
│  多智能体：无共享状态     每个智能体拥有独立的结构化状态│
│  缺乏行为感知          能够检测重复读取与分散操作 │
└─────────────────────────────────────────────────────────────┘

压缩后的任务恢复（双层保障）

当压缩触发时，内置的总结器往往会丢失任务特定的状态。Mnemos 使用两个独立的层面来确保恢复：

压缩前                    压缩后

PreCompact 钩子触发                第一次工具调用 → PreToolUse 钩子触发
├── 写入紧急检查点       ├── 检测“.mnemos/just-compacted”标记
├── 根据 signals.jsonl 构建任务叙述（文件、工具等）       ├── 读取 checkpoint-latest.json
├── 输出强保留指令给总结器       ├── 将完整检查点输出到上下文中
├── 写入“.mnemos/just-compacted”标记文件                      └── Claude 现在拥有：总结 + 检查点
└── 恢复完成

第一层（尽力而为）：PreCompact 告诉总结器需要保留哪些内容，包括带有类型化清除优先级的内联检查点内容。

第二层（保证）：压缩后的 PreToolUse 注入机制会在压缩后的首次工具调用时重新注入完整的检查点。这一过程不依赖于总结器。如果没有发生压缩，快速路径耗时约 5 毫秒。

为什么不直接写入普通文件？

当然可以——但你会立刻面临以下问题：采用什么格式？何时更新？如何区分“这是关键的”和“这只是锦上添花的”？MnemoGraph 的类型化节点解决了这些问题：

节点类型	清除策略	示例
GoalNode	绝不清除	“实现认证模块”
ConstraintNode	绝不清除	“API 向后兼容性”
ResultNode	先压缩	“JWT 中间件已测试” → 保留摘要
WorkingNode	先压缩	当前推理 / 进行中的分析
ContextNode	可清除	文件内容 → 从磁盘重新读取

如果没有类型化的优先级，检查点就只是一个简单的数据块。而有了它们，系统就能明确目标 > 约束 > 工作内存 > 上下文，并在 token 预算范围内做出智能的恢复决策。

正常压缩之外的韧性

真正的价值并不在于一切顺利的情况，而是在出现问题时：

故障模式	CC 内置	Mnemos
会话崩溃/中断	上下文丢失	磁盘上的检查点仍然存在
/compact 未触发	截断至上限	疲劳钩子已在更早时写入检查点
多智能体子进程死亡	无法恢复	子进程的 .mnemos/ 中保存着结构化状态
强制重启	通用摘要	SessionStart 会重新加载完整检查点
/clear 在多智能体中失败	卡在奇怪的状态	MnemoGraph 独立于 CC 的状态

疲劳模型

通过钩子被动观察的四个维度——无需智能体之间的协作：

维度	权重	信号来源	检测内容
Token 利用率	0.40	Statusline JSON	上下文窗口的满载程度
作用域分散	0.25	PreToolUse 文件路径	智能体在不同目录之间来回切换
重复读取比例	0.20	PreToolUse 的读取调用	智能体反复读取文件（上下文损失）
错误密度	0.15	PostToolUse 的结果	智能体遇到困难（高错误率）

疲劳状态：FLOW (0–0.4) → COMPRESS (0.4–0.6) → PRE-SLEEP (0.6–0.75) → REM (0.75–0.9) → EMERGENCY (0.9+)。疲劳模型确保检查点在问题恶化之前就被写入——因此，即使在 0.85 时发生崩溃，你仍然会有来自 0.6 的最新检查点。

CLI

mnemos init                    # 初始化 .mnemos/
mnemos status                  # 节点数量 + 疲劳状态
mnemos fatigue                 # 四维详细分解
mnemos checkpoint --force      # 立即写入检查点
mnemos resume                  # 输出检查点以供会话注入
mnemos add goal "构建认证"   # 创建一个 GoalNode
mnemos bridge-icpg             # 导入 iCPG ReasonNodes

开销： 每次工具调用约 5 毫秒（快速路径），磁盘占用 84KB。Token 信号通过 statusline 自动输入。

iCPG — 基于意图的代码属性图

iCPG 不仅记录代码的功能，还追踪代码存在的原因。每次代码变更都会与一个 ReasonNode 关联，该节点捕获了代码的意图、后置条件和不变式。

icpg create "实现认证" --scope src/auth/   # 创建意图
icpg record src/auth/middleware.ts                # 链接符号
icpg query constraints src/auth/middleware.ts     # 获取不变式
icpg drift                                        # 检查偏移
icpg bootstrap                                    # 从 Git 历史推断

任务前查询（通过 PreToolUse 钩子自动注入）：

• icpg query context <file> — 哪些意图与此文件相关？
• icpg query constraints <file> — 必须满足哪些不变式？
• icpg drift file <file> — 此文件是否偏离了其初衷？

6 维度偏移检测：规范偏移、决策偏移、所有权偏移、测试偏移、使用偏移、依赖偏移。

预配置权限

.claude/settings.json 包含权限规则，以避免用户在执行常规操作时频繁被询问：

{
  "permissions": {
    "allow": [
      "Bash(npm test *)",
      "Bash(npm run lint *)",
      "Bash(pytest *)",
      "Bash(git status *)",
      "Bash(gh pr *)"
    ],
    "deny": [
      "Bash(rm -rf *)",
      "Bash(git push --force *)",
      "Write(.env)",
      "Write(.env.*)"
    ]
  }
}

CLAUDE.local.md（私有覆盖）

每位开发者都有一个被 .gitignore 排除的 CLAUDE.local.md 文件，用于存储个人偏好：

# 我的偏好
- 我更喜欢详细的解释
- 我的本地数据库运行在 5433 端口
- 使用 pnpm 而不是 npm

此文件会以更高优先级加载，覆盖项目中的 CLAUDE.md——个人偏好会优先于团队配置，而不会污染仓库。

代理团队

每个项目都以协调一致的 AI 代理团队形式运行，并配有完整的 frontmatter 定义：

# .claude/agents/team-lead.md
---
name: team-lead
description: 协调代理团队
model: sonnet
tools: [Read, Glob, Grep, TaskCreate, TaskUpdate, TaskList, TaskGet, SendMessage]
disallowedTools: [Write, Edit, Bash]
maxTurns: 50
effort: high
---

默认团队：

代理	角色	是否可编辑代码？
团队负责人	协调并分配任务（不编写代码）	否
质量代理	验证 RED/GREEN TDD 流程，覆盖率 ≥ 80%	否
安全代理	OWASP 扫描、敏感信息检测、依赖审计	否
代码审查代理	多引擎代码审查	否
合并代理	通过 gh CLI 创建功能分支和 PR	否
功能代理（x N）	每个功能一个，遵循严格的 TDD 流程	是

流程（由任务依赖关系强制执行）：

规格 > 规格评审 > 测试 > RED 验证 > 实现 >
GREEN 验证 > 验证 > 代码审查 > 安全 > 分支+PR

# 自动由 /initialize-project 启动，或手动启动：
/spawn-team

项目结构

your-project/
├── .claude/
│   ├── agents/               # 代理定义，包含 frontmatter
│   │   ├── team-lead.md      # 名称、模型、工具、禁用工具、最大轮次
│   │   ├── quality.md
│   │   ├── security.md
│   │   ├── code-review.md
│   │   ├── merger.md
│   │   └── feature.md
│   ├── rules/                # 条件规则（路径：frontmatter）
│   │   ├── quality-gates.md  # 始终生效
│   │   ├── tdd-workflow.md   # 始终生效
│   │   ├── security.md       # 始终生效
│   │   ├── react.md          # 对 .tsx/.jsx 文件生效
│   │   ├── typescript.md     # 对 .ts/.tsx 文件生效
│   │   ├── python.md         # 对 .py 文件生效
│   │   └── nodejs-backend.md # 对 api/routes/server 文件生效
│   ├── skills/               # 通过 @include 加载的能力
│   │   ├── base/SKILL.md
│   │   ├── iterative-development/SKILL.md
│   │   ├── security/SKILL.md
│   │   ├── mnemos/SKILL.md
│   │   └── [framework]/SKILL.md
│   └── settings.json         # 权限、钩子和状态栏
├── scripts/
│   ├── tdd-loop-check.sh     # TDD 循环停止钩子脚本
│   ├── icpg/                 # 基于意图的代码属性图
│   └── mnemos/               # 任务范围内的记忆生命周期
├── .mnemos/                  # Mnemos 状态（自动生成，被 .gitignore 排除）
│   ├── mnemo.db              # SQLite MnemoGraph
│   ├── fatigue.json          # 实时疲劳信号
│   ├── signals.jsonl         # 行为信号日志
│   └── checkpoint-latest.json # 最近检查点
├── .github/workflows/
│   ├── quality.yml
│   └── security.yml
├── _project_specs/
│   ├── features/
│   └── todos/
├── CLAUDE.md                 # @include 指令，项目上下文
└── CLAUDE.local.md           # 私人开发者覆盖（被 .gitignore 排除）

提交规范

┌─────────────────────────────────────────────────────────────┐
│  提交规模阈值                                     │
├─────────────────────────────────────────────────────────────┤
│  合格：≤ 5 个文件，≤ 200 行                           │
│  警告：6–10 个文件，201–400 行 → “尽快提交”        │
│  停止：> 10 个文件，> 400 行 → “立即提交”         │
└─────────────────────────────────────────────────────────────┘

包含的能力（59 项）

核心能力

能力	目的
base.md	通用模式、约束、TDD 流程、原子化待办事项
iterative-development.md	通过停止钩子实现 TDD 循环（替代 Ralph Wiggum）
mnemos.md	任务范围内的记忆生命周期——疲劳监测、检查点、类型化压缩
icpg.md	基于意图的代码属性图——追踪代码存在的原因，检测偏移
code-review.md	强制性代码审查——Claude、Codex、Gemini 或多引擎审查
codex-review.md	OpenAI Codex CLI 代码审查
gemini-review.md	Google Gemini CLI 代码审查，1M token 上下文
workspace.md	多仓库工作区意识，合约跟踪
commit-hygiene.md	原子化提交，PR 尺寸限制
code-deduplication.md	通过能力索引防止语义重复
agent-teams.md	具有完整 frontmatter 定义的代理团队工作流
ticket-craft.md	面向 Claude Code 优化的 AI 原生工单撰写
team-coordination.md	多人协作项目，共享状态，交接
code-graph.md	通过 MCP 持久化代码图
cpg-analysis.md	深度 CPG 分析——Joern + CodeQL
security.md	OWASP 模式，敏感信息管理
credentials.md	中央化 API 密钥管理
session-management.md	上下文保持，可恢复性
project-tooling.md	gh、vercel、supabase CLI + 部署
existing-repo.md	分析现有仓库，设置护栏

语言与框架技能

技能	目的
python.md	Python + ruff + mypy + pytest
typescript.md	TypeScript strict + eslint + jest
nodejs-backend.md	Express/Fastify 模式、仓库模式
react-web.md	React + hooks + React Query + Zustand
react-native.md	移动端模式、平台特定代码
android-java.md	Android Java，使用 MVVM、ViewBinding、Espresso
android-kotlin.md	Android Kotlin，使用协程、Jetpack Compose、Hilt
flutter.md	Flutter，使用 Riverpod、Freezed、go_router

UI 技能

技能	目的
ui-web.md	Web UI - Tailwind、暗黑模式、可访问性
ui-mobile.md	移动端 UI - React Native、iOS/Android 模式
ui-testing.md	视觉测试
playwright-testing.md	端到端测试 - Playwright、Page Objects
user-journeys.md	用户体验流程
pwa-development.md	渐进式 Web 应用 - service workers、离线支持

数据库与后端技能

技能	目的
database-schema.md	模式意识
supabase.md	Supabase 核心 CLI、迁移、RLS
supabase-nextjs.md	Next.js + Supabase + Drizzle ORM
supabase-python.md	FastAPI + Supabase
supabase-node.md	Express/Hono + Supabase
firebase.md	Firebase Firestore、Auth、Storage
cloudflare-d1.md	Cloudflare D1 SQLite 结合 Workers
aws-dynamodb.md	AWS DynamoDB 单表设计
aws-aurora.md	AWS Aurora Serverless v2
azure-cosmosdb.md	Azure Cosmos DB

AI 与智能体技能

技能	目的
agentic-development.md	构建 AI 智能体
llm-patterns.md	AI 驱动的应用、LLM 测试
ai-models.md	最新模型参考

内容、集成及其他技能

技能	目的
aeo-optimization.md	AI 引擎优化
web-content.md	SEO + AI 发现
site-architecture.md	技术 SEO
web-payments.md	Stripe Checkout、订阅
reddit-api.md	Reddit API
reddit-ads.md	Reddit Ads API + 智能体优化
ms-teams-apps.md	Microsoft Teams 机器人
posthog-analytics.md	PostHog 分析
shopify-apps.md	Shopify 应用开发
woocommerce.md	WooCommerce REST API
medusa.md	Medusa 无头电商
klaviyo.md	Klaviyo 邮件/SMS 营销

使用模式

新项目

mkdir my-new-app && cd my-new-app
claude
> /initialize-project

现有项目

cd my-existing-app
claude
> /initialize-project
# 自动检测现有代码 → 先进行分析

全局更新技能

cd "$(cat ~/.claude/.bootstrap-dir)"
git pull
./install.sh

前置条件

# GitHub CLI
brew install gh && gh auth login

# Vercel CLI（可选）
npm i -g vercel && vercel login

# Supabase CLI（可选）
brew install supabase/tap/supabase && supabase login

与 v2.x 的主要区别

特性	v2.x（旧版）	v3.0.0（新版）
TDD 循环	Ralph Wiggum 插件（不存在）	Stop hooks（真正的 Claude Code 基础设施）
CLAUDE.md	以文本形式列出技能	@include 指令（在解析时实际加载）
质量规则	在 CLAUDE.md 中以散文形式描述	.claude/rules/ 文件，带有 paths: 前言
代理团队	需要设置 CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1	通过 .claude/agents/ 原生支持
代理定义	纯 Markdown	正式的前言：工具、模型、最大轮次、努力程度
权限	所有操作都需要手动批准	settings.json 中预配置的允许/拒绝
开发者覆盖	无	CLAUDE.local.md（被 git 忽略，优先级更高）
框架规则	总是加载（57 项技能 = 浪费 token）	根据文件路径有条件地激活规则
压缩	通用总结	PreCompact 钩子 + Mnemos 类型化保存
内存	在压缩或新会话时丢失	Mnemos 检查点可在会话间恢复
意图跟踪	无	iCPG 将代码与原因关联，并检测偏离
执行	“严格强制执行”的文字说明	实际运行代码的钩子

贡献

请参阅 CONTRIBUTING.md 获取指南。

更改日志

请参阅 CHANGELOG.md 查看版本历史。

许可证

MIT - 请参阅 LICENSE

致谢

基于在客户体验管理、智能体 AI 平台、移动应用和全栈 Web 应用等 100 多个项目中的经验构建而成。

---

需要帮助在贵公司规模化部署 AI 吗？ Claude Code & MCP 专家

Claude Bootstrap 快速上手指南

Claude Bootstrap 是一个专为 Claude Code 设计的意见化项目初始化系统。它默认采用多智能体协作模式，强制执行严格测试驱动开发（TDD）流程、多引擎代码审查以及安全优先原则，旨在解决 AI 生成代码后的理解与维护瓶颈。

环境准备

在开始之前，请确保您的开发环境满足以下要求：

• 操作系统: macOS 或 Linux (Windows 用户建议使用 WSL2)
• 核心依赖:
  • Node.js (推荐 LTS 版本)
  • Git
  • Claude Code CLI (必须已安装并登录)
• 可选工具链 (根据项目类型自动检测):
  • gh (GitHub CLI)
  • vercel (Vercel CLI)
  • supabase (Supabase CLI)

注意: 本工具深度集成 Claude Code 的原生 Hook 机制，无需安装额外插件。

安装步骤

1. 克隆与安装

将仓库克隆到任意目录并运行安装脚本。该脚本会自动配置全局钩子和基础规则。

# 克隆仓库
git clone https://github.com/alinaqi/claude-bootstrap.git

# 进入目录并执行安装
cd claude-bootstrap && ./install.sh

国内加速提示: 如果克隆速度较慢，可使用国内镜像源：

git clone https://gitee.com/mirror/claude-bootstrap.git # 示例镜像，请替换为实际可用的国内源
# 或者使用代理
git clone https://github.com/alinaqi/claude-bootstrap.git --config http.proxy=http://127.0.0.1:7890

2. 验证安装

安装完成后，您可以在任何新的或现有的项目目录中启动 Claude 来验证。

基本使用

初始化新项目

进入您的项目目录（或新建一个空目录），启动 Claude 并运行初始化命令：

cd my-new-project
claude

在 Claude 交互界面中输入：

> /initialize-project

初始化流程说明

执行 /initialize-project 后，Claude Bootstrap 将自动引导您完成以下步骤：

1. 工具验证: 检查 gh, vercel, supabase 等 CLI 是否可用。
2. 项目配置问答:
   • 选择编程语言与框架
   • 确认是否为 "AI First" 项目
   • 选择数据库类型
   • 设定代码图谱分析级别
3. 仓库设置: 自动创建或连接 GitHub 仓库。
4. 架构生成: 创建标准化的目录结构，包含技能库 (Skills)、规则 (Rules)、安全配置、CI/CD 流水线及规范文档。
5. 配置注入:
   • 复制预配置的 settings.json (含权限控制与 Stop Hooks)。
   • 生成模块化的 CLAUDE.md (使用 @include 指令加载技能)。
   • 生成 CLAUDE.local.md 模板供开发者私有覆盖。
6. 部署智能体团队: 自动激活由 Team Lead, Quality, Security, Review, Merger 和 Feature 组成的多智能体协作网络。

核心工作机制：TDD 循环 (Stop Hooks)

初始化后，系统将自动启用 TDD 闭环。您无需手动运行测试，系统会在每次 AI 响应结束后自动拦截并执行验证：

1. 您发出指令（例如："为注册功能添加邮箱验证"）。
2. Claude 编写测试用例并实现代码。
3. Claude 结束响应。
4. Stop Hook 自动触发: 运行 npm test && npm run lint。
5. 结果处理:
   • 通过 (Exit 0): 任务完成。
   • 失败 (Exit 2): 错误信息自动反馈给 Claude，触发其自动修复并重新提交，直到测试全部通过。

此过程完全基于 Claude Code 原生基础设施，无需伪造命令或安装第三方插件。

进阶特性概览

• 条件化规则: 规则仅在编辑特定文件时激活（如编辑 .tsx 时加载 React 规则），节省 Token 并减少干扰。
• 智能压缩 (PreCompact Hook): 在上下文窗口即将满时，自动注入项目特定的保留优先级（如 Schema 定义、API 契约），防止关键信息丢失。
• Mnemos 记忆系统: 提供基于磁盘的持久化状态存储，即使会话崩溃、重启或多智能体执行中断，也能保证任务上下文和目标的完整恢复。