czon 0.8.10 → 0.9.1

package/dist/ai/extractMetadataFromMarkdown.js

@@ -7,15 +7,22 @@ const openai_1 = require("../services/openai");
  * AI Metadata 提取模块
  *
  * 优化策略说明：
- * 1. 从 MetaData 全局状态读取已有 slug，不作为参数传递
- * 2. 如果已有 slug，条件化 prompt - 完全不提及 slug 相关指令
+ * 1. 从 MetaData 全局状态读取已有 title/slug，不作为参数传递
+ * 2. 如果已有 title/slug，条件化 prompt - 完全不提及对应字段的指令
  * 3. trade-off: 优先提升 AI 质量（减少无关任务干扰），可能降低 context 缓存命中率
  */
 async function extractMetadataFromMarkdown(filePath, content) {
-    const existingSlug = metadata_1.MetaData.files.find(f => f.path === filePath)?.metadata?.slug;
+    const existingMeta = metadata_1.MetaData.files.find(f => f.path === filePath)?.metadata;
+    const existingSlug = existingMeta?.slug;
     const hasExistingSlug = !!existingSlug;
+    const existingTitle = existingMeta?.title;
+    const hasExistingTitle = !!existingTitle;
     const fields = [
-        'title: 文档的标题（简洁明了，不超过 30 个字）',
+        ...(hasExistingTitle
+            ? []
+            : [
+                'title: 文档的标题（简洁明了，不超过 30 个字。优先采用文档的一级标题或 frontmatter 中的 title 字段，如果没有则自行提炼）',
+            ]),
         'tags: 关键词列表（3-8 个关键词，使用中文或英文）',
         'description: 文档的简短描述，微摘要（用一句话概括本文核心价值，不超过 100 字符），用于 SEO meta description，社交卡片短描述',
         'summary: 文档中型摘要（用一段话总结文章，包含关键论点和结论，控制在 300 字以内），用于 邮件推送内容，newsletter 介绍',
@@ -30,7 +37,7 @@ async function extractMetadataFromMarkdown(filePath, content) {
     ];
     const jsonFields = [
         '{',
-        '  "title": "文档标题",',
+        ...(hasExistingTitle ? [] : ['  "title": "文档标题",']),
         '  "description": "用一句话概括本文核心价值，不超过 100 字符",',
         '  "summary": "中型摘要，用一段话总结文章，包含关键论点和结论",',
         '  "short_summary": "超短摘要，用 2-3 句话概括文章主要内容，突出核心观点",',
@@ -70,7 +77,7 @@ ${jsonFields.join('\n')}`;
     });
     const metadata = JSON.parse(response.choices[0].message.content);
     const result = {
-        title: metadata.title?.trim() || '',
+        title: metadata.title?.trim() || existingTitle || '',
         description: metadata.description?.trim() || '',
         short_summary: metadata.short_summary?.trim() || '',
         audience: metadata.audience?.trim() || '',

package/dist/cli.js

@@ -15,6 +15,7 @@ const cli = new clipanion_1.Cli({
 });
 // 注册命令
 cli.register(commands_1.BuildCommand);
+cli.register(commands_1.CheckCommand);
 cli.register(commands_1.LsFilesCommand);
 cli.register(commands_1.SummaryCommand);
 cli.register(commands_1.ConfigGithubCommand);

package/dist/commands/check.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckCommand = void 0;
+const clipanion_1 = require("clipanion");
+const checkLinks_1 = require("../process/checkLinks");
+class CheckCommand extends clipanion_1.Command {
+    async execute() {
+        try {
+            const issues = await (0, checkLinks_1.checkLinks)();
+            const output = (0, checkLinks_1.formatCheckResults)(issues);
+            this.context.stdout.write(output + '\n');
+            return issues.length > 0 ? 1 : 0;
+        }
+        catch (error) {
+            this.context.stderr.write(`Check failed: ${error}\n`);
+            return 1;
+        }
+    }
+}
+exports.CheckCommand = CheckCommand;
+CheckCommand.paths = [['check']];
+CheckCommand.usage = clipanion_1.Command.Usage({
+    description: 'Check Markdown files for broken links and path format issues',
+    details: `
+      This command scans all Markdown files in the current directory and checks for:
+        - Dead links (link targets that do not exist)
+        - Path format issues (absolute paths starting with /)
+
+       Examples:
+         $ czon check
+    `,
+});
+//# sourceMappingURL=check.js.map

package/dist/commands/index.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SummaryCommand = exports.LsFilesCommand = exports.ConfigGithubCommand = exports.BuildCommand = void 0;
+exports.SummaryCommand = exports.LsFilesCommand = exports.ConfigGithubCommand = exports.CheckCommand = exports.BuildCommand = void 0;
 var build_1 = require("./build");
 Object.defineProperty(exports, "BuildCommand", { enumerable: true, get: function () { return build_1.BuildCommand; } });
+var check_1 = require("./check");
+Object.defineProperty(exports, "CheckCommand", { enumerable: true, get: function () { return check_1.CheckCommand; } });
 var config_github_1 = require("./config-github");
 Object.defineProperty(exports, "ConfigGithubCommand", { enumerable: true, get: function () { return config_github_1.ConfigGithubCommand; } });
 var ls_files_1 = require("./ls-files");

package/dist/commands/ls-files.js

@@ -9,10 +9,13 @@ class LsFilesCommand extends clipanion_1.Command {
         this.aigc = clipanion_1.Option.Boolean('--aigc', false, {
             description: 'Include files under .czon/AIGC directory',
         });
+        this.allTypes = clipanion_1.Option.Boolean('--all-types', false, {
+            description: 'List all file types, not just Markdown files',
+        });
     }
     async execute() {
         try {
-            const files = await (0, findEntries_1.findMarkdownEntries)(process.cwd(), { aigc: this.aigc });
+            const files = await (0, findEntries_1.findEntries)(process.cwd(), { aigc: this.aigc, allTypes: this.allTypes });
             if (files.length === 0) {
                 this.context.stdout.write('No markdown files found.\n');
             }
@@ -35,10 +38,12 @@ LsFilesCommand.usage = clipanion_1.Command.Usage({
     description: 'List all markdown files in the current directory',
     details: `
       This command lists all markdown files in the current directory using git.
-      It uses the same logic as the internal findMarkdownEntries function.
+      It uses the same logic as the internal findEntries function.
+      Use --all-types to list all file types, not just Markdown.
 
       Examples:
         $ czon ls-files
+        $ czon ls-files --all-types
     `,
 });
 //# sourceMappingURL=ls-files.js.map

package/dist/findEntries.js

@@ -1,23 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findMarkdownEntries = void 0;
+exports.findEntries = void 0;
 const child_process_1 = require("child_process");
 const path_1 = require("path");
 const util_1 = require("util");
 const isExists_1 = require("./utils/isExists");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
 /**
- * 使用git命令查找所有Markdown文件
+ * 使用git命令查找项目中的文件
  * 使用git ls-files --others --cached --exclude-standard获取所有文件
- * 然后过滤掉.czon目录和只保留.md文件
+ * 然后过滤掉.czon目录，默认只保留.md文件
  *
  * @param dirPath 要扫描的目录路径
  * @param options 可选参数
  * @param options.aigc 是否包含 .czon/AIGC 目录下的文件
- * @returns Promise<string[]> 返回Markdown文件的相对路径数组
+ * @param options.allTypes 是否返回所有类型的文件（默认 false，仅返回 .md 文件）
+ * @returns Promise<string[]> 返回文件的相对路径数组
  */
-const findMarkdownEntries = async (dirPath, options) => {
+const findEntries = async (dirPath, options) => {
     const aigc = options?.aigc ?? false;
+    const allTypes = options?.allTypes ?? false;
     // 获取git仓库的根目录
     const gitRoot = (await execAsync('git rev-parse --show-toplevel', { cwd: dirPath })).stdout.trim();
     // 使用git命令获取所有文件（包括已跟踪和未跟踪的文件）
@@ -31,7 +33,7 @@ const findMarkdownEntries = async (dirPath, options) => {
         .split('\0') // 按空字符分割文件名
         .filter(line => line.trim() !== '') // 移除空行
         .filter(file => !file.startsWith('.') || (aigc && file.startsWith('.czon/AIGC/'))) // 过滤掉隐藏目录下的文件（aigc 模式下保留 .czon/AIGC/）
-        .filter(file => file.endsWith('.md')); // 只保留.md文件
+        .filter(file => allTypes || file.endsWith('.md')); // allTypes 时返回所有文件，否则只保留 .md 文件
     // 排除文件系统中不存在的文件
     const existingFiles = [];
     for (const file of files) {
@@ -41,5 +43,5 @@ const findMarkdownEntries = async (dirPath, options) => {
     }
     return existingFiles;
 };
-exports.findMarkdownEntries = findMarkdownEntries;
+exports.findEntries = findEntries;
 //# sourceMappingURL=findEntries.js.map

package/dist/process/checkLinks.js

@@ -0,0 +1,260 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkLinks = checkLinks;
+exports.formatCheckResults = formatCheckResults;
+const promises_1 = require("fs/promises");
+const marked_1 = require("marked");
+/**
+ * 独立的 marked 实例，仅用于链接检查的词法分析。
+ * 不加载 marked-footnote / marked-katex 等全局扩展，避免扩展 tokenizer 的兼容性问题。
+ */
+const lexer = new marked_1.Marked({ gfm: true });
+const path_1 = __importDefault(require("path"));
+const findEntries_1 = require("../findEntries");
+const paths_1 = require("../paths");
+const isExists_1 = require("../utils/isExists");
+/**
+ * 递归遍历 marked token 树，收集所有真实的 link 和 image token。
+ * 自动跳过 code（代码块）和 codespan（行内代码）中的内容。
+ */
+function collectLinksFromTokens(tokens, results) {
+    for (const token of tokens) {
+        if (token.type === 'link') {
+            const link = token;
+            // 跳过脚注引用 — 无 marked-footnote 时 [^label] 会被误解析为链接
+            if (/^\[\^[^\]]+\]/.test(link.raw))
+                continue;
+            results.push({ raw: link.raw, href: link.href, isImage: false });
+        }
+        else if (token.type === 'image') {
+            const image = token;
+            results.push({ raw: image.raw, href: image.href, isImage: true });
+        }
+        // 跳过 code / codespan — 其中的链接语法不是真正的链接
+        if (token.type === 'code' || token.type === 'codespan')
+            continue;
+        // 递归子 token
+        if ('tokens' in token && Array.isArray(token.tokens)) {
+            collectLinksFromTokens(token.tokens, results);
+        }
+        // list -> items
+        if (token.type === 'list') {
+            const list = token;
+            for (const item of list.items) {
+                if (item.tokens) {
+                    collectLinksFromTokens(item.tokens, results);
+                }
+            }
+        }
+        // table -> header cells + row cells
+        if (token.type === 'table') {
+            const table = token;
+            for (const cell of table.header) {
+                if (cell.tokens) {
+                    collectLinksFromTokens(cell.tokens, results);
+                }
+            }
+            for (const row of table.rows) {
+                for (const cell of row) {
+                    if (cell.tokens) {
+                        collectLinksFromTokens(cell.tokens, results);
+                    }
+                }
+            }
+        }
+    }
+}
+/**
+ * 根据 token 的 raw 字段在原始内容中定位行号（1-based）。
+ * 使用递增的 searchIndex 来正确处理重复出现的相同 raw 文本。
+ */
+function findLineNumber(content, raw, startIndex) {
+    const idx = content.indexOf(raw, startIndex);
+    if (idx === -1) {
+        return { line: -1, nextIndex: startIndex };
+    }
+    const line = content.substring(0, idx).split('\n').length;
+    return { line, nextIndex: idx + raw.length };
+}
+/**
+ * 使用 marked 词法分析器从 Markdown 内容中提取所有真实链接及其行号。
+ * 代码块和行内代码中的链接语法会被正确忽略。
+ */
+function extractLinksWithLineNumbers(content) {
+    const tokens = lexer.lexer(content);
+    const extracted = [];
+    collectLinksFromTokens(tokens, extracted);
+    // 通过 raw 字段在原始内容中搜索来确定行号
+    const results = [];
+    let searchIndex = 0;
+    for (const link of extracted) {
+        const { line, nextIndex } = findLineNumber(content, link.raw, searchIndex);
+        searchIndex = nextIndex;
+        results.push({ line, raw: link.raw, href: link.href, isImage: link.isImage });
+    }
+    return results;
+}
+/**
+ * 检查所有 Markdown 文件中的超链接
+ * @returns 发现的问题列表
+ */
+async function checkLinks() {
+    console.log('🔍 正在扫描 Markdown 文件...');
+    const markdownFiles = await (0, findEntries_1.findEntries)(paths_1.INPUT_DIR, { aigc: true });
+    const allFiles = await (0, findEntries_1.findEntries)(paths_1.INPUT_DIR, { allTypes: true });
+    const issues = [];
+    // 构建已知文件集合，用于死链接检测
+    const knownFiles = new Set(markdownFiles);
+    // 构建全部文件集合，用于建议生成
+    const allFilesSet = new Set(allFiles);
+    // 构建 basename -> 相对路径列表 的索引，用于模糊匹配
+    const basenameIndex = new Map();
+    for (const file of allFiles) {
+        const base = path_1.default.basename(file);
+        const list = basenameIndex.get(base) ?? [];
+        list.push(file);
+        basenameIndex.set(base, list);
+    }
+    console.log(`📄 发现 ${markdownFiles.length} 个 Markdown 文件，${allFiles.length} 个总文件\n`);
+    for (const filePath of markdownFiles) {
+        const fullPath = path_1.default.join(paths_1.INPUT_DIR, filePath);
+        const content = await (0, promises_1.readFile)(fullPath, 'utf-8');
+        const links = extractLinksWithLineNumbers(content);
+        for (const link of links) {
+            // 跳过外部 URL
+            if (URL.canParse(link.href))
+                continue;
+            // 跳过锚点链接
+            if (link.href.startsWith('#'))
+                continue;
+            // 去掉锚点部分
+            const hrefWithoutHash = link.href.split('#')[0];
+            if (!hrefWithoutHash)
+                continue;
+            // 检查 1: 路径格式规范 — 不应使用 / 开头的绝对路径
+            if (hrefWithoutHash.startsWith('/')) {
+                // 尝试生成建议：去掉开头的 /，看是否能在已知文件中找到
+                const suggestions = [];
+                const targetRelative = hrefWithoutHash.slice(1); // 去掉开头的 /
+                if (allFilesSet.has(targetRelative)) {
+                    const suggested = path_1.default.relative(path_1.default.dirname(filePath), targetRelative);
+                    suggestions.push(suggested);
+                }
+                issues.push({
+                    file: filePath,
+                    line: link.line,
+                    raw: link.raw,
+                    href: link.href,
+                    type: 'absolute-path',
+                    message: '不应使用 / 开头的绝对路径，请使用相对路径',
+                    suggestions,
+                });
+                // 绝对路径无法正确解析，跳过死链接检测
+                continue;
+            }
+            // 解析相对路径
+            const resolvedRelative = path_1.default.normalize(path_1.default.join(path_1.default.dirname(filePath), hrefWithoutHash));
+            // 检查是否跳出项目目录
+            if (resolvedRelative.startsWith('..')) {
+                issues.push({
+                    file: filePath,
+                    line: link.line,
+                    raw: link.raw,
+                    href: link.href,
+                    type: 'dead-link',
+                    message: '链接指向项目目录之外',
+                    suggestions: [],
+                });
+                continue;
+            }
+            // 检查 2: .czon/src 边界隔离 — 外部文件不能引用 .czon/src 内部的文件
+            const sourceIsInternal = filePath.startsWith('.czon/src/');
+            const targetIsInternal = resolvedRelative.startsWith('.czon/src/');
+            if (!sourceIsInternal && targetIsInternal) {
+                issues.push({
+                    file: filePath,
+                    line: link.line,
+                    raw: link.raw,
+                    href: link.href,
+                    type: 'cross-boundary',
+                    message: '不能引用 .czon/src 内部的文件',
+                    suggestions: [],
+                });
+                continue;
+            }
+            // 检查 2: 死链接检测 — 目标文件是否存在
+            // 先检查已知的 Markdown 文件集合
+            if (hrefWithoutHash.endsWith('.md') && knownFiles.has(resolvedRelative)) {
+                continue; // 文件存在于已知集合中
+            }
+            // 再检查文件系统
+            const resolvedFullPath = path_1.default.join(paths_1.INPUT_DIR, resolvedRelative);
+            if (!(await (0, isExists_1.isExists)(resolvedFullPath))) {
+                // 通过 basename 模糊匹配，生成候选建议（最多 3 个）
+                const suggestions = [];
+                const targetBasename = path_1.default.basename(hrefWithoutHash);
+                const candidates = basenameIndex.get(targetBasename) ?? [];
+                for (const candidate of candidates) {
+                    if (suggestions.length >= 3)
+                        break;
+                    const suggested = path_1.default.relative(path_1.default.dirname(filePath), candidate);
+                    suggestions.push(suggested);
+                }
+                issues.push({
+                    file: filePath,
+                    line: link.line,
+                    raw: link.raw,
+                    href: link.href,
+                    type: 'dead-link',
+                    message: '目标文件不存在',
+                    suggestions,
+                });
+            }
+        }
+    }
+    return issues;
+}
+/**
+ * 格式化并输出检查结果到终端
+ */
+function formatCheckResults(issues) {
+    if (issues.length === 0) {
+        return '✅ 未发现链接问题。';
+    }
+    const lines = [];
+    // 按文件分组
+    const grouped = new Map();
+    for (const issue of issues) {
+        const list = grouped.get(issue.file) ?? [];
+        list.push(issue);
+        grouped.set(issue.file, list);
+    }
+    for (const [file, fileIssues] of grouped) {
+        lines.push(file);
+        for (const issue of fileIssues) {
+            const icon = issue.type === 'dead-link' ? '✖' : issue.type === 'cross-boundary' ? '⊘' : '⚠';
+            lines.push(`  line ${issue.line}: ${icon} ${issue.raw}`);
+            lines.push(`    ${issue.message}`);
+            for (const suggestion of issue.suggestions) {
+                lines.push(`    建议: ${suggestion}`);
+            }
+        }
+        lines.push('');
+    }
+    const deadCount = issues.filter(i => i.type === 'dead-link').length;
+    const formatCount = issues.filter(i => i.type === 'absolute-path').length;
+    const boundaryCount = issues.filter(i => i.type === 'cross-boundary').length;
+    const parts = [];
+    if (deadCount > 0)
+        parts.push(`${deadCount} 个死链接`);
+    if (formatCount > 0)
+        parts.push(`${formatCount} 个路径格式问题`);
+    if (boundaryCount > 0)
+        parts.push(`${boundaryCount} 个跨边界引用`);
+    lines.push(`发现 ${issues.length} 个问题（${parts.join('，')}），涉及 ${grouped.size} 个文件。`);
+    return lines.join('\n');
+}
+//# sourceMappingURL=checkLinks.js.map

package/dist/process/scanSourceFiles.js

@@ -25,7 +25,7 @@ async function scanSourceFiles() {
     console.log(`🔍 Scanning source directory...`);
     const queue = [];
     const isVisited = new Set();
-    const markdownFiles = await (0, findEntries_1.findMarkdownEntries)(paths_1.INPUT_DIR, { aigc: true });
+    const markdownFiles = await (0, findEntries_1.findEntries)(paths_1.INPUT_DIR, { aigc: true });
     for (const filePath of markdownFiles) {
         queue.push(filePath);
     }

package/dist/process/summary.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.processSummary = void 0;
 const promises_1 = require("fs/promises");
 const path_1 = require("path");
+const metadata_1 = require("../metadata");
 const paths_1 = require("../paths");
 const opencode_1 = require("../services/opencode");
 // Prompt 模板目录路径（在项目根目录的 prompts/ 文件夹中）
@@ -13,14 +14,54 @@ const SUMMARY_DIR = (0, path_1.join)(paths_1.CZON_DIR, 'AIGC', 'SUMMARY');
 const MAX_RETRIES = 3;
 // 风格配置
 const SUMMARY_STYLES = [
-    { skill: 'summary-objective', name: '客观中立' },
-    { skill: 'summary-critical', name: '客观批判' },
-    { skill: 'summary-positive', name: '赞扬鼓励' },
-    { skill: 'summary-popular', name: '科普介绍' },
-    { skill: 'summary-artistic', name: '文艺感性' },
-    { skill: 'summary-philosophical', name: '哲学思辨' },
-    { skill: 'summary-psychological', name: '心理分析' },
-    { skill: 'summary-historical', name: '历史时间跨度' },
+    {
+        skill: 'summary-objective',
+        name: '客观中立',
+        title: 'AI 总结: 客观中立风格',
+        slug: 'aigc-summary-objective',
+    },
+    {
+        skill: 'summary-critical',
+        name: '客观批判',
+        title: 'AI 总结: 客观批判风格',
+        slug: 'aigc-summary-critical',
+    },
+    {
+        skill: 'summary-positive',
+        name: '赞扬鼓励',
+        title: 'AI 总结: 赞扬鼓励风格',
+        slug: 'aigc-summary-positive',
+    },
+    {
+        skill: 'summary-popular',
+        name: '科普介绍',
+        title: 'AI 总结: 科普介绍风格',
+        slug: 'aigc-summary-popular',
+    },
+    {
+        skill: 'summary-artistic',
+        name: '文艺感性',
+        title: 'AI 总结: 文艺感性风格',
+        slug: 'aigc-summary-artistic',
+    },
+    {
+        skill: 'summary-philosophical',
+        name: '哲学思辨',
+        title: 'AI 总结: 哲学思辨风格',
+        slug: 'aigc-summary-philosophical',
+    },
+    {
+        skill: 'summary-psychological',
+        name: '心理分析',
+        title: 'AI 总结: 心理分析风格',
+        slug: 'aigc-summary-psychological',
+    },
+    {
+        skill: 'summary-historical',
+        name: '历史时间跨度',
+        title: 'AI 总结: 历史时间跨度风格',
+        slug: 'aigc-summary-historical',
+    },
 ];
 /**
  * 读取 Prompt 模板文件内容
@@ -114,6 +155,8 @@ ${styleContent}
  */
 const processSummary = async (model) => {
     const cwd = process.cwd();
+    // 加载 MetaData 以便写入预设的 title/slug
+    await (0, metadata_1.loadMetaData)();
     // 加载基础规则
     console.info('📖 加载基础规则...');
     const baseContent = await loadPromptTemplate('summary-base');
@@ -129,6 +172,18 @@ const processSummary = async (model) => {
             ...result,
         });
         if (result.success) {
+            // 预设 title 和 slug 到 MetaData（不设 hash，确保后续 AI 提取不跳过）
+            const relativePath = `.czon/AIGC/SUMMARY/${style.skill}.md`;
+            let fileMeta = metadata_1.MetaData.files.find(f => f.path === relativePath);
+            if (!fileMeta) {
+                fileMeta = { path: relativePath, links: [] };
+                metadata_1.MetaData.files.push(fileMeta);
+            }
+            fileMeta.metadata = {
+                ...fileMeta.metadata,
+                title: style.title,
+                slug: style.slug,
+            };
             console.info(`✅ 「${style.name}」风格报告生成成功\n`);
         }
         else {
@@ -167,6 +222,8 @@ const processSummary = async (model) => {
         const missingCount = SUMMARY_STYLES.length - successCount;
         throw new Error(`生成不完整: ${missingCount} 个报告未能成功生成。请检查上述错误信息并重试。`);
     }
+    // 保存 MetaData（包含预设的 title/slug）
+    await (0, metadata_1.saveMetaData)();
 };
 exports.processSummary = processSummary;
 //# sourceMappingURL=summary.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "czon",
-  "version": "0.8.10",
+  "version": "0.9.1",
   "description": "CZON - AI enhanced Markdown content engine",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/prompts/summary-base.md

@@ -115,20 +115,20 @@
 - 引用原文链接时，保证链接有效
 - **永远链接到具体的 Markdown 文件**，不要链接目录
 - **链接文本应当是对应的标题**，而不是文件名
-- 由于生成到 SUMMARY 目录，引用时使用 `../` 开头的相对路径
+- 由于生成到 `.czon/AIGC/SUMMARY/` 目录，引用时使用 `../../../` 开头的相对路径
 
 **正确示例**：
 
 ```markdown
-[资本持久战：个人投资者跨越阶级的战略](../INSIGHTS/6.md)
-[从创作到分发——构建AI-Native内容引擎](../INSIGHTS/4.md)
+[资本持久战：个人投资者跨越阶级的战略](../../../INSIGHTS/6.md)
+[从创作到分发——构建AI-Native内容引擎](../../../INSIGHTS/4.md)
 ```
 
 **错误示例**：
 
 ```markdown
-[INSIGHTS/6.md](../INSIGHTS/6.md) ← 使用了文件名而非标题
-[资本持久战](../INSIGHTS/) ← 链接到了目录
+[INSIGHTS/6.md](../../../INSIGHTS/6.md) ← 使用了文件名而非标题
+[资本持久战](../../../INSIGHTS/) ← 链接到了目录
 ```
 
 ### 3. 头部格式