xtep-workspace 1.10.10

package/dist/storage/MarkdownStorage.js

@@ -0,0 +1,918 @@
+// src/storage/MarkdownStorage.ts
+// ============================================================================
+// ⚠️ 重要：参数命名约定
+// ============================================================================
+// 本文件中的方法参数遵循以下命名规范：
+//
+// - workspaceId: 工作区的唯一标识符（如 "ws-abc123"）
+//   用于工作区级别的操作（Workspace.md, Log.md 等）
+//
+// - wsDirName: 工作区的实际目录名（可能与 workspaceId 不同）
+//   用于节点级别的操作，因为需要先定位工作区目录
+//
+// - nodeDirName: 节点的实际目录名（可能与 nodeId 不同）
+//   从 graph.json 中获取：graph.nodes[nodeId].dirName || nodeId
+//
+// 调用方在使用节点相关方法前，必须先通过 JsonStorage.readGraph() 获取正确的 dirName
+// 参见 src/http/services.ts 中的 resolveDirNames() 辅助函数
+// ============================================================================
+import { formatShort } from "../utils/time.js";
+import { validateMultilineContent, validateSingleLineContent, validateRules, escapeTableCell, unescapeTableCell, } from "../utils/contentValidation.js";
+/**
+ * Markdown 存储封装
+ * 提供 Markdown 文件的读写和 frontmatter 解析
+ */
+export class MarkdownStorage {
+    fs;
+    constructor(fs) {
+        this.fs = fs;
+    }
+    // ========== 解析与序列化 ==========
+    /**
+     * 解析 Markdown 内容（提取 frontmatter 和正文）
+     * 增强健壮性：处理各种边界情况和格式变体
+     */
+    parse(content) {
+        // 处理空内容
+        if (!content || typeof content !== "string") {
+            return {
+                frontmatter: {},
+                content: ""
+            };
+        }
+        // 规范化换行符（处理 Windows \r\n）
+        const normalizedContent = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+        // 更宽松的 frontmatter 正则：允许开头有空白，末尾可选换行
+        const frontmatterRegex = /^\s*---\n([\s\S]*?)\n---\n?([\s\S]*)$/;
+        const match = normalizedContent.match(frontmatterRegex);
+        if (!match) {
+            return {
+                frontmatter: {},
+                content: normalizedContent.trim()
+            };
+        }
+        const frontmatterStr = match[1];
+        const body = match[2];
+        // 增强的 YAML 解析（处理引号值、冒号在值中等情况）
+        const frontmatter = {};
+        const lines = frontmatterStr.split("\n");
+        for (const line of lines) {
+            // 跳过空行和注释
+            const trimmedLine = line.trim();
+            if (!trimmedLine || trimmedLine.startsWith("#")) {
+                continue;
+            }
+            const colonIndex = line.indexOf(":");
+            if (colonIndex !== -1) {
+                const key = line.substring(0, colonIndex).trim();
+                let value = line.substring(colonIndex + 1).trim();
+                // 处理引号包裹的值（支持单引号和双引号）
+                if ((value.startsWith('"') && value.endsWith('"')) ||
+                    (value.startsWith("'") && value.endsWith("'"))) {
+                    value = value.slice(1, -1);
+                }
+                if (key) {
+                    frontmatter[key] = value;
+                }
+            }
+        }
+        return {
+            frontmatter,
+            content: body
+        };
+    }
+    /**
+     * 安全地提取 section 内容
+     * @param content Markdown 内容
+     * @param sectionName section 名称（不含 ##）
+     * @param isLast 是否是最后一个 section（不需要后续 section 作为结束标记）
+     * @returns 提取的内容，如果未找到返回空字符串
+     */
+    extractSection(content, sectionName, isLast = false) {
+        if (!content)
+            return "";
+        // 规范化换行符
+        const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+        // 构建更宽松的正则：允许 section 标题后有可选的提示行（> 开头）
+        const pattern = isLast
+            ? new RegExp(`## ${sectionName}\\n\\n(?:>.*\\n\\n)?([\\s\\S]*)$`)
+            : new RegExp(`## ${sectionName}\\n\\n(?:>.*\\n\\n)?([\\s\\S]*?)(?=\\n## |$)`);
+        const match = normalized.match(pattern);
+        return match ? match[1].trim() : "";
+    }
+    /**
+     * 安全解析列表项
+     * @param content section 内容
+     * @returns 列表项数组
+     */
+    parseListItems(content) {
+        if (!content)
+            return [];
+        return content
+            .split("\n")
+            .filter(line => line.trim().startsWith("- "))
+            .map(line => line.trim().substring(2).trim())
+            .filter(item => item.length > 0);
+    }
+    /**
+     * 序列化 Markdown 数据
+     */
+    serialize(data) {
+        const frontmatterLines = [];
+        for (const [key, value] of Object.entries(data.frontmatter)) {
+            frontmatterLines.push(`${key}: ${value}`);
+        }
+        return `---\n${frontmatterLines.join("\n")}\n---\n${data.content}`;
+    }
+    // ========== Workspace.md ==========
+    /**
+     * 读取 Workspace.md
+     * @param isArchived 是否为归档工作区
+     */
+    async readWorkspaceMd(projectRoot, workspaceId, isArchived = false) {
+        const mdPath = isArchived
+            ? this.fs.getWorkspaceMdPathWithArchive(projectRoot, workspaceId, true)
+            : this.fs.getWorkspaceMdPath(projectRoot, workspaceId);
+        const content = await this.fs.readFile(mdPath);
+        const parsed = this.parse(content);
+        // 解析规则
+        const rules = [];
+        const rulesMatch = parsed.content.match(/## 规则\n\n(?:>.*\n\n)?([\s\S]*?)(?=\n## |$)/);
+        if (rulesMatch) {
+            const rulesContent = rulesMatch[1].trim();
+            if (rulesContent) {
+                const ruleLines = rulesContent.split("\n").filter(line => line.startsWith("- "));
+                for (const line of ruleLines) {
+                    rules.push(line.substring(2).trim());
+                }
+            }
+        }
+        // 解析文档
+        const docs = [];
+        const docsMatch = parsed.content.match(/## 文档\n\n(?:>.*\n\n)?([\s\S]*?)(?=\n## |$)/);
+        if (docsMatch) {
+            const docsContent = docsMatch[1].trim();
+            if (docsContent) {
+                const docLines = docsContent.split("\n").filter(line => line.startsWith("- "));
+                for (const line of docLines) {
+                    const docMatch = line.match(/- \[(.+?)\]\((.+?)\)(?: - (.+))?/);
+                    if (docMatch) {
+                        docs.push({
+                            path: docMatch[2],
+                            description: docMatch[3] || docMatch[1]
+                        });
+                    }
+                }
+            }
+        }
+        // goal 已移至根节点 requirement，不再从 Workspace.md 读取
+        return {
+            name: parsed.frontmatter.name || "",
+            createdAt: parsed.frontmatter.createdAt || "",
+            updatedAt: parsed.frontmatter.updatedAt || "",
+            rules,
+            docs,
+        };
+    }
+    /**
+     * 读取旧版 Workspace.md 中的 goal（仅用于懒迁移）
+     * 新版工作区 goal 存储在根节点 requirement 中
+     * @returns goal 内容，如果不存在或为空返回 null
+     */
+    async readLegacyGoal(projectRoot, workspaceId, isArchived = false) {
+        try {
+            const mdPath = isArchived
+                ? this.fs.getWorkspaceMdPathWithArchive(projectRoot, workspaceId, true)
+                : this.fs.getWorkspaceMdPath(projectRoot, workspaceId);
+            const content = await this.fs.readFile(mdPath);
+            const parsed = this.parse(content);
+            // 解析旧版 ## 目标 section
+            const goalMatch = parsed.content.match(/## 目标\n\n([\s\S]*?)(?=\n## |$)/);
+            if (goalMatch) {
+                const goal = goalMatch[1].trim();
+                if (goal) {
+                    return goal;
+                }
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * 写入 Workspace.md
+     */
+    async writeWorkspaceMd(projectRoot, workspaceId, data) {
+        // 验证内容格式
+        validateSingleLineContent(data.name, "工作区名称");
+        // goal 已移至根节点 requirement，不再写入 Workspace.md
+        if (data.rules.length > 0) {
+            validateRules(data.rules);
+        }
+        const mdPath = this.fs.getWorkspaceMdPath(projectRoot, workspaceId);
+        const rulesContent = data.rules.length > 0
+            ? data.rules.map(rule => `- ${rule}`).join("\n")
+            : "";
+        const docsContent = data.docs.length > 0
+            ? data.docs.map(doc => `- [${doc.description}](${doc.path})`).join("\n")
+            : "";
+        const content = `---
+name: ${data.name}
+createdAt: ${data.createdAt}
+updatedAt: ${data.updatedAt}
+---
+
+## 规则
+
+> 只读，上下文必须遵循的约束
+
+${rulesContent}
+
+## 文档
+
+> 读写，全局参考文档
+
+${docsContent}
+`;
+        await this.fs.writeFile(mdPath, content);
+    }
+    // ========== Node Info.md ==========
+    /**
+     * 读取节点 Info.md
+     * @param wsDirName 工作区目录名（非 workspaceId，需通过 graph 解析）
+     * @param nodeDirName 节点目录名（非 nodeId，需通过 graph.nodes[nodeId].dirName 获取）
+     * @param isArchived 是否为归档工作区
+     */
+    async readNodeInfo(projectRoot, wsDirName, nodeDirName, isArchived = false) {
+        const infoPath = isArchived
+            ? this.fs.getNodeInfoPathWithArchive(projectRoot, wsDirName, nodeDirName, true)
+            : this.fs.getNodeInfoPath(projectRoot, wsDirName, nodeDirName);
+        const content = await this.fs.readFile(infoPath);
+        const parsed = this.parse(content);
+        // 解析需求
+        let requirement = "";
+        const reqMatch = parsed.content.match(/## 需求\n\n([\s\S]*?)(?=\n## |$)/);
+        if (reqMatch) {
+            requirement = reqMatch[1].trim();
+        }
+        // 解析验收标准
+        const acceptanceCriteria = [];
+        const acMatch = parsed.content.match(/## 验收标准\n\n\| 条件 \(WHEN\) \| 期望结果 \(THEN\) \|\n\|[-\s|]+\|\n([\s\S]*?)(?=\n## |$)/);
+        if (acMatch) {
+            const acContent = acMatch[1].trim();
+            if (acContent) {
+                const acLines = acContent.split("\n").filter(line => line.startsWith("|"));
+                for (const line of acLines) {
+                    const cells = line.split("|").map(c => c.trim()).filter(Boolean);
+                    if (cells.length >= 2) {
+                        acceptanceCriteria.push({
+                            when: unescapeTableCell(cells[0]),
+                            then: unescapeTableCell(cells[1])
+                        });
+                    }
+                }
+            }
+        }
+        // 解析文档引用
+        const docs = [];
+        const docsMatch = parsed.content.match(/## 文档引用\n\n(?:>.*\n\n)?([\s\S]*?)(?=\n## |$)/);
+        if (docsMatch) {
+            const docsContent = docsMatch[1].trim();
+            if (docsContent) {
+                const docLines = docsContent.split("\n").filter(line => line.startsWith("- "));
+                for (const line of docLines) {
+                    const docMatch = line.match(/- \[(.+?)\]\((.+?)\)(?: - (.+))?/);
+                    if (docMatch) {
+                        docs.push({
+                            path: docMatch[2],
+                            description: docMatch[3] || docMatch[1]
+                        });
+                    }
+                }
+            }
+        }
+        // 解析备注
+        let notes = "";
+        const notesMatch = parsed.content.match(/## 备注\n\n([\s\S]*?)(?=\n## |$)/);
+        if (notesMatch) {
+            notes = notesMatch[1].trim();
+        }
+        // 解析结论
+        let conclusion = "";
+        const conclusionMatch = parsed.content.match(/## 结论\n\n(?:>.*\n\n)?([\s\S]*?)$/);
+        if (conclusionMatch) {
+            conclusion = conclusionMatch[1].trim();
+        }
+        return {
+            id: parsed.frontmatter.id || nodeDirName,
+            type: parsed.frontmatter.type || "execution",
+            title: parsed.frontmatter.title || "",
+            status: parsed.frontmatter.status || "pending",
+            createdAt: parsed.frontmatter.createdAt || "",
+            updatedAt: parsed.frontmatter.updatedAt || "",
+            requirement,
+            docs,
+            notes,
+            conclusion,
+            acceptanceCriteria: acceptanceCriteria.length > 0 ? acceptanceCriteria : undefined
+        };
+    }
+    /**
+     * 写入节点 Info.md
+     * @param wsDirName 工作区目录名（非 workspaceId）
+     * @param nodeDirName 节点目录名（非 nodeId）
+     */
+    async writeNodeInfo(projectRoot, wsDirName, nodeDirName, data) {
+        // 验证内容格式
+        validateSingleLineContent(data.title, "节点标题");
+        if (data.requirement) {
+            validateMultilineContent(data.requirement, "需求描述");
+        }
+        if (data.notes) {
+            validateMultilineContent(data.notes, "备注");
+        }
+        if (data.conclusion) {
+            validateMultilineContent(data.conclusion, "结论");
+        }
+        const infoPath = this.fs.getNodeInfoPath(projectRoot, wsDirName, nodeDirName);
+        const docsContent = data.docs.length > 0
+            ? data.docs.map(doc => `- [${doc.description}](${doc.path})`).join("\n")
+            : "";
+        // 渲染验收标准表格
+        let acceptanceCriteriaContent = "";
+        if (data.acceptanceCriteria && data.acceptanceCriteria.length > 0) {
+            const rows = data.acceptanceCriteria.map(ac => `| ${escapeTableCell(ac.when)} | ${escapeTableCell(ac.then)} |`).join("\n");
+            acceptanceCriteriaContent = `\n## 验收标准
+
+| 条件 (WHEN) | 期望结果 (THEN) |
+|-------------|-----------------|
+${rows}
+`;
+        }
+        const typeLabel = data.type === "planning" ? "规划" : "执行";
+        const content = `---
+id: ${data.id}
+type: ${data.type}
+title: ${data.title}
+status: ${data.status}
+createdAt: ${data.createdAt}
+updatedAt: ${data.updatedAt}
+---
+
+## 节点类型
+
+${typeLabel}节点
+
+## 需求
+
+${data.requirement ?? ""}
+${acceptanceCriteriaContent}
+## 文档引用
+
+> 格式：- [文件名](路径) - 说明 (状态)
+
+${docsContent}
+
+## 备注
+
+${data.notes}
+
+## 结论
+
+> 节点完成时填写
+
+${data.conclusion}
+`;
+        await this.fs.writeFile(infoPath, content);
+    }
+    // ========== Log.md ==========
+    /**
+     * 读取日志
+     * 增强健壮性：处理各种表格格式变体
+     */
+    async readLog(projectRoot, workspaceId, nodeId) {
+        const logPath = nodeId
+            ? this.fs.getNodeLogPath(projectRoot, workspaceId, nodeId)
+            : this.fs.getWorkspaceLogPath(projectRoot, workspaceId);
+        if (!(await this.fs.exists(logPath))) {
+            return [];
+        }
+        try {
+            const content = await this.fs.readFile(logPath);
+            return this.parseLogTableSafe(content);
+        }
+        catch {
+            // 文件读取或解析失败，返回空数组
+            return [];
+        }
+    }
+    /**
+     * 安全解析日志表格
+     * @param content 日志内容
+     * @returns 解析后的日志条目
+     */
+    parseLogTableSafe(content) {
+        if (!content || typeof content !== "string") {
+            return [];
+        }
+        const logs = [];
+        // 规范化换行符
+        const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+        // 解析表格行
+        const lines = normalized.split("\n");
+        for (const line of lines) {
+            // 跳过非表格行、表头和分隔线
+            if (!line.startsWith("|"))
+                continue;
+            if (line.includes("时间") || line.includes("Time"))
+                continue;
+            if (/^\|[\s-:|]+\|$/.test(line))
+                continue;
+            const parts = line.split("|").map(p => p.trim()).filter(p => p);
+            if (parts.length >= 3) {
+                // 还原转义的表格内容
+                const event = unescapeTableCell(parts[2] || "");
+                logs.push({
+                    time: parts[0] || "",
+                    operator: parts[1] || "AI",
+                    event
+                });
+            }
+        }
+        return logs;
+    }
+    /**
+     * 获取日志文件路径（支持归档目录）
+     */
+    getLogPath(projectRoot, wsDirName, nodeId, isArchived = false) {
+        const basePath = isArchived
+            ? this.fs.getArchivePath(projectRoot, wsDirName)
+            : this.fs.getWorkspacePath(projectRoot, wsDirName);
+        if (nodeId) {
+            return `${basePath}/nodes/${nodeId}/Log.md`;
+        }
+        return `${basePath}/Log.md`;
+    }
+    /**
+     * 追加日志
+     * @param isArchived 是否写入归档目录（当 nodeId 为 true 时表示 isArchived）
+     */
+    async appendLog(projectRoot, workspaceId, entry, nodeIdOrIsArchived, isArchived = false) {
+        // 处理参数重载：appendLog(projectRoot, workspaceId, entry, isArchived) 或 appendLog(projectRoot, workspaceId, entry, nodeId, isArchived)
+        let nodeId;
+        let archived = isArchived;
+        if (typeof nodeIdOrIsArchived === "boolean") {
+            archived = nodeIdOrIsArchived;
+        }
+        else if (typeof nodeIdOrIsArchived === "string") {
+            nodeId = nodeIdOrIsArchived;
+        }
+        const logPath = this.getLogPath(projectRoot, workspaceId, nodeId, archived);
+        let content;
+        if (await this.fs.exists(logPath)) {
+            content = await this.fs.readFile(logPath);
+        }
+        else {
+            content = `## 日志
+
+| 时间 | 操作者 | 事件 |
+|------|--------|------|
+`;
+        }
+        const formattedTime = formatShort(entry.time);
+        // 转义表格单元格内容（换行符和管道符）
+        const escapedEvent = escapeTableCell(entry.event);
+        content += `| ${formattedTime} | ${entry.operator} | ${escapedEvent} |\n`;
+        await this.fs.writeFile(logPath, content);
+    }
+    /**
+     * 创建空的日志文件
+     */
+    async createEmptyLog(projectRoot, workspaceId, nodeId) {
+        const logPath = nodeId
+            ? this.fs.getNodeLogPath(projectRoot, workspaceId, nodeId)
+            : this.fs.getWorkspaceLogPath(projectRoot, workspaceId);
+        const content = `## 日志
+
+| 时间 | 操作者 | 事件 |
+|------|--------|------|
+`;
+        await this.fs.writeFile(logPath, content);
+    }
+    // ========== Problem.md ==========
+    /**
+     * 读取问题
+     * @param isArchived 是否为归档工作区
+     */
+    async readProblem(projectRoot, workspaceId, nodeId, isArchived = false) {
+        const problemPath = nodeId
+            ? (isArchived
+                ? this.fs.getNodeProblemPathWithArchive(projectRoot, workspaceId, nodeId, true)
+                : this.fs.getNodeProblemPath(projectRoot, workspaceId, nodeId))
+            : (isArchived
+                ? this.fs.getWorkspaceProblemPathWithArchive(projectRoot, workspaceId, true)
+                : this.fs.getWorkspaceProblemPath(projectRoot, workspaceId));
+        if (!(await this.fs.exists(problemPath))) {
+            return {
+                currentProblem: "（暂无）",
+                nextStep: "（暂无）"
+            };
+        }
+        const content = await this.fs.readFile(problemPath);
+        let currentProblem = "（暂无）";
+        const problemMatch = content.match(/## 当前问题\n\n([\s\S]*?)(?=\n## |$)/);
+        if (problemMatch) {
+            currentProblem = problemMatch[1].trim();
+        }
+        let nextStep = "（暂无）";
+        const nextMatch = content.match(/## 下一步\n\n([\s\S]*?)$/);
+        if (nextMatch) {
+            nextStep = nextMatch[1].trim();
+        }
+        return { currentProblem, nextStep };
+    }
+    /**
+     * 写入问题
+     */
+    async writeProblem(projectRoot, workspaceId, data, nodeId) {
+        // 验证内容格式（跳过默认占位符）
+        if (data.currentProblem && data.currentProblem !== "（暂无）") {
+            validateMultilineContent(data.currentProblem, "当前问题");
+        }
+        if (data.nextStep && data.nextStep !== "（暂无）") {
+            validateMultilineContent(data.nextStep, "下一步");
+        }
+        const problemPath = nodeId
+            ? this.fs.getNodeProblemPath(projectRoot, workspaceId, nodeId)
+            : this.fs.getWorkspaceProblemPath(projectRoot, workspaceId);
+        const content = `## 当前问题
+
+${data.currentProblem}
+
+## 下一步
+
+${data.nextStep}
+`;
+        await this.fs.writeFile(problemPath, content);
+    }
+    /**
+     * 创建空的问题文件
+     */
+    async createEmptyProblem(projectRoot, workspaceId, nodeId) {
+        await this.writeProblem(projectRoot, workspaceId, {
+            currentProblem: "（暂无）",
+            nextStep: "（暂无）"
+        }, nodeId);
+    }
+    // ========== 原始文件读取 ==========
+    /**
+     * 读取 Workspace.md 原始内容
+     * @param isArchived 是否为归档工作区
+     */
+    async readWorkspaceMdRaw(projectRoot, workspaceId, isArchived = false) {
+        const mdPath = isArchived
+            ? this.fs.getWorkspaceMdPathWithArchive(projectRoot, workspaceId, true)
+            : this.fs.getWorkspaceMdPath(projectRoot, workspaceId);
+        return await this.fs.readFile(mdPath);
+    }
+    /**
+     * 读取节点 Info.md 原始内容
+     * @param wsDirName 工作区目录名（非 workspaceId）
+     * @param nodeDirName 节点目录名（非 nodeId）
+     * @param isArchived 是否为归档工作区
+     */
+    async readNodeInfoRaw(projectRoot, wsDirName, nodeDirName, isArchived = false) {
+        const infoPath = isArchived
+            ? this.fs.getNodeInfoPathWithArchive(projectRoot, wsDirName, nodeDirName, true)
+            : this.fs.getNodeInfoPath(projectRoot, wsDirName, nodeDirName);
+        return await this.fs.readFile(infoPath);
+    }
+    /**
+     * 读取日志原始内容
+     */
+    async readLogRaw(projectRoot, workspaceId, nodeId, isArchived = false) {
+        let logPath;
+        if (nodeId) {
+            logPath = isArchived
+                ? this.fs.getNodeLogPathWithArchive(projectRoot, workspaceId, nodeId, true)
+                : this.fs.getNodeLogPath(projectRoot, workspaceId, nodeId);
+        }
+        else {
+            // 工作区级别日志暂不支持归档路径（归档工作区通常只读取节点）
+            logPath = this.fs.getWorkspaceLogPath(projectRoot, workspaceId);
+        }
+        if (!(await this.fs.exists(logPath))) {
+            return "";
+        }
+        return await this.fs.readFile(logPath);
+    }
+    /**
+     * 读取问题原始内容
+     */
+    async readProblemRaw(projectRoot, workspaceId, nodeId, isArchived = false) {
+        let problemPath;
+        if (nodeId) {
+            problemPath = isArchived
+                ? this.fs.getNodeProblemPathWithArchive(projectRoot, workspaceId, nodeId, true)
+                : this.fs.getNodeProblemPath(projectRoot, workspaceId, nodeId);
+        }
+        else {
+            // 工作区级别问题暂不支持归档路径
+            problemPath = this.fs.getWorkspaceProblemPath(projectRoot, workspaceId);
+        }
+        if (!(await this.fs.exists(problemPath))) {
+            return "";
+        }
+        return await this.fs.readFile(problemPath);
+    }
+    // ========== Phase 2 扩展方法 ==========
+    /**
+     * 解析日志表格（返回带类型的日志条目）
+     * 增强健壮性：处理各种表格格式变体
+     */
+    parseLogTable(content) {
+        if (!content || typeof content !== "string") {
+            return [];
+        }
+        // 规范化换行符
+        const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+        const lines = normalized.split("\n");
+        const entries = [];
+        for (const line of lines) {
+            // 跳过非表格行
+            if (!line.startsWith("|"))
+                continue;
+            // 跳过表头和分隔线
+            if (line.includes("时间") || line.includes("Time"))
+                continue;
+            if (/^\|[\s-:|]+\|$/.test(line))
+                continue;
+            const cells = line.split("|").map(c => c.trim()).filter(Boolean);
+            if (cells.length >= 3) {
+                const operator = cells[1];
+                // 还原转义的表格内容
+                const event = unescapeTableCell(cells[2] || "");
+                entries.push({
+                    timestamp: cells[0] || "",
+                    operator: operator === "AI" || operator === "Human" ? operator : "AI",
+                    event,
+                });
+            }
+        }
+        return entries;
+    }
+    /**
+     * 追加带类型的日志条目
+     */
+    async appendTypedLogEntry(projectRoot, workspaceId, entry, nodeId) {
+        const logPath = nodeId
+            ? this.fs.getNodeLogPath(projectRoot, workspaceId, nodeId)
+            : this.fs.getWorkspaceLogPath(projectRoot, workspaceId);
+        let content;
+        if (await this.fs.exists(logPath)) {
+            content = await this.fs.readFile(logPath);
+        }
+        else {
+            content = `## 日志
+
+| 时间 | 操作者 | 事件 |
+|------|--------|------|
+`;
+        }
+        // 转义表格单元格内容（换行符和管道符）
+        const escapedEvent = escapeTableCell(entry.event);
+        const newLine = `| ${entry.timestamp} | ${entry.operator} | ${escapedEvent} |`;
+        const updatedContent = content.trimEnd() + "\n" + newLine + "\n";
+        await this.fs.writeFile(logPath, updatedContent);
+    }
+    /**
+     * 解析文档引用
+     * 格式：- [文件名](路径) - 说明
+     * 向后兼容：忽略旧数据中的 (active)/(expired) 状态
+     */
+    parseDocs(content) {
+        const docs = [];
+        // 匹配格式：- [name](path) - description
+        // 向后兼容：可选的 (active)/(expired) 状态会被忽略
+        const regex = /^- \[([^\]]+)\]\(([^)]+)\)(?: - (.+?))?(?:\s*\((?:active|expired)\))?$/gm;
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            docs.push({
+                path: match[2],
+                description: (match[3] || match[1]).trim(),
+            });
+        }
+        return docs;
+    }
+    /**
+     * 序列化文档引用
+     */
+    serializeDoc(doc) {
+        const name = doc.path.split("/").pop() ?? doc.path;
+        return `- [${name}](${doc.path}) - ${doc.description}`;
+    }
+    /**
+     * 更新 Info.md 的结论部分
+     * @param wsDirName 工作区目录名（非 workspaceId）
+     * @param nodeDirName 节点目录名（非 nodeId）
+     */
+    async updateConclusion(projectRoot, wsDirName, nodeDirName, conclusion) {
+        const info = await this.readNodeInfo(projectRoot, wsDirName, nodeDirName);
+        // 将字面量 \\n 转换为真正的换行符（MCP 工具调用时可能传入转义字符串）
+        info.conclusion = conclusion.replace(/\\n/g, "\n");
+        await this.writeNodeInfo(projectRoot, wsDirName, nodeDirName, info);
+    }
+    /**
+     * 更新 Info.md 的状态
+     * @param wsDirName 工作区目录名（非 workspaceId）
+     * @param nodeDirName 节点目录名（非 nodeId）
+     */
+    async updateNodeStatus(projectRoot, wsDirName, nodeDirName, status) {
+        const info = await this.readNodeInfo(projectRoot, wsDirName, nodeDirName);
+        info.status = status;
+        await this.writeNodeInfo(projectRoot, wsDirName, nodeDirName, info);
+    }
+    /**
+     * 读取节点 Info.md（包含文档引用）
+     * @param wsDirName 工作区目录名（非 workspaceId）
+     * @param nodeDirName 节点目录名（非 nodeId）
+     * @param isArchived 是否为归档工作区
+     */
+    async readNodeInfoFull(projectRoot, wsDirName, nodeDirName, isArchived = false) {
+        const infoPath = isArchived
+            ? this.fs.getNodeInfoPathWithArchive(projectRoot, wsDirName, nodeDirName, true)
+            : this.fs.getNodeInfoPath(projectRoot, wsDirName, nodeDirName);
+        const content = await this.fs.readFile(infoPath);
+        const parsed = this.parse(content);
+        // 解析需求
+        let requirement = "";
+        const reqMatch = parsed.content.match(/## 需求\n\n([\s\S]*?)(?=\n## |$)/);
+        if (reqMatch) {
+            requirement = reqMatch[1].trim();
+        }
+        // 解析验收标准
+        const acceptanceCriteria = [];
+        const acMatch = parsed.content.match(/## 验收标准\n\n\| 条件 \(WHEN\) \| 期望结果 \(THEN\) \|\n\|[-\s|]+\|\n([\s\S]*?)(?=\n## |$)/);
+        if (acMatch) {
+            const acContent = acMatch[1].trim();
+            if (acContent) {
+                const acLines = acContent.split("\n").filter(line => line.startsWith("|"));
+                for (const line of acLines) {
+                    const cells = line.split("|").map(c => c.trim()).filter(Boolean);
+                    if (cells.length >= 2) {
+                        acceptanceCriteria.push({
+                            when: unescapeTableCell(cells[0]),
+                            then: unescapeTableCell(cells[1])
+                        });
+                    }
+                }
+            }
+        }
+        // 解析文档引用（向后兼容：忽略旧数据中的状态）
+        const docs = [];
+        const docsMatch = parsed.content.match(/## 文档引用\n\n(?:>.*\n\n)?([\s\S]*?)(?=\n## |$)/);
+        if (docsMatch) {
+            const docsContent = docsMatch[1].trim();
+            if (docsContent) {
+                docs.push(...this.parseDocs(docsContent));
+            }
+        }
+        // 解析备注
+        let notes = "";
+        const notesMatch = parsed.content.match(/## 备注\n\n([\s\S]*?)(?=\n## |$)/);
+        if (notesMatch) {
+            notes = notesMatch[1].trim();
+        }
+        // 解析结论
+        let conclusion = "";
+        const conclusionMatch = parsed.content.match(/## 结论\n\n(?:>.*\n\n)?([\s\S]*?)$/);
+        if (conclusionMatch) {
+            conclusion = conclusionMatch[1].trim();
+        }
+        return {
+            id: parsed.frontmatter.id || nodeDirName,
+            type: parsed.frontmatter.type || "execution",
+            title: parsed.frontmatter.title || "",
+            status: parsed.frontmatter.status || "pending",
+            createdAt: parsed.frontmatter.createdAt || "",
+            updatedAt: parsed.frontmatter.updatedAt || "",
+            requirement,
+            docs,
+            notes,
+            conclusion,
+            acceptanceCriteria: acceptanceCriteria.length > 0 ? acceptanceCriteria : undefined
+        };
+    }
+    /**
+     * 读取 Workspace.md（包含文档引用）
+     * @param isArchived 是否为归档工作区
+     */
+    async readWorkspaceMdFull(projectRoot, workspaceId, isArchived = false) {
+        const mdPath = isArchived
+            ? this.fs.getWorkspaceMdPathWithArchive(projectRoot, workspaceId, true)
+            : this.fs.getWorkspaceMdPath(projectRoot, workspaceId);
+        const content = await this.fs.readFile(mdPath);
+        const parsed = this.parse(content);
+        // 解析规则
+        const rules = [];
+        const rulesMatch = parsed.content.match(/## 规则\n\n(?:>.*\n\n)?([\s\S]*?)(?=\n## |$)/);
+        if (rulesMatch) {
+            const rulesContent = rulesMatch[1].trim();
+            if (rulesContent) {
+                const ruleLines = rulesContent.split("\n").filter(line => line.startsWith("- "));
+                for (const line of ruleLines) {
+                    rules.push(line.substring(2).trim());
+                }
+            }
+        }
+        // 解析文档（向后兼容：忽略旧数据中的状态）
+        const docs = [];
+        const docsMatch = parsed.content.match(/## 文档\n\n(?:>.*\n\n)?([\s\S]*?)(?=\n## |$)/);
+        if (docsMatch) {
+            const docsContent = docsMatch[1].trim();
+            if (docsContent) {
+                docs.push(...this.parseDocs(docsContent));
+            }
+        }
+        // goal 已移至根节点 requirement，不再从 Workspace.md 读取
+        return {
+            name: parsed.frontmatter.name || "",
+            createdAt: parsed.frontmatter.createdAt || "",
+            updatedAt: parsed.frontmatter.updatedAt || "",
+            rules,
+            docs,
+        };
+    }
+    /**
+     * 写入节点 Info.md（完整版本，用于服务层）
+     * @param wsDirName 工作区目录名（非 workspaceId）
+     * @param nodeDirName 节点目录名（非 nodeId）
+     */
+    async writeNodeInfoFull(projectRoot, wsDirName, nodeDirName, data) {
+        // 验证内容格式
+        validateSingleLineContent(data.title, "节点标题");
+        if (data.requirement) {
+            validateMultilineContent(data.requirement, "需求描述");
+        }
+        if (data.notes) {
+            validateMultilineContent(data.notes, "备注");
+        }
+        if (data.conclusion) {
+            validateMultilineContent(data.conclusion, "结论");
+        }
+        const infoPath = this.fs.getNodeInfoPath(projectRoot, wsDirName, nodeDirName);
+        // 序列化文档引用
+        let docsContent = "";
+        if (data.docs.length > 0) {
+            docsContent = data.docs.map(doc => this.serializeDoc(doc)).join("\n");
+        }
+        // 渲染验收标准表格
+        let acceptanceCriteriaContent = "";
+        if (data.acceptanceCriteria && data.acceptanceCriteria.length > 0) {
+            const rows = data.acceptanceCriteria.map(ac => `| ${escapeTableCell(ac.when)} | ${escapeTableCell(ac.then)} |`).join("\n");
+            acceptanceCriteriaContent = `\n## 验收标准
+
+| 条件 (WHEN) | 期望结果 (THEN) |
+|-------------|-----------------|
+${rows}
+`;
+        }
+        const typeLabel = data.type === "planning" ? "规划" : "执行";
+        const content = `---
+id: ${data.id}
+type: ${data.type}
+title: ${data.title}
+status: ${data.status}
+createdAt: ${data.createdAt}
+updatedAt: ${data.updatedAt}
+---
+
+## 节点类型
+
+${typeLabel}节点
+
+## 需求
+
+${data.requirement ?? ""}
+${acceptanceCriteriaContent}
+## 文档引用
+
+> 格式：- [文件名](路径) - 说明
+
+${docsContent}
+
+## 备注
+
+${data.notes}
+
+## 结论
+
+> 节点完成时填写
+
+${data.conclusion}
+`;
+        await this.fs.writeFile(infoPath, content);
+    }
+}
+//# sourceMappingURL=MarkdownStorage.js.map