@winspan/claude-forge 8.54.4 → 9.2.0

package/dist/claudemd/claudemd-generator.js

@@ -1,419 +1,144 @@
 /**
- * CLAUDE.md Generator — AI 驱动的 CLAUDE.md 生成与管理
+ * CLAUDE.md Generator — file I/O + directory scan helpers.
+ *
+ * History: this module used to drive a host-side AI completion to synthesize
+ * CLAUDE.md.  After spec `0902-ai-config-removal-master-spec.md` (decision
+ * `f5a5b030`, sub-spec A R-D) all AI synthesis moved to the `claude` CLI
+ * shell-out path in `src/cli/commands/claudemd.ts` (via
+ * `src/core/utils/claude-cli-spawn.ts` against the `claudemd-writer`
+ * sub-agent).  This module now only retains:
+ *
+ *   - AUTO marker read/write helpers (used by callers that still want to
+ *     preserve user-authored content outside the auto block — currently a
+ *     reusable primitive with no production consumer, but kept since the
+ *     associated tests still pin its contract)
+ *   - The directory-tree scanner (also imported by the CLI to build the
+ *     `<project_directory_tree>` payload for the agent)
+ *
+ * No `ai: ClaudeProvider` field; no `complete(...)` call sites.
  */
 import { readFileSync, writeFileSync, existsSync, readdirSync, statSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { join } from 'node:path';
 import { TechDetector } from './tech-detector.js';
 const AUTO_START = '<!-- forge:claudemd-auto -->';
 const AUTO_END = '<!-- forge:end-claudemd-auto -->';
 /**
- * Swarm Protocol — fixed CLAUDE.md preface injected into every project.
- *
- * Loaded from `templates/swarm-protocol.md` (same directory as this module's
- * compiled output). `fileURLToPath(import.meta.url)` resolves to either
- * `src/claudemd/` (dev via tsx) or `dist/claudemd/` (npm install) — both
- * have a sibling `templates/` directory after build (see package.json `build`
- * script which copies *.md into dist/claudemd/templates/).
+ * Java-aware directory annotations.  Re-used when the caller passes
+ * `addComments: true` (typically only for Java projects where the package
+ * structure is dense).
+ */
+const JAVA_COMMENTS = {
+    'controller': '# 控制器层',
+    'service': '# 服务层',
+    'impl': '# 服务实现类',
+    'mapper': '# MyBatis Mapper 接口',
+    'entity': '# 实体类',
+    'dto': '# 数据传输对象',
+    'vo': '# 视图对象',
+    'config': '# 配置类',
+    'util': '# 工具类',
+    'utils': '# 工具类',
+    'common': '# 公共模块',
+    'exception': '# 异常类',
+    'interceptor': '# 拦截器',
+    'filter': '# 过滤器',
+    'aspect': '# 切面',
+    'resources': '# 配置文件、静态资源',
+    'application.yml': '# 应用配置文件',
+    'application.yaml': '# 应用配置文件',
+    'pom.xml': '# Maven 配置文件',
+    'build.gradle': '# Gradle 配置文件',
+    'README.md': '# 项目说明文档',
+};
+const IGNORE_DIRS = new Set([
+    'node_modules', '.git', '.idea', '.vscode', '.DS_Store',
+    'dist', 'build', 'target', 'out', '.next', '.nuxt',
+    '__pycache__', '.pytest_cache', '.mypy_cache',
+    'vendor', 'coverage', '.nyc_output', 'tmp', 'temp',
+]);
+// Deep noise: traversed at depth 1 but never descended into.
+const SHALLOW_ONLY = new Set([
+    'executions', 'by-route', 'history', 'logs', 'cache',
+]);
+/**
+ * Scan a project directory and return a tree representation suitable for
+ * embedding in markdown.  Used by both `ClaudeMdGenerator` (legacy callers /
+ * tests) and `src/cli/commands/claudemd.ts` (current `cf claudemd` flow that
+ * feeds the tree to the `claudemd-writer` agent).
  *
- * Cached at module level: the file is read at most once per process.
+ * - `maxDepth` controls how deep to recurse (typical: 2 for non-Java, 4 for
+ *   Java where the package nesting matters).
+ * - `addComments=true` enables Java directory-name annotations (controller,
+ *   service, mapper, …) — host caller decides based on detected stack.
  */
-let _swarmProtocolCache = null;
-function getSwarmProtocol() {
-    if (_swarmProtocolCache !== null)
-        return _swarmProtocolCache;
-    const thisDir = dirname(fileURLToPath(import.meta.url));
-    const p = join(thisDir, 'templates', 'swarm-protocol.md');
-    if (!existsSync(p)) {
-        throw new Error(`[ClaudeMdGenerator] swarm-protocol.md not found at ${p}. ` +
-            `This indicates a broken build/install. Run \`npm run build\` or reinstall the package.`);
-    }
-    _swarmProtocolCache = readFileSync(p, 'utf-8');
-    return _swarmProtocolCache;
-}
-export class ClaudeMdGenerator {
-    ai;
-    detector;
-    constructor(ai, detector) {
-        this.ai = ai;
-        this.detector = detector ?? new TechDetector();
-    }
-    /**
-     * 检测技术栈 + 生成 CLAUDE.md
-     *
-     * 策略：Swarm 协议是固定内容（不依赖 AI），项目信息尝试用 AI 生成，
-     * 失败时回退到基于技术栈检测的模板。
-     */
-    async generate(projectPath, userContent) {
-        const stack = this.detector.detect(projectPath);
-        // 1. 尝试 AI 生成项目特定内容
-        let projectContent = '';
+export function scanDirectoryTree(projectPath, maxDepth, addComments = false) {
+    const lines = [];
+    const walk = (dir, prefix, depth) => {
+        if (depth > maxDepth)
+            return;
+        let entries = [];
         try {
-            const prompt = this.buildPrompt(stack, projectPath);
-            const aiResult = await this.ai.complete(prompt, {
-                system: 'You are a technical writer. Output ONLY markdown content for a CLAUDE.md file. Do NOT ask questions or explain what you will do. Start directly with ## headers.',
-                maxTokens: 4096,
-                // 4096-token 生成在转发网关（如 one.iflytek 等）下容易超过默认 30s；
-                // 给 CLAUDE.md 生成单独拉长超时，失败再回退到本地模板。
-                timeoutMs: 120_000,
-            });
-            // 验证 AI 输出是否有效（至少包含一个 ## 标题）
-            if (aiResult && aiResult.includes('##')) {
-                // AI 经常在"目录结构"章节退化成 project-root/com/example/project 模板，
-                // 不可信任；强制替换为真实扫描结果。
-                projectContent = this.overrideDirectoryStructure(aiResult, stack, projectPath);
-            }
+            entries = readdirSync(dir).filter((e) => !IGNORE_DIRS.has(e));
         }
         catch {
-            // AI 失败，使用模板回退
-        }
-        // 2. 如果 AI 失败或返回无效内容，使用模板
-        if (!projectContent) {
-            projectContent = this.buildFallbackContent(stack, projectPath);
-        }
-        // 3. Swarm 协议 + 项目内容
-        const full = getSwarmProtocol() + '\n\n' + projectContent;
-        return this.merge(full, userContent);
-    }
-    /**
-     * 基于技术栈检测的回退模板（不依赖 AI）
-     *
-     * 即使 AI 调用失败，也要生成足够丰富的项目指引，让 Claude Code 拿到：
-     *   - 技术栈概览（含版本、包管理器、测试 / Linter）
-     *   - 构建 / 测试 / 运行命令（按包管理器分发）
-     *   - 目录结构（扫描项目根目录真实结构）
-     *   - 代码规范（命名、提交信息、PR 流程）
-     *   - 常见陷阱（按技术栈定制）
-     *   - 贡献指南
-     */
-    buildFallbackContent(stack, projectPath) {
-        const sections = [];
-        sections.push(this.sectionOverview(stack));
-        sections.push(this.sectionTechStack(stack));
-        sections.push(this.sectionBuildCommands(stack));
-        sections.push(this.sectionDirectoryStructure(stack, projectPath));
-        sections.push(this.sectionCodingStandards(stack));
-        sections.push(this.sectionCommonPitfalls(stack));
-        sections.push(this.sectionContributionGuide(stack));
-        return sections.filter(Boolean).join('\n\n');
-    }
-    sectionOverview(stack) {
-        const lang = stack.language[0] || '未识别';
-        const framework = stack.framework.length > 0 ? ` + ${stack.framework.join(' / ')}` : '';
-        return [
-            '## 项目概述',
-            '',
-            `本项目基于 ${lang}${framework} 构建。请根据实际业务补充项目目标、核心模块职责与上下游依赖。`,
-        ].join('\n');
-    }
-    sectionTechStack(stack) {
-        const lines = ['## 技术栈', ''];
-        if (stack.language.length > 0) {
-            lines.push(`- **语言**: ${stack.language.join(', ')}`);
-        }
-        if (stack.framework.length > 0) {
-            const descs = stack.framework.map(fw => `${fw}${this.frameworkHint(fw)}`);
-            lines.push(`- **框架**: ${descs.join(', ')}`);
-        }
-        lines.push(`- **包管理器**: ${stack.packageManager}`);
-        if (stack.testFramework) {
-            lines.push(`- **测试框架**: ${stack.testFramework}`);
-        }
-        if (stack.linter) {
-            lines.push(`- **代码检查**: ${stack.linter}`);
-        }
-        const ecosystem = this.ecosystemNotes(stack);
-        if (ecosystem) {
-            lines.push('', ecosystem);
-        }
-        return lines.join('\n');
-    }
-    frameworkHint(fw) {
-        const hints = {
-            'Spring Boot': '（IoC 容器 + 自动配置，所有组件通过注解注入）',
-            MyBatis: '（SQL 映射，Mapper 接口 + XML）',
-            Dubbo: '（RPC 框架，服务注册与发现）',
-            React: '（组件化 UI，单向数据流）',
-            'Next.js': '（React 全栈框架，支持 SSR / SSG）',
-            Vue: '（渐进式 UI 框架）',
-            Express: '（Node.js Web 框架，中间件模型）',
-            Fastify: '（高性能 Node.js Web 框架）',
-            NestJS: '（Node.js 企业级框架，装饰器 + DI）',
-        };
-        return hints[fw] || '';
-    }
-    ecosystemNotes(stack) {
-        if (stack.language.some(l => l.startsWith('Java'))) {
-            return '> Java 生态约定：包名全小写，类名 PascalCase，方法 camelCase；Maven / Gradle 依赖统一在顶层 pom.xml / build.gradle 管理，子模块只声明坐标不重复版本。';
-        }
-        if (stack.language.includes('TypeScript')) {
-            return '> TypeScript 生态约定：开启 strict 模式，模块边界用 interface，内部用 type；async/await 优先，禁止混用 Promise 链。';
-        }
-        if (stack.language.some(l => l.startsWith('Go'))) {
-            return '> Go 生态约定：使用 gofmt 自动格式化；错误值必须显式处理，不得丢弃；包名全小写且与目录名一致。';
-        }
-        if (stack.language.includes('Rust')) {
-            return '> Rust 生态约定：`cargo fmt` + `cargo clippy` 双重检查；尽量使用 Result / Option，避免 panic；mod.rs 或 `<name>.rs` 二选一。';
-        }
-        if (stack.language.includes('Python')) {
-            return '> Python 生态约定：遵循 PEP8；建议启用 mypy / ruff；虚拟环境隔离依赖。';
-        }
-        return '';
-    }
-    sectionBuildCommands(stack) {
-        const lines = ['## 构建与测试', '', '```bash'];
-        const pm = stack.packageManager;
-        if (pm === 'npm') {
-            lines.push('# 安装依赖', 'npm install', '', '# 开发模式（如适用）', 'npm run dev', '', '# 构建产物', 'npm run build', '', '# 运行测试', 'npm test', '', '# 类型检查（TypeScript）', 'npx tsc --noEmit');
-        }
-        else if (pm === 'pnpm') {
-            lines.push('pnpm install', 'pnpm dev', 'pnpm build', 'pnpm test');
-        }
-        else if (pm === 'yarn') {
-            lines.push('yarn', 'yarn dev', 'yarn build', 'yarn test');
-        }
-        else if (pm === 'bun') {
-            lines.push('bun install', 'bun run dev', 'bun run build', 'bun test');
-        }
-        else if (pm === 'maven') {
-            lines.push('# 清理并编译', 'mvn clean compile', '', '# 运行测试', 'mvn test', '', '# 打包（跳过测试加 -DskipTests）', 'mvn clean package', '', '# 本地安装到 ~/.m2', 'mvn clean install', '', '# 启动 Spring Boot（若适用）', 'mvn spring-boot:run');
-        }
-        else if (pm === 'gradle') {
-            lines.push('# 构建', './gradlew build', '', '# 运行测试', './gradlew test', '', '# 清理', './gradlew clean', '', '# 启动 Spring Boot（若适用）', './gradlew bootRun');
-        }
-        else if (pm === 'go mod') {
-            lines.push('go mod tidy', 'go build ./...', 'go test ./...', 'go vet ./...');
-        }
-        else if (pm === 'cargo') {
-            lines.push('cargo build', 'cargo test', 'cargo clippy -- -D warnings', 'cargo fmt --check');
-        }
-        else if (pm === 'pip' || pm === 'poetry' || pm === 'pipenv') {
-            const prefix = pm === 'poetry' ? 'poetry run ' : pm === 'pipenv' ? 'pipenv run ' : '';
-            lines.push(`${prefix}pytest`, `${prefix}python -m build`);
-        }
-        else {
-            lines.push('# 请补充构建与测试命令');
+            return;
         }
-        lines.push('```');
-        return lines.join('\n');
-    }
-    sectionDirectoryStructure(stack, projectPath) {
-        // Java 项目需要更深的层级才能看到包结构
-        const isJava = stack.language.some(l => l.startsWith('Java'));
-        const maxDepth = isJava ? 4 : 2;
-        const tree = this.scanDirectoryTree(projectPath, maxDepth, isJava);
-        if (!tree)
-            return '';
-        return ['## 目录结构', '', '```', tree, '```'].join('\n');
-    }
-    /**
-     * 扫描项目根目录，生成树形结构（过滤噪声目录）
-     */
-    scanDirectoryTree(projectPath, maxDepth, addComments = false) {
-        const IGNORE = new Set([
-            'node_modules', '.git', '.idea', '.vscode', '.DS_Store',
-            'dist', 'build', 'target', 'out', '.next', '.nuxt',
-            '__pycache__', '.pytest_cache', '.mypy_cache',
-            'vendor', 'coverage', '.nyc_output', 'tmp', 'temp',
-        ]);
-        // 深目录噪声：这些目录即使不在 IGNORE 里，也不递归进去（避免爆炸）
-        const SHALLOW_ONLY = new Set([
-            'executions', 'by-route', 'history', 'logs', 'cache',
-        ]);
-        // Java 项目目录注释映射
-        const JAVA_COMMENTS = {
-            'controller': '# 控制器层',
-            'service': '# 服务层',
-            'impl': '# 服务实现类',
-            'mapper': '# MyBatis Mapper 接口',
-            'entity': '# 实体类',
-            'dto': '# 数据传输对象',
-            'vo': '# 视图对象',
-            'config': '# 配置类',
-            'util': '# 工具类',
-            'utils': '# 工具类',
-            'common': '# 公共模块',
-            'exception': '# 异常类',
-            'interceptor': '# 拦截器',
-            'filter': '# 过滤器',
-            'aspect': '# 切面',
-            'resources': '# 配置文件、静态资源',
-            'application.yml': '# 应用配置文件',
-            'application.yaml': '# 应用配置文件',
-            'pom.xml': '# Maven 配置文件',
-            'build.gradle': '# Gradle 配置文件',
-            'README.md': '# 项目说明文档',
-        };
-        const lines = [];
-        const walk = (dir, prefix, depth) => {
-            if (depth > maxDepth)
-                return;
-            let entries = [];
+        const stats = entries.map((e) => {
             try {
-                entries = readdirSync(dir).filter(e => !IGNORE.has(e));
+                return { name: e, isDir: statSync(join(dir, e)).isDirectory() };
             }
             catch {
-                return;
+                return { name: e, isDir: false };
             }
-            // 文件在前，目录在后
-            const stats = entries.map(e => {
-                try {
-                    return { name: e, isDir: statSync(join(dir, e)).isDirectory() };
-                }
-                catch {
-                    return { name: e, isDir: false };
-                }
-            });
-            const files = stats.filter(s => !s.isDir).map(s => s.name);
-            const dirs = stats.filter(s => s.isDir).map(s => s.name);
-            const sorted = [...dirs.sort(), ...files.sort()];
-            sorted.forEach((name, idx) => {
-                const isLast = idx === sorted.length - 1;
-                const connector = isLast ? '└── ' : '├── ';
-                const childPrefix = isLast ? '    ' : '│   ';
-                const fullPath = join(dir, name);
-                let isDir = false;
-                try {
-                    isDir = statSync(fullPath).isDirectory();
-                }
-                catch {
-                    // ignore
-                }
-                // 构建行：名称 + 可选注释
-                let line = prefix + connector + name + (isDir ? '/' : '');
-                if (addComments) {
-                    const comment = JAVA_COMMENTS[name] || JAVA_COMMENTS[name.toLowerCase()];
-                    if (comment) {
-                        // 对齐注释（假设最长路径 60 字符）
-                        const padding = Math.max(1, 60 - line.length);
-                        line += ' '.repeat(padding) + comment;
-                    }
-                }
-                lines.push(line);
-                // 递归条件：是目录 + 未达深度上限 + 不在浅层名单里
-                if (isDir && depth < maxDepth && !SHALLOW_ONLY.has(name)) {
-                    walk(fullPath, prefix + childPrefix, depth + 1);
+        });
+        const files = stats.filter((s) => !s.isDir).map((s) => s.name);
+        const dirs = stats.filter((s) => s.isDir).map((s) => s.name);
+        const sorted = [...dirs.sort(), ...files.sort()];
+        sorted.forEach((name, idx) => {
+            const isLast = idx === sorted.length - 1;
+            const connector = isLast ? '└── ' : '├── ';
+            const childPrefix = isLast ? '    ' : '│   ';
+            const fullPath = join(dir, name);
+            let isDir = false;
+            try {
+                isDir = statSync(fullPath).isDirectory();
+            }
+            catch {
+                // ignore
+            }
+            let line = prefix + connector + name + (isDir ? '/' : '');
+            if (addComments) {
+                const comment = JAVA_COMMENTS[name] || JAVA_COMMENTS[name.toLowerCase()];
+                if (comment) {
+                    const padding = Math.max(1, 60 - line.length);
+                    line += ' '.repeat(padding) + comment;
                 }
-            });
-        };
-        // 根目录名：从路径提取真实项目名
-        const rootName = projectPath.split('/').filter(Boolean).pop() || 'project';
-        lines.push(rootName + '/');
-        walk(projectPath, '', 1);
-        return lines.join('\n');
-    }
-    sectionCodingStandards(stack) {
-        const isJava = stack.language.some(l => l.startsWith('Java'));
-        const isTs = stack.language.includes('TypeScript');
-        const lines = ['## 代码规范', ''];
-        lines.push('### 命名约定', '');
-        if (isJava) {
-            lines.push('- 包名：全小写，使用反向域名（`com.company.project.module`）');
-            lines.push('- 类名：PascalCase（`UserService`、`OrderController`）');
-            lines.push('- 方法名 / 变量名：camelCase（`getUserById`、`orderList`）');
-            lines.push('- 常量：UPPER_SNAKE_CASE（`MAX_RETRY_COUNT`）');
-            lines.push('- DTO 后缀：`*Request` / `*Response` / `*DTO` / `*VO` 根据团队约定');
-        }
-        else if (isTs) {
-            lines.push('- 文件名：kebab-case（`user-service.ts`）或 camelCase（视团队约定）');
-            lines.push('- 类型 / 接口：PascalCase（`interface User`、`type OrderStatus`）');
-            lines.push('- 函数 / 变量：camelCase');
-            lines.push('- 常量：UPPER_SNAKE_CASE 或 camelCase（不可变配置）');
-        }
-        else {
-            lines.push('- 遵循所在语言生态的官方风格指南');
-        }
-        lines.push('', '### 代码组织', '');
-        lines.push('- 单文件职责单一，超过 300 行考虑拆分');
-        lines.push('- 避免循环依赖；模块边界清晰');
-        lines.push('- 公共工具函数沉淀到 `utils` / `common`，不重复造轮子');
-        lines.push('- **先读再改**：修改已有文件前必须先 Read，理解上下文再编辑');
-        lines.push('', '### 注释', '');
-        lines.push('- 默认不写注释；仅在"为什么这么做"不明显时补充');
-        lines.push('- 不要写"这个函数做什么"（代码本身应该自解释）');
-        lines.push('- 禁止遗留 `// TODO` 不跟单号、`// 临时` 不标日期');
-        lines.push('', '### 错误处理', '');
-        if (isJava) {
-            lines.push('- 优先抛出明确的业务异常，不吞异常');
-            lines.push('- Controller 层统一异常处理器（`@ControllerAdvice`）');
-            lines.push('- 事务边界清晰：`@Transactional` 只标注 Service 层');
-        }
-        else if (isTs) {
-            lines.push('- async/await 配合 try/catch，不要混用 Promise 链');
-            lines.push('- 错误类型显式声明，不要 throw 裸字符串');
-            lines.push('- 边界层（HTTP handler、消息消费者）必须有统一错误出口');
-        }
-        else {
-            lines.push('- 显式处理每一个错误返回值，不静默吞异常');
-        }
-        return lines.join('\n');
-    }
-    sectionCommonPitfalls(stack) {
-        const pitfalls = [];
-        if (stack.framework.includes('Spring Boot')) {
-            pitfalls.push('- **循环依赖**：优先重构为单向依赖，不要用 `@Lazy` 掩盖');
-            pitfalls.push('- **配置覆盖**：`application-{profile}.yml` 会覆盖 `application.yml`，排查配置问题时两边都要看');
-            pitfalls.push('- **事务失效**：`@Transactional` 同类内部方法调用不生效，需要通过 Spring 代理调用');
-        }
-        if (stack.framework.includes('MyBatis')) {
-            pitfalls.push('- **Mapper XML `#{}` vs `${}`**：`${}` 会导致 SQL 注入，只用于表名 / 列名等元数据');
-            pitfalls.push('- **N+1 查询**：使用 `<resultMap>` + `<collection>` 一次 JOIN 获取，避免循环查询');
-        }
-        if (stack.language.includes('TypeScript')) {
-            pitfalls.push('- **类型断言滥用**：`as unknown as T` 通常是设计问题的信号，优先修正类型定义');
-            pitfalls.push('- **Promise 未 await**：async 函数返回 Promise，调用方忘记 await 会导致错误被吞');
-        }
-        if (stack.framework.includes('React')) {
-            pitfalls.push('- **useEffect 依赖**：依赖数组遗漏变量会导致闭包陷阱；使用 ESLint `exhaustive-deps` 规则');
-            pitfalls.push('- **列表 key**：不要用 index 作为 key，列表重排时会错乱');
-        }
-        if (stack.language.some(l => l.startsWith('Go'))) {
-            pitfalls.push('- **goroutine 泄漏**：启动 goroutine 必须有退出路径（context.Done / channel close）');
-            pitfalls.push('- **for 循环变量捕获**：Go 1.21 之前循环变量在 goroutine 里共享，需要局部变量拷贝');
-        }
-        if (pitfalls.length === 0) {
-            pitfalls.push('- 依赖升级前先运行全量测试');
-            pitfalls.push('- 修改公共接口前先 grep 所有调用方，评估影响面');
-            pitfalls.push('- 禁止在 main 分支直接提交，所有改动走 PR / MR 流程');
-        }
-        return ['## 常见陷阱', '', ...pitfalls].join('\n');
-    }
-    sectionContributionGuide(stack) {
-        const isJava = stack.language.some(l => l.startsWith('Java'));
-        const lines = ['## 贡献指南', ''];
-        lines.push('### 分支策略', '');
-        lines.push('- `main` / `master`：受保护分支，只接受 PR 合并');
-        lines.push('- `feature/<ticket>-<slug>`：新功能开发');
-        lines.push('- `fix/<ticket>-<slug>`：Bug 修复');
-        lines.push('- `refactor/<scope>`：重构');
-        lines.push('', '### 提交信息（Conventional Commits）', '');
-        lines.push('```');
-        lines.push('<type>(<scope>): <subject>');
-        lines.push('');
-        lines.push('类型（type）：feat / fix / refactor / perf / test / docs / chore / style');
-        lines.push('范围（scope）：模块或目录名，例如 auth / api / ui');
-        lines.push('主题（subject）：50 字以内，祈使句，不加句号');
-        lines.push('```');
-        lines.push('');
-        lines.push('示例：`feat(auth): 新增 OAuth2 Google 登录`');
-        lines.push('', '### PR / MR 检查清单', '');
-        lines.push('- [ ] 通过所有自动化测试');
-        if (isJava) {
-            lines.push('- [ ] 通过 `mvn verify` / `./gradlew check`');
-        }
-        else if (stack.language.includes('TypeScript')) {
-            lines.push('- [ ] 通过 `npx tsc --noEmit`（类型检查）');
-            if (stack.linter)
-                lines.push(`- [ ] 通过 ${stack.linter} 检查`);
-        }
-        lines.push('- [ ] 新增代码有对应测试（除纯文档 / 配置外）');
-        lines.push('- [ ] 公共接口变更已更新文档');
-        lines.push('- [ ] 无敏感信息（密钥、token、内网地址）');
-        lines.push('- [ ] 经过至少一位 reviewer 审核');
-        return lines.join('\n');
+            }
+            lines.push(line);
+            if (isDir && depth < maxDepth && !SHALLOW_ONLY.has(name)) {
+                walk(fullPath, prefix + childPrefix, depth + 1);
+            }
+        });
+    };
+    const rootName = projectPath.split('/').filter(Boolean).pop() || 'project';
+    lines.push(rootName + '/');
+    walk(projectPath, '', 1);
+    return lines.join('\n');
+}
+export class ClaudeMdGenerator {
+    detector;
+    constructor(detector) {
+        this.detector = detector ?? new TechDetector();
     }
     /**
-     * 写入 CLAUDE.md，保留用户手动编辑的内容
+     * Write a CLAUDE.md file with the auto-generated block wrapped in
+     * `<!-- forge:claudemd-auto -->` markers, preserving any user-authored
+     * content that sits outside the block.
+     *
+     * Note: as of sub-spec A R-D, the `cf claudemd init/update` path no longer
+     * routes through this helper — it writes the file directly from the
+     * `claudemd-writer` agent output.  This method remains for any external
+     * embedder that still wants the marker-preserving merge semantics.
      */
     write(projectPath, content) {
         const claudeMdPath = join(projectPath, 'CLAUDE.md');
@@ -425,7 +150,8 @@ export class ClaudeMdGenerator {
         writeFileSync(claudeMdPath, final, 'utf-8');
     }
     /**
-     * 读取并分离自动生成和用户内容
+     * Read a CLAUDE.md file and split the auto-generated block from the
+     * surrounding user content.
      */
     read(projectPath) {
         const claudeMdPath = join(projectPath, 'CLAUDE.md');
@@ -446,60 +172,13 @@ export class ClaudeMdGenerator {
         const user = [before, after].filter(Boolean).join('\n\n');
         return { auto, user };
     }
-    // ── Private Methods ────────────────────────────────────────────────────
-    buildPrompt(stack, projectPath) {
-        const projectName = projectPath.split('/').filter(Boolean).pop() || 'project';
-        const isJava = stack.language.some(l => l.startsWith('Java'));
-        const realTree = this.scanDirectoryTree(projectPath, isJava ? 4 : 2, isJava);
-        const sections = [
-            `请为项目 "${projectName}" 生成 CLAUDE.md 文件内容，包含以下章节：`,
-            '',
-            '1. 项目概述',
-            '2. 技术栈',
-            '3. 开发规范',
-            '4. 构建与测试命令',
-            '5. 目录结构（**必须**直接使用下方给出的真实目录树，不得编造或改名）',
-            '6. 代码风格',
-            '7. 常见陷阱',
-            '8. 贡献指南',
-            '',
-            '## 检测到的技术栈',
-            '',
-            `- 语言: ${stack.language.join(', ') || '未检测到'}`,
-            `- 框架: ${stack.framework.join(', ') || '无'}`,
-            `- 包管理器: ${stack.packageManager}`,
-        ];
-        if (stack.testFramework) {
-            sections.push(`- 测试框架: ${stack.testFramework}`);
-        }
-        if (stack.linter) {
-            sections.push(`- Linter: ${stack.linter}`);
-        }
-        sections.push('', '## 项目真实目录结构（必须原样使用）', '', '```', realTree, '```', '', '⚠️ 生成"目录结构"章节时，**必须**用上面这个真实目录树，禁止使用 `project-root/`、`com/example/project/` 等占位符。', '', '请直接输出 Markdown 内容，不要包含代码块包裹。', '使用中文撰写。每个章节保持简洁，总长度控制在 200 行以内。');
-        return sections.join('\n');
-    }
     /**
-     * 强制替换 AI 输出中的"目录结构"章节为真实扫描结果。
-     *
-     * AI 经常即使拿到真实目录也会退化成模板（project-root/com/example/project）。
-     * 做字符串替换是最稳妥的兜底。
+     * Instance-level convenience wrapper around the module-level
+     * `scanDirectoryTree` export, kept for any external caller that already
+     * holds a `ClaudeMdGenerator` instance.
      */
-    overrideDirectoryStructure(content, stack, projectPath) {
-        const isJava = stack.language.some(l => l.startsWith('Java'));
-        const realTree = this.scanDirectoryTree(projectPath, isJava ? 4 : 2, isJava);
-        const realSection = ['## 目录结构', '', '```', realTree, '```'].join('\n');
-        // 匹配 "## 目录结构" 到下一个 "##" 之前的所有内容
-        const pattern = /^##\s+目录结构[\s\S]*?(?=^##\s|\Z)/m;
-        if (pattern.test(content)) {
-            return content.replace(pattern, realSection + '\n\n');
-        }
-        // 如果 AI 没生成目录结构章节，追加到末尾
-        return content.trimEnd() + '\n\n' + realSection + '\n';
-    }
-    merge(generated, userContent) {
-        if (!userContent)
-            return generated;
-        return [generated.trim(), '', '---', '', userContent.trim()].join('\n');
+    scanDirectoryTree(projectPath, maxDepth, addComments = false) {
+        return scanDirectoryTree(projectPath, maxDepth, addComments);
     }
 }
 //# sourceMappingURL=claudemd-generator.js.map