soloforge 1.0.0

package/dist/engine/knowledge_manager.js

@@ -0,0 +1,781 @@
+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