@claudeink/mcp-server 0.7.0 → 0.9.0

package/dist/index.js

@@ -8,6 +8,8 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z } from "zod";
 import { mkdir as mkdir2, readFile as readFile3 } from "fs/promises";
 import { join as join3 } from "path";
+import { execSync } from "child_process";
+import { readdirSync } from "fs";
 
 // src/lib/state.ts
 import { readFile, writeFile, mkdir, chmod } from "fs/promises";
@@ -37,6 +39,7 @@ var DEFAULT_STATE = {
   configs: {},
   crawlerSources: {},
   writingMasters: {},
+  knowledge: {},
   tagQueue: {
     queue: [],
     failed: []
@@ -47,9 +50,17 @@ async function ensureDir() {
   await mkdir(getClaudeinkDir(), { recursive: true });
 }
 async function readState() {
+  const statePath = getStatePath();
+  let raw;
   try {
-    const content = await readFile(getStatePath(), "utf-8");
-    const parsed = JSON.parse(content);
+    raw = await readFile(statePath, "utf-8");
+  } catch {
+    const state = { ...DEFAULT_STATE };
+    state.config.workflowDir = getWorkDir();
+    return state;
+  }
+  try {
+    const parsed = JSON.parse(raw);
     const state = {
       ...DEFAULT_STATE,
       ...parsed,
@@ -59,6 +70,12 @@ async function readState() {
     state.config.workflowDir = getWorkDir();
     return state;
   } catch {
+    const backupPath = statePath + ".corrupted." + Date.now();
+    try {
+      await writeFile(backupPath, raw, "utf-8");
+    } catch {
+    }
+    console.error(`[ClaudeInk] state.json corrupted, backed up to ${backupPath}`);
     const state = { ...DEFAULT_STATE };
     state.config.workflowDir = getWorkDir();
     return state;
@@ -118,14 +135,17 @@ async function removeCrawlerSource(id) {
   delete state.crawlerSources[id];
   await writeState(state);
 }
-async function updateLastSyncAt() {
+async function mergeCloudData(cloud) {
   const state = await readState();
+  if (cloud.sources !== void 0) state.sources = cloud.sources;
+  if (cloud.drafts !== void 0) state.drafts = cloud.drafts;
+  if (cloud.published !== void 0) state.published = cloud.published;
+  if (cloud.configs !== void 0) state.configs = cloud.configs;
+  if (cloud.crawlerSources !== void 0) state.crawlerSources = cloud.crawlerSources;
+  if (cloud.writingMasters !== void 0) state.writingMasters = cloud.writingMasters;
   state.lastSyncAt = (/* @__PURE__ */ new Date()).toISOString();
   await writeState(state);
 }
-async function replaceState(newState) {
-  await writeState(newState);
-}
 async function getTagQueue() {
   const state = await readState();
   return {
@@ -240,6 +260,37 @@ async function markTagFailed(file) {
   await saveTagQueue(queue);
 }
 
+// src/lib/push.ts
+function fireAndForgetPush(payload) {
+  doPush(payload).catch(() => {
+  });
+}
+async function doPush(partial) {
+  const creds = await getCredentials();
+  if (!creds?.token) return;
+  const config = await getConfig();
+  const payload = {
+    sources: partial.sources || [],
+    drafts: partial.drafts || [],
+    published: partial.published || [],
+    configs: partial.configs || [],
+    crawlerSources: partial.crawlerSources || [],
+    analytics: partial.analytics || []
+  };
+  try {
+    await fetch(`${config.apiBaseUrl}/api/sync/batch`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${creds.token}`
+      },
+      body: JSON.stringify(payload)
+    });
+  } catch (err) {
+    console.error("[ClaudeInk] auto-push failed:", err instanceof Error ? err.message : err);
+  }
+}
+
 // src/tools/source.ts
 var sourceAddSchema = z.object({
   title: z.string().describe("\u7D20\u6750\u6807\u9898"),
@@ -267,7 +318,7 @@ async function sourceAdd(input) {
       }
     })() : "manual",
     published: date,
-    url: input.url
+    ...input.url ? { url: input.url } : {}
   };
   if (input.tags && input.tags.length > 0) {
     meta.tags = input.tags;
@@ -284,6 +335,18 @@ async function sourceAdd(input) {
       publishedAt: date,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
+    fireAndForgetPush({
+      sources: [{
+        id: slug,
+        title: input.title,
+        source: meta.source,
+        tags: input.tags || [],
+        sourceUrl: input.url || "",
+        coverUrl: "",
+        sourceIcon: "",
+        createdAt: date
+      }]
+    });
     return {
       success: true,
       message: `\u7D20\u6750\u5DF2\u5165\u5E93: ${filename}\uFF08\u542B ${input.tags.length} \u4E2A\u6807\u7B7E\uFF09`,
@@ -303,6 +366,18 @@ async function sourceAdd(input) {
       publishedAt: date,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
+    fireAndForgetPush({
+      sources: [{
+        id: slug,
+        title: input.title,
+        source: meta.source,
+        tags: input.tags || [],
+        sourceUrl: input.url || "",
+        coverUrl: "",
+        sourceIcon: "",
+        createdAt: date
+      }]
+    });
     return {
       success: true,
       message: `\u7D20\u6750\u5DF2\u5165\u5E93: ${filename}\uFF08\u5DF2\u52A0\u5165\u6807\u7B7E\u961F\u5217\uFF0C\u7B49\u5F85 Claude \u6253\u6807\u7B7E\uFF09`,
@@ -315,7 +390,8 @@ var sourceCrawlSchema = z.object({
 });
 async function sourceCrawl(input) {
   const config = await getConfig();
-  const configPath = join3(config.workflowDir || process.cwd(), "tools", "crawler", "config.json");
+  const crawlerDir = join3(config.workflowDir || process.cwd(), "tools", "crawler");
+  const configPath = join3(crawlerDir, "config.json");
   let crawlerConfig;
   try {
     crawlerConfig = JSON.parse(await readFile3(configPath, "utf-8"));
@@ -328,18 +404,97 @@ async function sourceCrawl(input) {
       message: "\u6682\u65E0\u914D\u7F6E\u722C\u866B\u6E90\u3002\u8BF7\u5148\u7528 source.subscribe \u6DFB\u52A0\u3002"
     };
   }
-  const targets = input.sourceId ? crawlerConfig.sources.filter((s) => s.name === input.sourceId) : crawlerConfig.sources.filter((s) => s.enabled !== false);
+  const targets = input.sourceId ? crawlerConfig.sources.filter((s) => s.id === input.sourceId) : crawlerConfig.sources.filter((s) => s.enabled !== false);
   if (targets.length === 0) {
     return {
       success: false,
-      message: `\u672A\u627E\u5230\u722C\u866B\u6E90: ${input.sourceId}`
+      message: input.sourceId ? `\u672A\u627E\u5230\u722C\u866B\u6E90: ${input.sourceId}` : "\u6CA1\u6709\u5DF2\u542F\u7528\u7684\u722C\u866B\u6E90"
     };
   }
-  return {
-    success: true,
-    message: `\u5DF2\u89E6\u53D1 ${targets.length} \u4E2A\u722C\u866B\u6E90: ${targets.map((t) => t.name).join(", ")}`,
-    data: { triggered: targets.map((t) => t.name) }
-  };
+  const crawlScript = join3(crawlerDir, "crawl.mjs");
+  const args = input.sourceId ? `--source ${input.sourceId}` : "";
+  try {
+    execSync(`node "${crawlScript}" ${args}`, {
+      cwd: crawlerDir,
+      encoding: "utf-8",
+      timeout: 5 * 60 * 1e3,
+      // 5 minute timeout
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let newFiles = [];
+    for (const target of targets) {
+      const sourceDir = join3(config.workflowDir, "sources", "articles", target.id);
+      try {
+        const files = readdirSync(sourceDir).filter((f) => f.endsWith(".md"));
+        for (const f of files) {
+          const filePath = `sources/articles/${target.id}/${f}`;
+          newFiles.push({
+            file: filePath,
+            title: f.replace(/^\d{4}-\d{2}-\d{2}-/, "").replace(/\.md$/, "").replace(/-/g, " "),
+            sourceId: target.id
+          });
+        }
+      } catch {
+      }
+    }
+    let queued = 0;
+    for (const item of newFiles) {
+      try {
+        const fullPath = join3(config.workflowDir, item.file);
+        const source = await readSourceFile(fullPath);
+        const slug = item.file.replace(/^.*\//, "").replace(/\.md$/, "");
+        const date = source.meta.published || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+        await updateSource(slug, {
+          title: source.meta.title || item.title,
+          source: item.sourceId,
+          sourceIcon: "",
+          sourceUrl: source.meta.url || "",
+          coverUrl: "",
+          tags: source.meta.tags || [],
+          publishedAt: date,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        if (!source.meta.tags || source.meta.tags.length === 0) {
+          await addToTagQueue(item.file, source.meta.title || item.title, "crawl");
+          queued++;
+        }
+        fireAndForgetPush({
+          sources: [{
+            id: slug,
+            title: source.meta.title || item.title,
+            source: item.sourceId,
+            tags: source.meta.tags || [],
+            sourceUrl: source.meta.url || "",
+            coverUrl: "",
+            sourceIcon: "",
+            createdAt: date
+          }]
+        });
+      } catch {
+      }
+    }
+    return {
+      success: true,
+      message: [
+        `\u2705 \u722C\u53D6\u5B8C\u6210`,
+        `   \u76EE\u6807\u6E90: ${targets.map((t) => t.name).join(", ")}`,
+        `   \u53D1\u73B0\u6587\u7AE0: ${newFiles.length} \u7BC7`,
+        queued > 0 ? `   \u52A0\u5165\u6807\u7B7E\u961F\u5217: ${queued} \u7BC7` : "",
+        `   \u5143\u6570\u636E\u5DF2\u540C\u6B65\u5230\u4E91\u7AEF`
+      ].filter(Boolean).join("\n"),
+      data: {
+        sources: targets.map((t) => t.name),
+        articles: newFiles.length,
+        queued
+      }
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (message.includes("ETIMEDOUT") || message.includes("timed out")) {
+      return { success: false, message: "\u722C\u53D6\u8D85\u65F6\uFF085 \u5206\u949F\u9650\u5236\uFF09\u3002\u8BF7\u5C1D\u8BD5\u6307\u5B9A\u5355\u4E2A\u6E90: source.crawl({ sourceId: 'xxx' })" };
+    }
+    return { success: false, message: `\u722C\u53D6\u5931\u8D25: ${message.slice(0, 200)}` };
+  }
 }
 var sourceTagSchema = z.object({
   mode: z.enum(["queue", "single"]).describe("queue=\u5904\u7406\u6807\u7B7E\u961F\u5217, single=\u5355\u4E2A\u6587\u4EF6\u6253\u6807\u7B7E"),
@@ -422,6 +577,19 @@ async function sourceTagApply(input) {
     await updateSourceTags2(fullPath, input.tags);
     await markTagged(input.file, input.tags.length);
     await updateSourceTags(input.file, input.tags);
+    const slug = input.file.replace(/^.*\//, "").replace(/\.md$/, "");
+    fireAndForgetPush({
+      sources: [{
+        id: slug,
+        title: "",
+        source: "",
+        tags: input.tags,
+        sourceUrl: "",
+        coverUrl: "",
+        sourceIcon: "",
+        createdAt: ""
+      }]
+    });
     return {
       success: true,
       message: `\u6807\u7B7E\u5DF2\u5199\u5165: ${input.tags.join(", ")}`,
@@ -446,7 +614,18 @@ var sourceSubscribeSchema = z2.object({
   name: z2.string().optional().describe("\u8BA2\u9605\u6E90\u540D\u79F0"),
   url: z2.string().optional().describe("RSS/\u535A\u5BA2 URL"),
   type: z2.enum(["rss", "blog", "sitemap"]).optional().describe("\u6E90\u7C7B\u578B"),
-  icon: z2.string().optional().describe("\u6765\u6E90 icon URL")
+  icon: z2.string().optional().describe("\u6765\u6E90 icon URL"),
+  crawlConfig: z2.object({
+    articleSelector: z2.string(),
+    articleUrlPattern: z2.string().optional(),
+    pagination: z2.object({
+      pattern: z2.string(),
+      startPage: z2.number(),
+      maxPages: z2.number()
+    }).optional(),
+    excludePatterns: z2.array(z2.string()).optional(),
+    maxArticles: z2.number().optional()
+  }).optional().describe("\u722C\u53D6\u9002\u914D\u89C4\u5219\uFF08Claude \u5206\u6790\u751F\u6210\uFF09")
 });
 async function sourceSubscribe(input) {
   const config = await getConfig();
@@ -474,11 +653,18 @@ async function sourceSubscribe(input) {
     const newSource = {
       id: input.id,
       name: input.name,
-      url: input.url,
-      type: input.type || "rss",
+      blogUrl: input.url,
+      type: input.type === "blog" ? "paginated" : input.type || "rss",
       icon: input.icon || "",
       enabled: true
     };
+    if (input.crawlConfig) {
+      newSource.articleSelector = input.crawlConfig.articleSelector;
+      if (input.crawlConfig.articleUrlPattern) newSource.articleUrlPattern = input.crawlConfig.articleUrlPattern;
+      if (input.crawlConfig.pagination) newSource.pagination = input.crawlConfig.pagination;
+      if (input.crawlConfig.excludePatterns) newSource.excludePatterns = input.crawlConfig.excludePatterns;
+      if (input.crawlConfig.maxArticles) newSource.maxArticles = input.crawlConfig.maxArticles;
+    }
     crawlerConfig.sources.push(newSource);
     await writeFile3(configPath, JSON.stringify(crawlerConfig, null, 2));
     await updateCrawlerSource(input.id, {
@@ -488,6 +674,18 @@ async function sourceSubscribe(input) {
       icon: input.icon || "",
       enabled: true
     });
+    const stateAfterAdd = await readState();
+    fireAndForgetPush({
+      crawlerSources: Object.entries(stateAfterAdd.crawlerSources).map(([id, cs]) => ({
+        id,
+        name: cs.name,
+        url: cs.url,
+        type: cs.type,
+        icon: cs.icon,
+        enabled: cs.enabled,
+        ...id === input.id && input.crawlConfig ? { crawlConfig: input.crawlConfig } : {}
+      }))
+    });
     return { success: true, message: `\u8BA2\u9605\u6E90 ${input.name} \u5DF2\u6DFB\u52A0` };
   }
   if (input.action === "remove") {
@@ -497,6 +695,17 @@ async function sourceSubscribe(input) {
     crawlerConfig.sources = crawlerConfig.sources.filter((s) => s.id !== input.id);
     await writeFile3(configPath, JSON.stringify(crawlerConfig, null, 2));
     await removeCrawlerSource(input.id);
+    const stateAfterRemove = await readState();
+    fireAndForgetPush({
+      crawlerSources: Object.entries(stateAfterRemove.crawlerSources).map(([id, cs]) => ({
+        id,
+        name: cs.name,
+        url: cs.url,
+        type: cs.type,
+        icon: cs.icon,
+        enabled: cs.enabled
+      }))
+    });
     return { success: true, message: `\u8BA2\u9605\u6E90 ${input.id} \u5DF2\u5220\u9664` };
   }
   return { success: false, message: "\u672A\u77E5\u64CD\u4F5C" };
@@ -550,6 +759,20 @@ async function saveDraft(options) {
   await writeFile4(filePath, output, "utf-8");
   return { filePath, meta, content: options.content };
 }
+async function updateDraft2(options) {
+  const raw = await readFile5(options.file, "utf-8");
+  const { data, content } = matter2(raw);
+  const meta = data;
+  if (options.title) meta.title = options.title;
+  if (options.status) meta.status = options.status;
+  if (options.tags) meta.tags = options.tags;
+  const newContent = options.content ?? content.trim();
+  meta.wordCount = newContent.length;
+  meta.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const output = matter2.stringify(newContent, meta);
+  await writeFile4(options.file, output, "utf-8");
+  return { filePath: options.file, meta, content: newContent };
+}
 async function publishDraft(options) {
   const raw = await readFile5(options.file, "utf-8");
   const { data, content } = matter2(raw);
@@ -569,6 +792,25 @@ async function publishDraft(options) {
 }
 
 // src/tools/draft.ts
+function fireAndForgetDraftUpload(draftId, account, title, content) {
+  (async () => {
+    const creds = await getCredentials();
+    if (!creds?.token) return;
+    const config = await getConfig();
+    try {
+      await fetch(`${config.apiBaseUrl}/api/drafts/upload`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${creds.token}`
+        },
+        body: JSON.stringify({ draftId, account, title, content })
+      });
+    } catch {
+    }
+  })().catch(() => {
+  });
+}
 var draftSaveSchema = z3.object({
   account: z3.string().describe("\u8D26\u53F7\u540D\u79F0"),
   platform: z3.string().describe("\u5E73\u53F0\u540D\u79F0\uFF0C\u5982 wechat"),
@@ -596,6 +838,20 @@ async function draftSave(input) {
     createdAt: draft.meta.createdAt,
     updatedAt: draft.meta.updatedAt
   });
+  fireAndForgetPush({
+    drafts: [{
+      id: draft.meta.id,
+      account: input.account,
+      platform: input.platform,
+      title: draft.meta.title,
+      status: draft.meta.status,
+      wordCount: draft.meta.wordCount,
+      tags: input.tags || [],
+      createdAt: draft.meta.createdAt,
+      updatedAt: draft.meta.updatedAt
+    }]
+  });
+  fireAndForgetDraftUpload(draft.meta.id, input.account, draft.meta.title, input.content);
   return {
     success: true,
     message: `\u8349\u7A3F\u5DF2\u4FDD\u5B58: ${draft.meta.title} (${draft.meta.wordCount} \u5B57)`,
@@ -606,6 +862,55 @@ async function draftSave(input) {
     }
   };
 }
+var draftUpdateSchema = z3.object({
+  file: z3.string().describe("\u8349\u7A3F\u6587\u4EF6\u8DEF\u5F84"),
+  content: z3.string().optional().describe("\u66F4\u65B0\u540E\u7684\u6B63\u6587\uFF08Markdown\uFF09"),
+  title: z3.string().optional().describe("\u66F4\u65B0\u540E\u7684\u6807\u9898"),
+  status: z3.enum(["draft", "review", "ready"]).optional().describe("\u66F4\u65B0\u72B6\u6001"),
+  tags: z3.array(z3.string()).optional().describe("\u66F4\u65B0\u6807\u7B7E")
+});
+async function draftUpdate(input) {
+  const draft = await updateDraft2({
+    file: input.file,
+    content: input.content,
+    title: input.title,
+    status: input.status,
+    tags: input.tags
+  });
+  await updateDraft(draft.meta.id, {
+    title: draft.meta.title,
+    account: draft.meta.account,
+    platform: draft.meta.platform,
+    status: draft.meta.status,
+    wordCount: draft.meta.wordCount,
+    tags: draft.meta.tags || [],
+    createdAt: draft.meta.createdAt,
+    updatedAt: draft.meta.updatedAt
+  });
+  fireAndForgetPush({
+    drafts: [{
+      id: draft.meta.id,
+      account: draft.meta.account,
+      platform: draft.meta.platform,
+      title: draft.meta.title,
+      status: draft.meta.status,
+      wordCount: draft.meta.wordCount,
+      tags: draft.meta.tags || [],
+      createdAt: draft.meta.createdAt,
+      updatedAt: draft.meta.updatedAt
+    }]
+  });
+  fireAndForgetDraftUpload(draft.meta.id, draft.meta.account, draft.meta.title, draft.content);
+  return {
+    success: true,
+    message: `\u8349\u7A3F\u5DF2\u66F4\u65B0: ${draft.meta.title} (${draft.meta.wordCount} \u5B57)`,
+    data: {
+      file: draft.filePath,
+      id: draft.meta.id,
+      status: draft.meta.status
+    }
+  };
+}
 var draftPublishSchema = z3.object({
   file: z3.string().describe("\u8349\u7A3F\u6587\u4EF6\u8DEF\u5F84"),
   platformUrl: z3.string().optional().describe("\u5E73\u53F0\u53D1\u5E03\u94FE\u63A5")
@@ -622,6 +927,16 @@ async function draftPublish(input) {
     platformUrl: draft.meta.platformUrl || "",
     publishedAt: draft.meta.publishedAt || (/* @__PURE__ */ new Date()).toISOString()
   });
+  fireAndForgetPush({
+    published: [{
+      id: draft.meta.id,
+      account: draft.meta.account,
+      platform: draft.meta.platform,
+      title: draft.meta.title,
+      platformUrl: draft.meta.platformUrl,
+      publishedAt: draft.meta.publishedAt || (/* @__PURE__ */ new Date()).toISOString()
+    }]
+  });
   return {
     success: true,
     message: `\u5DF2\u53D1\u5E03: ${draft.meta.title} \u2192 ${draft.filePath}`,
@@ -738,7 +1053,6 @@ import { z as z5 } from "zod";
 import { writeFile as writeFile5, mkdir as mkdir4 } from "fs/promises";
 import { join as join6 } from "path";
 var syncSchema = z5.object({
-  action: z5.enum(["push", "pull", "sync"]).describe("push=\u63A8\u9001\u672C\u5730\u5230\u4E91\u7AEF, pull=\u62C9\u53D6\u4E91\u7AEF\u5230\u672C\u5730, sync=\u5148push\u518Dpull"),
   workDir: z5.string().optional().describe("\u5DE5\u4F5C\u76EE\u5F55\uFF08\u9ED8\u8BA4\u4F7F\u7528\u914D\u7F6E\u4E2D\u7684 workflowDir\uFF09")
 });
 async function sync(input) {
@@ -747,160 +1061,31 @@ async function sync(input) {
   if (!creds?.token) {
     return { success: false, message: "\u672A\u6FC0\u6D3B\uFF0C\u8BF7\u5148\u4F7F\u7528 workflow.init \u6FC0\u6D3B License" };
   }
-  if (input.action === "push") {
-    return doPush(creds.token);
-  } else if (input.action === "pull") {
-    return doPull(creds.token, input.workDir);
-  } else {
-    const pushResult = await doPush(creds.token);
-    const pullResult = await doPull(creds.token, input.workDir);
-    const messages = [];
-    if (pushResult.success) messages.push(pushResult.message);
-    else messages.push(`Push \u5931\u8D25: ${pushResult.message}`);
-    if (pullResult.success) messages.push(pullResult.message);
-    else messages.push(`Pull \u5931\u8D25: ${pullResult.message}`);
-    return {
-      success: pushResult.success && pullResult.success,
-      message: messages.join("\n\n"),
-      data: { push: pushResult.data, pull: pullResult.data }
-    };
-  }
-}
-async function doPush(token) {
-  const config = await getConfig();
-  const state = await readState();
-  const payload = {
-    sources: Object.entries(state.sources).map(([id, s]) => ({
-      id,
-      title: s.title,
-      source: s.source,
-      tags: s.tags,
-      sourceUrl: s.sourceUrl,
-      coverUrl: s.coverUrl,
-      sourceIcon: s.sourceIcon,
-      createdAt: s.publishedAt
-    })),
-    drafts: Object.entries(state.drafts).map(([id, d]) => ({
-      id,
-      account: d.account,
-      platform: d.platform,
-      title: d.title,
-      status: d.status,
-      wordCount: d.wordCount,
-      tags: d.tags,
-      createdAt: d.createdAt,
-      updatedAt: d.updatedAt
-    })),
-    published: Object.entries(state.published).map(([id, p]) => ({
-      id,
-      account: p.account,
-      platform: p.platform,
-      title: p.title,
-      platformUrl: p.platformUrl,
-      publishedAt: p.publishedAt
-    })),
-    configs: Object.entries(state.configs).map(([_key, c]) => ({
-      type: c.type,
-      name: c.name,
-      displayName: c.displayName,
-      content: c.content,
-      metadata: c.metadata
-    })),
-    crawlerSources: Object.entries(state.crawlerSources).map(([id, cs]) => ({
-      id,
-      name: cs.name,
-      url: cs.url,
-      type: cs.type,
-      icon: cs.icon,
-      enabled: cs.enabled
-    })),
-    analytics: []
-  };
-  try {
-    const res = await fetch(`${config.apiBaseUrl}/api/sync/batch`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${token}`
-      },
-      body: JSON.stringify(payload)
-    });
-    const result = await res.json();
-    if (res.ok) {
-      await updateLastSyncAt();
-      return {
-        success: true,
-        message: [
-          "\u2705 \u63A8\u9001\u5B8C\u6210",
-          `   \u7D20\u6750: ${payload.sources.length} \u7BC7`,
-          `   \u8349\u7A3F: ${payload.drafts.length} \u7BC7`,
-          `   \u5DF2\u53D1\u5E03: ${payload.published.length} \u7BC7`,
-          `   \u914D\u7F6E: ${payload.configs.length} \u4E2A`,
-          `   \u8BA2\u9605\u6E90: ${payload.crawlerSources.length} \u4E2A`,
-          `   \u4E91\u7AEF\u63A5\u53D7: ${result.accepted || 0} \u6761`
-        ].join("\n"),
-        data: { accepted: result.accepted || 0 }
-      };
-    } else {
-      return { success: false, message: `\u63A8\u9001\u5931\u8D25: HTTP ${res.status}` };
-    }
-  } catch (err) {
-    return { success: false, message: `\u63A8\u9001\u7F51\u7EDC\u9519\u8BEF: ${err instanceof Error ? err.message : err}` };
-  }
+  return doPull(creds.token, input.workDir);
 }
 async function doPull(token, workDir) {
   const config = await getConfig();
   const effectiveWorkDir = workDir || config.workflowDir;
   try {
     const res = await fetch(`${config.apiBaseUrl}/api/sync/pull`, {
-      headers: { "Authorization": `Bearer ${token}` }
+      headers: { Authorization: `Bearer ${token}` }
     });
     if (!res.ok) {
       if (res.status === 404) {
-        return { success: true, message: "\u4E91\u7AEF\u65E0\u5DF2\u6709\u914D\u7F6E\uFF0C\u4F7F\u7528\u672C\u5730\u9ED8\u8BA4" };
+        return { success: true, message: "\u4E91\u7AEF\u65E0\u6570\u636E" };
       }
       return { success: false, message: `\u62C9\u53D6\u5931\u8D25: HTTP ${res.status}` };
     }
     const cloudData = await res.json();
-    if (!cloudData.configs || cloudData.configs.length === 0) {
-      return { success: true, message: "\u4E91\u7AEF\u65E0\u914D\u7F6E\u6570\u636E" };
-    }
-    let updated = 0;
-    const state = await readState();
-    for (const cfgItem of cloudData.configs) {
-      const stateKey = `${cfgItem.type}:${cfgItem.name}`;
-      const localUpdatedAt = state.configs[stateKey]?.updatedAt || "";
-      if (!localUpdatedAt || cfgItem.updatedAt > localUpdatedAt) {
-        let filePath = "";
-        if (cfgItem.type === "base_rules") {
-          filePath = join6(effectiveWorkDir, "base-rules.md");
-        } else if (cfgItem.type === "platform") {
-          filePath = join6(effectiveWorkDir, "platforms", `${cfgItem.name}.md`);
-        } else if (cfgItem.type === "account") {
-          filePath = join6(effectiveWorkDir, "accounts", `${cfgItem.name}.yaml`);
-        }
-        if (filePath && cfgItem.content) {
-          await writeFile5(filePath, cfgItem.content, "utf-8");
-          state.configs[stateKey] = {
-            type: cfgItem.type,
-            name: cfgItem.name,
-            displayName: cfgItem.displayName,
-            content: cfgItem.content,
-            metadata: cfgItem.metadata || {},
-            updatedAt: cfgItem.updatedAt
-          };
-          updated++;
-        }
-      }
-    }
-    let crawlerCount = 0;
-    state.crawlerSources = {};
+    const counts = { configs: 0, sources: 0, drafts: 0, published: 0, crawlerSources: 0, writingMasters: 0 };
+    const configsRecord = {};
+    const crawlerSourcesRecord = {};
     for (const cfg of cloudData.configs || []) {
       if (cfg.type === "crawler" && cfg.content) {
         try {
           const sources = JSON.parse(cfg.content);
           for (const s of sources) {
-            state.crawlerSources[s.id] = {
+            crawlerSourcesRecord[s.id] = {
               name: s.name,
               url: s.url,
               type: s.type || "rss",
@@ -910,37 +1095,62 @@ async function doPull(token, workDir) {
           }
           const crawlerDir = join6(effectiveWorkDir, "tools", "crawler");
           await mkdir4(crawlerDir, { recursive: true });
-          const crawlerConfigPath = join6(crawlerDir, "config.json");
-          await writeFile5(crawlerConfigPath, JSON.stringify({ sources }, null, 2), "utf-8");
-          crawlerCount = sources.length;
+          await writeFile5(join6(crawlerDir, "config.json"), JSON.stringify({ sources }, null, 2), "utf-8");
+          counts.crawlerSources = sources.length;
         } catch (e) {
           console.error("[sync] Failed to parse crawler sources:", e);
         }
-      }
-    }
-    if (cloudData.writingMasters && Object.keys(cloudData.writingMasters).length > 0) {
-      state.writingMasters = state.writingMasters || {};
-      for (const [accountName, master] of Object.entries(cloudData.writingMasters)) {
-        state.writingMasters[accountName] = {
-          id: master.id,
-          name: master.name,
-          stylePrompt: master.stylePrompt
+      } else {
+        const stateKey = `${cfg.type}:${cfg.name}`;
+        const state = await readState();
+        const localUpdatedAt = state.configs[stateKey]?.updatedAt || "";
+        if (!localUpdatedAt || cfg.updatedAt > localUpdatedAt) {
+          let filePath = "";
+          if (cfg.type === "base_rules") filePath = join6(effectiveWorkDir, "base-rules.md");
+          else if (cfg.type === "platform") filePath = join6(effectiveWorkDir, "platforms", `${cfg.name}.md`);
+          else if (cfg.type === "account") filePath = join6(effectiveWorkDir, "accounts", `${cfg.name}.yaml`);
+          if (filePath && cfg.content) {
+            await writeFile5(filePath, cfg.content, "utf-8");
+            counts.configs++;
+          }
+        }
+        configsRecord[stateKey] = {
+          type: cfg.type,
+          name: cfg.name,
+          displayName: cfg.displayName,
+          content: cfg.content,
+          metadata: cfg.metadata || {},
+          updatedAt: cfg.updatedAt
         };
       }
     }
-    await replaceState(state);
-    const masterCount = cloudData.writingMasters ? Object.keys(cloudData.writingMasters).length : 0;
+    counts.sources = Object.keys(cloudData.sources || {}).length;
+    counts.drafts = Object.keys(cloudData.drafts || {}).length;
+    counts.published = Object.keys(cloudData.published || {}).length;
+    counts.writingMasters = Object.keys(cloudData.writingMasters || {}).length;
+    await mergeCloudData({
+      sources: cloudData.sources || {},
+      drafts: cloudData.drafts || {},
+      published: cloudData.published || {},
+      configs: configsRecord,
+      crawlerSources: crawlerSourcesRecord,
+      writingMasters: cloudData.writingMasters || {}
+    });
+    const parts = [
+      counts.sources > 0 ? `\u7D20\u6750 ${counts.sources}` : "",
+      counts.drafts > 0 ? `\u8349\u7A3F ${counts.drafts}` : "",
+      counts.published > 0 ? `\u5DF2\u53D1\u5E03 ${counts.published}` : "",
+      counts.configs > 0 ? `\u914D\u7F6E\u66F4\u65B0 ${counts.configs}` : "",
+      counts.crawlerSources > 0 ? `\u8BA2\u9605\u6E90 ${counts.crawlerSources}` : "",
+      counts.writingMasters > 0 ? `\u5199\u4F5C\u5927\u5E08 ${counts.writingMasters}` : ""
+    ].filter(Boolean);
     return {
       success: true,
-      message: updated > 0 || masterCount > 0 || crawlerCount > 0 ? [
-        `\u2705 \u4ECE\u4E91\u7AEF\u540C\u6B65\u4E86 ${updated} \u4E2A\u914D\u7F6E\u6587\u4EF6`,
-        crawlerCount > 0 ? `   \u8BA2\u9605\u6E90: ${crawlerCount} \u4E2A` : "",
-        masterCount > 0 ? `   \u5199\u4F5C\u5927\u5E08: ${masterCount} \u4E2A` : ""
-      ].filter(Boolean).join("\n") : "\u672C\u5730\u914D\u7F6E\u5DF2\u662F\u6700\u65B0\uFF0C\u65E0\u9700\u66F4\u65B0",
-      data: { updated, crawlerSources: crawlerCount, writingMasters: masterCount }
+      message: parts.length > 0 ? `\u2705 \u5DF2\u540C\u6B65: ${parts.join(", ")}` : "\u4E91\u7AEF\u65E0\u6570\u636E",
+      data: counts
     };
   } catch (err) {
-    return { success: false, message: `\u62C9\u53D6\u9519\u8BEF: ${err instanceof Error ? err.message : err}` };
+    return { success: false, message: `\u540C\u6B65\u5931\u8D25: ${err instanceof Error ? err.message : err}` };
   }
 }
 async function syncPull(input) {
@@ -954,7 +1164,7 @@ async function syncPull(input) {
 
 // src/tools/workflow.ts
 import { z as z6 } from "zod";
-import { cp, mkdir as mkdir5, access as access2, writeFile as writeFile6, chmod as chmod2 } from "fs/promises";
+import { cp, mkdir as mkdir5, access as access2, unlink as unlink2 } from "fs/promises";
 import { join as join7, dirname } from "path";
 import { fileURLToPath } from "url";
 var DEFAULT_API_BASE_URL = "https://app.claudeink.com";
@@ -983,58 +1193,31 @@ async function workflowInit(input) {
       }
     }
     const claudeinkDir = join7(cwd, ".claudeink");
-    const dirs = [
-      "sources/articles",
-      "sources/video-transcripts",
-      "sources/notes",
-      "sources/data",
-      "sources/daily",
-      "templates"
-    ];
+    const dirs = ["sources/articles", "sources/video-transcripts", "sources/notes", "sources/data", "sources/daily", "templates"];
     for (const dir of dirs) {
       await mkdir5(join7(cwd, dir), { recursive: true });
     }
     await mkdir5(claudeinkDir, { recursive: true });
     results.push("\u2705 \u8FD0\u884C\u65F6\u76EE\u5F55\u5DF2\u521B\u5EFA");
-    const statePath = join7(claudeinkDir, "state.json");
+    const state = await readState();
+    state.config.workflowDir = cwd;
+    const oldCredsPath = join7(claudeinkDir, "credentials.json");
     try {
-      await access2(statePath);
-      results.push("\u23ED\uFE0F state.json \u5DF2\u5B58\u5728\uFF0C\u8DF3\u8FC7");
+      await access2(oldCredsPath);
+      await unlink2(oldCredsPath);
+      results.push("\u{1F9F9} \u5DF2\u6E05\u7406\u65E7\u7248 credentials.json");
     } catch {
-      const initialState = {
-        credentials: null,
-        config: {
-          apiBaseUrl: DEFAULT_API_BASE_URL,
-          workflowDir: cwd
-        },
-        sources: {},
-        drafts: {},
-        published: {},
-        configs: {},
-        crawlerSources: {},
-        writingMasters: {},
-        tagQueue: {
-          queue: [],
-          failed: []
-        },
-        lastSyncAt: ""
-      };
-      await writeFile6(statePath, JSON.stringify(initialState, null, 2), "utf-8");
-      await chmod2(statePath, 384);
-      results.push("\u2705 state.json");
     }
     let activated = false;
     if (input.licenseKey) {
       try {
-        const activateUrl = `${DEFAULT_API_BASE_URL}/api/auth/activate`;
-        const res = await fetch(activateUrl, {
+        const res = await fetch(`${DEFAULT_API_BASE_URL}/api/auth/activate`, {
           method: "POST",
           headers: { "Content-Type": "application/json" },
           body: JSON.stringify({ key: input.licenseKey })
         });
         const data = await res.json();
         if (data.userId) {
-          const state = await readState();
           state.credentials = {
             licenseKey: input.licenseKey,
             token: data.token,
@@ -1042,7 +1225,6 @@ async function workflowInit(input) {
             plan: data.plan,
             expiresAt: data.expiresAt
           };
-          await writeState(state);
           results.push(`\u2705 License \u6FC0\u6D3B\u6210\u529F\uFF08\u5957\u9910: ${data.plan}\uFF09`);
           activated = true;
         } else {
@@ -1052,25 +1234,30 @@ async function workflowInit(input) {
         results.push(`\u26A0\uFE0F \u6FC0\u6D3B\u7F51\u7EDC\u9519\u8BEF: ${err instanceof Error ? err.message : err}`);
       }
     }
+    await writeState(state);
+    results.push("\u2705 state.json");
     if (activated) {
       try {
         const pullResult = await syncPull({ workDir: cwd });
-        if (pullResult.success && pullResult.data && pullResult.data.updated > 0) {
-          results.push("\u2705 \u5DF2\u4ECE\u4E91\u7AEF\u540C\u6B65\u914D\u7F6E\uFF08\u8DE8\u8BBE\u5907\u6062\u590D\uFF09");
+        if (pullResult.success && pullResult.data) {
+          const d = pullResult.data;
+          const total = (d.sources || 0) + (d.drafts || 0) + (d.published || 0) + (d.configs || 0);
+          if (total > 0) {
+            results.push("\u2705 \u5DF2\u4ECE\u4E91\u7AEF\u540C\u6B65\u6570\u636E");
+          } else {
+            results.push("\u2139\uFE0F \u4E91\u7AEF\u65E0\u5DF2\u6709\u6570\u636E\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u6A21\u677F");
+          }
         } else {
-          results.push("\u2139\uFE0F \u4E91\u7AEF\u65E0\u5DF2\u6709\u914D\u7F6E\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u6A21\u677F");
+          results.push("\u2139\uFE0F \u4E91\u7AEF\u65E0\u5DF2\u6709\u6570\u636E\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u6A21\u677F");
         }
       } catch {
-        results.push("\u2139\uFE0F \u4E91\u7AEF\u65E0\u5DF2\u6709\u914D\u7F6E\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u6A21\u677F");
+        results.push("\u2139\uFE0F \u4E91\u7AEF\u540C\u6B65\u8DF3\u8FC7");
       }
     }
     try {
       await access2(join7(cwd, "tools", "crawler", "package.json"));
-      const { execSync } = await import("child_process");
-      execSync("npm install --silent", {
-        cwd: join7(cwd, "tools", "crawler"),
-        stdio: "pipe"
-      });
+      const { execSync: execSync2 } = await import("child_process");
+      execSync2("npm install --silent", { cwd: join7(cwd, "tools", "crawler"), stdio: "pipe" });
       results.push("\u2705 \u722C\u866B\u4F9D\u8D56\u5DF2\u5B89\u88C5");
     } catch {
     }
@@ -1094,16 +1281,724 @@ async function workflowInit(input) {
   }
 }
 
+// src/tools/ink.ts
+import { z as z7 } from "zod";
+
+// src/lib/knowledge.ts
+import { readFile as readFile6, writeFile as writeFile6, mkdir as mkdir6, unlink as unlink3 } from "fs/promises";
+import { join as join8 } from "path";
+import matter3 from "gray-matter";
+function getKnowledgeDir() {
+  return join8(getWorkDir(), ".claudeink", "knowledge");
+}
+function getIndexPath() {
+  return join8(getWorkDir(), ".claudeink", "knowledge", "index.json");
+}
+async function generateId() {
+  const now = /* @__PURE__ */ new Date();
+  const dateStr = now.toISOString().slice(0, 10).replace(/-/g, "");
+  const index = await readIndex();
+  let maxSeq = 0;
+  const prefix = `k_${dateStr}_`;
+  for (const id of Object.keys(index.entries)) {
+    if (id.startsWith(prefix)) {
+      const seq = parseInt(id.slice(prefix.length), 10);
+      if (seq > maxSeq) maxSeq = seq;
+    }
+  }
+  const nextSeq = String(maxSeq + 1).padStart(3, "0");
+  return `${prefix}${nextSeq}`;
+}
+function toSlug(title) {
+  return title.replace(/[^\u4e00-\u9fa5a-zA-Z0-9\s-]/g, "").replace(/\s+/g, "-").slice(0, 50).replace(/-+$/, "");
+}
+async function readIndex() {
+  try {
+    const raw = await readFile6(getIndexPath(), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { entries: {}, updated_at: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+}
+async function saveIndex(index) {
+  index.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+  const dir = getKnowledgeDir();
+  await mkdir6(dir, { recursive: true });
+  await writeFile6(getIndexPath(), JSON.stringify(index, null, 2), "utf-8");
+}
+async function addToIndex(entry) {
+  const index = await readIndex();
+  index.entries[entry.id] = entry;
+  await saveIndex(index);
+}
+async function removeFromIndex(id) {
+  const index = await readIndex();
+  delete index.entries[id];
+  await saveIndex(index);
+}
+async function writeKnowledgeFile(meta, content) {
+  const now = /* @__PURE__ */ new Date();
+  const monthDir = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}`;
+  const dir = join8(getKnowledgeDir(), monthDir);
+  await mkdir6(dir, { recursive: true });
+  const slug = toSlug(meta.title) || meta.id;
+  const filename = `${now.toISOString().slice(0, 10)}-${slug}.md`;
+  const filePath = join8(dir, filename);
+  const frontmatter = {
+    id: meta.id,
+    title: meta.title,
+    tags: meta.tags,
+    category: meta.category,
+    source_type: meta.source_type,
+    created_at: meta.created_at,
+    updated_at: meta.updated_at
+  };
+  if (meta.url) frontmatter.url = meta.url;
+  const output = matter3.stringify(content, frontmatter);
+  await writeFile6(filePath, output, "utf-8");
+  return join8(monthDir, filename);
+}
+async function readKnowledgeFile(id) {
+  const index = await readIndex();
+  const entry = index.entries[id];
+  if (!entry) return null;
+  const filePath = join8(getKnowledgeDir(), entry.file_path);
+  try {
+    const raw = await readFile6(filePath, "utf-8");
+    const { data, content } = matter3(raw);
+    return {
+      meta: data,
+      content: content.trim(),
+      filePath
+    };
+  } catch {
+    return null;
+  }
+}
+async function updateKnowledgeFile(id, updates) {
+  const file = await readKnowledgeFile(id);
+  if (!file) return null;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const meta = { ...file.meta };
+  if (updates.title !== void 0) meta.title = updates.title;
+  if (updates.tags !== void 0) meta.tags = updates.tags;
+  if (updates.category !== void 0) meta.category = updates.category;
+  meta.updated_at = now;
+  const content = updates.content !== void 0 ? updates.content : file.content;
+  const frontmatter = {
+    id: meta.id,
+    title: meta.title,
+    tags: meta.tags,
+    category: meta.category,
+    source_type: meta.source_type,
+    created_at: meta.created_at,
+    updated_at: meta.updated_at
+  };
+  if (meta.url) frontmatter.url = meta.url;
+  const output = matter3.stringify(content, frontmatter);
+  await writeFile6(file.filePath, output, "utf-8");
+  const index = await readIndex();
+  const entry = index.entries[id];
+  if (entry) {
+    entry.title = meta.title;
+    entry.tags = meta.tags;
+    entry.category = meta.category;
+    entry.preview = generatePreview(content);
+    entry.updated_at = now;
+    await saveIndex(index);
+  }
+  return { meta, content, filePath: file.filePath };
+}
+async function deleteKnowledgeFile(id) {
+  const index = await readIndex();
+  const entry = index.entries[id];
+  if (!entry) return false;
+  const filePath = join8(getKnowledgeDir(), entry.file_path);
+  try {
+    await unlink3(filePath);
+  } catch {
+  }
+  await removeFromIndex(id);
+  return true;
+}
+function generatePreview(content, maxLen = 200) {
+  return content.replace(/^#+\s.+$/gm, "").replace(/\n+/g, " ").trim().slice(0, maxLen);
+}
+function searchKnowledge(index, filters) {
+  let entries = Object.values(index.entries);
+  if (filters.tags && filters.tags.length > 0) {
+    const filterTags = filters.tags.map((t) => t.toLowerCase());
+    entries = entries.filter(
+      (e) => e.tags.some((t) => filterTags.includes(t.toLowerCase()))
+    );
+  }
+  if (filters.category) {
+    entries = entries.filter((e) => e.category === filters.category);
+  }
+  if (filters.date_from) {
+    entries = entries.filter((e) => e.created_at >= filters.date_from);
+  }
+  if (filters.date_to) {
+    entries = entries.filter((e) => e.created_at <= filters.date_to);
+  }
+  if (filters.query) {
+    const q = filters.query.toLowerCase();
+    entries = entries.map((e) => {
+      let score = 0;
+      if (e.title.toLowerCase().includes(q)) score += 10;
+      if (e.preview.toLowerCase().includes(q)) score += 5;
+      if (e.tags.some((t) => t.toLowerCase().includes(q))) score += 3;
+      return { ...e, _score: score };
+    }).filter((e) => e._score > 0).sort((a, b) => b._score - a._score);
+  } else {
+    entries.sort((a, b) => b.created_at.localeCompare(a.created_at));
+  }
+  const total = entries.length;
+  const limit = filters.limit || 10;
+  const results = entries.slice(0, limit).map((e) => ({
+    id: e.id,
+    title: e.title,
+    tags: e.tags,
+    category: e.category,
+    created_at: e.created_at,
+    preview: e.preview
+  }));
+  return { results, total };
+}
+async function saveKnowledge(params) {
+  const id = await generateId();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const meta = {
+    id,
+    title: params.title,
+    tags: params.tags,
+    category: params.category,
+    source_type: params.source_type,
+    url: params.url,
+    created_at: now,
+    updated_at: now
+  };
+  const relativePath = await writeKnowledgeFile(meta, params.content);
+  await addToIndex({
+    id,
+    title: params.title,
+    tags: params.tags,
+    category: params.category,
+    source_type: params.source_type,
+    preview: generatePreview(params.content),
+    file_path: relativePath,
+    created_at: now,
+    updated_at: now
+  });
+  return { id, filePath: relativePath };
+}
+async function readMultipleKnowledgeFiles(ids) {
+  const results = [];
+  for (const id of ids) {
+    const file = await readKnowledgeFile(id);
+    if (file) results.push(file);
+  }
+  return results;
+}
+function getAllTags(index) {
+  const tagCounts = {};
+  for (const entry of Object.values(index.entries)) {
+    for (const tag of entry.tags) {
+      tagCounts[tag] = (tagCounts[tag] || 0) + 1;
+    }
+  }
+  return Object.entries(tagCounts).map(([name, count]) => ({ name, count })).sort((a, b) => b.count - a.count);
+}
+async function renameTag(oldTag, newTag) {
+  const index = await readIndex();
+  let count = 0;
+  for (const entry of Object.values(index.entries)) {
+    const idx = entry.tags.indexOf(oldTag);
+    if (idx !== -1) {
+      entry.tags[idx] = newTag;
+      count++;
+      const file = await readKnowledgeFile(entry.id);
+      if (file) {
+        const tagIdx = file.meta.tags.indexOf(oldTag);
+        if (tagIdx !== -1) {
+          file.meta.tags[tagIdx] = newTag;
+          await updateKnowledgeFile(entry.id, { tags: file.meta.tags });
+        }
+      }
+    }
+  }
+  if (count > 0) {
+    await saveIndex(index);
+  }
+  return count;
+}
+async function mergeTags(sourceTags, targetTag) {
+  const index = await readIndex();
+  let count = 0;
+  for (const entry of Object.values(index.entries)) {
+    const hasSource = entry.tags.some((t) => sourceTags.includes(t));
+    if (hasSource) {
+      const newTags = entry.tags.filter((t) => !sourceTags.includes(t));
+      if (!newTags.includes(targetTag)) {
+        newTags.push(targetTag);
+      }
+      entry.tags = newTags;
+      count++;
+      await updateKnowledgeFile(entry.id, { tags: newTags });
+    }
+  }
+  if (count > 0) {
+    await saveIndex(index);
+  }
+  return count;
+}
+
+// src/tools/ink.ts
+var inkSaveSchema = z7.object({
+  content: z7.string().describe("\u8981\u4FDD\u5B58\u7684\u5185\u5BB9\uFF08\u5FC5\u586B\uFF09"),
+  title: z7.string().describe("\u6807\u9898\uFF08Claude \u81EA\u52A8\u751F\u6210\uFF09"),
+  tags: z7.array(z7.string()).optional().default([]).describe("\u6807\u7B7E\uFF08Claude \u81EA\u52A8\u751F\u6210\uFF0C\u7528\u6237\u53EF\u6307\u5B9A\uFF09"),
+  category: z7.enum(["insight", "decision", "analysis", "idea", "reference", "action"]).optional().default("reference").describe("\u5206\u7C7B\uFF1Ainsight / decision / analysis / idea / reference / action"),
+  source_type: z7.enum(["conversation", "url", "manual"]).optional().default("conversation").describe("\u6765\u6E90\u7C7B\u578B\uFF1Aconversation / url / manual"),
+  url: z7.string().optional().describe("\u6765\u6E90 URL\uFF08\u5982\u679C\u662F\u5916\u90E8\u7D20\u6750\uFF09")
+});
+async function inkSave(input) {
+  try {
+    const { id } = await saveKnowledge({
+      content: input.content,
+      title: input.title,
+      tags: input.tags,
+      category: input.category,
+      source_type: input.source_type,
+      url: input.url
+    });
+    const categoryNames = {
+      insight: "\u6D1E\u5BDF",
+      decision: "\u51B3\u7B56",
+      analysis: "\u5206\u6790",
+      idea: "\u60F3\u6CD5",
+      reference: "\u53C2\u8003",
+      action: "\u884C\u52A8"
+    };
+    const catName = categoryNames[input.category] || input.category;
+    const tagStr = input.tags.length > 0 ? input.tags.join("\u3001") : "\u65E0\u6807\u7B7E";
+    return {
+      success: true,
+      message: `\u5DF2\u4FDD\u5B58\u5230\u300C${catName}\u300D\uFF0C\u6807\u7B7E\uFF1A${tagStr}`,
+      data: { id }
+    };
+  } catch (err) {
+    return {
+      success: false,
+      message: `\u4FDD\u5B58\u5931\u8D25\uFF1A${err.message}`
+    };
+  }
+}
+var inkSearchSchema = z7.object({
+  query: z7.string().optional().describe("\u641C\u7D22\u5173\u952E\u8BCD"),
+  tags: z7.array(z7.string()).optional().describe("\u6309\u6807\u7B7E\u8FC7\u6EE4"),
+  category: z7.enum(["insight", "decision", "analysis", "idea", "reference", "action"]).optional().describe("\u6309\u5206\u7C7B\u8FC7\u6EE4"),
+  date_from: z7.string().optional().describe("\u8D77\u59CB\u65E5\u671F\uFF08ISO \u683C\u5F0F\uFF09"),
+  date_to: z7.string().optional().describe("\u622A\u6B62\u65E5\u671F\uFF08ISO \u683C\u5F0F\uFF09"),
+  limit: z7.number().optional().default(10).describe("\u8FD4\u56DE\u6570\u91CF\uFF0C\u9ED8\u8BA4 10")
+});
+async function inkSearch(input) {
+  try {
+    const index = await readIndex();
+    const { results, total } = searchKnowledge(index, {
+      query: input.query,
+      tags: input.tags,
+      category: input.category,
+      date_from: input.date_from,
+      date_to: input.date_to,
+      limit: input.limit
+    });
+    if (total === 0) {
+      return {
+        success: true,
+        message: "\u6CA1\u6709\u627E\u5230\u5339\u914D\u7684\u77E5\u8BC6\u7247\u6BB5",
+        data: { results: [], total: 0 }
+      };
+    }
+    return {
+      success: true,
+      message: `\u627E\u5230 ${total} \u6761\u76F8\u5173\u8BB0\u5F55${total > results.length ? `\uFF0C\u663E\u793A\u524D ${results.length} \u6761` : ""}`,
+      data: { results, total }
+    };
+  } catch (err) {
+    return {
+      success: false,
+      message: `\u641C\u7D22\u5931\u8D25\uFF1A${err.message}`
+    };
+  }
+}
+var inkGetSchema = z7.object({
+  id: z7.string().describe("\u77E5\u8BC6\u7247\u6BB5 ID")
+});
+async function inkGet(input) {
+  try {
+    const file = await readKnowledgeFile(input.id);
+    if (!file) {
+      return {
+        success: false,
+        message: `\u672A\u627E\u5230 ID \u4E3A ${input.id} \u7684\u77E5\u8BC6\u7247\u6BB5`
+      };
+    }
+    return {
+      success: true,
+      message: file.meta.title,
+      data: {
+        id: file.meta.id,
+        title: file.meta.title,
+        content: file.content,
+        tags: file.meta.tags,
+        category: file.meta.category,
+        source_type: file.meta.source_type,
+        url: file.meta.url,
+        created_at: file.meta.created_at,
+        updated_at: file.meta.updated_at
+      }
+    };
+  } catch (err) {
+    return {
+      success: false,
+      message: `\u83B7\u53D6\u5931\u8D25\uFF1A${err.message}`
+    };
+  }
+}
+var inkReviewSchema = z7.object({
+  period: z7.enum(["today", "week", "month", "custom"]).optional().default("week").describe("\u56DE\u987E\u65F6\u95F4\u6BB5\uFF1Atoday / week / month / custom"),
+  date_from: z7.string().optional().describe("\u81EA\u5B9A\u4E49\u8D77\u59CB\u65E5\u671F\uFF08ISO \u683C\u5F0F\uFF0Cperiod=custom \u65F6\u4F7F\u7528\uFF09"),
+  date_to: z7.string().optional().describe("\u81EA\u5B9A\u4E49\u622A\u6B62\u65E5\u671F\uFF08ISO \u683C\u5F0F\uFF0Cperiod=custom \u65F6\u4F7F\u7528\uFF09"),
+  category: z7.enum(["insight", "decision", "analysis", "idea", "reference", "action"]).optional().describe("\u6309\u5206\u7C7B\u8FC7\u6EE4")
+});
+async function inkReview(input) {
+  try {
+    const index = await readIndex();
+    const entries = Object.values(index.entries);
+    const now = /* @__PURE__ */ new Date();
+    let dateFrom;
+    let dateTo = now.toISOString();
+    switch (input.period) {
+      case "today":
+        dateFrom = new Date(now.getFullYear(), now.getMonth(), now.getDate()).toISOString();
+        break;
+      case "week": {
+        const weekAgo = new Date(now);
+        weekAgo.setDate(weekAgo.getDate() - 7);
+        dateFrom = weekAgo.toISOString();
+        break;
+      }
+      case "month": {
+        const monthAgo = new Date(now);
+        monthAgo.setMonth(monthAgo.getMonth() - 1);
+        dateFrom = monthAgo.toISOString();
+        break;
+      }
+      case "custom":
+        dateFrom = input.date_from || (/* @__PURE__ */ new Date(0)).toISOString();
+        dateTo = input.date_to || now.toISOString();
+        break;
+    }
+    let filtered = entries.filter(
+      (e) => e.created_at >= dateFrom && e.created_at <= dateTo
+    );
+    if (input.category) {
+      filtered = filtered.filter((e) => e.category === input.category);
+    }
+    filtered.sort((a, b) => b.created_at.localeCompare(a.created_at));
+    const byCategory = {};
+    for (const e of filtered) {
+      byCategory[e.category] = (byCategory[e.category] || 0) + 1;
+    }
+    const tagCounts = {};
+    for (const e of filtered) {
+      for (const t of e.tags) {
+        tagCounts[t] = (tagCounts[t] || 0) + 1;
+      }
+    }
+    const topTags = Object.entries(tagCounts).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([tag, count]) => ({ tag, count }));
+    const categoryNames = {
+      insight: "\u6D1E\u5BDF",
+      decision: "\u51B3\u7B56",
+      analysis: "\u5206\u6790",
+      idea: "\u60F3\u6CD5",
+      reference: "\u53C2\u8003",
+      action: "\u884C\u52A8"
+    };
+    const periodNames = {
+      today: "\u4ECA\u65E5",
+      week: "\u672C\u5468",
+      month: "\u672C\u6708",
+      custom: "\u81EA\u5B9A\u4E49\u65F6\u6BB5"
+    };
+    return {
+      success: true,
+      message: `${periodNames[input.period]}\u77E5\u8BC6\u56DE\u987E\uFF1A\u5171 ${filtered.length} \u6761\u8BB0\u5F55`,
+      data: {
+        period: input.period,
+        date_from: dateFrom,
+        date_to: dateTo,
+        total: filtered.length,
+        by_category: Object.entries(byCategory).map(([cat, count]) => ({
+          category: cat,
+          label: categoryNames[cat] || cat,
+          count
+        })),
+        top_tags: topTags,
+        items: filtered.map((e) => ({
+          id: e.id,
+          title: e.title,
+          category: e.category,
+          tags: e.tags,
+          created_at: e.created_at,
+          preview: e.preview
+        }))
+      }
+    };
+  } catch (err) {
+    return {
+      success: false,
+      message: `\u56DE\u987E\u5931\u8D25\uFF1A${err.message}`
+    };
+  }
+}
+var inkUpdateSchema = z7.object({
+  id: z7.string().describe("\u77E5\u8BC6\u7247\u6BB5 ID"),
+  title: z7.string().optional().describe("\u65B0\u6807\u9898"),
+  content: z7.string().optional().describe("\u65B0\u5185\u5BB9"),
+  tags: z7.array(z7.string()).optional().describe("\u65B0\u6807\u7B7E\uFF08\u5B8C\u6574\u66FF\u6362\uFF09"),
+  category: z7.enum(["insight", "decision", "analysis", "idea", "reference", "action"]).optional().describe("\u65B0\u5206\u7C7B")
+});
+async function inkUpdate(input) {
+  try {
+    const { id, ...updates } = input;
+    if (!updates.title && !updates.content && !updates.tags && !updates.category) {
+      return {
+        success: false,
+        message: "\u8BF7\u81F3\u5C11\u63D0\u4F9B\u4E00\u4E2A\u8981\u66F4\u65B0\u7684\u5B57\u6BB5\uFF08title / content / tags / category\uFF09"
+      };
+    }
+    const result = await updateKnowledgeFile(id, updates);
+    if (!result) {
+      return {
+        success: false,
+        message: `\u672A\u627E\u5230 ID \u4E3A ${id} \u7684\u77E5\u8BC6\u7247\u6BB5`
+      };
+    }
+    const changed = Object.keys(updates).filter(
+      (k) => updates[k] !== void 0
+    );
+    return {
+      success: true,
+      message: `\u5DF2\u66F4\u65B0\u300C${result.meta.title}\u300D\u7684 ${changed.join("\u3001")}`,
+      data: {
+        id: result.meta.id,
+        title: result.meta.title,
+        tags: result.meta.tags,
+        category: result.meta.category,
+        updated_at: result.meta.updated_at
+      }
+    };
+  } catch (err) {
+    return {
+      success: false,
+      message: `\u66F4\u65B0\u5931\u8D25\uFF1A${err.message}`
+    };
+  }
+}
+var inkDeleteSchema = z7.object({
+  id: z7.string().describe("\u77E5\u8BC6\u7247\u6BB5 ID"),
+  confirm: z7.boolean().optional().default(false).describe("\u786E\u8BA4\u5220\u9664\uFF08\u5FC5\u987B\u4E3A true \u624D\u4F1A\u6267\u884C\u5220\u9664\uFF09")
+});
+async function inkDelete(input) {
+  try {
+    if (!input.confirm) {
+      const index = await readIndex();
+      const entry = index.entries[input.id];
+      if (!entry) {
+        return {
+          success: false,
+          message: `\u672A\u627E\u5230 ID \u4E3A ${input.id} \u7684\u77E5\u8BC6\u7247\u6BB5`
+        };
+      }
+      return {
+        success: false,
+        message: `\u786E\u8BA4\u5220\u9664\u300C${entry.title}\u300D\uFF1F\u8BF7\u5C06 confirm \u8BBE\u4E3A true \u4EE5\u786E\u8BA4\u5220\u9664\u3002`,
+        data: {
+          id: entry.id,
+          title: entry.title,
+          category: entry.category,
+          tags: entry.tags,
+          created_at: entry.created_at
+        }
+      };
+    }
+    const deleted = await deleteKnowledgeFile(input.id);
+    if (!deleted) {
+      return {
+        success: false,
+        message: `\u672A\u627E\u5230 ID \u4E3A ${input.id} \u7684\u77E5\u8BC6\u7247\u6BB5`
+      };
+    }
+    return {
+      success: true,
+      message: `\u5DF2\u5220\u9664\u77E5\u8BC6\u7247\u6BB5 ${input.id}`,
+      data: { id: input.id }
+    };
+  } catch (err) {
+    return {
+      success: false,
+      message: `\u5220\u9664\u5931\u8D25\uFF1A${err.message}`
+    };
+  }
+}
+var inkCompileSchema = z7.object({
+  ids: z7.array(z7.string()).optional().describe("\u6307\u5B9A\u8981\u6574\u5408\u7684\u77E5\u8BC6\u7247\u6BB5 ID \u5217\u8868"),
+  query: z7.string().optional().describe("\u641C\u7D22\u6761\u4EF6\uFF08\u4E0E ids \u4E8C\u9009\u4E00\uFF09"),
+  tags: z7.array(z7.string()).optional().describe("\u6309\u6807\u7B7E\u7B5B\u9009\uFF08\u4E0E query \u642D\u914D\uFF09"),
+  format: z7.enum(["outline", "article", "summary"]).optional().default("summary").describe("\u8F93\u51FA\u683C\u5F0F\uFF1Aoutline\uFF08\u5927\u7EB2\uFF09/ article\uFF08\u6587\u7AE0\uFF09/ summary\uFF08\u6458\u8981\uFF09"),
+  instruction: z7.string().optional().describe("\u989D\u5916\u6574\u5408\u6307\u4EE4")
+});
+async function inkCompile(input) {
+  try {
+    let ids = [];
+    if (input.ids && input.ids.length > 0) {
+      ids = input.ids;
+    } else if (input.query || input.tags && input.tags.length > 0) {
+      const index = await readIndex();
+      const { results } = searchKnowledge(index, {
+        query: input.query,
+        tags: input.tags,
+        limit: 20
+      });
+      ids = results.map((r) => r.id);
+    }
+    if (ids.length === 0) {
+      return {
+        success: false,
+        message: "\u6CA1\u6709\u627E\u5230\u8981\u6574\u5408\u7684\u77E5\u8BC6\u7247\u6BB5\uFF0C\u8BF7\u6307\u5B9A ids \u6216\u63D0\u4F9B\u641C\u7D22\u6761\u4EF6"
+      };
+    }
+    const files = await readMultipleKnowledgeFiles(ids);
+    if (files.length === 0) {
+      return {
+        success: false,
+        message: "\u672A\u80FD\u8BFB\u53D6\u4EFB\u4F55\u77E5\u8BC6\u7247\u6BB5\u5185\u5BB9"
+      };
+    }
+    const sections = files.map((f, i) => {
+      const tagStr = f.meta.tags.length > 0 ? ` [${f.meta.tags.join(", ")}]` : "";
+      return `### ${i + 1}. ${f.meta.title}${tagStr}
+> ${f.meta.category} | ${f.meta.created_at.slice(0, 10)}
+
+${f.content}`;
+    });
+    const formatLabels = {
+      outline: "\u5927\u7EB2",
+      article: "\u6587\u7AE0",
+      summary: "\u6458\u8981"
+    };
+    const compiled = sections.join("\n\n---\n\n");
+    return {
+      success: true,
+      message: `\u5DF2\u6574\u5408 ${files.length} \u6761\u77E5\u8BC6\u7247\u6BB5\uFF0C\u683C\u5F0F\uFF1A${formatLabels[input.format]}`,
+      data: {
+        source_count: files.length,
+        source_ids: files.map((f) => f.meta.id),
+        format: input.format,
+        instruction: input.instruction || null,
+        compiled_content: compiled
+      }
+    };
+  } catch (err) {
+    return {
+      success: false,
+      message: `\u6574\u5408\u5931\u8D25\uFF1A${err.message}`
+    };
+  }
+}
+var inkTagsSchema = z7.object({
+  action: z7.enum(["list", "rename", "merge"]).describe("\u64CD\u4F5C\uFF1Alist\uFF08\u5217\u51FA\u6240\u6709\u6807\u7B7E\uFF09/ rename\uFF08\u91CD\u547D\u540D\uFF09/ merge\uFF08\u5408\u5E76\uFF09"),
+  tag: z7.string().optional().describe("\u76EE\u6807\u6807\u7B7E\uFF08rename/merge \u65F6\u4F7F\u7528\uFF09"),
+  new_tag: z7.string().optional().describe("\u65B0\u6807\u7B7E\u540D\uFF08rename \u65F6\u4F7F\u7528\uFF09"),
+  source_tags: z7.array(z7.string()).optional().describe("\u8981\u5408\u5E76\u7684\u6E90\u6807\u7B7E\u5217\u8868\uFF08merge \u65F6\u4F7F\u7528\uFF09")
+});
+async function inkTags(input) {
+  try {
+    const index = await readIndex();
+    switch (input.action) {
+      case "list": {
+        const tags = getAllTags(index);
+        return {
+          success: true,
+          message: tags.length > 0 ? `\u5171 ${tags.length} \u4E2A\u6807\u7B7E` : "\u6682\u65E0\u6807\u7B7E",
+          data: { tags }
+        };
+      }
+      case "rename": {
+        if (!input.tag || !input.new_tag) {
+          return {
+            success: false,
+            message: "rename \u64CD\u4F5C\u9700\u8981\u63D0\u4F9B tag\uFF08\u539F\u6807\u7B7E\uFF09\u548C new_tag\uFF08\u65B0\u6807\u7B7E\u540D\uFF09"
+          };
+        }
+        const count = await renameTag(input.tag, input.new_tag);
+        if (count === 0) {
+          return {
+            success: false,
+            message: `\u672A\u627E\u5230\u4F7F\u7528\u6807\u7B7E\u300C${input.tag}\u300D\u7684\u77E5\u8BC6\u7247\u6BB5`
+          };
+        }
+        return {
+          success: true,
+          message: `\u5DF2\u5C06 ${count} \u6761\u77E5\u8BC6\u7247\u6BB5\u7684\u6807\u7B7E\u300C${input.tag}\u300D\u91CD\u547D\u540D\u4E3A\u300C${input.new_tag}\u300D`,
+          data: { old_tag: input.tag, new_tag: input.new_tag, affected: count }
+        };
+      }
+      case "merge": {
+        if (!input.source_tags || input.source_tags.length === 0 || !input.new_tag) {
+          return {
+            success: false,
+            message: "merge \u64CD\u4F5C\u9700\u8981\u63D0\u4F9B source_tags\uFF08\u6E90\u6807\u7B7E\u5217\u8868\uFF09\u548C new_tag\uFF08\u76EE\u6807\u6807\u7B7E\uFF09"
+          };
+        }
+        const count = await mergeTags(input.source_tags, input.new_tag);
+        if (count === 0) {
+          return {
+            success: false,
+            message: `\u672A\u627E\u5230\u4F7F\u7528\u8FD9\u4E9B\u6807\u7B7E\u7684\u77E5\u8BC6\u7247\u6BB5`
+          };
+        }
+        return {
+          success: true,
+          message: `\u5DF2\u5C06 ${count} \u6761\u77E5\u8BC6\u7247\u6BB5\u7684\u6807\u7B7E\u5408\u5E76\u4E3A\u300C${input.new_tag}\u300D`,
+          data: {
+            source_tags: input.source_tags,
+            target_tag: input.new_tag,
+            affected: count
+          }
+        };
+      }
+    }
+  } catch (err) {
+    return {
+      success: false,
+      message: `\u6807\u7B7E\u64CD\u4F5C\u5931\u8D25\uFF1A${err.message}`
+    };
+  }
+}
+
 // src/index.ts
 var server = new McpServer({
   name: "ClaudeInk",
-  version: "0.7.0"
+  version: "0.9.0"
 });
 server.tool("workflow.init", "\u521D\u59CB\u5316\u5199\u4F5C\u5DE5\u4F5C\u6D41\uFF08\u91CA\u653E\u4E09\u5C42\u914D\u7F6E + \u6FC0\u6D3B License + \u81EA\u52A8\u540C\u6B65\u4E91\u7AEF\u914D\u7F6E\uFF09", workflowInitSchema.shape, async (input) => {
   const result = await workflowInit(input);
   return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
 });
-server.tool("sync", "\u540C\u6B65\u672C\u5730\u4E0E\u4E91\u7AEF\u6570\u636E\uFF08push=\u63A8\u9001, pull=\u62C9\u53D6, sync=\u53CC\u5411\u540C\u6B65\uFF09", syncSchema.shape, async (input) => {
+server.tool("sync", "\u4ECE\u4E91\u7AEF\u540C\u6B65\u5168\u91CF\u5143\u6570\u636E\u5230\u672C\u5730", syncSchema.shape, async (input) => {
   const result = await sync(input);
   return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
 });
@@ -1127,10 +2022,14 @@ server.tool("source.subscribe", "\u7BA1\u7406\u8BA2\u9605\u6E90\uFF08\u6DFB\u52A
   const result = await sourceSubscribe(input);
   return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
 });
-server.tool("draft.save", "\u4FDD\u5B58\u8349\u7A3F", draftSaveSchema.shape, async (input) => {
+server.tool("draft.save", "\u65B0\u5EFA\u8349\u7A3F", draftSaveSchema.shape, async (input) => {
   const result = await draftSave(input);
   return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
 });
+server.tool("draft.update", "\u66F4\u65B0\u5DF2\u6709\u8349\u7A3F\uFF08\u5185\u5BB9/\u6807\u9898/\u72B6\u6001/\u6807\u7B7E\uFF09", draftUpdateSchema.shape, async (input) => {
+  const result = await draftUpdate(input);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
 server.tool("draft.publish", "\u6807\u8BB0\u8349\u7A3F\u4E3A\u5DF2\u53D1\u5E03", draftPublishSchema.shape, async (input) => {
   const result = await draftPublish(input);
   return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
@@ -1143,6 +2042,38 @@ server.tool("analytics.report", "\u83B7\u53D6\u6570\u636E\u5206\u6790\u62A5\u544
   const result = await analyticsReport(input);
   return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
 });
+server.tool("ink.save", "\u4FDD\u5B58\u77E5\u8BC6\u7247\u6BB5\u5230\u672C\u5730\u77E5\u8BC6\u5E93\uFF08\u5BF9\u8BDD\u6D1E\u5BDF\u3001\u51B3\u7B56\u3001\u5206\u6790\u7B49\uFF09", inkSaveSchema.shape, async (input) => {
+  const result = await inkSave(input);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("ink.search", "\u641C\u7D22\u77E5\u8BC6\u5E93\uFF08\u652F\u6301\u5173\u952E\u8BCD\u3001\u6807\u7B7E\u3001\u5206\u7C7B\u3001\u65F6\u95F4\u8303\u56F4\u8FC7\u6EE4\uFF09", inkSearchSchema.shape, async (input) => {
+  const result = await inkSearch(input);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("ink.get", "\u83B7\u53D6\u77E5\u8BC6\u7247\u6BB5\u5B8C\u6574\u5185\u5BB9", inkGetSchema.shape, async (input) => {
+  const result = await inkGet(input);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("ink.review", "\u6309\u65F6\u95F4\u6BB5\u56DE\u987E\u77E5\u8BC6\u5E93\uFF08\u7EDF\u8BA1 + \u5217\u8868\uFF09", inkReviewSchema.shape, async (input) => {
+  const result = await inkReview(input);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("ink.update", "\u66F4\u65B0\u5DF2\u4FDD\u5B58\u7684\u77E5\u8BC6\u7247\u6BB5\uFF08\u6807\u9898/\u5185\u5BB9/\u6807\u7B7E/\u5206\u7C7B\uFF09", inkUpdateSchema.shape, async (input) => {
+  const result = await inkUpdate(input);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("ink.delete", "\u5220\u9664\u77E5\u8BC6\u7247\u6BB5\uFF08\u9700\u786E\u8BA4\uFF09", inkDeleteSchema.shape, async (input) => {
+  const result = await inkDelete(input);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("ink.compile", "\u6574\u5408\u591A\u6761\u77E5\u8BC6\u7247\u6BB5\u4E3A\u7ED3\u6784\u5316\u5185\u5BB9\uFF08\u6309 ID \u6216\u641C\u7D22\u6761\u4EF6\uFF09", inkCompileSchema.shape, async (input) => {
+  const result = await inkCompile(input);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("ink.tags", "\u6807\u7B7E\u7BA1\u7406\uFF08\u5217\u51FA / \u91CD\u547D\u540D / \u5408\u5E76\u6807\u7B7E\uFF09", inkTagsSchema.shape, async (input) => {
+  const result = await inkTags(input);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
 async function main() {
   try {
     const state = await readState();
@@ -1154,7 +2085,7 @@ async function main() {
   }
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error("[ClaudeInk MCP] Server started on stdio (11 tools)");
+  console.error("[ClaudeInk MCP] Server started on stdio (17 tools)");
 }
 main().catch((err) => {
   console.error("[ClaudeInk MCP] Fatal error:", err);