agent-wiki 0.1.0 → 0.2.0

package/README.md

@@ -6,24 +6,90 @@
 
 ## 安装
 
-**Claude Code：**
+所有主流 Agent 通用，底层都是同一个 `npx agent-wiki`。装完重启 Agent 就行。
+
+### Claude Code
+
 ```bash
 claude mcp add agent-wiki -- npx agent-wiki
 ```
 
-**Cursor / Windsurf**（编辑 MCP 配置）：
+### Cursor
+
+Settings → MCP → Add new MCP Server：
+
+```json
+{
+  "mcpServers": {
+    "agent-wiki": {
+      "command": "npx",
+      "args": ["-y", "agent-wiki"]
+    }
+  }
+}
+```
+
+### Trae
+
+Settings → MCP → 添加服务器（或从 MCP Marketplace 搜索安装）：
+
+```json
+{
+  "mcpServers": {
+    "agent-wiki": {
+      "command": "npx",
+      "args": ["-y", "agent-wiki"]
+    }
+  }
+}
+```
+
+### Qoder
+
+MCP Settings → Connect your own MCP server（或从 MCP Square 搜索安装）：
+
 ```json
 {
   "mcpServers": {
     "agent-wiki": {
       "command": "npx",
-      "args": ["agent-wiki"]
+      "args": ["-y", "agent-wiki"]
     }
   }
 }
 ```
 
-装完重启 Agent 就行，不需要别的配置。
+### Windsurf
+
+Plugins → Browse MCP Servers → Install，或编辑 `mcp_config.json`：
+
+```json
+{
+  "mcpServers": {
+    "agent-wiki": {
+      "command": "npx",
+      "args": ["-y", "agent-wiki"]
+    }
+  }
+}
+```
+
+### OpenClaw
+
+编辑 `~/.openclaw/workspace/_workspace/config/mcporter.json`：
+
+```json
+{
+  "mcpServers": {
+    "agent-wiki": {
+      "command": "npx",
+      "args": ["-y", "agent-wiki"]
+      "env": {},
+      "disabled": false
+    }
+  }
+}
+```
 
 ## 首次使用
 
@@ -50,15 +116,28 @@ Agent：你好！我是 agent-wiki 知识库助手。
 你：整理一下知识库
 你：搜一下 RAG 相关的内容
 你：帮我写一篇 Agent 工程化的综述
+你：这段分析不错，存到知识库吧
 你：检查一下知识库健不健康
 ```
 
+## 支持的文件格式
+
+| 格式 | 处理方式 |
+|------|---------|
+| `.md` | 直接摄入 |
+| `.txt` | 自动转为 .md |
+| `.html` | 去标签提取正文，转 .md |
+| `.csv` | 转为 Markdown 表格 |
+| `.pdf` / `.docx` / `.xlsx` | 原样存储，Agent 多模态读取 |
+| 图片 | 存储到 raw/assets/ |
+
 ## 知识库结构
 
 ```
 你的知识库目录/
 ├── SCHEMA.md       # 知识库说明书（Agent 自动读取）
 ├── raw/            # 原始文章（不可变）
+│   └── assets/     # 图片等资源
 ├── wiki/           # AI 编译后的维基页面
 │   ├── INDEX.md    # 分类索引
 │   ├── LOG.md      # 操作日志
@@ -72,12 +151,13 @@ Agent：你好！我是 agent-wiki 知识库助手。
 |------|------|
 | wiki_status | 查询知识库状态，首次使用自动引导 |
 | wiki_init | 初始化知识库（创建目录 + SCHEMA.md） |
-| wiki_ingest | 摄入文章到 raw/ |
+| wiki_ingest | 摄入文章到 raw/（支持 md/txt/html/csv/pdf/docx/xlsx/图片） |
 | wiki_tag | 写入标签到 frontmatter |
 | wiki_compile | 生成 Wiki 页面 + 更新索引 + 记录日志 |
 | wiki_search | 标签 + 全文搜索 |
 | wiki_article | 保存原创文章到 outputs/ |
 | wiki_lint | 自检死链接、缺摘要等 |
+| wiki_feedback | 保存问答分析到知识库（用户确认后） |
 
 ## 写文章风格
 
@@ -86,6 +166,10 @@ Agent：你好！我是 agent-wiki 知识库助手。
 - 有自己的观点和态度
 - 适合直接发微信公众号
 
+## 知识自进化
+
+每次问答中的综合分析，用户确认后会自动存入知识库。问得越多，知识库越厚。存入的内容会标记为 `query-derived`，与原始材料编译的内容区分开。
+
 ## 技术栈
 
 - TypeScript + @modelcontextprotocol/sdk

package/dist/index.js

@@ -20,6 +20,7 @@ import { handleCompile } from "./tools/compile.js";
 import { handleSearch } from "./tools/search.js";
 import { handleArticle } from "./tools/article.js";
 import { handleLint } from "./tools/lint.js";
+import { handleFeedback } from "./tools/feedback.js";
 const server = new McpServer({
     name: "agent-wiki",
     version: "0.1.0",
@@ -42,11 +43,11 @@ server.tool("wiki_init", "初始化知识库。创建目录结构和 SCHEMA.md
     interests: z.array(z.string()).describe("兴趣方向列表，如 ['LLM', '创业', 'RAG']"),
 }, async (params) => handleInit(params));
 /**
- * wiki_ingest — 摄入 MD 文件到知识库
- * 从指定路径复制 MD 文件到 raw/（增量）
- * 返回每个文件的前 500 字预览供 Agent 用 LLM 处理
+ * wiki_ingest — 摄入文件到知识库（支持多格式）
+ * md/txt/html/csv 零依赖转换为 md
+ * pdf/docx/xlsx/图片原样存储，Agent 多模态读取
  */
-server.tool("wiki_ingest", "摄入 MD 文件到知识库。从指定路径复制 .md 文件到 raw/ 目录（增量，已摄入的跳过）。返回新文件内容预览，供你用 LLM 提取标签和摘要。", {
+server.tool("wiki_ingest", "摄入文件到知识库。支持 md/txt/html/csv（自动转 markdown）、pdf/docx/xlsx/图片（原样存储）。从指定路径复制到 raw/ 目录（增量，已摄入的跳过）。返回新文件内容预览，供你用 LLM 提取标签和摘要。", {
     source: z.string().describe("源文件路径或目录路径"),
     force: z.boolean().optional().describe("强制重新摄入已存在的文件，默认 false"),
 }, async (params) => handleIngest(params));
@@ -99,6 +100,19 @@ server.tool("wiki_article", "保存原创文章到 outputs/ 目录。保存前
 server.tool("wiki_lint", "自检知识库健康状态。检测死链接、缺失摘要、内容过短、缺少标签等问题，返回问题列表。", {
     check_only: z.boolean().optional().describe("仅检测不修复，默认 true"),
 }, async (params) => handleLint(params));
+/**
+ * wiki_feedback — 保存问答分析到知识库（用户确认版）
+ * 用户问问题 → Agent 回答 → 如果回答有综合分析价值 → 用户说"存" → 调用此工具
+ * 标记 type: query-derived，区分原始材料编译 vs 问答生成
+ * 防止幻觉复利：不自动存，必须用户确认
+ */
+server.tool("wiki_feedback", "保存问答分析到知识库。仅当用户明确说'存'或'保存'时才调用。将问答中的综合分析、对比、洞察保存为新的 Wiki 页面，标记为 query-derived 类型（区分原始材料编译 vs 问答生成）。", {
+    question: z.string().describe("用户的原始问题"),
+    answer: z.string().describe("Agent 的回答内容（有价值综合分析部分）"),
+    sources: z.array(z.string()).describe("参考了哪些 Wiki 页面（文件名列表）"),
+    tags: z.array(z.string()).describe("标签列表，如 ['RAG', '对比分析']"),
+    category: z.string().describe("分类名，如 'AI工程化'"),
+}, async (params) => handleFeedback(params));
 // ─── 启动 MCP Server ───
 async function main() {
     const transport = new StdioServerTransport();

package/dist/tools/feedback.d.ts

@@ -0,0 +1,20 @@
+/**
+ * wiki_feedback — 保存问答分析到知识库（用户确认版）
+ *
+ * 核心理念（来自 Karpathy）：
+ *   "good answers can be filed back into the wiki as new pages"
+ *   用户的提问和 Agent 的回答，不应该消失在聊天记录里，应该沉淀回知识库
+ *
+ * 防止幻觉复利的关键设计：
+ *   ❌ 不自动存：必须用户说"存"才调用
+ *   ✅ 标记来源：type: query-derived，区分原始材料 vs 问答生成
+ *   ✅ 搜索排序：compiled 类型排在 query-derived 前面
+ */
+import { ToolResult } from "../types.js";
+export declare function handleFeedback(params: {
+    question: string;
+    answer: string;
+    sources: string[];
+    tags: string[];
+    category: string;
+}): Promise<ToolResult>;

package/dist/tools/feedback.js

@@ -0,0 +1,118 @@
+/**
+ * wiki_feedback — 保存问答分析到知识库（用户确认版）
+ *
+ * 核心理念（来自 Karpathy）：
+ *   "good answers can be filed back into the wiki as new pages"
+ *   用户的提问和 Agent 的回答，不应该消失在聊天记录里，应该沉淀回知识库
+ *
+ * 防止幻觉复利的关键设计：
+ *   ❌ 不自动存：必须用户说"存"才调用
+ *   ✅ 标记来源：type: query-derived，区分原始材料 vs 问答生成
+ *   ✅ 搜索排序：compiled 类型排在 query-derived 前面
+ */
+import * as path from "path";
+import * as fs from "fs";
+import { getWikiDir, getWikiPagesDir } from "../state.js";
+import { safeFilename, todayStr, nowStr } from "../utils.js";
+import { textResult } from "../types.js";
+export async function handleFeedback(params) {
+    const wikiDir = getWikiDir();
+    if (!wikiDir) {
+        return textResult(JSON.stringify({ error: "知识库未初始化" }));
+    }
+    const { question, answer, sources, tags, category } = params;
+    const wikiPagesDir = getWikiPagesDir(wikiDir);
+    // 从问题生成标题（截取前 30 字符）
+    const title = `Q&A: ${question.substring(0, 30)}${question.length > 30 ? "..." : ""}`;
+    const fileName = `${safeFilename(title)}.md`;
+    const filePath = path.join(wikiPagesDir, fileName);
+    // 构建 sources 的 wikilink 格式
+    const sourceLinks = sources.map((s) => `- "[[${s}]]"`).join("\n");
+    // 生成 Wiki 页面内容
+    const content = `---
+title: "${title.replace(/"/g, '\\"')}"
+date: ${todayStr()}
+tags: [${tags.join(", ")}]
+category: ${category}
+type: query-derived
+sources:
+  ${sourceLinks}
+---
+
+# ${title}
+
+## 问题
+${question}
+
+## 回答
+${answer}
+
+## 参考来源
+${sources.map((s) => `- [[${s.replace(".md", "")}]]`).join("\n")}
+
+---
+*来源: 用户问答反馈 · 生成时间: ${nowStr()}*
+`;
+    // 写入 Wiki 页面
+    fs.writeFileSync(filePath, content, "utf-8");
+    // 更新 INDEX.md
+    const indexPath = path.join(wikiPagesDir, "INDEX.md");
+    if (fs.existsSync(indexPath)) {
+        const indexContent = fs.readFileSync(indexPath, "utf-8");
+        // 解析已有分类
+        const sections = {};
+        const lines = indexContent.split("\n");
+        let currentCategory = "";
+        for (const line of lines) {
+            if (line.startsWith("## ") && !line.includes("知识库索引")) {
+                currentCategory = line.replace("## ", "").trim();
+                if (!sections[currentCategory])
+                    sections[currentCategory] = [];
+            }
+            else if (line.startsWith("- [[") && currentCategory) {
+                const linkMatch = line.match(/- \[\[(.+?)\]\]\s*\((.+?)\)/);
+                if (linkMatch && !sections[currentCategory]) {
+                    sections[currentCategory] = [];
+                }
+            }
+        }
+        if (!sections[category])
+            sections[category] = [];
+        sections[category].push({ title, tags: tags.slice(0, 3) });
+        // 重新生成 INDEX.md
+        const totalEntries = Object.values(sections).reduce((s, e) => s + e.length, 0);
+        const newLines = [
+            "---",
+            `title: 知识库索引`,
+            `date: ${todayStr()}`,
+            "---",
+            "",
+            "# 知识库索引",
+            "",
+        ];
+        for (const [cat, entries] of Object.entries(sections)) {
+            if (entries.length === 0)
+                continue;
+            newLines.push(`## ${cat}`);
+            for (const entry of entries) {
+                newLines.push(`- [[${entry.title}]] (${entry.tags.join(", ")})`);
+            }
+            newLines.push("");
+        }
+        newLines.push(`---\n*共 ${totalEntries} 篇 · 更新于 ${todayStr()}*`);
+        fs.writeFileSync(indexPath, newLines.join("\n"), "utf-8");
+    }
+    // 追加 LOG.md
+    const logPath = path.join(wikiPagesDir, "LOG.md");
+    const logEntry = `\n## [${nowStr()}] feedback | ${title}\n来源: 用户问答 | 分类: ${category} | 标签: ${tags.join(", ")} | 参考: ${sources.join(", ")}\n`;
+    if (fs.existsSync(logPath)) {
+        fs.appendFileSync(logPath, logEntry, "utf-8");
+    }
+    return textResult(JSON.stringify({
+        status: "ok",
+        file: fileName,
+        title,
+        type: "query-derived",
+        note: "已保存为 Wiki 页面。搜索时 compiled 类型结果会排在 query-derived 前面。",
+    }));
+}

package/dist/tools/ingest.d.ts

@@ -1,9 +1,10 @@
 /**
- * wiki_ingest — 从指定路径复制 MD 文件到 raw/（增量）
+ * wiki_ingest — 从指定路径摄入文件到 raw/（增量，支持多格式）
  *
- * source 可以是单个文件或目录
+ * 零依赖转换：.md（直接复制）、.txt（改后缀）、.html（去标签）、.csv（转表格）
+ * 原样存储：.pdf、.docx、.xlsx、.xls、图片 → Agent 多模态读取
  * 已摄入的文件跳过（除非 force=true）
- * 返回每个文件的名称和前 500 字预览（供 Agent 用 LLM 处理）
+ * 返回每个文件的名称、类型和前 500 字预览（供 Agent 用 LLM 处理）
  */
 import { ToolResult } from "../types.js";
 export declare function handleIngest(params: {

package/dist/tools/ingest.js

@@ -1,65 +1,256 @@
 /**
- * wiki_ingest — 从指定路径复制 MD 文件到 raw/（增量）
+ * wiki_ingest — 从指定路径摄入文件到 raw/（增量，支持多格式）
  *
- * source 可以是单个文件或目录
+ * 零依赖转换：.md（直接复制）、.txt（改后缀）、.html（去标签）、.csv（转表格）
+ * 原样存储：.pdf、.docx、.xlsx、.xls、图片 → Agent 多模态读取
  * 已摄入的文件跳过（除非 force=true）
- * 返回每个文件的名称和前 500 字预览（供 Agent 用 LLM 处理）
+ * 返回每个文件的名称、类型和前 500 字预览（供 Agent 用 LLM 处理）
  */
 import * as path from "path";
 import * as fs from "fs";
 import { getWikiDir, getRawDir, getState, setState } from "../state.js";
 import { readFile_safe, ensureDir } from "../utils.js";
 import { textResult } from "../types.js";
+// ─── 支持的文件类型 ───
+/** 零依赖可转为 .md 的格式 */
+const CONVERTIBLE_EXTENSIONS = new Set([".md", ".txt", ".html", ".csv"]);
+/** 原样存储的二进制格式（Agent 多模态读取） */
+const BINARY_EXTENSIONS = new Set([".pdf", ".docx", ".xlsx", ".xls"]);
+/** 图片格式 */
+const IMAGE_EXTENSIONS = new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".svg"]);
+/** 所有支持的格式 */
+const SUPPORTED_EXTENSIONS = new Set([
+    ...CONVERTIBLE_EXTENSIONS,
+    ...BINARY_EXTENSIONS,
+    ...IMAGE_EXTENSIONS,
+]);
+// ─── 格式转换函数 ───
+/**
+ * .txt → .md（直接改后缀，内容不变）
+ */
+function convertTxt(content) {
+    return content;
+}
+/**
+ * .html → .md（去除 HTML 标签，保留纯文本）
+ * 零依赖，用正则处理。不追求完美还原，只提取可读文本
+ */
+function convertHtml(html) {
+    let text = html;
+    // 去除 script、style 标签及其内容
+    text = text.replace(/<script[\s\S]*?<\/script>/gi, "");
+    text = text.replace(/<style[\s\S]*?<\/style>/gi, "");
+    // 处理常见块级标签，转为换行
+    text = text.replace(/<\/?(p|div|br|h[1-6]|li|tr|blockquote)[^>]*>/gi, "\n");
+    // 处理标题标签，转为 markdown 标题
+    text = text.replace(/<h1[^>]*>([\s\S]*?)<\/h1>/gi, "# $1\n");
+    text = text.replace(/<h2[^>]*>([\s\S]*?)<\/h2>/gi, "## $1\n");
+    text = text.replace(/<h3[^>]*>([\s\S]*?)<\/h3>/gi, "### $1\n");
+    text = text.replace(/<h4[^>]*>([\s\S]*?)<\/h4>/gi, "#### $1\n");
+    // 处理列表项
+    text = text.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, "- $1\n");
+    // 处理加粗和斜体
+    text = text.replace(/<(strong|b)[^>]*>([\s\S]*?)<\/(strong|b)>/gi, "**$2**");
+    text = text.replace(/<(em|i)[^>]*>([\s\S]*?)<\/(em|i)>/gi, "*$2*");
+    // 处理链接
+    text = text.replace(/<a[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi, "[$2]($1)");
+    // 去除所有剩余 HTML 标签
+    text = text.replace(/<[^>]+>/g, "");
+    // 解码常见 HTML 实体
+    text = text.replace(/&amp;/g, "&");
+    text = text.replace(/&lt;/g, "<");
+    text = text.replace(/&gt;/g, ">");
+    text = text.replace(/&quot;/g, '"');
+    text = text.replace(/&#39;/g, "'");
+    text = text.replace(/&nbsp;/g, " ");
+    // 清理多余空行（超过 2 个连续换行压缩为 2 个）
+    text = text.replace(/\n{3,}/g, "\n\n");
+    return text.trim();
+}
+/**
+ * .csv → markdown 表格
+ * 零依赖，手动解析。处理简单 CSV（带引号的字段、逗号在引号内）
+ */
+function convertCsv(csv) {
+    // 简单 CSV 解析（处理引号内的逗号）
+    function parseLine(line) {
+        const fields = [];
+        let current = "";
+        let inQuotes = false;
+        for (let i = 0; i < line.length; i++) {
+            const ch = line[i];
+            if (ch === '"') {
+                if (inQuotes && i + 1 < line.length && line[i + 1] === '"') {
+                    // 转义引号 ""
+                    current += '"';
+                    i++;
+                }
+                else {
+                    inQuotes = !inQuotes;
+                }
+            }
+            else if (ch === "," && !inQuotes) {
+                fields.push(current.trim());
+                current = "";
+            }
+            else {
+                current += ch;
+            }
+        }
+        fields.push(current.trim());
+        return fields;
+    }
+    const lines = csv.split(/\r?\n/).filter((line) => line.trim());
+    if (lines.length === 0)
+        return "";
+    // 第一行是表头
+    const headers = parseLine(lines[0]);
+    const colCount = headers.length;
+    // 构建 markdown 表格
+    const mdLines = [];
+    // 表头行
+    mdLines.push("| " + headers.join(" | ") + " |");
+    // 分隔行
+    mdLines.push("| " + headers.map(() => "---").join(" | ") + " |");
+    // 数据行
+    for (let i = 1; i < lines.length; i++) {
+        const fields = parseLine(lines[i]);
+        // 补齐或截断到与表头同列数
+        while (fields.length < colCount)
+            fields.push("");
+        mdLines.push("| " + fields.slice(0, colCount).join(" | ") + " |");
+    }
+    return mdLines.join("\n");
+}
+/**
+ * 根据文件扩展名，将文件内容转为 .md 格式
+ * 返回 null 表示无法转换（二进制文件）
+ */
+function convertToMarkdown(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const content = readFile_safe(filePath);
+    if (content === null)
+        return null;
+    switch (ext) {
+        case ".md":
+            return content;
+        case ".txt":
+            return convertTxt(content);
+        case ".html":
+            return convertHtml(content);
+        case ".csv":
+            return convertCsv(content);
+        default:
+            return null;
+    }
+}
+// ─── 文件类型判断 ───
+function getFileType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (CONVERTIBLE_EXTENSIONS.has(ext))
+        return "convertible";
+    if (BINARY_EXTENSIONS.has(ext))
+        return "binary";
+    if (IMAGE_EXTENSIONS.has(ext))
+        return "image";
+    return "unsupported";
+}
+// ─── 主处理函数 ───
 export async function handleIngest(params) {
     const wikiDir = getWikiDir();
     if (!wikiDir) {
         return textResult(JSON.stringify({ error: "知识库未初始化，请先调用 wiki_init" }));
     }
     const rawDir = getRawDir(wikiDir);
+    const assetsDir = path.join(rawDir, "assets");
     ensureDir(rawDir);
+    ensureDir(assetsDir);
     const state = getState(wikiDir);
     const source = params.source.replace(/^~/, process.env.HOME || "~");
     const force = params.force ?? false;
     // 收集要摄入的文件列表
     let filesToIngest = [];
     if (fs.statSync(source).isDirectory()) {
+        // 目录：扫描所有支持的文件类型
         filesToIngest = fs
             .readdirSync(source)
-            .filter((f) => f.endsWith(".md"))
+            .filter((f) => SUPPORTED_EXTENSIONS.has(path.extname(f).toLowerCase()))
             .map((f) => path.join(source, f));
     }
-    else if (source.endsWith(".md")) {
-        filesToIngest = [source];
-    }
     else {
-        return textResult(JSON.stringify({ error: "source 必须是 .md 文件或包含 .md 文件的目录" }));
+        // 单文件：检查是否支持
+        const ext = path.extname(source).toLowerCase();
+        if (SUPPORTED_EXTENSIONS.has(ext)) {
+            filesToIngest = [source];
+        }
+        else {
+            return textResult(JSON.stringify({
+                error: `不支持的文件格式: ${ext}。支持的格式: md, txt, html, csv, pdf, docx, xlsx, xls, png, jpg, jpeg, gif, webp`,
+            }));
+        }
     }
-    // 增量过滤
+    // 增量过滤 + 处理
     const results = [];
     let ingested = 0;
     for (const filePath of filesToIngest) {
         const fileName = path.basename(filePath);
-        const destPath = path.join(rawDir, fileName);
+        const fileType = getFileType(filePath);
+        // 生成 raw/ 中的目标文件名
+        let destFileName = fileName;
+        if (fileType === "convertible" && !fileName.endsWith(".md")) {
+            // 可转换格式：目标文件名改为 .md
+            destFileName = path.basename(fileName, path.extname(fileName)) + ".md";
+        }
         // 已摄入则跳过（除非 force）
-        if (!force && state.ingested.includes(fileName)) {
-            results.push({ name: fileName, content_preview: "(已摄入，跳过)", skipped: true });
+        if (!force && state.ingested.includes(destFileName)) {
+            results.push({ name: fileName, type: fileType, content_preview: "(已摄入，跳过)", skipped: true });
             continue;
         }
-        // 复制到 raw/
-        const content = readFile_safe(filePath);
-        if (!content) {
-            results.push({ name: fileName, content_preview: "(无法读取文件)", skipped: true });
-            continue;
+        if (fileType === "convertible") {
+            // ── 零依赖转换 ──
+            const mdContent = convertToMarkdown(filePath);
+            if (!mdContent) {
+                results.push({ name: fileName, type: fileType, content_preview: "(无法读取文件)", skipped: true });
+                continue;
+            }
+            const destPath = path.join(rawDir, destFileName);
+            fs.writeFileSync(destPath, mdContent, "utf-8");
+            if (!state.ingested.includes(destFileName)) {
+                state.ingested.push(destFileName);
+            }
+            results.push({
+                name: fileName,
+                type: "converted",
+                content_preview: mdContent.substring(0, 500),
+                note: `已转为 ${destFileName}`,
+            });
+        }
+        else if (fileType === "binary") {
+            // ── 原样存储（PDF/DOCX/XLSX） ──
+            const destPath = path.join(rawDir, fileName);
+            fs.copyFileSync(filePath, destPath);
+            if (!state.ingested.includes(fileName)) {
+                state.ingested.push(fileName);
+            }
+            results.push({
+                name: fileName,
+                type: "binary",
+                note: "原文件已存储，请直接读取 raw/ 下的文件",
+            });
         }
-        fs.writeFileSync(destPath, content, "utf-8");
-        // 更新状态
-        if (!state.ingested.includes(fileName)) {
-            state.ingested.push(fileName);
+        else if (fileType === "image") {
+            // ── 图片存储到 raw/assets/ ──
+            const destPath = path.join(assetsDir, fileName);
+            fs.copyFileSync(filePath, destPath);
+            if (!state.ingested.includes(fileName)) {
+                state.ingested.push(fileName);
+            }
+            results.push({
+                name: fileName,
+                type: "image",
+                note: "已存储到 raw/assets/，可直接查看",
+            });
         }
-        results.push({
-            name: fileName,
-            content_preview: content.substring(0, 500),
-        });
         ingested++;
     }
     // 保存状态

package/dist/tools/search.js

@@ -80,12 +80,15 @@ export async function handleSearch(params) {
         }
         // 至少有一点匹配才加入结果
         if (score > 0) {
+            // 类型权重：compiled（原始材料编译）排在 query-derived（问答生成）前面
+            const typeBoost = String(meta.type) === "query-derived" ? 0.9 : 1.0;
             results.push({
                 title,
                 file: fileName,
                 tags: fileTags,
                 summary,
-                score: Math.round(score * 100) / 100,
+                score: Math.round(score * typeBoost * 100) / 100,
+                type: String(meta.type || "compiled"),
             });
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-wiki",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "卡帕西智能知识库 MCP 插件 — 一行安装，纯对话交互，Agent 自动帮你管理知识库、写有人味儿的原创文章",
   "type": "module",
   "main": "dist/index.js",