soloforge 1.1.2 → 1.1.31

package/dist/engine/knowledge_manager.js

@@ -1,781 +0,0 @@
-import fs from "node:fs/promises";
-import fss from "node:fs";
-import path from "node:path";
-import matter from "gray-matter";
-export async function auditKnowledge(knowledgeIndex, config) {
-    const { global: globalEntries, project: projectEntries } = knowledgeIndex.getAllEntries();
-    const all = [...globalEntries, ...projectEntries];
-    const findings = [];
-    const now = Date.now();
-    let findingId = 0;
-    // 1. Stale entries: last_used_at > 90 days or usage_count === 0
-    for (const entry of all) {
-        if (entry.status === "deprecated")
-            continue;
-        if (entry.usage_count === 0) {
-            findings.push({
-                id: `AUD-${String(++findingId).padStart(3, "0")}`,
-                severity: "info",
-                category: "stale",
-                entry_name: entry.name,
-                message: `从未被匹配使用: ${entry.name}`,
-                suggestion: "检查 when 触发词是否覆盖实际场景，或标记为 deprecated",
-            });
-        }
-        else if (entry.last_used_at) {
-            const daysSinceUse = (now - new Date(entry.last_used_at).getTime()) / (1000 * 60 * 60 * 24);
-            if (daysSinceUse > 90) {
-                findings.push({
-                    id: `AUD-${String(++findingId).padStart(3, "0")}`,
-                    severity: "warning",
-                    category: "stale",
-                    entry_name: entry.name,
-                    message: `超过 ${Math.floor(daysSinceUse)} 天未被使用: ${entry.name}`,
-                    suggestion: "评估是否仍需要，考虑更新触发词或标记为 deprecated",
-                });
-            }
-        }
-    }
-    // 2. Duplicate: similar when triggers
-    for (let i = 0; i < all.length; i++) {
-        for (let j = i + 1; j < all.length; j++) {
-            if (all[i].type !== all[j].type)
-                continue;
-            const overlap = keywordOverlap(all[i].when, all[j].when);
-            if (overlap >= 0.6) {
-                findings.push({
-                    id: `AUD-${String(++findingId).padStart(3, "0")}`,
-                    severity: "info",
-                    category: "duplicate",
-                    entry_name: `${all[i].name} / ${all[j].name}`,
-                    message: `触发词高度重叠 (${Math.round(overlap * 100)}%): "${all[i].name}" 和 "${all[j].name}"`,
-                    suggestion: "考虑合并或区分触发词",
-                });
-            }
-        }
-    }
-    // 3. Format: missing required frontmatter fields + schema validation
-    for (const entry of all) {
-        if (entry.status === "deprecated")
-            continue;
-        const issues = [];
-        if (!entry.when || entry.when.trim().length === 0)
-            issues.push("when");
-        if (!entry.scope || entry.scope.length === 0)
-            issues.push("scope");
-        if (!entry.products || entry.products.length === 0)
-            issues.push("products");
-        if (issues.length > 0) {
-            findings.push({
-                id: `AUD-${String(++findingId).padStart(3, "0")}`,
-                severity: "warning",
-                category: "format",
-                entry_name: entry.name,
-                message: `缺少必需字段: ${issues.join(", ")}`,
-                suggestion: `补充 ${issues.join("、")} 字段`,
-            });
-        }
-        // 3b. Schema validation: read raw file for deeper checks
-        const schemaIssues = await validateFormatSchema(entry);
-        for (const issue of schemaIssues) {
-            findings.push({
-                id: `AUD-${String(++findingId).padStart(3, "0")}`,
-                severity: "info",
-                category: "format",
-                entry_name: entry.name,
-                message: issue.message,
-                suggestion: issue.suggestion,
-            });
-        }
-    }
-    // 4. Coverage: check knowledge types have entries
-    const requiredTypes = ["pattern", "procedure", "domain", "review_rule"];
-    for (const type of requiredTypes) {
-        const count = all.filter((e) => e.type === type && e.status !== "deprecated").length;
-        if (count === 0) {
-            findings.push({
-                id: `AUD-${String(++findingId).padStart(3, "0")}`,
-                severity: "warning",
-                category: "coverage",
-                entry_name: `type=${type}`,
-                message: `缺少 ${type} 类型的知识条目`,
-                suggestion: `新增至少一个 ${type} 条目`,
-            });
-        }
-    }
-    // 5. Completeness: check rule/AC counts against type thresholds
-    for (const entry of all) {
-        if (entry.status === "deprecated")
-            continue;
-        if (!entry.file_path || !fss.existsSync(entry.file_path))
-            continue;
-        const thresholds = COMPLETENESS_THRESHOLDS[entry.type];
-        if (!thresholds)
-            continue;
-        let raw;
-        try {
-            raw = await fs.readFile(entry.file_path, "utf-8");
-        }
-        catch {
-            continue;
-        }
-        const { content: body } = matter(raw);
-        for (const check of thresholds) {
-            const count = countPattern(body, check.pattern);
-            if (count < check.minimum) {
-                findings.push({
-                    id: `AUD-${String(++findingId).padStart(3, "0")}`,
-                    severity: "info",
-                    category: "completeness",
-                    entry_name: entry.name,
-                    message: `${entry.type} 条目"${entry.name}"的 ${check.field} 不足：实际 ${count} 条，要求 ≥ ${check.minimum} 条`,
-                    suggestion: `运行 sf_knowledge_update 补充 ${check.field}，或调用 sf_knowledge_add 的 auto_enrich 机制自动探索行业最佳实践`,
-                });
-            }
-        }
-    }
-    const summary = {
-        stale: findings.filter((f) => f.category === "stale").length,
-        duplicate: findings.filter((f) => f.category === "duplicate").length,
-        format: findings.filter((f) => f.category === "format").length,
-        coverage: findings.filter((f) => f.category === "coverage").length,
-        completeness: findings.filter((f) => f.category === "completeness").length,
-        design_drift: 0,
-    };
-    return {
-        total_entries: all.filter((e) => e.status !== "deprecated").length,
-        findings,
-        summary,
-        audited_at: new Date().toISOString(),
-    };
-}
-export async function addKnowledge(input, config) {
-    const knowledgeDir = getProjectKnowledgeDir(config);
-    const fileName = `${input.title}.md`;
-    // Determine save location
-    const typeDir = getTypeDirectory(input.type);
-    const draftsDir = path.join(knowledgeDir, "drafts");
-    const targetDir = input.save_to_drafts !== false
-        ? draftsDir
-        : path.join(knowledgeDir, typeDir);
-    // Ensure directory exists
-    await fs.mkdir(targetDir, { recursive: true });
-    const filePath = path.join(targetDir, fileName);
-    // Check if file already exists
-    if (fss.existsSync(filePath)) {
-        return {
-            success: false,
-            file_path: filePath,
-            is_draft: input.save_to_drafts !== false,
-            message: `文件已存在: ${filePath}，请使用 sf_knowledge_update 更新`,
-        };
-    }
-    // Generate content
-    const content = generateKnowledgeContent(input);
-    await fs.writeFile(filePath, content, "utf-8");
-    const enrichment_guide = input.auto_enrich !== false
-        ? buildEnrichmentGuide(input)
-        : undefined;
-    return {
-        success: true,
-        file_path: filePath,
-        is_draft: input.save_to_drafts !== false,
-        message: input.save_to_drafts !== false
-            ? `知识条目草稿已保存到: ${filePath}\n人工 review 后可移至正式目录: ${path.join(knowledgeDir, typeDir, fileName)}`
-            : `知识条目已保存到: ${filePath}`,
-        enrichment_guide,
-    };
-}
-export async function updateKnowledge(input, knowledgeIndex, config) {
-    const entry = knowledgeIndex.getEntry(input.entry_name)
-        ?? knowledgeIndex.getAllEntries().global.find((e) => e.name === input.entry_name)
-        ?? knowledgeIndex.getAllEntries().project.find((e) => e.name === input.entry_name);
-    if (!entry) {
-        return {
-            success: false,
-            file_path: "",
-            backup_path: "",
-            message: `未找到知识条目: ${input.entry_name}`,
-        };
-    }
-    const filePath = entry.file_path;
-    if (!fss.existsSync(filePath)) {
-        return {
-            success: false,
-            file_path: filePath,
-            backup_path: "",
-            message: `文件不存在: ${filePath}`,
-        };
-    }
-    // Read and parse
-    const raw = await fs.readFile(filePath, "utf-8");
-    const { data: frontmatter, content: body } = matter(raw);
-    // Create backup
-    const backupDir = path.join(path.dirname(filePath), ".backups");
-    await fs.mkdir(backupDir, { recursive: true });
-    const backupPath = path.join(backupDir, `${entry.name}-${Date.now()}.md`);
-    await fs.writeFile(backupPath, raw, "utf-8");
-    // Apply updates
-    let updated = false;
-    if (input.updates.when_triggers) {
-        frontmatter.when = input.updates.when_triggers;
-        updated = true;
-    }
-    if (input.updates.status) {
-        frontmatter.status = input.updates.status;
-        updated = true;
-    }
-    let newBody = body;
-    if (input.updates.add_decision_rules?.length) {
-        const rulesSection = input.updates.add_decision_rules
-            .map((r) => `- ${r}`)
-            .join("\n");
-        if (newBody.includes("## 决策规则")) {
-            newBody = newBody.replace(/## 决策规则\n/, `## 决策规则\n${rulesSection}\n`);
-        }
-        else {
-            newBody += `\n\n## 决策规则\n${rulesSection}\n`;
-        }
-        updated = true;
-    }
-    if (input.updates.add_acceptance_criteria?.length) {
-        const acSection = input.updates.add_acceptance_criteria
-            .map((ac, i) => `- [AC-${String(i + 1).padStart(2, "0")}] ${ac}`)
-            .join("\n");
-        if (newBody.includes("## 验收项")) {
-            newBody = newBody.replace(/## 验收项\n/, `## 验收项\n${acSection}\n`);
-        }
-        else {
-            newBody += `\n\n## 验收项\n${acSection}\n`;
-        }
-        updated = true;
-    }
-    if (!updated) {
-        return {
-            success: false,
-            file_path: filePath,
-            backup_path: backupPath,
-            message: "未提供任何更新内容",
-        };
-    }
-    // Write updated file
-    const output = matter.stringify(newBody, frontmatter);
-    await fs.writeFile(filePath, output, "utf-8");
-    return {
-        success: true,
-        file_path: filePath,
-        backup_path: backupPath,
-        message: `知识条目已更新: ${filePath}\n备份: ${backupPath}`,
-    };
-}
-// ── Format Schema ──
-const CANONICAL_FM_ORDER = ["name", "type", "when", "scope", "products"];
-const FORMAT_SCHEMA = {
-    pattern: {
-        required_headings: ["## 决策规则", "## 验收项"],
-    },
-    domain: {
-        required_headings: ["## 业务规则", "## 约束条件", "## 例外情况", "## 关联模式"],
-    },
-    procedure: {
-        required_headings: ["## 适用场景", "## 步骤", "## 检查点", "## 注意事项"],
-    },
-    pipeline_procedure: {
-        required_headings: [],
-        partial_match_headings: ["### 第"],
-    },
-    review_rule: {
-        required_headings: [],
-        partial_match_headings: ["pattern:", "severity:", "description:"],
-    },
-    acceptance_template: {
-        required_headings: [],
-    },
-};
-const COMPLETENESS_THRESHOLDS = {
-    pattern: [
-        { field: "决策规则", pattern: /^- /gm, minimum: 5 },
-        { field: "验收项", pattern: /^- \[AC-/gm, minimum: 3 },
-    ],
-    domain: [
-        { field: "业务规则", pattern: /^(?:- |\d+\.)/gm, minimum: 6 },
-    ],
-    procedure: [
-        { field: "步骤", pattern: /^\d+\.\s/gm, minimum: 5 },
-        { field: "检查点", pattern: /^- \[ \]/gm, minimum: 3 },
-    ],
-    pipeline_procedure: [
-        { field: "阶段", pattern: /^### 第\d+步/gm, minimum: 3 },
-    ],
-    review_rule: [
-        { field: "规则", pattern: /^## [A-Z]+-\d+/gm, minimum: 5 },
-    ],
-};
-function countPattern(body, pattern) {
-    return (body.match(pattern) ?? []).length;
-}
-async function validateFormatSchema(entry) {
-    const results = [];
-    if (!entry.file_path || !fss.existsSync(entry.file_path))
-        return results;
-    let raw;
-    try {
-        raw = await fs.readFile(entry.file_path, "utf-8");
-    }
-    catch {
-        return results;
-    }
-    const { data: fm, content: body } = matter(raw);
-    // Check frontmatter field order
-    const fmKeys = Object.keys(fm);
-    const orderIssues = [];
-    for (let i = 0; i < CANONICAL_FM_ORDER.length; i++) {
-        const expected = CANONICAL_FM_ORDER[i];
-        if (i < fmKeys.length && fmKeys[i] !== expected) {
-            orderIssues.push(`期望第 ${i + 1} 个字段为 ${expected}，实际为 ${fmKeys[i]}`);
-            break;
-        }
-    }
-    if (orderIssues.length > 0) {
-        results.push({
-            message: `frontmatter 字段顺序不规范: ${orderIssues[0]}`,
-            suggestion: `标准顺序: ${CANONICAL_FM_ORDER.join(" → ")}`,
-        });
-    }
-    // Check when style: first comma-separated segment should be ≤ 10 Chinese chars
-    const whenStr = fm.when ?? "";
-    const firstSegment = whenStr.split(/[,\s，]/)[0] ?? "";
-    const chineseCharCount = (firstSegment.match(/[一-鿿]/g) ?? []).length;
-    if (chineseCharCount > 10 && firstSegment.length > 12) {
-        results.push({
-            message: `when 字段首个触发词过长（${chineseCharCount} 个中文字符），疑似描述性短语: "${firstSegment}"`,
-            suggestion: "when 应为纯关键词逗号分隔，如: 数据导出, CSV, Excel, 批量导出",
-        });
-    }
-    // Check body headings
-    const schema = FORMAT_SCHEMA[entry.type];
-    if (schema) {
-        for (const heading of schema.required_headings) {
-            if (!body.includes(heading)) {
-                results.push({
-                    message: `body 缺少必需标题: ${heading}（type=${entry.type}）`,
-                    suggestion: `按格式规约补充 ${heading} 部分`,
-                });
-            }
-        }
-        if (schema.partial_match_headings) {
-            for (const partial of schema.partial_match_headings) {
-                if (!body.includes(partial)) {
-                    results.push({
-                        message: `body 缺少必需内容: "${partial}"（type=${entry.type}）`,
-                        suggestion: `按格式规约补充包含 "${partial}" 的内容`,
-                    });
-                }
-            }
-        }
-    }
-    return results;
-}
-// ── Helpers ──
-function keywordOverlap(a, b) {
-    const wordsA = new Set(a.toLowerCase().split(/[,\s，]+/).filter(Boolean));
-    const wordsB = new Set(b.toLowerCase().split(/[,\s，]+/).filter(Boolean));
-    if (wordsA.size === 0 || wordsB.size === 0)
-        return 0;
-    let overlap = 0;
-    for (const w of wordsA) {
-        if (wordsB.has(w))
-            overlap++;
-    }
-    return overlap / Math.min(wordsA.size, wordsB.size);
-}
-function getTypeDirectory(type) {
-    const map = {
-        pattern: "patterns",
-        procedure: "procedures",
-        pipeline_procedure: "procedures",
-        domain: "domain",
-        acceptance_template: "acceptance_templates",
-        review_rule: "review_rules",
-    };
-    return map[type] ?? "procedures";
-}
-function generateFrontmatter(input) {
-    return `---
-name: ${input.title}
-type: ${input.type}
-when: "${input.when_triggers}"
-scope: [${input.scope.join(", ")}]
-products: ["*"]
----`;
-}
-function generateKnowledgeContent(input) {
-    const fm = generateFrontmatter(input);
-    const generators = {
-        pattern: () => generatePatternBody(input),
-        domain: () => generateDomainBody(input),
-        procedure: () => generateProcedureBody(input),
-        pipeline_procedure: () => generatePipelineBody(input),
-        review_rule: () => generateReviewRuleBody(input),
-        acceptance_template: () => generateAcceptanceBody(input),
-    };
-    const gen = generators[input.type] ?? generators.pattern;
-    return `${fm}\n\n${gen()}\n`;
-}
-function generatePatternBody(input) {
-    const rules = input.decision_rules
-        ? input.decision_rules.split("\n").filter(Boolean).map((r) => `- ${r}`).join("\n")
-        : "- (待补充决策规则)";
-    return `## 决策规则
-${rules}
-
-## 验收项
-- [AC-01] (待补充验收标准)`;
-}
-function generateDomainBody(input) {
-    const rules = input.decision_rules
-        ? input.decision_rules.split("\n").filter(Boolean).map((r) => `${r}`).join("\n\n")
-        : "(待补充业务规则)";
-    return `## 业务规则
-${rules}
-
-## 约束条件
-- (待补充约束条件)
-
-## 例外情况
-- (待补充例外情况)
-
-## 关联模式
-- (待补充关联模式)`;
-}
-function generateProcedureBody(input) {
-    return `## 适用场景
-(待补充适用场景描述)
-
-## 步骤
-1. (待补充步骤)
-
-## 检查点
-- [ ] (待补充检查点)
-
-## 注意事项
-- (待补充注意事项)`;
-}
-function generatePipelineBody(input) {
-    return `# ${input.title}
-
-### 第1步：定义阶段
-(待补充阶段描述)
-产出保存到：.soloforge/output/01-产出.md
-工具：sf_classify, sf_expand
-
-### 第2步：执行阶段
-(待补充阶段描述)
-工具：sf_verify`;
-}
-function generateReviewRuleBody(input) {
-    const code = input.title.toUpperCase().replace(/-/g, "").slice(0, 3);
-    return `## ${code}-01: (待补充规则标题)
-pattern: /(待补充正则)/
-severity: warning
-scope: ${input.scope.join(", ")}
-description: (待补充规则描述)`;
-}
-function generateAcceptanceBody(input) {
-    return `# ${input.title}
-
-## 1. (待补充章节标题)
-(待补充内容)
-
-## 2. (待补充章节标题)
-(待补充内容)`;
-}
-// ── Enrichment Guide ──
-function extractTopicFromTitle(title) {
-    return title.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
-}
-function buildEnrichmentGuide(input) {
-    const builders = {
-        pattern: () => buildPatternGuide(input),
-        domain: () => buildDomainGuide(input),
-        procedure: () => buildProcedureGuide(input),
-        pipeline_procedure: () => buildPipelineGuide(input),
-        review_rule: () => buildReviewRuleGuide(input),
-        acceptance_template: () => buildAcceptanceGuide(input),
-    };
-    return builders[input.type]();
-}
-function buildPatternGuide(input) {
-    const topic = extractTopicFromTitle(input.title);
-    return {
-        entry_name: input.title,
-        type: "pattern",
-        overview: `从行业最佳实践中提取"${topic}"领域的决策规则和验收标准。规则应具体、可操作、可验证，覆盖安全、性能、可维护性等维度。`,
-        steps: [
-            {
-                step_number: 1,
-                action: `搜索"${topic}"的最佳实践、常见陷阱和反模式`,
-                search_queries: [`${topic} best practices software development`, `${topic} common mistakes anti-patterns`, `${topic} production checklist enterprise`],
-                focus_areas: ["常见错误", "性能陷阱", "安全风险", "可维护性"],
-            },
-            {
-                step_number: 2,
-                action: `从搜索结果中提取至少 5 条决策规则`,
-                search_queries: [`${topic} coding guidelines ${input.scope.join(" ")}`, `${topic} design patterns enterprise java`],
-                focus_areas: ["规则具体性", "可操作性", "互斥性"],
-            },
-            {
-                step_number: 3,
-                action: "为每条规则设计可验证的验收标准（AC）",
-                focus_areas: ["可自动化检查", "明确的通过/失败标准"],
-            },
-            {
-                step_number: 4,
-                action: `调用 sf_knowledge_update 将探索到的规则和验收项写入文件`,
-                focus_areas: ["使用 add_decision_rules 和 add_acceptance_criteria 参数"],
-            },
-        ],
-        authoritative_sources: [
-            "OWASP Cheat Sheet Series — 安全相关模式",
-            "Google Engineering Practices (google.github.io/eng-practices) — 代码评审实践",
-            "Alibaba Java Development Manual — Java 开发最佳实践",
-            "Martin Fowler's Patterns Catalog — 设计模式",
-            "Microsoft API Guidelines — API 设计模式",
-        ],
-        completeness_thresholds: [
-            { field: "decision_rules", minimum: 5 },
-            { field: "acceptance_criteria", minimum: 3 },
-        ],
-        update_call_template: `sf_knowledge_update(entry_name="${input.title}", add_decision_rules=[规则1, 规则2, ...], add_acceptance_criteria=[标准1, 标准2, ...])`,
-    };
-}
-function buildDomainGuide(input) {
-    const topic = extractTopicFromTitle(input.title);
-    return {
-        entry_name: input.title,
-        type: "domain",
-        overview: `研究"${topic}"领域的行业标准和监管要求，提取业务规则、约束条件、例外情况和关联模式。`,
-        steps: [
-            {
-                step_number: 1,
-                action: `搜索"${topic}"领域的行业标准和法规要求`,
-                search_queries: [`${topic} business rules industry standard`, `${topic} compliance regulatory requirements`, `${topic} domain driven design`],
-                focus_areas: ["行业法规", "合规要求", "业务约束"],
-            },
-            {
-                step_number: 2,
-                action: "提取核心业务规则（什么必须为真、什么不能发生）",
-                focus_areas: ["业务规则", "状态约束", "数据完整性"],
-            },
-            {
-                step_number: 3,
-                action: "识别技术约束和操作约束",
-                focus_areas: ["性能约束", "安全约束", "容量约束"],
-            },
-            {
-                step_number: 4,
-                action: "列举例外场景和边界条件",
-                focus_areas: ["边缘场景", "特殊条件", "豁免情况"],
-            },
-            {
-                step_number: 5,
-                action: `调用 sf_knowledge_update 将探索到的内容写入文件`,
-                focus_areas: ["使用 add_decision_rules 写入业务规则"],
-            },
-        ],
-        authoritative_sources: [
-            "OWASP — 安全相关领域",
-            "PCI-DSS — 支付相关领域",
-            "GDPR / 个人信息保护法 — 数据隐私领域",
-            "Domain-Driven Design (Eric Evans) — 领域建模",
-            "行业特定标准（HIPAA/SOX/ISO 27001）",
-        ],
-        completeness_thresholds: [
-            { field: "business_rules", minimum: 6 },
-            { field: "constraints", minimum: 4 },
-            { field: "exceptions", minimum: 2 },
-            { field: "related_patterns", minimum: 1 },
-        ],
-        update_call_template: `sf_knowledge_update(entry_name="${input.title}", add_decision_rules=[业务规则1, 业务规则2, ...])`,
-    };
-}
-function buildProcedureGuide(input) {
-    const topic = extractTopicFromTitle(input.title);
-    return {
-        entry_name: input.title,
-        type: "procedure",
-        overview: `研究"${topic}"的标准操作流程，拆分为有序步骤、检查点和注意事项。`,
-        steps: [
-            {
-                step_number: 1,
-                action: `搜索"${topic}"的标准流程和行业实践`,
-                search_queries: [`${topic} standard procedure workflow`, `${topic} step by step guide`, `${topic} operational best practices`],
-                focus_areas: ["标准流程", "关键步骤", "验证节点"],
-            },
-            {
-                step_number: 2,
-                action: "将流程拆分为有序的原子步骤",
-                focus_areas: ["步骤顺序", "步骤原子性", "输入输出明确"],
-            },
-            {
-                step_number: 3,
-                action: "在关键节点设计检查点（验证门禁）",
-                focus_areas: ["质量门禁", "可验证条件"],
-            },
-            {
-                step_number: 4,
-                action: "识别常见陷阱和注意事项",
-                focus_areas: ["常见错误", "风险点", "最佳实践"],
-            },
-            {
-                step_number: 5,
-                action: `调用 sf_knowledge_update 将步骤内容写入文件`,
-                focus_areas: ["使用 add_decision_rules 写入步骤和注意事项"],
-            },
-        ],
-        authoritative_sources: [
-            "Google SRE Book — 运维流程实践",
-            "CI/CD Pipeline Best Practices — 部署发布流程",
-            "Git Workflow Guides — 代码管理流程",
-            "OWASP Secure Development Lifecycle — 安全开发流程",
-        ],
-        completeness_thresholds: [
-            { field: "steps", minimum: 5 },
-            { field: "checkpoints", minimum: 3 },
-            { field: "notes", minimum: 3 },
-        ],
-        update_call_template: `sf_knowledge_update(entry_name="${input.title}", add_decision_rules=[步骤内容, 注意事项, ...])`,
-    };
-}
-function buildPipelineGuide(input) {
-    const topic = extractTopicFromTitle(input.title);
-    return {
-        entry_name: input.title,
-        type: "pipeline_procedure",
-        overview: `设计"${topic}"的多阶段流水线，明确每个阶段的工具、产出和检查点。`,
-        steps: [
-            {
-                step_number: 1,
-                action: `搜索"${topic}"相关的流水线或工作流设计`,
-                search_queries: [`${topic} pipeline workflow design`, `${topic} multi-phase process`],
-                focus_areas: ["阶段划分", "阶段边界", "入口/出口条件"],
-            },
-            {
-                step_number: 2,
-                action: "为每个阶段映射具体的 SoloForge 工具（sf_classify, sf_expand, sf_verify 等）",
-                focus_areas: ["工具选择", "工具参数"],
-            },
-            {
-                step_number: 3,
-                action: "定义每个阶段的产出物和保存路径",
-                focus_areas: ["产出格式", "路径规范"],
-            },
-            {
-                step_number: 4,
-                action: `调用 sf_knowledge_update 将阶段内容写入文件`,
-                focus_areas: ["使用 add_decision_rules 写入阶段定义"],
-            },
-        ],
-        authoritative_sources: [
-            "CI/CD Pipeline Best Practices",
-            "Google SRE Release Engineering",
-            "GitHub Actions Workflow Patterns",
-        ],
-        completeness_thresholds: [
-            { field: "phases", minimum: 3 },
-            { field: "tools_per_phase", minimum: 1 },
-        ],
-        update_call_template: `sf_knowledge_update(entry_name="${input.title}", add_decision_rules=[阶段定义1, 阶段定义2, ...])`,
-    };
-}
-function buildReviewRuleGuide(input) {
-    const topic = extractTopicFromTitle(input.title);
-    return {
-        entry_name: input.title,
-        type: "review_rule",
-        overview: `研究"${topic}"相关的代码质量问题，定义正则匹配规则、严重级别和描述。规则需覆盖安全、性能、质量维度。`,
-        steps: [
-            {
-                step_number: 1,
-                action: `搜索"${topic}"相关的常见代码质量问题和安全漏洞`,
-                search_queries: [`${topic} code review checklist`, `${topic} static analysis rules`, `${topic} common vulnerabilities patterns`],
-                focus_areas: ["代码异味", "安全漏洞模式", "性能反模式"],
-            },
-            {
-                step_number: 2,
-                action: "为每个问题定义可匹配的正则表达式（pattern）",
-                focus_areas: ["正则精确性", "误报率控制", "覆盖变体"],
-            },
-            {
-                step_number: 3,
-                action: "分配严重级别（critical/warning/info）并编写描述",
-                focus_areas: ["严重度合理性", "描述清晰性", "修复建议"],
-            },
-            {
-                step_number: 4,
-                action: `调用 sf_knowledge_update 将规则写入文件`,
-                focus_areas: ["使用 add_decision_rules 写入规则定义"],
-            },
-        ],
-        authoritative_sources: [
-            "OWASP Code Review Guide — 安全审查规则",
-            "ESLint / PMD / Checkstyle Rule Catalogs — 静态分析规则",
-            "Google Style Guides — 代码风格规则",
-            "Alibaba Java Development Manual — Java 规则",
-            "SonarQube Rule Definitions — 质量规则",
-        ],
-        completeness_thresholds: [
-            { field: "rules", minimum: 5 },
-            { field: "critical_rules", minimum: 1 },
-        ],
-        update_call_template: `sf_knowledge_update(entry_name="${input.title}", add_decision_rules=[规则定义1, 规则定义2, ...])`,
-    };
-}
-function buildAcceptanceGuide(input) {
-    const topic = extractTopicFromTitle(input.title);
-    return {
-        entry_name: input.title,
-        type: "acceptance_template",
-        overview: `研究"${topic}"的行业标准验收门禁，设计覆盖安全、性能、质量维度的验收清单，每个验收项需包含可执行的检查命令。`,
-        steps: [
-            {
-                step_number: 1,
-                action: `搜索"${topic}"的质量门禁和验收标准`,
-                search_queries: [`${topic} acceptance criteria checklist`, `${topic} quality gate verification`, `${topic} production readiness review`],
-                focus_areas: ["安全验收", "性能验收", "功能验收", "合规验收"],
-            },
-            {
-                step_number: 2,
-                action: "为每个验收项设计可执行的检查命令（grep/find/test 命令）",
-                focus_areas: ["命令可执行性", "结果可判定性"],
-            },
-            {
-                step_number: 3,
-                action: "确保验收项覆盖安全（≥2项）和质量（≥2项）维度",
-                focus_areas: ["安全覆盖", "质量覆盖", "独立性"],
-            },
-            {
-                step_number: 4,
-                action: `调用 sf_knowledge_update 将验收项写入文件`,
-                focus_areas: ["使用 add_acceptance_criteria 写入验收项"],
-            },
-        ],
-        authoritative_sources: [
-            "OWASP ASVS (Application Security Verification Standard) — 安全验收",
-            "Microsoft Security Development Lifecycle — 安全开发验收",
-            "Google Engineering Practices — 代码质量验收",
-            "IEEE Software Quality Standards — 软件质量标准",
-        ],
-        completeness_thresholds: [
-            { field: "acceptance_criteria", minimum: 10 },
-            { field: "security_acs", minimum: 2 },
-            { field: "check_commands", minimum: 10 },
-        ],
-        update_call_template: `sf_knowledge_update(entry_name="${input.title}", add_acceptance_criteria=[验收项1, 验收项2, ...])`,
-    };
-}
-function getProjectKnowledgeDir(config) {
-    const projectDir = config._projectPath ?? process.cwd();
-    return path.join(projectDir, ".soloforge", "knowledge");
-}
-//# sourceMappingURL=knowledge_manager.js.map