[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"similar-alinaqi--claude-bootstrap":3,"tool-alinaqi--claude-bootstrap":61},[4,18,26,36,44,53],{"id":5,"name":6,"github_repo":7,"description_zh":8,"stars":9,"difficulty_score":10,"last_commit_at":11,"category_tags":12,"status":17},4358,"openclaw","openclaw\u002Fopenclaw","OpenClaw 是一款专为个人打造的本地化 AI 助手，旨在让你在自己的设备上拥有完全可控的智能伙伴。它打破了传统 AI 助手局限于特定网页或应用的束缚，能够直接接入你日常使用的各类通讯渠道，包括微信、WhatsApp、Telegram、Discord、iMessage 等数十种平台。无论你在哪个聊天软件中发送消息，OpenClaw 都能即时响应，甚至支持在 macOS、iOS 和 Android 设备上进行语音交互，并提供实时的画布渲染功能供你操控。\n\n这款工具主要解决了用户对数据隐私、响应速度以及“始终在线”体验的需求。通过将 AI 部署在本地，用户无需依赖云端服务即可享受快速、私密的智能辅助，真正实现了“你的数据，你做主”。其独特的技术亮点在于强大的网关架构，将控制平面与核心助手分离，确保跨平台通信的流畅性与扩展性。\n\nOpenClaw 非常适合希望构建个性化工作流的技术爱好者、开发者，以及注重隐私保护且不愿被单一生态绑定的普通用户。只要具备基础的终端操作能力（支持 macOS、Linux 及 Windows WSL2），即可通过简单的命令行引导完成部署。如果你渴望拥有一个懂你",349277,3,"2026-04-06T06:32:30",[13,14,15,16],"Agent","开发框架","图像","数据工具","ready",{"id":19,"name":20,"github_repo":21,"description_zh":22,"stars":23,"difficulty_score":10,"last_commit_at":24,"category_tags":25,"status":17},3808,"stable-diffusion-webui","AUTOMATIC1111\u002Fstable-diffusion-webui","stable-diffusion-webui 是一个基于 Gradio 构建的网页版操作界面，旨在让用户能够轻松地在本地运行和使用强大的 Stable Diffusion 图像生成模型。它解决了原始模型依赖命令行、操作门槛高且功能分散的痛点，将复杂的 AI 绘图流程整合进一个直观易用的图形化平台。\n\n无论是希望快速上手的普通创作者、需要精细控制画面细节的设计师，还是想要深入探索模型潜力的开发者与研究人员，都能从中获益。其核心亮点在于极高的功能丰富度：不仅支持文生图、图生图、局部重绘（Inpainting）和外绘（Outpainting）等基础模式，还独创了注意力机制调整、提示词矩阵、负向提示词以及“高清修复”等高级功能。此外，它内置了 GFPGAN 和 CodeFormer 等人脸修复工具，支持多种神经网络放大算法，并允许用户通过插件系统无限扩展能力。即使是显存有限的设备，stable-diffusion-webui 也提供了相应的优化选项，让高质量的 AI 艺术创作变得触手可及。",162132,"2026-04-05T11:01:52",[14,15,13],{"id":27,"name":28,"github_repo":29,"description_zh":30,"stars":31,"difficulty_score":32,"last_commit_at":33,"category_tags":34,"status":17},1381,"everything-claude-code","affaan-m\u002Feverything-claude-code","everything-claude-code 是一套专为 AI 编程助手（如 Claude Code、Codex、Cursor 等）打造的高性能优化系统。它不仅仅是一组配置文件，而是一个经过长期实战打磨的完整框架，旨在解决 AI 代理在实际开发中面临的效率低下、记忆丢失、安全隐患及缺乏持续学习能力等核心痛点。\n\n通过引入技能模块化、直觉增强、记忆持久化机制以及内置的安全扫描功能，everything-claude-code 能显著提升 AI 在复杂任务中的表现，帮助开发者构建更稳定、更智能的生产级 AI 代理。其独特的“研究优先”开发理念和针对 Token 消耗的优化策略，使得模型响应更快、成本更低，同时有效防御潜在的攻击向量。\n\n这套工具特别适合软件开发者、AI 研究人员以及希望深度定制 AI 工作流的技术团队使用。无论您是在构建大型代码库，还是需要 AI 协助进行安全审计与自动化测试，everything-claude-code 都能提供强大的底层支持。作为一个曾荣获 Anthropic 黑客大奖的开源项目，它融合了多语言支持与丰富的实战钩子（hooks），让 AI 真正成长为懂上",146793,2,"2026-04-08T23:32:35",[14,13,35],"语言模型",{"id":37,"name":38,"github_repo":39,"description_zh":40,"stars":41,"difficulty_score":32,"last_commit_at":42,"category_tags":43,"status":17},2271,"ComfyUI","Comfy-Org\u002FComfyUI","ComfyUI 是一款功能强大且高度模块化的视觉 AI 引擎，专为设计和执行复杂的 Stable Diffusion 图像生成流程而打造。它摒弃了传统的代码编写模式，采用直观的节点式流程图界面，让用户通过连接不同的功能模块即可构建个性化的生成管线。\n\n这一设计巧妙解决了高级 AI 绘图工作流配置复杂、灵活性不足的痛点。用户无需具备编程背景，也能自由组合模型、调整参数并实时预览效果，轻松实现从基础文生图到多步骤高清修复等各类复杂任务。ComfyUI 拥有极佳的兼容性，不仅支持 Windows、macOS 和 Linux 全平台，还广泛适配 NVIDIA、AMD、Intel 及苹果 Silicon 等多种硬件架构，并率先支持 SDXL、Flux、SD3 等前沿模型。\n\n无论是希望深入探索算法潜力的研究人员和开发者，还是追求极致创作自由度的设计师与资深 AI 绘画爱好者，ComfyUI 都能提供强大的支持。其独特的模块化架构允许社区不断扩展新功能，使其成为当前最灵活、生态最丰富的开源扩散模型工具之一，帮助用户将创意高效转化为现实。",108111,"2026-04-08T11:23:26",[14,15,13],{"id":45,"name":46,"github_repo":47,"description_zh":48,"stars":49,"difficulty_score":32,"last_commit_at":50,"category_tags":51,"status":17},4721,"markitdown","microsoft\u002Fmarkitdown","MarkItDown 是一款由微软 AutoGen 团队打造的轻量级 Python 工具，专为将各类文件高效转换为 Markdown 格式而设计。它支持 PDF、Word、Excel、PPT、图片（含 OCR）、音频（含语音转录）、HTML 乃至 YouTube 链接等多种格式的解析，能够精准提取文档中的标题、列表、表格和链接等关键结构信息。\n\n在人工智能应用日益普及的今天，大语言模型（LLM）虽擅长处理文本，却难以直接读取复杂的二进制办公文档。MarkItDown 恰好解决了这一痛点，它将非结构化或半结构化的文件转化为模型“原生理解”且 Token 效率极高的 Markdown 格式，成为连接本地文件与 AI 分析 pipeline 的理想桥梁。此外，它还提供了 MCP（模型上下文协议）服务器，可无缝集成到 Claude Desktop 等 LLM 应用中。\n\n这款工具特别适合开发者、数据科学家及 AI 研究人员使用，尤其是那些需要构建文档检索增强生成（RAG）系统、进行批量文本分析或希望让 AI 助手直接“阅读”本地文件的用户。虽然生成的内容也具备一定可读性，但其核心优势在于为机器",93400,"2026-04-06T19:52:38",[52,14],"插件",{"id":54,"name":55,"github_repo":56,"description_zh":57,"stars":58,"difficulty_score":10,"last_commit_at":59,"category_tags":60,"status":17},4487,"LLMs-from-scratch","rasbt\u002FLLMs-from-scratch","LLMs-from-scratch 是一个基于 PyTorch 的开源教育项目，旨在引导用户从零开始一步步构建一个类似 ChatGPT 的大型语言模型（LLM）。它不仅是同名技术著作的官方代码库，更提供了一套完整的实践方案，涵盖模型开发、预训练及微调的全过程。\n\n该项目主要解决了大模型领域“黑盒化”的学习痛点。许多开发者虽能调用现成模型，却难以深入理解其内部架构与训练机制。通过亲手编写每一行核心代码，用户能够透彻掌握 Transformer 架构、注意力机制等关键原理，从而真正理解大模型是如何“思考”的。此外，项目还包含了加载大型预训练权重进行微调的代码，帮助用户将理论知识延伸至实际应用。\n\nLLMs-from-scratch 特别适合希望深入底层原理的 AI 开发者、研究人员以及计算机专业的学生。对于不满足于仅使用 API，而是渴望探究模型构建细节的技术人员而言，这是极佳的学习资源。其独特的技术亮点在于“循序渐进”的教学设计：将复杂的系统工程拆解为清晰的步骤，配合详细的图表与示例，让构建一个虽小但功能完备的大模型变得触手可及。无论你是想夯实理论基础，还是为未来研发更大规模的模型做准备",90106,"2026-04-06T11:19:32",[35,15,13,14],{"id":62,"github_repo":63,"name":64,"description_en":65,"description_zh":66,"ai_summary_zh":66,"readme_en":67,"readme_zh":68,"quickstart_zh":69,"use_case_zh":70,"hero_image_url":71,"owner_login":72,"owner_name":73,"owner_avatar_url":74,"owner_bio":75,"owner_company":76,"owner_location":77,"owner_email":76,"owner_twitter":76,"owner_website":76,"owner_url":78,"languages":79,"stars":88,"forks":89,"last_commit_at":90,"license":91,"difficulty_score":32,"env_os":92,"env_gpu":93,"env_ram":93,"env_deps":94,"category_tags":102,"github_topics":103,"view_count":32,"oss_zip_url":76,"oss_zip_packed_at":76,"status":17,"created_at":113,"updated_at":114,"faqs":115,"releases":146},5759,"alinaqi\u002Fclaude-bootstrap","claude-bootstrap","Opinionated project initialization for Claude Code. Security-first, spec-driven, AI-native.","claude-bootstrap 是专为 Claude Code 打造的项目初始化系统，旨在通过“安全优先、规范驱动”的理念，为 AI 生成的代码建立可靠护栏。当前 AI 编码的瓶颈已从“生成”转向“理解与维护”，该工具通过严格的测试驱动开发（TDD）流程解决这一痛点：它利用停止钩子（Stop Hooks）在每次 AI 响应后自动运行测试，确保代码在通过验证前绝不交付，从而保证产出简洁、安全且可验证。\n\n这套系统特别适合追求高质量工程实践的开发者团队。其核心亮点在于默认采用\"AI 代理团队”协作模式，将项目拆解为由不同角色代理协同完成的任务；同时实施极致的代码简约原则（如单函数不超过 20 行），并具备基于文件路径的条件规则机制，仅在编辑特定类型文件时加载对应规范，有效节省上下文资源。此外，最新版本引入了意图增强的代码属性图谱与多层级记忆恢复技术，能精准追踪代码演变、防止重复劳动，并在会话中断时无缝恢复上下文。只需简单命令，claude-bootstrap 即可自动配置包含技能库、安全策略及 CI\u002FCD 在内的完整开发环境，让开发者从繁琐的设置中解放，专注于核心逻辑构建。","# Claude Bootstrap\n\n> An opinionated project initialization system for Claude Code. **Agent teams by default, strict TDD pipeline, multi-engine code review, security-first.**\n\n**The bottleneck has moved from code generation to code comprehension.** AI can generate infinite code, but humans still need to review, understand, and maintain it. Claude Bootstrap provides guardrails that keep AI-generated code simple, secure, and verifiable.\n\n**New in v3.3.1:** Mnemos two-layer post-compaction task restoration — guaranteed context recovery when Claude Code's compaction fires, crashes, or doesn't run. Typed memory graph (goals never evicted), 4-dimension fatigue monitoring, checkpoint\u002Fresume across sessions. iCPG intent-augmented code property graph — track why code exists, detect drift, prevent duplicate work.\n\n## Core Philosophy\n\n```\n┌────────────────────────────────────────────────────────────────┐\n│  TDD LOOPS VIA STOP HOOKS                                      │\n│  ─────────────────────────────────────────────────────────────│\n│  Stop hooks run tests after each Claude response.              │\n│  Failures feed back automatically. Claude iterates until green.│\n│  Real Claude Code infrastructure — no plugins needed.          │\n├────────────────────────────────────────────────────────────────┤\n│  TESTS FIRST, ALWAYS                                           │\n│  ─────────────────────────────────────────────────────────────│\n│  Features: Write tests → Watch them fail → Implement → Pass    │\n│  Bugs: Find test gap → Write failing test → Fix → Pass         │\n│  No code ships without a test that failed first.               │\n├────────────────────────────────────────────────────────────────┤\n│  SIMPLICITY IS THE GOAL                                        │\n│  ─────────────────────────────────────────────────────────────│\n│  20 lines per function │ 200 lines per file │ 3 params max     │\n│  Enforced via .claude\u002Frules\u002F with paths: frontmatter.          │\n├────────────────────────────────────────────────────────────────┤\n│  SECURITY BY DEFAULT                                           │\n│  ─────────────────────────────────────────────────────────────│\n│  No secrets in code │ Permission deny rules for .env files     │\n│  Dependency scanning │ Pre-commit hooks │ CI enforcement       │\n├────────────────────────────────────────────────────────────────┤\n│  AGENT TEAMS BY DEFAULT                                        │\n│  ─────────────────────────────────────────────────────────────│\n│  Every project runs as a coordinated team of AI agents.        │\n│  Agent definitions use proper frontmatter: tools, model,       │\n│  maxTurns, effort, disallowedTools.                            │\n├────────────────────────────────────────────────────────────────┤\n│  CONDITIONAL RULES                                             │\n│  ─────────────────────────────────────────────────────────────│\n│  Rules in .claude\u002Frules\u002F activate based on file paths.         │\n│  React rules only load when editing .tsx files.                │\n│  Python rules only load when editing .py files.                │\n│  Saves tokens. Reduces noise. More targeted guidance.          │\n└────────────────────────────────────────────────────────────────┘\n```\n\n## Quick Start\n\n```bash\n# Clone and install (clone anywhere you like)\ngit clone https:\u002F\u002Fgithub.com\u002Falinaqi\u002Fclaude-bootstrap.git\ncd claude-bootstrap && .\u002Finstall.sh\n\n# In any project directory\nclaude\n> \u002Finitialize-project\n```\n\nClaude will:\n1. **Validate tools** - Check gh, vercel, supabase CLIs\n2. **Ask questions** - Language, framework, AI-first?, database, graph analysis level\n3. **Set up repository** - Create or connect GitHub repo\n4. **Create structure** - Skills, rules, settings, security, CI\u002FCD, specs, todos\n5. **Copy settings.json** - Pre-configured permissions and Stop hooks\n6. **Generate CLAUDE.md** - With `@include` directives for modular skills\n7. **Generate CLAUDE.local.md** - Template for private developer overrides\n8. **Spawn agent team** - Deploy Team Lead + Quality + Security + Review + Merger + Feature agents\n\n## How TDD Loops Work (Stop Hooks)\n\n**No plugins. No fake commands.** Claude Code's Stop hook runs a script when Claude finishes a response. Exit code 2 feeds stderr back to Claude and continues the conversation.\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│  1. You say: \"Add email validation to signup\"               │\n│  2. Claude writes tests + implementation                    │\n│  3. Claude finishes response                                │\n│  4. Stop hook runs: npm test && npm run lint                │\n│  5a. All pass (exit 0) → Done!                              │\n│  5b. Failures (exit 2) → stderr fed back to Claude          │\n│  6. Claude sees failures, fixes, finishes again             │\n│  7. Stop hook runs again → repeat until green               │\n└─────────────────────────────────────────────────────────────┘\n```\n\n**Configuration** in `.claude\u002Fsettings.json`:\n\n```json\n{\n  \"hooks\": {\n    \"Stop\": [{\n      \"hooks\": [{\n        \"type\": \"command\",\n        \"command\": \"scripts\u002Ftdd-loop-check.sh\",\n        \"timeout\": 60,\n        \"statusMessage\": \"Running tests...\"\n      }]\n    }]\n  }\n}\n```\n\nThe `tdd-loop-check.sh` script runs tests, lint, and typecheck. It tracks iteration count (max 25) and distinguishes code errors (loop) from environment errors (stop).\n\n## @include Directives\n\nCLAUDE.md uses `@include` to modularly load skills:\n\n```markdown\n# CLAUDE.md\n@.claude\u002Fskills\u002Fbase\u002FSKILL.md\n@.claude\u002Fskills\u002Fiterative-development\u002FSKILL.md\n@.claude\u002Fskills\u002Fsecurity\u002FSKILL.md\n```\n\nThese are **resolved at load time** by Claude Code — the content is recursively inlined (max depth 5, cycle detection built in). This means skills actually become part of the prompt instead of just being listed as text.\n\n## Conditional Rules\n\nRules in `.claude\u002Frules\u002F` use YAML frontmatter with `paths:` to activate only when relevant files are being edited:\n\n```yaml\n# .claude\u002Frules\u002Freact.md\n---\npaths: [\"src\u002Fcomponents\u002F**\", \"**\u002F*.tsx\"]\n---\nPrefer functional components with hooks...\n```\n\n```yaml\n# .claude\u002Frules\u002Fpython.md\n---\npaths: [\"**\u002F*.py\"]\n---\nUse type hints, pytest, ruff...\n```\n\n**Included rules:**\n\n| Rule | Activates When |\n|------|----------------|\n| `quality-gates.md` | Always (no paths: filter) |\n| `tdd-workflow.md` | Always |\n| `security.md` | Always |\n| `react.md` | Editing .tsx\u002F.jsx files |\n| `typescript.md` | Editing .ts\u002F.tsx files |\n| `python.md` | Editing .py files |\n| `nodejs-backend.md` | Editing api\u002Froutes\u002Fserver files |\n\n## Smarter Compaction (PreCompact Hook)\n\nClaude Code's built-in compaction fires at ~83% context and summarizes everything into 20K tokens using a generic 9-section template. It doesn't know what YOUR project cares about.\n\nThe PreCompact hook fixes this by injecting **project-specific preservation priorities** into the summarizer:\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│  Built-in compaction:                                       │\n│  \"Summarize this conversation\" → generic summary            │\n├─────────────────────────────────────────────────────────────┤\n│  With PreCompact hook:                                      │\n│  \"Summarize, but preserve ALL schema decisions verbatim,    │\n│   keep exact error messages, keep API contract details,     │\n│   reference these Key Decisions by name, and here's the     │\n│   current git state to include\" → project-aware summary     │\n└─────────────────────────────────────────────────────────────┘\n```\n\nThe hook auto-detects:\n- **Project type** (TypeScript\u002FNext.js, Python\u002FFastAPI, Flutter, etc.)\n- **Schema files** (Drizzle, Prisma, SQLAlchemy) → tells summarizer to preserve schema discussion\n- **API directories** → tells summarizer to preserve endpoint paths and contracts\n- **Key Decisions from CLAUDE.md** → tells summarizer to reference them by name\n- **Git state** → injects branch, uncommitted changes, staged files\n\nZero overhead during normal usage. Only runs when compaction actually fires.\n\n## Mnemos — Task-Scoped Memory Lifecycle\n\nClaude Code's built-in compaction is lossy and unreliable. It sometimes doesn't fire, `\u002Fcompact` and `\u002Fclear` can fail (especially in multi-agent executions), and crashes\u002Frestarts lose all context. Mnemos provides **disk-persistent structured state** that survives all of these failure modes.\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│  DEFAULT CLAUDE CODE          vs  WITH MNEMOS               │\n├─────────────────────────────────────────────────────────────┤\n│  Blind until 83.5%               Continuous 4-dim monitoring│\n│  Sudden hard compaction           Graduated: 40→60→75→83%   │\n│  Uniform summarization            Typed: goals never evict  │\n│  No cross-session memory          Auto checkpoint\u002Fresume    │\n│  Crash = total context loss       Crash = resume from disk  │\n│  Multi-agent: no shared state     Per-agent structured state│\n│  No behavioral awareness          Detects re-reads, scatter │\n└─────────────────────────────────────────────────────────────┘\n```\n\n### Post-Compaction Task Restoration (Two-Layer Defense)\n\nWhen compaction fires, the built-in summarizer often drops task-specific state. Mnemos uses two independent layers to guarantee restoration:\n\n```\nBEFORE COMPACTION                    AFTER COMPACTION\n\nPreCompact hook fires                First tool call → PreToolUse fires\n├── Write emergency checkpoint       ├── Detect \".mnemos\u002Fjust-compacted\" marker\n├── Build task narrative from        ├── Read checkpoint-latest.json\n│   signals.jsonl (files, tools)     ├── Output full checkpoint into context\n├── Output STRONG preservation       ├── Delete marker (one-shot)\n│   instructions to summarizer       └── Claude now has: summary + checkpoint\n└── Write \".mnemos\u002Fjust-compacted\"\n    marker file                      = Task fully restored\n```\n\n**Layer 1** (best-effort): PreCompact tells the summarizer what to keep, including inline checkpoint content with typed eviction priorities.\n\n**Layer 2** (guaranteed): Post-compaction injection via PreToolUse re-injects the full checkpoint on the first tool call after compaction. Doesn't depend on the summarizer. Fast path ~5ms when no compaction occurred.\n\n### Why Not Just Write to a Plain File?\n\nYou could — but you'd immediately face: what format? When to update? How to distinguish \"this is critical\" from \"this is nice to have\"? The MnemoGraph's typed nodes solve this:\n\n| Node Type | Eviction Policy | Example |\n|-----------|----------------|---------|\n| GoalNode | NEVER evict | \"Implement auth module\" |\n| ConstraintNode | NEVER evict | \"API backward compatibility\" |\n| ResultNode | Compress first | \"JWT middleware tested\" → summary kept |\n| WorkingNode | Compress first | Current reasoning \u002F in-progress analysis |\n| ContextNode | Evictable | File contents → re-read from disk |\n\nWithout typed priorities, a checkpoint is just a blob. With them, the system knows goals > constraints > working memory > context, and makes intelligent decisions about what to restore within token budgets.\n\n### Resilience Beyond Normal Compaction\n\nThe real value isn't the happy path — it's when things go wrong:\n\n| Failure Mode | CC Built-in | Mnemos |\n|---|---|---|\n| Session crash\u002Fcollapse | Context gone | Checkpoint on disk survives |\n| `\u002Fcompact` doesn't fire | Truncation at limit | Fatigue hooks wrote checkpoints earlier |\n| Multi-agent child dies | No recovery | Child's `.mnemos\u002F` has structured state |\n| Forced restart | Generic summary | SessionStart reloads full checkpoint |\n| `\u002Fclear` fails in multi-agent | Stuck in weird state | MnemoGraph is independent of CC's state |\n\n### Fatigue Model\n\n4 dimensions passively observed from hooks — no agent cooperation needed:\n\n| Dimension | Weight | Signal Source | Detects |\n|-----------|--------|---------------|---------|\n| Token utilization | 0.40 | Statusline JSON | How full the context window is |\n| Scope scatter | 0.25 | PreToolUse file paths | Agent bouncing between directories |\n| Re-read ratio | 0.20 | PreToolUse Read calls | Agent re-reading files (context loss) |\n| Error density | 0.15 | PostToolUse outcomes | Agent struggling (high error rate) |\n\nFatigue states: **FLOW** (0-0.4) → **COMPRESS** (0.4-0.6) → **PRE-SLEEP** (0.6-0.75) → **REM** (0.75-0.9) → **EMERGENCY** (0.9+). The fatigue model ensures checkpoints are written *before* things go wrong — so when a crash happens at 0.85, you have a recent checkpoint from 0.6.\n\n### CLI\n\n```bash\nmnemos init                    # Initialize .mnemos\u002F\nmnemos status                  # Node counts + fatigue\nmnemos fatigue                 # Detailed 4-dimension breakdown\nmnemos checkpoint --force      # Write checkpoint now\nmnemos resume                  # Output checkpoint for session inject\nmnemos add goal \"Build auth\"   # Create a GoalNode\nmnemos bridge-icpg             # Import iCPG ReasonNodes\n```\n\n**Overhead:** ~5ms per tool call (fast path), 84KB on disk. Token signal auto-feeds via statusline.\n\n## iCPG — Intent-Augmented Code Property Graph\n\niCPG tracks *why* code exists, not just what it does. Every code change is linked to a ReasonNode that captures the intent, postconditions, and invariants.\n\n```bash\nicpg create \"Implement auth\" --scope src\u002Fauth\u002F   # Create intent\nicpg record src\u002Fauth\u002Fmiddleware.ts                # Link symbols\nicpg query constraints src\u002Fauth\u002Fmiddleware.ts     # Get invariants\nicpg drift                                        # Check for drift\nicpg bootstrap                                    # Infer from git history\n```\n\n**Pre-Task Queries** (injected automatically via PreToolUse hook):\n- `icpg query context \u003Cfile>` — What intents touch this file?\n- `icpg query constraints \u003Cfile>` — What invariants must hold?\n- `icpg drift file \u003Cfile>` — Has this file drifted from its intent?\n\n**6-Dimension Drift Detection:** spec drift, decision drift, ownership drift, test drift, usage drift, dependency drift.\n\n## Pre-configured Permissions\n\n`.claude\u002Fsettings.json` includes permission rules so users don't get pestered for routine operations:\n\n```json\n{\n  \"permissions\": {\n    \"allow\": [\n      \"Bash(npm test *)\",\n      \"Bash(npm run lint *)\",\n      \"Bash(pytest *)\",\n      \"Bash(git status *)\",\n      \"Bash(gh pr *)\"\n    ],\n    \"deny\": [\n      \"Bash(rm -rf *)\",\n      \"Bash(git push --force *)\",\n      \"Write(.env)\",\n      \"Write(.env.*)\"\n    ]\n  }\n}\n```\n\n## CLAUDE.local.md (Private Overrides)\n\nEach developer gets a `.gitignore`'d `CLAUDE.local.md` for personal preferences:\n\n```markdown\n# My Preferences\n- I prefer verbose explanations\n- My local DB runs on port 5433\n- Use pnpm instead of npm\n```\n\nThis loads at **higher priority** than project `CLAUDE.md` — personal preferences override team config without polluting the repo.\n\n## Agent Teams\n\nEvery project runs as a coordinated team of AI agents with **proper frontmatter definitions**:\n\n```yaml\n# .claude\u002Fagents\u002Fteam-lead.md\n---\nname: team-lead\ndescription: Orchestrates the agent team\nmodel: sonnet\ntools: [Read, Glob, Grep, TaskCreate, TaskUpdate, TaskList, TaskGet, SendMessage]\ndisallowedTools: [Write, Edit, Bash]\nmaxTurns: 50\neffort: high\n---\n```\n\n**Default Team:**\n\n| Agent | Role | Can Edit Code? |\n|-------|------|----------------|\n| **Team Lead** | Orchestrates, assigns tasks (never writes code) | No |\n| **Quality Agent** | Verifies RED\u002FGREEN TDD phases, coverage >= 80% | No |\n| **Security Agent** | OWASP scanning, secrets detection, dependency audit | No |\n| **Code Review Agent** | Multi-engine reviews | No |\n| **Merger Agent** | Creates feature branches and PRs via `gh` CLI | No |\n| **Feature Agent (x N)** | One per feature, follows strict TDD pipeline | Yes |\n\n**Pipeline (enforced by task dependencies):**\n\n```\nSpec > Spec Review > Tests > RED Verify > Implement >\nGREEN Verify > Validate > Code Review > Security > Branch+PR\n```\n\n```bash\n# Auto-spawned by \u002Finitialize-project, or manually:\n\u002Fspawn-team\n```\n\n## What Gets Created\n\n```\nyour-project\u002F\n├── .claude\u002F\n│   ├── agents\u002F               # Agent definitions with frontmatter\n│   │   ├── team-lead.md      # name, model, tools, disallowedTools, maxTurns\n│   │   ├── quality.md\n│   │   ├── security.md\n│   │   ├── code-review.md\n│   │   ├── merger.md\n│   │   └── feature.md\n│   ├── rules\u002F                # Conditional rules (paths: frontmatter)\n│   │   ├── quality-gates.md  # Always active\n│   │   ├── tdd-workflow.md   # Always active\n│   │   ├── security.md       # Always active\n│   │   ├── react.md          # Active on .tsx\u002F.jsx files\n│   │   ├── typescript.md     # Active on .ts\u002F.tsx files\n│   │   ├── python.md         # Active on .py files\n│   │   └── nodejs-backend.md # Active on api\u002Froutes\u002Fserver files\n│   ├── skills\u002F               # Skills loaded via @include\n│   │   ├── base\u002FSKILL.md\n│   │   ├── iterative-development\u002FSKILL.md\n│   │   ├── security\u002FSKILL.md\n│   │   ├── mnemos\u002FSKILL.md\n│   │   └── [framework]\u002FSKILL.md\n│   └── settings.json         # Permissions + hooks + statusline\n├── scripts\u002F\n│   ├── tdd-loop-check.sh     # Stop hook script for TDD loops\n│   ├── icpg\u002F                 # Intent-Augmented Code Property Graph\n│   └── mnemos\u002F               # Task-Scoped Memory Lifecycle\n├── .mnemos\u002F                  # Mnemos state (auto-created, gitignored)\n│   ├── mnemo.db              # SQLite MnemoGraph\n│   ├── fatigue.json          # Live fatigue signal\n│   ├── signals.jsonl         # Behavioral signal log\n│   └── checkpoint-latest.json # Most recent checkpoint\n├── .github\u002Fworkflows\u002F\n│   ├── quality.yml\n│   └── security.yml\n├── _project_specs\u002F\n│   ├── features\u002F\n│   └── todos\u002F\n├── CLAUDE.md                 # @include directives, project context\n└── CLAUDE.local.md           # Private developer overrides (gitignored)\n```\n\n## Commit Hygiene\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│  COMMIT SIZE THRESHOLDS                                     │\n├─────────────────────────────────────────────────────────────┤\n│  OK:     ≤ 5 files,  ≤ 200 lines                           │\n│  WARN:   6-10 files, 201-400 lines  → \"Commit soon\"        │\n│  STOP:   > 10 files, > 400 lines    → \"Commit NOW\"         │\n└─────────────────────────────────────────────────────────────┘\n```\n\n## Skills Included (59 Skills)\n\n### Core Skills\n| Skill | Purpose |\n|-------|---------|\n| `base.md` | Universal patterns, constraints, TDD workflow, atomic todos |\n| `iterative-development.md` | TDD loops via Stop hooks (replaces Ralph Wiggum) |\n| `mnemos.md` | Task-scoped memory lifecycle — fatigue monitoring, checkpoints, typed compaction |\n| `icpg.md` | Intent-augmented code property graph — track why code exists, detect drift |\n| `code-review.md` | Mandatory code reviews - Claude, Codex, Gemini, or multi-engine |\n| `codex-review.md` | OpenAI Codex CLI code review |\n| `gemini-review.md` | Google Gemini CLI code review, 1M token context |\n| `workspace.md` | Multi-repo workspace awareness, contract tracking |\n| `commit-hygiene.md` | Atomic commits, PR size limits |\n| `code-deduplication.md` | Prevent semantic duplication with capability index |\n| `agent-teams.md` | Agent team workflow with proper frontmatter definitions |\n| `ticket-craft.md` | AI-native ticket writing optimized for Claude Code |\n| `team-coordination.md` | Multi-person projects, shared state, handoffs |\n| `code-graph.md` | Persistent code graph via MCP |\n| `cpg-analysis.md` | Deep CPG analysis - Joern + CodeQL |\n| `security.md` | OWASP patterns, secrets management |\n| `credentials.md` | Centralized API key management |\n| `session-management.md` | Context preservation, resumability |\n| `project-tooling.md` | gh, vercel, supabase CLI + deployment |\n| `existing-repo.md` | Analyze existing repos, setup guardrails |\n\n### Language & Framework Skills\n| Skill | Purpose |\n|-------|---------|\n| `python.md` | Python + ruff + mypy + pytest |\n| `typescript.md` | TypeScript strict + eslint + jest |\n| `nodejs-backend.md` | Express\u002FFastify patterns, repositories |\n| `react-web.md` | React + hooks + React Query + Zustand |\n| `react-native.md` | Mobile patterns, platform-specific code |\n| `android-java.md` | Android Java with MVVM, ViewBinding, Espresso |\n| `android-kotlin.md` | Android Kotlin with Coroutines, Jetpack Compose, Hilt |\n| `flutter.md` | Flutter with Riverpod, Freezed, go_router |\n\n### UI Skills\n| Skill | Purpose |\n|-------|---------|\n| `ui-web.md` | Web UI - Tailwind, dark mode, accessibility |\n| `ui-mobile.md` | Mobile UI - React Native, iOS\u002FAndroid patterns |\n| `ui-testing.md` | Visual testing |\n| `playwright-testing.md` | E2E testing - Playwright, Page Objects |\n| `user-journeys.md` | User experience flows |\n| `pwa-development.md` | Progressive Web Apps - service workers, offline |\n\n### Database & Backend Skills\n| Skill | Purpose |\n|-------|---------|\n| `database-schema.md` | Schema awareness |\n| `supabase.md` | Core Supabase CLI, migrations, RLS |\n| `supabase-nextjs.md` | Next.js + Supabase + Drizzle ORM |\n| `supabase-python.md` | FastAPI + Supabase |\n| `supabase-node.md` | Express\u002FHono + Supabase |\n| `firebase.md` | Firebase Firestore, Auth, Storage |\n| `cloudflare-d1.md` | Cloudflare D1 SQLite with Workers |\n| `aws-dynamodb.md` | AWS DynamoDB single-table design |\n| `aws-aurora.md` | AWS Aurora Serverless v2 |\n| `azure-cosmosdb.md` | Azure Cosmos DB |\n\n### AI & Agentic Skills\n| Skill | Purpose |\n|-------|---------|\n| `agentic-development.md` | Build AI agents |\n| `llm-patterns.md` | AI-first apps, LLM testing |\n| `ai-models.md` | Latest models reference |\n\n### Content, Integration & Other Skills\n| Skill | Purpose |\n|-------|---------|\n| `aeo-optimization.md` | AI Engine Optimization |\n| `web-content.md` | SEO + AI discovery |\n| `site-architecture.md` | Technical SEO |\n| `web-payments.md` | Stripe Checkout, subscriptions |\n| `reddit-api.md` | Reddit API |\n| `reddit-ads.md` | Reddit Ads API + agentic optimization |\n| `ms-teams-apps.md` | Microsoft Teams bots |\n| `posthog-analytics.md` | PostHog analytics |\n| `shopify-apps.md` | Shopify app development |\n| `woocommerce.md` | WooCommerce REST API |\n| `medusa.md` | Medusa headless commerce |\n| `klaviyo.md` | Klaviyo email\u002FSMS marketing |\n\n## Usage Patterns\n\n### New Project\n```bash\nmkdir my-new-app && cd my-new-app\nclaude\n> \u002Finitialize-project\n```\n\n### Existing Project\n```bash\ncd my-existing-app\nclaude\n> \u002Finitialize-project\n# Auto-detects existing code → runs analysis first\n```\n\n### Update Skills Globally\n```bash\ncd \"$(cat ~\u002F.claude\u002F.bootstrap-dir)\"\ngit pull\n.\u002Finstall.sh\n```\n\n## Prerequisites\n\n```bash\n# GitHub CLI\nbrew install gh && gh auth login\n\n# Vercel CLI (optional)\nnpm i -g vercel && vercel login\n\n# Supabase CLI (optional)\nbrew install supabase\u002Ftap\u002Fsupabase && supabase login\n```\n\n## Key Differences from v2.x\n\n| Feature | v2.x (Old) | v3.0.0 (New) |\n|---------|-------------|---------------|\n| **TDD Loops** | Ralph Wiggum plugin (doesn't exist) | Stop hooks (real Claude Code infrastructure) |\n| **CLAUDE.md** | Lists skills as text | `@include` directives (actually load at parse time) |\n| **Quality Rules** | In CLAUDE.md as prose | `.claude\u002Frules\u002F` with `paths:` frontmatter |\n| **Agent Teams** | Required `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` | Works natively via `.claude\u002Fagents\u002F` |\n| **Agent Definitions** | Plain markdown | Proper frontmatter: tools, model, maxTurns, effort |\n| **Permissions** | Manual approval for everything | Pre-configured allow\u002Fdeny in settings.json |\n| **Developer Overrides** | None | `CLAUDE.local.md` (gitignored, higher priority) |\n| **Framework Rules** | Always loaded (57 skills = token waste) | Conditional rules activate by file path |\n| **Compaction** | Generic summarization | PreCompact hook + Mnemos typed preservation |\n| **Memory** | Lost on compaction\u002Fnew session | Mnemos checkpoint\u002Fresume across sessions |\n| **Intent Tracking** | None | iCPG links code to reasons, detects drift |\n| **Enforcement** | \"STRICTLY ENFORCED\" prose | Real hooks that run code |\n\n## Contributing\n\nSee [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.\n\n## Changelog\n\nSee [CHANGELOG.md](CHANGELOG.md) for version history.\n\n## License\n\nMIT - See [LICENSE](LICENSE)\n\n## Credits\n\nBuilt on learnings from 100+ projects across customer experience management, agentic AI platforms, mobile apps, and full-stack web applications.\n\n---\n\n**Need help scaling AI in your org?** [Claude Code & MCP experts](https:\u002F\u002Fleanai.ventures\u002Faiops\u002Fclaude)\n","# Claude Bootstrap\n\n> 一个为 Claude Code 设计的、带有明确立场的项目初始化系统。**默认采用代理团队模式，严格遵循 TDD 流程，支持多引擎代码评审，并将安全性置于首位。**\n\n**瓶颈已从代码生成转移到代码理解。** AI 能够生成无限量的代码，但人类仍然需要对这些代码进行审查、理解和维护。Claude Bootstrap 提供了一系列约束机制，确保 AI 生成的代码简洁、安全且可验证。\n\n**v3.3.1 新增功能：** Mnemos 两层后压缩任务恢复——当 Claude Code 的压缩功能触发、崩溃或未运行时，也能保证上下文的完整恢复。类型化内存图（目标永不被驱逐）、四维疲劳监测，以及跨会话的检查点与恢复功能。iCPG 意图增强型代码属性图——追踪代码存在的原因，检测偏差，避免重复工作。\n\n## 核心理念\n\n```\n┌────────────────────────────────────────────────────────────────┐\n│  通过停止钩子实现 TDD 循环                                      │\n│  ─────────────────────────────────────────────────────────────│\n│  停止钩子会在每次 Claude 回应后运行测试。                      │\n│  如果测试失败，反馈会自动回传给 Claude，直到测试全部通过。    │\n│  这是真正的 Claude Code 基础设施——无需任何插件。              │\n├────────────────────────────────────────────────────────────────┤\n│  测试先行，始终如此                                           │\n│  ─────────────────────────────────────────────────────────────│\n│  功能开发流程：编写测试 → 观察测试失败 → 实现功能 → 通过测试   │\n│  Bug 修复流程：发现测试缺失 → 编写失败的测试 → 修复 → 通过测试  │\n│  没有经过失败测试的代码不会被部署。                            │\n├────────────────────────────────────────────────────────────────┤\n│  简洁性是目标                                        │\n│  ─────────────────────────────────────────────────────────────│\n│  每个函数不超过 20 行 │ 每个文件不超过 200 行 │ 参数最多 3 个     │\n│  通过 .claude\u002Frules\u002F 中的 frontmatter 路径强制执行。            │\n├────────────────────────────────────────────────────────────────┤\n│  默认安全                                            │\n│  ─────────────────────────────────────────────────────────────│\n│  代码中不包含任何敏感信息 │ 对 .env 文件实施权限拒绝规则     │\n│  依赖项扫描 │ 提交前钩子 │ CI 强制执行       │\n├────────────────────────────────────────────────────────────────┤\n│  默认使用代理团队                                    │\n│  ─────────────────────────────────────────────────────────────│\n│  每个项目都以协调一致的 AI 代理团队形式运行。                  │\n│  代理定义使用规范的 frontmatter：工具、模型、                   │\n│  最大轮次、努力程度、禁止使用的工具等。                        │\n├────────────────────────────────────────────────────────────────┤\n│  条件规则                                            │\n│  ─────────────────────────────────────────────────────────────│\n│  .claude\u002Frules\u002F 中的规则会根据文件路径激活。                    │\n│  React 规则仅在编辑 .tsx 文件时加载。                           │\n│  Python 规则仅在编辑 .py 文件时加载。                           │\n│  这样可以节省 token，减少噪音，提供更精准的指导。              │\n└────────────────────────────────────────────────────────────────┘\n```\n\n## 快速入门\n\n```bash\n# 克隆并安装（可克隆到任意位置）\ngit clone https:\u002F\u002Fgithub.com\u002Falinaqi\u002Fclaude-bootstrap.git\ncd claude-bootstrap && .\u002Finstall.sh\n\n# 在任意项目目录下\nclaude\n> \u002Finitialize-project\n```\n\nClaude 将执行以下操作：\n1. **验证工具** - 检查 gh、vercel、supabase 的 CLI 是否可用\n2. **提问** - 选择编程语言、框架、是否以 AI 优先、数据库类型、图分析级别等\n3. **设置仓库** - 创建或连接 GitHub 仓库\n4. **创建结构** - 包括技能、规则、配置、安全措施、CI\u002FCD、规格说明和待办事项\n5. **复制 settings.json** - 预配置的权限和停止钩子\n6. **生成 CLAUDE.md** - 包含用于模块化技能的 `@include` 指令\n7. **生成 CLAUDE.local.md** - 用于开发者私有覆盖的模板\n8. **启动代理团队** - 部署团队负责人 + 质量控制 + 安全 + 评审 + 合并 + 功能代理\n\n## TDD 循环的工作原理（停止钩子）\n\n**无需插件，也无假命令。** 当 Claude 完成一次响应时，Claude Code 的停止钩子会运行一段脚本。如果脚本退出码为 2，则会将 stderr 反馈给 Claude，并继续对话。\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│  1. 用户说：“在注册功能中添加邮箱验证”                       │\n│  2. Claude 编写测试用例及实现代码                             │\n│  3. Claude 完成响应                                            │\n│  4. 停止钩子运行：npm test && npm run lint                     │\n│  5a. 所有测试通过（退出码 0）→ 完成！                          │\n│  5b. 测试失败（退出码 2）→ stderr 被反馈给 Claude             │\n│  6. Claude 发现问题，修复后再次完成响应                         │\n│  7. 停止钩子再次运行 → 重复此过程，直到所有测试通过为止        │\n└─────────────────────────────────────────────────────────────┘\n```\n\n**配置**位于 `.claude\u002Fsettings.json` 中：\n\n```json\n{\n  \"hooks\": {\n    \"Stop\": [{\n      \"hooks\": [{\n        \"type\": \"command\",\n        \"command\": \"scripts\u002Ftdd-loop-check.sh\",\n        \"timeout\": 60,\n        \"statusMessage\": \"正在运行测试...\"\n      }]\n    }]\n  }\n}\n```\n\n`tdd-loop-check.sh` 脚本会运行测试、代码风格检查和类型检查。它还会记录迭代次数（最多 25 次），并区分代码错误（循环）和环境错误（停止）。\n\n## @include 指令\n\nCLAUDE.md 使用 `@include` 指令来模块化加载技能：\n\n```markdown\n# CLAUDE.md\n@.claude\u002Fskills\u002Fbase\u002FSKILL.md\n@.claude\u002Fskills\u002Fiterative-development\u002FSKILL.md\n@.claude\u002Fskills\u002Fsecurity\u002FSKILL.md\n```\n\n这些内容会在加载时由 Claude Code 解析——内容会被递归内联（最大深度 5，内置循环检测）。这意味着技能实际上会成为提示的一部分，而不仅仅是作为文本列出。\n\n## 条件规则\n\n`.claude\u002Frules\u002F` 中的规则使用 YAML frontmatter 的 `paths:` 字段，仅在编辑相关文件时才会生效：\n\n```yaml\n# .claude\u002Frules\u002Freact.md\n---\npaths: [\"src\u002Fcomponents\u002F**\", \"**\u002F*.tsx\"]\n---\n优先使用带 hooks 的函数式组件...\n```\n\n```yaml\n# .claude\u002Frules\u002Fpython.md\n---\npaths: [\"**\u002F*.py\"]\n---\n使用类型注解、pytest 和 ruff...\n```\n\n**包含的规则：**\n\n| 规则               | 激活条件                                   |\n|--------------------|--------------------------------------------|\n| `quality-gates.md` | 始终（无 paths: 过滤）                     |\n| `tdd-workflow.md`  | 始终                                     |\n| `security.md`      | 始终                                     |\n| `react.md`         | 编辑 .tsx\u002F.jsx 文件                       |\n| `typescript.md`    | 编辑 .ts\u002F.tsx 文件                       |\n| `python.md`        | 编辑 .py 文件                             |\n| `nodejs-backend.md`| 编辑 api\u002Froutes\u002Fserver 文件               |\n\n## 更智能的压缩（PreCompact 钩子）\n\nClaude Code 内置的压缩机制会在上下文使用率达到约 83% 时触发，并使用一个通用的 9 段模板将所有内容总结为 20,000 个 token。然而，它并不了解你的项目真正关心的内容。\n\nPreCompact 钩子通过向总结器注入**项目特定的保留优先级**来解决这一问题：\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│  内置压缩：                                       │\n│  “总结本次对话” → 通用摘要            │\n├─────────────────────────────────────────────────────────────┤\n│  使用 PreCompact 钩子：                                      │\n│  “请总结，但要逐字保留所有模式决策、精确的错误信息、API 合同细节，   │\n│   并按名称引用这些关键决策，同时附上当前的 Git 状态以便包含在内” → 项目感知的总结     │\n└─────────────────────────────────────────────────────────────┘\n```\n\n该钩子会自动检测：\n- **项目类型**（TypeScript\u002FNext.js、Python\u002FFastAPI、Flutter 等）\n- **模式文件**（Drizzle、Prisma、SQLAlchemy）→ 告知总结器保留模式相关的讨论\n- **API 目录**→ 告知总结器保留端点路径和合同内容\n- **CLAUDE.md 中的关键决策**→ 告知总结器按名称引用这些决策\n- **Git 状态**→ 注入分支、未提交的更改以及暂存文件\n\n在正常使用过程中无额外开销，仅在压缩真正触发时才会运行。\n\n## Mnemos — 任务范围内的内存生命周期\n\nClaude Code 的内置压缩具有损耗性且不可靠。它有时不会触发，`\u002Fcompact` 和 `\u002Fclear` 命令也可能失败（尤其是在多智能体执行中），而崩溃或重启则会导致所有上下文丢失。Mnemos 提供了**持久化到磁盘的结构化状态**，能够抵御所有这些故障模式。\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│  默认 Claude Code          与  使用 Mnemos               │\n├─────────────────────────────────────────────────────────────┤\n│  盲目等待至 83.5%               持续进行四维监控│\n│  突然强制压缩           分阶段触发：40→60→75→83%   │\n│  统一总结            类型化：目标永远不会被清除  │\n│  无跨会话记忆          自动检查点与恢复    │\n│  崩溃 = 完全丢失上下文       崩溃 = 从磁盘恢复  │\n│  多智能体：无共享状态     每个智能体拥有独立的结构化状态│\n│  缺乏行为感知          能够检测重复读取与分散操作 │\n└─────────────────────────────────────────────────────────────┘\n```\n\n### 压缩后的任务恢复（双层保障）\n\n当压缩触发时，内置的总结器往往会丢失任务特定的状态。Mnemos 使用两个独立的层面来确保恢复：\n\n```\n压缩前                    压缩后\n\nPreCompact 钩子触发                第一次工具调用 → PreToolUse 钩子触发\n├── 写入紧急检查点       ├── 检测“.mnemos\u002Fjust-compacted”标记\n├── 根据 signals.jsonl 构建任务叙述（文件、工具等）       ├── 读取 checkpoint-latest.json\n├── 输出强保留指令给总结器       ├── 将完整检查点输出到上下文中\n├── 写入“.mnemos\u002Fjust-compacted”标记文件                      └── Claude 现在拥有：总结 + 检查点\n└── 恢复完成\n```\n\n**第一层**（尽力而为）：PreCompact 告诉总结器需要保留哪些内容，包括带有类型化清除优先级的内联检查点内容。\n\n**第二层**（保证）：压缩后的 PreToolUse 注入机制会在压缩后的首次工具调用时重新注入完整的检查点。这一过程不依赖于总结器。如果没有发生压缩，快速路径耗时约 5 毫秒。\n\n### 为什么不直接写入普通文件？\n\n当然可以——但你会立刻面临以下问题：采用什么格式？何时更新？如何区分“这是关键的”和“这只是锦上添花的”？MnemoGraph 的类型化节点解决了这些问题：\n\n| 节点类型 | 清除策略 | 示例 |\n|-----------|----------------|---------|\n| GoalNode | 绝不清除 | “实现认证模块” |\n| ConstraintNode | 绝不清除 | “API 向后兼容性” |\n| ResultNode | 先压缩 | “JWT 中间件已测试” → 保留摘要 |\n| WorkingNode | 先压缩 | 当前推理 \u002F 进行中的分析 |\n| ContextNode | 可清除 | 文件内容 → 从磁盘重新读取 |\n\n如果没有类型化的优先级，检查点就只是一个简单的数据块。而有了它们，系统就能明确目标 > 约束 > 工作内存 > 上下文，并在 token 预算范围内做出智能的恢复决策。\n\n### 正常压缩之外的韧性\n\n真正的价值并不在于一切顺利的情况，而是在出现问题时：\n\n| 故障模式 | CC 内置 | Mnemos |\n|---|---|---|\n| 会话崩溃\u002F中断 | 上下文丢失 | 磁盘上的检查点仍然存在 |\n| `\u002Fcompact` 未触发 | 截断至上限 | 疲劳钩子已在更早时写入检查点 |\n| 多智能体子进程死亡 | 无法恢复 | 子进程的 `.mnemos\u002F` 中保存着结构化状态 |\n| 强制重启 | 通用摘要 | SessionStart 会重新加载完整检查点 |\n| `\u002Fclear` 在多智能体中失败 | 卡在奇怪的状态 | MnemoGraph 独立于 CC 的状态 |\n\n### 疲劳模型\n\n通过钩子被动观察的四个维度——无需智能体之间的协作：\n\n| 维度 | 权重 | 信号来源 | 检测内容 |\n|-----------|--------|---------------|---------|\n| Token 利用率 | 0.40 | Statusline JSON | 上下文窗口的满载程度 |\n| 作用域分散 | 0.25 | PreToolUse 文件路径 | 智能体在不同目录之间来回切换 |\n| 重复读取比例 | 0.20 | PreToolUse 的读取调用 | 智能体反复读取文件（上下文损失） |\n| 错误密度 | 0.15 | PostToolUse 的结果 | 智能体遇到困难（高错误率） |\n\n疲劳状态：**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 的最新检查点。\n\n### CLI\n\n```bash\nmnemos init                    # 初始化 .mnemos\u002F\nmnemos status                  # 节点数量 + 疲劳状态\nmnemos fatigue                 # 四维详细分解\nmnemos checkpoint --force      # 立即写入检查点\nmnemos resume                  # 输出检查点以供会话注入\nmnemos add goal \"构建认证\"   # 创建一个 GoalNode\nmnemos bridge-icpg             # 导入 iCPG ReasonNodes\n```\n\n**开销：** 每次工具调用约 5 毫秒（快速路径），磁盘占用 84KB。Token 信号通过 statusline 自动输入。\n\n## iCPG — 基于意图的代码属性图\n\niCPG 不仅记录代码的功能，还追踪代码存在的**原因**。每次代码变更都会与一个 ReasonNode 关联，该节点捕获了代码的意图、后置条件和不变式。\n\n```bash\nicpg create \"实现认证\" --scope src\u002Fauth\u002F   # 创建意图\nicpg record src\u002Fauth\u002Fmiddleware.ts                # 链接符号\nicpg query constraints src\u002Fauth\u002Fmiddleware.ts     # 获取不变式\nicpg drift                                        # 检查偏移\nicpg bootstrap                                    # 从 Git 历史推断\n```\n\n**任务前查询**（通过 PreToolUse 钩子自动注入）：\n- `icpg query context \u003Cfile>` — 哪些意图与此文件相关？\n- `icpg query constraints \u003Cfile>` — 必须满足哪些不变式？\n- `icpg drift file \u003Cfile>` — 此文件是否偏离了其初衷？\n\n**6 维度偏移检测**：规范偏移、决策偏移、所有权偏移、测试偏移、使用偏移、依赖偏移。\n\n## 预配置权限\n\n`.claude\u002Fsettings.json` 包含权限规则，以避免用户在执行常规操作时频繁被询问：\n\n```json\n{\n  \"permissions\": {\n    \"allow\": [\n      \"Bash(npm test *)\",\n      \"Bash(npm run lint *)\",\n      \"Bash(pytest *)\",\n      \"Bash(git status *)\",\n      \"Bash(gh pr *)\"\n    ],\n    \"deny\": [\n      \"Bash(rm -rf *)\",\n      \"Bash(git push --force *)\",\n      \"Write(.env)\",\n      \"Write(.env.*)\"\n    ]\n  }\n}\n```\n\n## CLAUDE.local.md（私有覆盖）\n\n每位开发者都有一个被 `.gitignore` 排除的 `CLAUDE.local.md` 文件，用于存储个人偏好：\n\n```markdown\n# 我的偏好\n- 我更喜欢详细的解释\n- 我的本地数据库运行在 5433 端口\n- 使用 pnpm 而不是 npm\n```\n\n此文件会以**更高优先级**加载，覆盖项目中的 `CLAUDE.md`——个人偏好会优先于团队配置，而不会污染仓库。\n\n## 代理团队\n\n每个项目都以协调一致的 AI 代理团队形式运行，并配有**完整的 frontmatter 定义**：\n\n```yaml\n# .claude\u002Fagents\u002Fteam-lead.md\n---\nname: team-lead\ndescription: 协调代理团队\nmodel: sonnet\ntools: [Read, Glob, Grep, TaskCreate, TaskUpdate, TaskList, TaskGet, SendMessage]\ndisallowedTools: [Write, Edit, Bash]\nmaxTurns: 50\neffort: high\n---\n```\n\n**默认团队：**\n\n| 代理 | 角色 | 是否可编辑代码？ |\n|-------|------|----------------|\n| **团队负责人** | 协调并分配任务（不编写代码） | 否 |\n| **质量代理** | 验证 RED\u002FGREEN TDD 流程，覆盖率 ≥ 80% | 否 |\n| **安全代理** | OWASP 扫描、敏感信息检测、依赖审计 | 否 |\n| **代码审查代理** | 多引擎代码审查 | 否 |\n| **合并代理** | 通过 `gh` CLI 创建功能分支和 PR | 否 |\n| **功能代理（x N）** | 每个功能一个，遵循严格的 TDD 流程 | 是 |\n\n**流程（由任务依赖关系强制执行）：**\n\n```\n规格 > 规格评审 > 测试 > RED 验证 > 实现 >\nGREEN 验证 > 验证 > 代码审查 > 安全 > 分支+PR\n```\n\n```bash\n# 自动由 \u002Finitialize-project 启动，或手动启动：\n\u002Fspawn-team\n```\n\n## 项目结构\n\n```\nyour-project\u002F\n├── .claude\u002F\n│   ├── agents\u002F               # 代理定义，包含 frontmatter\n│   │   ├── team-lead.md      # 名称、模型、工具、禁用工具、最大轮次\n│   │   ├── quality.md\n│   │   ├── security.md\n│   │   ├── code-review.md\n│   │   ├── merger.md\n│   │   └── feature.md\n│   ├── rules\u002F                # 条件规则（路径：frontmatter）\n│   │   ├── quality-gates.md  # 始终生效\n│   │   ├── tdd-workflow.md   # 始终生效\n│   │   ├── security.md       # 始终生效\n│   │   ├── react.md          # 对 .tsx\u002F.jsx 文件生效\n│   │   ├── typescript.md     # 对 .ts\u002F.tsx 文件生效\n│   │   ├── python.md         # 对 .py 文件生效\n│   │   └── nodejs-backend.md # 对 api\u002Froutes\u002Fserver 文件生效\n│   ├── skills\u002F               # 通过 @include 加载的能力\n│   │   ├── base\u002FSKILL.md\n│   │   ├── iterative-development\u002FSKILL.md\n│   │   ├── security\u002FSKILL.md\n│   │   ├── mnemos\u002FSKILL.md\n│   │   └── [framework]\u002FSKILL.md\n│   └── settings.json         # 权限、钩子和状态栏\n├── scripts\u002F\n│   ├── tdd-loop-check.sh     # TDD 循环停止钩子脚本\n│   ├── icpg\u002F                 # 基于意图的代码属性图\n│   └── mnemos\u002F               # 任务范围内的记忆生命周期\n├── .mnemos\u002F                  # Mnemos 状态（自动生成，被 .gitignore 排除）\n│   ├── mnemo.db              # SQLite MnemoGraph\n│   ├── fatigue.json          # 实时疲劳信号\n│   ├── signals.jsonl         # 行为信号日志\n│   └── checkpoint-latest.json # 最近检查点\n├── .github\u002Fworkflows\u002F\n│   ├── quality.yml\n│   └── security.yml\n├── _project_specs\u002F\n│   ├── features\u002F\n│   └── todos\u002F\n├── CLAUDE.md                 # @include 指令，项目上下文\n└── CLAUDE.local.md           # 私人开发者覆盖（被 .gitignore 排除）\n```\n\n## 提交规范\n\n```\n┌─────────────────────────────────────────────────────────────┐\n│  提交规模阈值                                     │\n├─────────────────────────────────────────────────────────────┤\n│  合格：≤ 5 个文件，≤ 200 行                           │\n│  警告：6–10 个文件，201–400 行 → “尽快提交”        │\n│  停止：> 10 个文件，> 400 行 → “立即提交”         │\n└─────────────────────────────────────────────────────────────┘\n```\n\n## 包含的能力（59 项）\n\n### 核心能力\n| 能力 | 目的 |\n|-------|---------|\n| `base.md` | 通用模式、约束、TDD 流程、原子化待办事项 |\n| `iterative-development.md` | 通过停止钩子实现 TDD 循环（替代 Ralph Wiggum） |\n| `mnemos.md` | 任务范围内的记忆生命周期——疲劳监测、检查点、类型化压缩 |\n| `icpg.md` | 基于意图的代码属性图——追踪代码存在的原因，检测偏移 |\n| `code-review.md` | 强制性代码审查——Claude、Codex、Gemini 或多引擎审查 |\n| `codex-review.md` | OpenAI Codex CLI 代码审查 |\n| `gemini-review.md` | Google Gemini CLI 代码审查，1M token 上下文 |\n| `workspace.md` | 多仓库工作区意识，合约跟踪 |\n| `commit-hygiene.md` | 原子化提交，PR 尺寸限制 |\n| `code-deduplication.md` | 通过能力索引防止语义重复 |\n| `agent-teams.md` | 具有完整 frontmatter 定义的代理团队工作流 |\n| `ticket-craft.md` | 面向 Claude Code 优化的 AI 原生工单撰写 |\n| `team-coordination.md` | 多人协作项目，共享状态，交接 |\n| `code-graph.md` | 通过 MCP 持久化代码图 |\n| `cpg-analysis.md` | 深度 CPG 分析——Joern + CodeQL |\n| `security.md` | OWASP 模式，敏感信息管理 |\n| `credentials.md` | 中央化 API 密钥管理 |\n| `session-management.md` | 上下文保持，可恢复性 |\n| `project-tooling.md` | gh、vercel、supabase CLI + 部署 |\n| `existing-repo.md` | 分析现有仓库，设置护栏 |\n\n### 语言与框架技能\n| 技能 | 目的 |\n|-------|---------|\n| `python.md` | Python + ruff + mypy + pytest |\n| `typescript.md` | TypeScript strict + eslint + jest |\n| `nodejs-backend.md` | Express\u002FFastify 模式、仓库模式 |\n| `react-web.md` | React + hooks + React Query + Zustand |\n| `react-native.md` | 移动端模式、平台特定代码 |\n| `android-java.md` | Android Java，使用 MVVM、ViewBinding、Espresso |\n| `android-kotlin.md` | Android Kotlin，使用协程、Jetpack Compose、Hilt |\n| `flutter.md` | Flutter，使用 Riverpod、Freezed、go_router |\n\n### UI 技能\n| 技能 | 目的 |\n|-------|---------|\n| `ui-web.md` | Web UI - Tailwind、暗黑模式、可访问性 |\n| `ui-mobile.md` | 移动端 UI - React Native、iOS\u002FAndroid 模式 |\n| `ui-testing.md` | 视觉测试 |\n| `playwright-testing.md` | 端到端测试 - Playwright、Page Objects |\n| `user-journeys.md` | 用户体验流程 |\n| `pwa-development.md` | 渐进式 Web 应用 - service workers、离线支持 |\n\n### 数据库与后端技能\n| 技能 | 目的 |\n|-------|---------|\n| `database-schema.md` | 模式意识 |\n| `supabase.md` | Supabase 核心 CLI、迁移、RLS |\n| `supabase-nextjs.md` | Next.js + Supabase + Drizzle ORM |\n| `supabase-python.md` | FastAPI + Supabase |\n| `supabase-node.md` | Express\u002FHono + Supabase |\n| `firebase.md` | Firebase Firestore、Auth、Storage |\n| `cloudflare-d1.md` | Cloudflare D1 SQLite 结合 Workers |\n| `aws-dynamodb.md` | AWS DynamoDB 单表设计 |\n| `aws-aurora.md` | AWS Aurora Serverless v2 |\n| `azure-cosmosdb.md` | Azure Cosmos DB |\n\n### AI 与智能体技能\n| 技能 | 目的 |\n|-------|---------|\n| `agentic-development.md` | 构建 AI 智能体 |\n| `llm-patterns.md` | AI 驱动的应用、LLM 测试 |\n| `ai-models.md` | 最新模型参考 |\n\n### 内容、集成及其他技能\n| 技能 | 目的 |\n|-------|---------|\n| `aeo-optimization.md` | AI 引擎优化 |\n| `web-content.md` | SEO + AI 发现 |\n| `site-architecture.md` | 技术 SEO |\n| `web-payments.md` | Stripe Checkout、订阅 |\n| `reddit-api.md` | Reddit API |\n| `reddit-ads.md` | Reddit Ads API + 智能体优化 |\n| `ms-teams-apps.md` | Microsoft Teams 机器人 |\n| `posthog-analytics.md` | PostHog 分析 |\n| `shopify-apps.md` | Shopify 应用开发 |\n| `woocommerce.md` | WooCommerce REST API |\n| `medusa.md` | Medusa 无头电商 |\n| `klaviyo.md` | Klaviyo 邮件\u002FSMS 营销 |\n\n## 使用模式\n\n### 新项目\n```bash\nmkdir my-new-app && cd my-new-app\nclaude\n> \u002Finitialize-project\n```\n\n### 现有项目\n```bash\ncd my-existing-app\nclaude\n> \u002Finitialize-project\n# 自动检测现有代码 → 先进行分析\n```\n\n### 全局更新技能\n```bash\ncd \"$(cat ~\u002F.claude\u002F.bootstrap-dir)\"\ngit pull\n.\u002Finstall.sh\n```\n\n## 前置条件\n\n```bash\n# GitHub CLI\nbrew install gh && gh auth login\n\n# Vercel CLI（可选）\nnpm i -g vercel && vercel login\n\n# Supabase CLI（可选）\nbrew install supabase\u002Ftap\u002Fsupabase && supabase login\n```\n\n## 与 v2.x 的主要区别\n\n| 特性 | v2.x（旧版） | v3.0.0（新版） |\n|---------|-------------|---------------|\n| **TDD 循环** | Ralph Wiggum 插件（不存在） | Stop hooks（真正的 Claude Code 基础设施） |\n| **CLAUDE.md** | 以文本形式列出技能 | `@include` 指令（在解析时实际加载） |\n| **质量规则** | 在 CLAUDE.md 中以散文形式描述 | `.claude\u002Frules\u002F` 文件，带有 `paths:` 前言 |\n| **代理团队** | 需要设置 `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` | 通过 `.claude\u002Fagents\u002F` 原生支持 |\n| **代理定义** | 纯 Markdown | 正式的前言：工具、模型、最大轮次、努力程度 |\n| **权限** | 所有操作都需要手动批准 | settings.json 中预配置的允许\u002F拒绝 |\n| **开发者覆盖** | 无 | `CLAUDE.local.md`（被 git 忽略，优先级更高） |\n| **框架规则** | 总是加载（57 项技能 = 浪费 token） | 根据文件路径有条件地激活规则 |\n| **压缩** | 通用总结 | PreCompact 钩子 + Mnemos 类型化保存 |\n| **内存** | 在压缩或新会话时丢失 | Mnemos 检查点可在会话间恢复 |\n| **意图跟踪** | 无 | iCPG 将代码与原因关联，并检测偏离 |\n| **执行** | “严格强制执行”的文字说明 | 实际运行代码的钩子 |\n\n## 贡献\n\n请参阅 [CONTRIBUTING.md](CONTRIBUTING.md) 获取指南。\n\n## 更改日志\n\n请参阅 [CHANGELOG.md](CHANGELOG.md) 查看版本历史。\n\n## 许可证\n\nMIT - 请参阅 [LICENSE](LICENSE)\n\n## 致谢\n\n基于在客户体验管理、智能体 AI 平台、移动应用和全栈 Web 应用等 100 多个项目中的经验构建而成。\n\n---\n\n**需要帮助在贵公司规模化部署 AI 吗？** [Claude Code & MCP 专家](https:\u002F\u002Fleanai.ventures\u002Faiops\u002Fclaude)","# Claude Bootstrap 快速上手指南\n\nClaude Bootstrap 是一个专为 **Claude Code** 设计的意见化项目初始化系统。它默认采用**多智能体协作模式**，强制执行**严格测试驱动开发（TDD）流程**、**多引擎代码审查**以及**安全优先**原则，旨在解决 AI 生成代码后的理解与维护瓶颈。\n\n## 环境准备\n\n在开始之前，请确保您的开发环境满足以下要求：\n\n*   **操作系统**: macOS 或 Linux (Windows 用户建议使用 WSL2)\n*   **核心依赖**:\n    *   [Node.js](https:\u002F\u002Fnodejs.org\u002F) (推荐 LTS 版本)\n    *   [Git](https:\u002F\u002Fgit-scm.com\u002F)\n    *   **Claude Code CLI** (必须已安装并登录)\n*   **可选工具链** (根据项目类型自动检测):\n    *   `gh` (GitHub CLI)\n    *   `vercel` (Vercel CLI)\n    *   `supabase` (Supabase CLI)\n\n> **注意**: 本工具深度集成 Claude Code 的原生 Hook 机制，无需安装额外插件。\n\n## 安装步骤\n\n### 1. 克隆与安装\n将仓库克隆到任意目录并运行安装脚本。该脚本会自动配置全局钩子和基础规则。\n\n```bash\n# 克隆仓库\ngit clone https:\u002F\u002Fgithub.com\u002Falinaqi\u002Fclaude-bootstrap.git\n\n# 进入目录并执行安装\ncd claude-bootstrap && .\u002Finstall.sh\n```\n\n> **国内加速提示**: 如果克隆速度较慢，可使用国内镜像源：\n> ```bash\n> git clone https:\u002F\u002Fgitee.com\u002Fmirror\u002Fclaude-bootstrap.git # 示例镜像，请替换为实际可用的国内源\n> # 或者使用代理\n> git clone https:\u002F\u002Fgithub.com\u002Falinaqi\u002Fclaude-bootstrap.git --config http.proxy=http:\u002F\u002F127.0.0.1:7890\n> ```\n\n### 2. 验证安装\n安装完成后，您可以在任何新的或现有的项目目录中启动 Claude 来验证。\n\n## 基本使用\n\n### 初始化新项目\n\n进入您的项目目录（或新建一个空目录），启动 Claude 并运行初始化命令：\n\n```bash\ncd my-new-project\nclaude\n```\n\n在 Claude 交互界面中输入：\n\n```text\n> \u002Finitialize-project\n```\n\n### 初始化流程说明\n\n执行 `\u002Finitialize-project` 后，Claude Bootstrap 将自动引导您完成以下步骤：\n\n1.  **工具验证**: 检查 `gh`, `vercel`, `supabase` 等 CLI 是否可用。\n2.  **项目配置问答**:\n    *   选择编程语言与框架\n    *   确认是否为 \"AI First\" 项目\n    *   选择数据库类型\n    *   设定代码图谱分析级别\n3.  **仓库设置**: 自动创建或连接 GitHub 仓库。\n4.  **架构生成**: 创建标准化的目录结构，包含技能库 (Skills)、规则 (Rules)、安全配置、CI\u002FCD 流水线及规范文档。\n5.  **配置注入**:\n    *   复制预配置的 `settings.json` (含权限控制与 Stop Hooks)。\n    *   生成模块化的 `CLAUDE.md` (使用 `@include` 指令加载技能)。\n    *   生成 `CLAUDE.local.md` 模板供开发者私有覆盖。\n6.  **部署智能体团队**: 自动激活由 **Team Lead**, **Quality**, **Security**, **Review**, **Merger** 和 **Feature** 组成的多智能体协作网络。\n\n### 核心工作机制：TDD 循环 (Stop Hooks)\n\n初始化后，系统将自动启用 **TDD 闭环**。您无需手动运行测试，系统会在每次 AI 响应结束后自动拦截并执行验证：\n\n1.  您发出指令（例如：\"为注册功能添加邮箱验证\"）。\n2.  Claude 编写测试用例并实现代码。\n3.  Claude 结束响应。\n4.  **Stop Hook 自动触发**: 运行 `npm test && npm run lint`。\n5.  **结果处理**:\n    *   **通过 (Exit 0)**: 任务完成。\n    *   **失败 (Exit 2)**: 错误信息自动反馈给 Claude，触发其自动修复并重新提交，直到测试全部通过。\n\n此过程完全基于 Claude Code 原生基础设施，无需伪造命令或安装第三方插件。\n\n### 进阶特性概览\n\n*   **条件化规则**: 规则仅在编辑特定文件时激活（如编辑 `.tsx` 时加载 React 规则），节省 Token 并减少干扰。\n*   **智能压缩 (PreCompact Hook)**: 在上下文窗口即将满时，自动注入项目特定的保留优先级（如 Schema 定义、API 契约），防止关键信息丢失。\n*   **Mnemos 记忆系统**: 提供基于磁盘的持久化状态存储，即使会话崩溃、重启或多智能体执行中断，也能保证任务上下文和目标的完整恢复。","某初创团队的后端工程师正利用 Claude Code 快速构建一个包含敏感用户数据的金融 API 服务，需要在极短时间内交付高质量且安全的代码。\n\n### 没有 claude-bootstrap 时\n- **代码质量失控**：AI 生成的函数往往过长且参数混乱，缺乏统一规范，导致后期人工审查和维护成本极高。\n- **测试滞后或缺失**：通常是先写业务代码再补测试，甚至遗漏测试，使得潜在 Bug 流入生产环境的风险大增。\n- **安全隐患频发**：开发者容易疏忽将密钥硬编码在代码中，或缺少对依赖包的自动安全扫描，埋下数据泄露隐患。\n- **上下文丢失严重**：在长对话中，一旦遇到模型上下文压缩或会话中断，之前的开发意图和架构决策常常丢失，导致重复劳动。\n- **协作效率低下**：缺乏预定义的“代理团队”分工，单个 AI 实例需同时处理架构、编码和调试，容易顾此失彼。\n\n### 使用 claude-bootstrap 后\n- **强制简约架构**：通过内置规则自动限制函数不超过 20 行、文件不超过 200 行，确保生成的代码天然简洁易读。\n- **严格 TDD 闭环**：利用 Stop Hooks 机制，强制要求“先写失败测试再实现功能”，若测试不通过则自动阻断并让 AI 迭代修复。\n- **默认安全优先**：自动配置权限拒绝规则防止 `.env` 文件泄露，并在提交前自动扫描依赖漏洞，从源头杜绝常见安全问题。\n- **智能记忆恢复**：借助 Mnemos 双层任务恢复和类型化记忆图，即使会话崩溃或上下文被压缩，也能精准找回开发目标与意图。\n- **多代理协同作业**：自动组建由不同专长 AI 代理构成的团队，分别负责编码、测试和审查，大幅提升复杂任务的完成度。\n\nclaude-bootstrap 通过将松散的 AI 代码生成转变为受控、安全且可验证的工程化流程，彻底解决了\"AI 写得快但人看不懂”的核心瓶颈。","https:\u002F\u002Foss.gittoolsai.com\u002Fimages\u002Falinaqi_claude-bootstrap_3a190b57.png","alinaqi","Ali Shaheen","https:\u002F\u002Foss.gittoolsai.com\u002Favatars\u002Falinaqi_6490e40e.jpg","Applying AI to push boundaries.",null,"Berlin","https:\u002F\u002Fgithub.com\u002Falinaqi",[80,84],{"name":81,"color":82,"percentage":83},"Python","#3572A5",65.6,{"name":85,"color":86,"percentage":87},"Shell","#89e051",34.4,571,46,"2026-04-08T15:18:15","MIT","Linux, macOS","未说明",{"notes":95,"python":93,"dependencies":96},"该工具是 Claude Code 的项目初始化系统，而非独立的 AI 模型，因此无需本地 GPU 或特定显存。运行核心依赖是安装并配置好 'Claude Code' 环境。安装脚本 (install.sh) 暗示主要支持类 Unix 系统 (Linux\u002FmacOS)。项目强依赖多个命令行工具 (gh, vercel, supabase)，需在系统中预先安装。其功能通过 .claude\u002Fsettings.json 中的 Stop hooks 和 PreCompact hooks 实现，利用磁盘持久化存储 (Mnemos) 来管理上下文状态。",[97,98,99,100,101],"Claude Code","gh CLI","vercel CLI","supabase CLI","npm\u002Fnodejs (推断)",[13,14],[104,105,106,107,108,109,110,111,112],"ai-coding","claude","claude-code","developer-tools","project-initialization","python","react","security","typescript","2026-03-27T02:49:30.150509","2026-04-09T10:23:48.194498",[116,121,126,131,136,141],{"id":117,"question_zh":118,"answer_zh":119,"source_url":120},26128,"为什么技能文件夹结构看起来不正确，导致技能无法加载？","早期版本确实存在扁平化文件结构的问题，现已修复。正确的结构应为每个技能拥有独立的文件夹，并在其中包含 `SKILL.md` 文件。例如：`~\u002F.claude\u002Fskills\u002Fpython\u002FSKILL.md`。每个 `SKILL.md` 现在都包含带有 `name` 和 `description` 字段的 YAML 前言。要更新到正确结构，请运行以下命令：\n```bash\ncd ~\u002F.claude-bootstrap\ngit pull\n.\u002Finstall.sh\n```","https:\u002F\u002Fgithub.com\u002Falinaqi\u002Fclaude-bootstrap\u002Fissues\u002F1",{"id":122,"question_zh":123,"answer_zh":124,"source_url":125},26129,"技能文档中提到的 'Load with: base.md' 是什么意思？是否缺少了 base.md 文件？","这是旧版本遗留的无效文本，可以忽略或删除。自 v3.0 版本起，基础技能（base skill）位于 `skills\u002Fbase\u002FSKILL.md`，并通过项目 `CLAUDE.md` 中的 `@include` 指令加载，不再需要在每个技能文件中单独引用。维护者已从所有受影响的技能中删除了该行以消除混淆。","https:\u002F\u002Fgithub.com\u002Falinaqi\u002Fclaude-bootstrap\u002Fissues\u002F13",{"id":127,"question_zh":128,"answer_zh":129,"source_url":130},26130,"pre-push 钩子在代码审查通过（无严重问题）时仍然阻止推送，显示 'PUSH BLOCKED'，如何解决？","这是一个已修复的 Bug。旧版本的钩子脚本使用过于宽泛的 grep 模式匹配关键词（如 'Critical'），导致误判表格标题或“无严重问题”的提示语。修复后的钩子采用三层检查机制：\n1. 优先查找明确的 `Status: ✅ PASS` 或 `Status: ❌` 状态行；\n2. 备用方案是从摘要表中解析实际的严重程度计数（如 `Critical: N`）；\n3. 不再将 'Critical' 或 'High' 作为独立关键词匹配。\n请拉取最新代码并重新安装以应用修复：\n```bash\ncd ~\u002F.claude-bootstrap\ngit pull\n.\u002Finstall.sh\n```","https:\u002F\u002Fgithub.com\u002Falinaqi\u002Fclaude-bootstrap\u002Fissues\u002F8",{"id":132,"question_zh":133,"answer_zh":134,"source_url":135},26131,"安全扫描工具报告了 'EXTERNAL_DOWNLOADS' 和 'REMOTE_CODE_EXECUTION' 风险，这是否意味着技能文件不安全？","这是误报（False Positive）。`SKILL.md` 文件仅是供 Claude Code 代理阅读的文档和指令，并非可执行代码。\n1. **EXTERNAL_DOWNLOADS**：扫描器检测到的 Gradle 依赖声明仅存在于 Markdown 代码示例中，引用的库均来自 Google、JetBrains 等官方来源。\n2. **REMOTE_CODE_EXECUTION**：对 `proguard-rules.pro` 的引用仅是配置示例，实际文件中并不存在该文件。\n因此，这里不存在实际的安全风险。","https:\u002F\u002Fgithub.com\u002Falinaqi\u002Fclaude-bootstrap\u002Fissues\u002F10",{"id":137,"question_zh":138,"answer_zh":139,"source_url":140},26132,"除了 Supabase，该项目还支持哪些数据库技能？如何获取它们？","项目已扩展支持多种数据库技能，包括 Firebase、Cloudflare D1、AWS DynamoDB、AWS Aurora 和 Azure Cosmos DB。每个新技能都包含最佳实践、TypeScript\u002FPython 代码示例及 CLI 参考。\n要使用这些新技能，请更新您的 claude-bootstrap 并重新初始化项目：\n```bash\ncd ~\u002F.claude-bootstrap\ngit pull\n.\u002Finstall.sh\n```\n然后在您的项目中运行 `\u002Finitialize-project` 即可加载新技能。","https:\u002F\u002Fgithub.com\u002Falinaqi\u002Fclaude-bootstrap\u002Fissues\u002F7",{"id":142,"question_zh":143,"answer_zh":144,"source_url":145},26133,"我的技能没有描述，这会影响发现性吗？应该如何添加？","是的，缺少描述会限制第三方工具（如 Dispatch）推荐该技能的效果。技能描述应定义在 `SKILL.md` 文件的 YAML 前言（frontmatter）中，包含 `description` 字段。维护者计划对所有技能进行清理，确保每个技能都有简明的 1-2 句描述以提高可见性。如果您自行开发技能，请确保在 YAML 头部添加类似 `description: \"简短描述技能功能\"` 的字段。","https:\u002F\u002Fgithub.com\u002Falinaqi\u002Fclaude-bootstrap\u002Fissues\u002F12",[]]