finch-markdown-editor 0.1.9 → 0.2.0

package/dist/index.js

@@ -1,69 +1,13 @@
 // src/index.ts
-import { createHash } from "node:crypto";
-import { mkdir, readFile, realpath, rm, stat, writeFile } from "node:fs/promises";
+import { createHash as createHash3 } from "node:crypto";
+import { mkdir as mkdir2, readFile as readFile2, realpath, stat, writeFile as writeFile2 } from "node:fs/promises";
 import { watch } from "node:fs";
-import { spawn } from "node:child_process";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
+import { spawn as spawn2 } from "node:child_process";
+import path3 from "node:path";
 import os from "node:os";
-var PASTE_IMAGE_EXT = {
-  "image/png": "png",
-  "image/jpeg": "jpg",
-  "image/jpg": "jpg",
-  "image/gif": "gif",
-  "image/webp": "webp",
-  "image/svg+xml": "svg",
-  "image/bmp": "bmp"
-};
-var IMAGE_MIME_BY_EXT = {
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".svg": "image/svg+xml",
-  ".bmp": "image/bmp"
-};
-var MAX_CLIPBOARD_INLINE_IMAGE_BYTES = 20 * 1024 * 1024;
-async function readClipboardImageDataUrls(ctx, urls) {
-  const result2 = {};
-  const assetsRoot = await realpath(path.join(ctx.storagePath, "assets"));
-  for (const originalUrl of urls.slice(0, 30)) {
-    try {
-      const parsed = new URL(originalUrl);
-      const requested = parsed.protocol === "finch-file:" && parsed.hostname === "local" ? parsed.searchParams.get("path") : null;
-      if (!requested) continue;
-      const target = await realpath(requested);
-      const relative = path.relative(assetsRoot, target);
-      const mimeType = IMAGE_MIME_BY_EXT[path.extname(target).toLowerCase()];
-      if ((!relative || !relative.startsWith(".." + path.sep) && relative !== "..") && mimeType) {
-        const info = await stat(target);
-        if (info.size > MAX_CLIPBOARD_INLINE_IMAGE_BYTES) continue;
-        result2[originalUrl] = `data:${mimeType};base64,${(await readFile(target)).toString("base64")}`;
-      }
-    } catch {
-    }
-  }
-  return result2;
-}
-async function openLocalImagePreview(ctx, filePath) {
-  if (!path.isAbsolute(filePath) || !IMAGE_MIME_BY_EXT[path.extname(filePath).toLowerCase()]) {
-    throw new Error("Unsupported local image file.");
-  }
-  await ctx.ui.openFilePreview(filePath);
-}
-async function openMarkdownImagePreview(ctx, rawUrl) {
-  const url = new URL(rawUrl);
-  if (url.protocol === "http:" || url.protocol === "https:") {
-    await ctx.browser.open(url.href);
-    return;
-  }
-  throw new Error(`Unsupported image URL: ${url.protocol}`);
-}
-var STYLE_SLOT_COUNT = 3;
-function result(message, isError = false) {
-  return { content: [{ type: "text", text: message }], isError };
-}
+
+// src/document.ts
+import path from "node:path";
 function unwrapTextEnvelope(content) {
   const bom = content.startsWith("\uFEFF") ? "\uFEFF" : "";
   const text = bom ? content.slice(1) : content;
@@ -119,43 +63,14 @@ function documentTitle(markdown, filePath) {
   const heading = markdown.match(/^#\s+(.+)$/m)?.[1]?.trim();
   return heading || (filePath ? path.basename(filePath, path.extname(filePath)) : "Untitled article");
 }
-function stateFile(ctx) {
-  return path.join(ctx.storagePath, "state.json");
-}
-function styleSlotsFile(ctx) {
-  return path.join(ctx.storagePath, "style-slots.json");
-}
-function normalizeStyleSlots(raw) {
-  const arr = Array.isArray(raw) ? raw : [];
-  const slots = [];
-  for (let i = 0; i < STYLE_SLOT_COUNT; i++) {
-    const item = arr[i];
-    if (item && typeof item === "object" && typeof item.css === "string") {
-      slots.push({ css: item.css, label: String(item.label ?? "\u81EA\u5B9A\u4E49\u98CE\u683C") });
-    } else {
-      slots.push(null);
-    }
-  }
-  return slots;
-}
-async function readStyleSlots(ctx) {
-  try {
-    const raw = await readFile(styleSlotsFile(ctx), "utf8");
-    return normalizeStyleSlots(JSON.parse(raw));
-  } catch {
-    return normalizeStyleSlots([]);
-  }
-}
-async function writeStyleSlot(ctx, slot, value) {
-  const slots = await readStyleSlots(ctx);
-  slots[slot] = value;
-  await mkdir(ctx.storagePath, { recursive: true });
-  await writeFile(styleSlotsFile(ctx), JSON.stringify(slots), "utf8");
-  return slots;
-}
+
+// src/drafts.ts
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import path2 from "node:path";
 function draftPathFor(ctx, sourcePath) {
   const digest = createHash("sha256").update(sourcePath).digest("hex").slice(0, 32);
-  return path.join(ctx.storagePath, "drafts", `${digest}.json`);
+  return path2.join(ctx.storagePath, "drafts", `${digest}.json`);
 }
 function hashText(text) {
   return createHash("sha256").update(text).digest("hex");
@@ -171,7 +86,7 @@ async function readDraft(ctx, sourcePath) {
 async function writeDraft(ctx, sourcePath, markdown, base) {
   try {
     const file = draftPathFor(ctx, sourcePath);
-    await mkdir(path.dirname(file), { recursive: true });
+    await mkdir(path2.dirname(file), { recursive: true });
     const entry = { path: sourcePath, markdown, savedAt: Date.now() };
     if (typeof base === "string") entry.baseHash = hashText(base);
     await writeFile(file, JSON.stringify(entry), "utf8");
@@ -216,23 +131,165 @@ async function readFileWithDraft(ctx, sourcePath) {
   if (diskMatchesBaseline) return { markdown: draft.markdown, diskMarkdown, draftRestored: true, draftConflict: false };
   return { markdown: diskMarkdown, diskMarkdown, draftRestored: false, draftConflict: true };
 }
+
+// src/renderer.ts
+import { createHash as createHash2 } from "node:crypto";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+var BMMD_BIN_PATH = fileURLToPath(new URL("./bmmd/bin/bmmd.mjs", import.meta.url));
+async function runBmmd(args, input) {
+  const binPath = BMMD_BIN_PATH;
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [binPath, ...args], { stdio: ["pipe", "pipe", "pipe"] });
+    let output = "";
+    let errors = "";
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      output += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      errors += chunk;
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) resolve(output);
+      else reject(new Error(errors.trim() || `bmmd exited with code ${code}`));
+    });
+    child.stdin.end(input, "utf8");
+  });
+}
+var FINCH_FILE_IMAGE_RE = /finch-file:\/\/local\?path=[^\s)"']+/g;
+var FINCH_IMAGE_PLACEHOLDER_ORIGIN = "https://finch-local.invalid/markdown-image/";
+function substituteFinchFileImagesForBm(markdown) {
+  const urls = /* @__PURE__ */ new Map();
+  let sequence = 0;
+  const substituted = markdown.replace(FINCH_FILE_IMAGE_RE, (originalUrl) => {
+    const placeholder = `${FINCH_IMAGE_PLACEHOLDER_ORIGIN}${createHash2("sha256").update(`${originalUrl}:${sequence++}`).digest("hex")}`;
+    urls.set(placeholder, originalUrl);
+    return placeholder;
+  });
+  return { markdown: substituted, urls };
+}
+async function renderWithBm(markdown, markdownStyle, customCss) {
+  const args = ["render", "--platform", "wechat", "--markdown-style", markdownStyle || "kami"];
+  if (customCss && customCss.trim()) args.push("--custom-css", customCss);
+  const prepared = substituteFinchFileImagesForBm(markdown);
+  let html = await runBmmd(args, prepared.markdown);
+  for (const [placeholder, originalUrl] of prepared.urls) html = html.split(placeholder).join(originalUrl);
+  return html;
+}
+
+// src/index.ts
+var PASTE_IMAGE_EXT = {
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/jpg": "jpg",
+  "image/gif": "gif",
+  "image/webp": "webp",
+  "image/svg+xml": "svg",
+  "image/bmp": "bmp"
+};
+var IMAGE_MIME_BY_EXT = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".bmp": "image/bmp"
+};
+var MAX_CLIPBOARD_INLINE_IMAGE_BYTES = 20 * 1024 * 1024;
+async function readClipboardImageDataUrls(ctx, urls) {
+  const result2 = {};
+  const assetsRoot = await realpath(path3.join(ctx.storagePath, "assets"));
+  for (const originalUrl of urls.slice(0, 30)) {
+    try {
+      const parsed = new URL(originalUrl);
+      const requested = parsed.protocol === "finch-file:" && parsed.hostname === "local" ? parsed.searchParams.get("path") : null;
+      if (!requested) continue;
+      const target = await realpath(requested);
+      const relative = path3.relative(assetsRoot, target);
+      const mimeType = IMAGE_MIME_BY_EXT[path3.extname(target).toLowerCase()];
+      if ((!relative || !relative.startsWith(".." + path3.sep) && relative !== "..") && mimeType) {
+        const info = await stat(target);
+        if (info.size > MAX_CLIPBOARD_INLINE_IMAGE_BYTES) continue;
+        result2[originalUrl] = `data:${mimeType};base64,${(await readFile2(target)).toString("base64")}`;
+      }
+    } catch {
+    }
+  }
+  return result2;
+}
+async function openLocalImagePreview(ctx, filePath) {
+  if (!path3.isAbsolute(filePath) || !IMAGE_MIME_BY_EXT[path3.extname(filePath).toLowerCase()]) {
+    throw new Error("Unsupported local image file.");
+  }
+  await ctx.ui.openFilePreview(filePath);
+}
+async function openMarkdownImagePreview(ctx, rawUrl) {
+  const url = new URL(rawUrl);
+  if (url.protocol === "http:" || url.protocol === "https:") {
+    await ctx.browser.open(url.href);
+    return;
+  }
+  throw new Error(`Unsupported image URL: ${url.protocol}`);
+}
+var STYLE_SLOT_COUNT = 3;
+function result(message, isError = false) {
+  return { content: [{ type: "text", text: message }], isError };
+}
+function stateFile(ctx) {
+  return path3.join(ctx.storagePath, "state.json");
+}
+function styleSlotsFile(ctx) {
+  return path3.join(ctx.storagePath, "style-slots.json");
+}
+function normalizeStyleSlots(raw) {
+  const arr = Array.isArray(raw) ? raw : [];
+  const slots = [];
+  for (let i = 0; i < STYLE_SLOT_COUNT; i++) {
+    const item = arr[i];
+    if (item && typeof item === "object" && typeof item.css === "string") {
+      slots.push({ css: item.css, label: String(item.label ?? "\u81EA\u5B9A\u4E49\u98CE\u683C") });
+    } else {
+      slots.push(null);
+    }
+  }
+  return slots;
+}
+async function readStyleSlots(ctx) {
+  try {
+    const raw = await readFile2(styleSlotsFile(ctx), "utf8");
+    return normalizeStyleSlots(JSON.parse(raw));
+  } catch {
+    return normalizeStyleSlots([]);
+  }
+}
+async function writeStyleSlot(ctx, slot, value) {
+  const slots = await readStyleSlots(ctx);
+  slots[slot] = value;
+  await mkdir2(ctx.storagePath, { recursive: true });
+  await writeFile2(styleSlotsFile(ctx), JSON.stringify(slots), "utf8");
+  return slots;
+}
 function sessionBucketKey(panel) {
   return panel.sessionId || "__global__";
 }
 async function readLastPathState(ctx) {
   try {
-    const raw = await readFile(stateFile(ctx), "utf8");
+    const raw = await readFile2(stateFile(ctx), "utf8");
     return JSON.parse(raw);
   } catch {
     return {};
   }
 }
 function resolveRecentScope(state, cwd, sessionId, spaceId) {
-  if (path.isAbsolute(cwd)) {
+  if (path3.isAbsolute(cwd)) {
     if (sessionId && !spaceId) state.homePath = cwd;
     return { scope: cwd };
   }
-  if (!cwd && !sessionId && !spaceId && path.isAbsolute(state.homePath ?? "")) {
+  if (!cwd && !sessionId && !spaceId && path3.isAbsolute(state.homePath ?? "")) {
     return { scope: state.homePath, fallbackCwd: state.homePath };
   }
   return {};
@@ -241,12 +298,33 @@ function addRecentPath(state, scope, sourcePath) {
   const existing = state.recentPathsByScope?.[scope] ?? [];
   state.recentPathsByScope = {
     ...state.recentPathsByScope,
-    [scope]: [sourcePath, ...existing].filter((value, index, values) => path.isAbsolute(value) && values.indexOf(value) === index).slice(0, 50)
+    [scope]: [sourcePath, ...existing].filter((value, index, values) => path3.isAbsolute(value) && values.indexOf(value) === index).slice(0, 50)
   };
 }
+function pathBelongsTo(root, target) {
+  const relative = path3.relative(root, target);
+  return relative === "" || !relative.startsWith(`..${path3.sep}`) && relative !== ".." && !path3.isAbsolute(relative);
+}
+async function resolveDocumentScope(ctx, sourcePath, fallbackCwd) {
+  const spaces = await ctx.spaces.list().catch(() => []);
+  const matches = spaces.filter((space2) => path3.isAbsolute(space2.directoryPath ?? "") && pathBelongsTo(space2.directoryPath, sourcePath)).sort((a, b) => (b.directoryPath?.length ?? 0) - (a.directoryPath?.length ?? 0));
+  const space = matches[0];
+  if (space?.directoryPath) {
+    const spaceName = space.name || space.alias || path3.basename(space.directoryPath);
+    return { scope: space.directoryPath, spaceId: space.id, spaceName, scopeLabel: spaceName, scopeKind: "space" };
+  }
+  const workspaceRoot = ctx.workspace.projectPath;
+  if (workspaceRoot && pathBelongsTo(workspaceRoot, sourcePath)) {
+    return { scope: workspaceRoot, scopeKind: "workspace" };
+  }
+  if (fallbackCwd && path3.isAbsolute(fallbackCwd) && pathBelongsTo(fallbackCwd, sourcePath)) {
+    return { scope: fallbackCwd, scopeKind: "workspace" };
+  }
+  return { scope: path3.dirname(sourcePath), scopeKind: "external" };
+}
 async function rememberPanelRecentScope(ctx, panel, cwd, sessionId, spaceId) {
   try {
-    await mkdir(ctx.storagePath, { recursive: true });
+    await mkdir2(ctx.storagePath, { recursive: true });
     const state = await readLastPathState(ctx);
     const resolved = resolveRecentScope(state, cwd, sessionId, spaceId);
     if (resolved.scope) {
@@ -254,7 +332,7 @@ async function rememberPanelRecentScope(ctx, panel, cwd, sessionId, spaceId) {
       const panelPath = state.panels?.[panel.id];
       if (panelPath) addRecentPath(state, resolved.scope, panelPath);
     }
-    await writeFile(stateFile(ctx), JSON.stringify(state), "utf8");
+    await writeFile2(stateFile(ctx), JSON.stringify(state), "utf8");
     return resolved;
   } catch (error) {
     ctx.logger.warn(`Could not persist panel recent scope: ${String(error)}`);
@@ -263,24 +341,28 @@ async function rememberPanelRecentScope(ctx, panel, cwd, sessionId, spaceId) {
 }
 async function rememberLastPath(ctx, panel, sourcePath) {
   try {
-    await mkdir(ctx.storagePath, { recursive: true });
+    await mkdir2(ctx.storagePath, { recursive: true });
     const state = await readLastPathState(ctx);
     state.panels = { ...state.panels, [panel.id]: sourcePath };
     state.sessions = { ...state.sessions, [sessionBucketKey(panel)]: sourcePath };
-    const scope = state.panelRecentScopes?.[panel.id];
+    let scope = state.panelRecentScopes?.[panel.id];
+    if (!scope && panel.view === "appView") {
+      scope = (await resolveDocumentScope(ctx, sourcePath)).scope;
+      state.panelRecentScopes = { ...state.panelRecentScopes, [panel.id]: scope };
+    }
     if (scope) addRecentPath(state, scope, sourcePath);
-    await writeFile(stateFile(ctx), JSON.stringify(state), "utf8");
+    await writeFile2(stateFile(ctx), JSON.stringify(state), "utf8");
   } catch (error) {
     ctx.logger.warn(`Could not persist last-opened path: ${String(error)}`);
   }
 }
 async function rememberRecentPath(ctx, sourcePath, panel) {
   try {
-    await mkdir(ctx.storagePath, { recursive: true });
+    await mkdir2(ctx.storagePath, { recursive: true });
     const state = await readLastPathState(ctx);
     const scope = panel ? state.panelRecentScopes?.[panel.id] : resolveRecentScope(state, ctx.session.cwd ?? "", ctx.session.id ?? "", ctx.session.spaceId ?? "").scope;
     if (scope) addRecentPath(state, scope, sourcePath);
-    await writeFile(stateFile(ctx), JSON.stringify(state), "utf8");
+    await writeFile2(stateFile(ctx), JSON.stringify(state), "utf8");
   } catch (error) {
     ctx.logger.warn(`Could not persist recent path: ${String(error)}`);
   }
@@ -321,18 +403,18 @@ async function collectRecentDocuments(ctx, requestedCwd, sessionId, spaceId) {
   if (!resolved.scope) return { documents: [] };
   const scope = resolved.scope;
   const candidates = (state.recentPathsByScope?.[scope] ?? []).filter(
-    (value, index, values) => typeof value === "string" && path.isAbsolute(value) && isMarkdownPath(value) && values.indexOf(value) === index
+    (value, index, values) => typeof value === "string" && path3.isAbsolute(value) && isMarkdownPath(value) && values.indexOf(value) === index
   );
   const documents = await Promise.all(
     candidates.map(async (filePath) => {
       try {
         const info = await stat(filePath);
         if (!info.isFile()) return void 0;
-        const markdown = await readFile(filePath, "utf8");
-        const fileName = path.basename(filePath);
+        const markdown = await readFile2(filePath, "utf8");
+        const fileName = path3.basename(filePath);
         return {
           path: filePath,
-          relativePath: path.relative(scope, filePath),
+          relativePath: path3.relative(scope, filePath),
           fileName,
           title: deriveTitle(markdown, fileName.replace(/\.[^.]+$/, "")),
           preview: derivePreview(markdown),
@@ -348,13 +430,39 @@ async function collectRecentDocuments(ctx, requestedCwd, sessionId, spaceId) {
     fallbackCwd: resolved.fallbackCwd
   };
 }
+async function collectLibraryDocuments(ctx) {
+  const state = await readLastPathState(ctx);
+  const candidates = Object.values(state.recentPathsByScope ?? {}).flat().concat(Object.values(state.panels ?? {})).filter((value, index, values) => path3.isAbsolute(value) && isMarkdownPath(value) && values.indexOf(value) === index);
+  const documents = await Promise.all(candidates.map(async (filePath) => {
+    try {
+      const [info, markdown, scope] = await Promise.all([stat(filePath), readFile2(filePath, "utf8"), resolveDocumentScope(ctx, filePath, state.homePath)]);
+      if (!info.isFile()) return void 0;
+      const fileName = path3.basename(filePath);
+      return {
+        path: filePath,
+        relativePath: path3.relative(scope.scope, filePath),
+        fileName,
+        title: deriveTitle(markdown, fileName.replace(/\.[^.]+$/, "")),
+        preview: derivePreview(markdown),
+        modifiedAt: info.mtimeMs,
+        spaceId: scope.spaceId,
+        spaceName: scope.spaceName,
+        scopeLabel: scope.scopeLabel,
+        scopeKind: scope.scopeKind
+      };
+    } catch {
+      return void 0;
+    }
+  }));
+  return documents.filter((entry) => Boolean(entry)).sort((a, b) => b.modifiedAt - a.modifiedAt).slice(0, RECENT_LIMIT);
+}
 var livePanelDocuments = /* @__PURE__ */ new Map();
 async function sendDocument(panel, state) {
   livePanelDocuments.set(panel.id, state);
   await panel.postMessage({ type: "document", ...state });
 }
 async function sendLiveDocument(ctx, panel, liveDocument) {
-  if (liveDocument.path && path.isAbsolute(liveDocument.path)) {
+  if (liveDocument.path && path3.isAbsolute(liveDocument.path)) {
     try {
       const { markdown, diskMarkdown, draftRestored, draftConflict } = await readFileWithDraft(ctx, liveDocument.path);
       await sendDocument(panel, { ...liveDocument, markdown, title: documentTitle(markdown, liveDocument.path), draftRestored, draftConflict, diskMarkdown });
@@ -369,10 +477,10 @@ function payloadPath(panel) {
   const payload = panel.payload;
   if (!payload || typeof payload !== "object" || Array.isArray(payload)) return void 0;
   const value = payload.path;
-  return typeof value === "string" && path.isAbsolute(value) ? value : void 0;
+  return typeof value === "string" && path3.isAbsolute(value) ? value : void 0;
 }
 async function restoreDocument(ctx, panel) {
-  if (!panel.sessionId) return false;
+  if (!panel.sessionId && panel.view !== "appView") return false;
   const sourcePath = await readLastPath(ctx, panel) ?? payloadPath(panel);
   if (!sourcePath) return false;
   try {
@@ -386,49 +494,6 @@ async function restoreDocument(ctx, panel) {
     return false;
   }
 }
-var BMMD_BIN_PATH = fileURLToPath(new URL("./bmmd/bin/bmmd.mjs", import.meta.url));
-async function runBmmd(args, input) {
-  const binPath = BMMD_BIN_PATH;
-  return new Promise((resolve, reject) => {
-    const child = spawn(process.execPath, [binPath, ...args], { stdio: ["pipe", "pipe", "pipe"] });
-    let output = "";
-    let errors = "";
-    child.stdout.setEncoding("utf8");
-    child.stderr.setEncoding("utf8");
-    child.stdout.on("data", (chunk) => {
-      output += chunk;
-    });
-    child.stderr.on("data", (chunk) => {
-      errors += chunk;
-    });
-    child.on("error", reject);
-    child.on("close", (code) => {
-      if (code === 0) resolve(output);
-      else reject(new Error(errors.trim() || `bmmd exited with code ${code}`));
-    });
-    child.stdin.end(input, "utf8");
-  });
-}
-var FINCH_FILE_IMAGE_RE = /finch-file:\/\/local\?path=[^\s)"']+/g;
-var FINCH_IMAGE_PLACEHOLDER_ORIGIN = "https://finch-local.invalid/markdown-image/";
-function substituteFinchFileImagesForBm(markdown) {
-  const urls = /* @__PURE__ */ new Map();
-  let sequence = 0;
-  const substituted = markdown.replace(FINCH_FILE_IMAGE_RE, (originalUrl) => {
-    const placeholder = `${FINCH_IMAGE_PLACEHOLDER_ORIGIN}${createHash("sha256").update(`${originalUrl}:${sequence++}`).digest("hex")}`;
-    urls.set(placeholder, originalUrl);
-    return placeholder;
-  });
-  return { markdown: substituted, urls };
-}
-async function renderWithBm(markdown, markdownStyle, customCss) {
-  const args = ["render", "--platform", "wechat", "--markdown-style", markdownStyle || "kami"];
-  if (customCss && customCss.trim()) args.push("--custom-css", customCss);
-  const prepared = substituteFinchFileImagesForBm(markdown);
-  let html = await runBmmd(args, prepared.markdown);
-  for (const [placeholder, originalUrl] of prepared.urls) html = html.split(placeholder).join(originalUrl);
-  return html;
-}
 var panelWatchers = /* @__PURE__ */ new Map();
 var lastPanel;
 function stopWatching(panelId) {
@@ -447,7 +512,7 @@ function watchSource(ctx, panel, sourcePath) {
       if (entry.timer) clearTimeout(entry.timer);
       entry.timer = setTimeout(async () => {
         try {
-          const markdown = await readFile(sourcePath, "utf8");
+          const markdown = await readFile2(sourcePath, "utf8");
           await sendDocument(panel, { path: sourcePath, markdown, title: documentTitle(markdown, sourcePath) });
         } catch (error) {
           ctx.logger.warn(`Source refresh failed: ${String(error)}`);
@@ -496,16 +561,98 @@ async function revealInFileManager(ctx, targetPath) {
     const info = await stat(targetPath).catch(() => void 0);
     const isFile = info?.isFile() ?? false;
     if (process.platform === "darwin") {
-      spawn("open", isFile ? ["-R", targetPath] : [targetPath], { stdio: "ignore", detached: true }).unref();
+      spawn2("open", isFile ? ["-R", targetPath] : [targetPath], { stdio: "ignore", detached: true }).unref();
     } else if (process.platform === "win32") {
-      spawn("explorer", isFile ? [`/select,${targetPath}`] : [targetPath], { stdio: "ignore", detached: true }).unref();
+      spawn2("explorer", isFile ? [`/select,${targetPath}`] : [targetPath], { stdio: "ignore", detached: true }).unref();
     } else {
-      spawn("xdg-open", [isFile ? path.dirname(targetPath) : targetPath], { stdio: "ignore", detached: true }).unref();
+      spawn2("xdg-open", [isFile ? path3.dirname(targetPath) : targetPath], { stdio: "ignore", detached: true }).unref();
     }
   } catch (error) {
     ctx.logger.warn(`Could not open file manager for ${targetPath}: ${String(error)}`);
   }
 }
+async function readRewriteSession(ctx, sourcePath) {
+  const state = await readLastPathState(ctx);
+  const id = state.rewriteSessions?.[sourcePath];
+  if (!id) return void 0;
+  const session = await ctx.sessions.get(id).catch(() => void 0);
+  return session ? id : void 0;
+}
+async function rememberRewriteSession(ctx, sourcePath, sessionId) {
+  try {
+    const state = await readLastPathState(ctx);
+    state.rewriteSessions = { ...state.rewriteSessions, [sourcePath]: sessionId };
+    await writeFile2(stateFile(ctx), JSON.stringify(state), "utf8");
+  } catch (error) {
+    ctx.logger.warn(`Could not persist rewrite session: ${String(error)}`);
+  }
+}
+async function startRewriteSession(ctx, panel, message) {
+  const sourcePath = String(message.path ?? "").trim();
+  const selectedText = String(message.selectedText ?? "").trim();
+  const rewriteMode = message.rewriteMode === "continue" ? "continue" : "replace";
+  const requirement = String(message.requirement ?? "").trim() || (rewriteMode === "continue" ? "\u81EA\u7136\u5730\u627F\u63A5\u4E0A\u4E0B\u6587\u7EE7\u7EED\u5199\u4F5C" : "\u8BA9\u8868\u8FBE\u66F4\u6E05\u6670\u3001\u81EA\u7136\uFF0C\u5E76\u4FDD\u6301\u539F\u610F");
+  const hasTarget = rewriteMode === "continue" ? !!message.startLine : !!selectedText;
+  if (panel.view !== "appView" || !path3.isAbsolute(sourcePath) || !hasTarget) {
+    await panel.postMessage({ type: "rewriteSessionFailed", message: "\u6539\u5199\u9700\u8981 App View \u4E2D\u5DF2\u4FDD\u5B58\u7684\u672C\u5730\u6587\u6863\u548C\u9009\u4E2D\u6587\u672C\u6216\u7EED\u5199\u4F4D\u7F6E\u3002" });
+    return;
+  }
+  const scope = await resolveDocumentScope(ctx, sourcePath);
+  let sessionId = await readRewriteSession(ctx, sourcePath);
+  if (!sessionId) {
+    const session = await ctx.sessions.create({
+      ...scope.spaceId ? { space: { spaceId: scope.spaceId } } : {},
+      title: `\u6539\u5199\uFF1A${path3.basename(sourcePath)}`,
+      activity: "interactive",
+      permissionMode: "acceptCalls"
+    });
+    sessionId = session.sessionId;
+    await rememberRewriteSession(ctx, sourcePath, sessionId);
+  }
+  const lineText = message.startLine ? `\u4F4D\u7F6E\uFF1A\u7B2C ${message.startLine}${message.endLine && message.endLine !== message.startLine ? `\u2013${message.endLine}` : ""} \u884C\u3002` : "";
+  const prompt = rewriteMode === "continue" ? `\u8BF7\u5728\u4E0B\u9762\u8FD9\u4EFD Markdown \u6587\u4EF6\u7684\u6307\u5B9A\u4F4D\u7F6E\u7EED\u5199\u5185\u5BB9\uFF0C\u5E76\u628A\u7ED3\u679C\u5199\u56DE\u6587\u4EF6\u3002
+
+\u6587\u4EF6\uFF1A${sourcePath}
+${lineText}
+\u8981\u6C42\uFF1A${requirement}
+
+\u8BF7\u8BFB\u53D6\u6587\u4EF6\u5F53\u524D\u5185\u5BB9\uFF1A\u7B2C ${message.startLine} \u884C\u5F53\u524D\u662F\u4E00\u4E2A\u7A7A\u884C\uFF0C\u8BF7\u628A\u7EED\u5199\u7684\u65B0\u5185\u5BB9\u76F4\u63A5\u5199\u5165\u8FD9\u4E00\u884C\u672C\u8EAB\uFF08\u628A\u8FD9\u4E2A\u7A7A\u884C\u66FF\u6362\u6210\u65B0\u5185\u5BB9\uFF09\uFF0C\u4E0D\u8981\u5728\u5B83\u524D\u540E\u989D\u5916\u63D2\u5165\u65B0\u7684\u7A7A\u884C\uFF0C\u4E5F\u4E0D\u8981\u6539\u52A8\u7B2C ${message.startLine} \u884C\u4E4B\u5916\u7684\u539F\u6709\u5185\u5BB9\uFF1B\u8C03\u7528 markdown_editor_document \u7684 apply\uFF0C\u4EE5 edits \u505A\u7CBE\u786E\u7684\u5C40\u90E8\u66FF\u6362\u3002\u4E0D\u8981\u53EA\u7ED9\u5EFA\u8BAE\uFF0C\u4E0D\u8981\u91CD\u53D1\u5168\u6587\uFF1B\u5B8C\u6210\u5199\u56DE\u540E\u7B80\u77ED\u8BF4\u660E\u3002` : `\u8BF7\u76F4\u63A5\u6539\u5199\u4E0B\u9762\u8FD9\u6BB5 Markdown\uFF0C\u5E76\u628A\u7ED3\u679C\u5199\u56DE\u6587\u4EF6\u3002
+
+\u6587\u4EF6\uFF1A${sourcePath}
+${lineText}
+\u8981\u6C42\uFF1A${requirement}
+
+\u539F\u6587\uFF1A
+${selectedText}
+
+\u8BF7\u8BFB\u53D6\u6587\u4EF6\u5F53\u524D\u5185\u5BB9\uFF0C\u8C03\u7528 markdown_editor_document \u7684 apply\uFF0C\u4EE5 edits \u505A\u552F\u4E00\u3001\u7CBE\u786E\u7684\u5C40\u90E8\u66FF\u6362\u3002\u4E0D\u8981\u53EA\u7ED9\u5EFA\u8BAE\uFF0C\u4E0D\u8981\u91CD\u53D1\u5168\u6587\uFF1B\u5B8C\u6210\u5199\u56DE\u540E\u7B80\u77ED\u8BF4\u660E\u3002`;
+  const receipt = await ctx.sessions.send(sessionId, {
+    text: prompt,
+    idempotencyKey: `rewrite-${createHash3("sha256").update(`${sourcePath}:${rewriteMode}:${selectedText}:${requirement}:${message.startLine ?? ""}:${Date.now()}`).digest("hex")}`
+  });
+  if (receipt.state === "rejected") {
+    await panel.postMessage({ type: "rewriteSessionFailed", message: "\u6539\u5199\u4F1A\u8BDD\u961F\u5217\u7E41\u5FD9\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002" });
+    return;
+  }
+  await panel.postMessage({
+    type: "rewriteSessionStarted",
+    sessionId,
+    spaceName: scope.spaceName,
+    title: `${rewriteMode === "continue" ? "\u7EED\u5199" : "\u6539\u5199"}\uFF1A${path3.basename(sourcePath)}`,
+    startLine: message.startLine,
+    endLine: message.endLine ?? message.startLine,
+    rewriteMode
+  });
+  void ctx.sessions.waitForTurn(sessionId, receipt.turnId, { timeoutMs: 6e5 }).then(async (result2) => {
+    const verb = rewriteMode === "continue" ? "\u7EED\u5199" : "\u6539\u5199";
+    await panel.postMessage({
+      type: result2.state === "completed" ? "rewriteSessionFinished" : "rewriteSessionFailed",
+      sessionId,
+      message: result2.state === "completed" ? `${verb}\u5DF2\u5B8C\u6210\u3002` : result2.state === "timeout" ? `${verb}\u4ECD\u5728\u4F1A\u8BDD\u4E2D\u7EE7\u7EED\u3002` : `${verb}\u4F1A\u8BDD\u672A\u5B8C\u6210\u3002`
+    }).catch(() => {
+    });
+  });
+}
 async function handleMessage(ctx, panel, raw) {
   const message = raw;
   switch (message.type) {
@@ -555,7 +702,8 @@ async function handleMessage(ctx, panel, raw) {
       try {
         const handle = ctx.ui.pickFile({
           title: "\u9009\u62E9Markdown\u6587\u4EF6",
-          filter: { extensions: [".md", ".markdown"] }
+          filter: { extensions: [".md", ".markdown"] },
+          allowSpaceSwitch: panel.view === "appView"
         });
         ctx.logger.info("ctx.ui.pickFile() call returned a handle, awaiting resolution\u2026");
         const picked = await handle;
@@ -581,7 +729,7 @@ async function handleMessage(ctx, panel, raw) {
     }
     case "loadPath": {
       const sourcePath = String(message.path ?? "").trim();
-      if (!path.isAbsolute(sourcePath)) {
+      if (!path3.isAbsolute(sourcePath)) {
         await panel.postMessage({ type: "error", message: "Please provide an absolute Markdown path." });
         return;
       }
@@ -597,7 +745,7 @@ async function handleMessage(ctx, panel, raw) {
     }
     case "watchPath": {
       const sourcePath = String(message.path ?? "").trim();
-      if (!path.isAbsolute(sourcePath)) return;
+      if (!path3.isAbsolute(sourcePath)) return;
       watchSource(ctx, panel, sourcePath);
       await rememberLastPath(ctx, panel, sourcePath);
       await panel.postMessage({ type: "watchStarted", path: sourcePath });
@@ -614,7 +762,7 @@ async function handleMessage(ctx, panel, raw) {
     }
     case "openPath": {
       const targetPath = String(message.path ?? "").trim();
-      if (targetPath && path.isAbsolute(targetPath)) await revealInFileManager(ctx, targetPath);
+      if (targetPath && path3.isAbsolute(targetPath)) await revealInFileManager(ctx, targetPath);
       return;
     }
     case "goHome": {
@@ -627,20 +775,29 @@ async function handleMessage(ctx, panel, raw) {
       const sessionId = String(message.sessionId ?? "").trim();
       const spaceId = String(message.spaceId ?? "").trim();
       try {
-        await rememberPanelRecentScope(ctx, panel, cwd, sessionId, spaceId);
-        const recent = await collectRecentDocuments(ctx, cwd, sessionId, spaceId);
-        await panel.postMessage({ type: "recentDocuments", cwd, documents: recent.documents, fallbackCwd: recent.fallbackCwd });
+        if (panel.view === "appView") {
+          const documents = await collectLibraryDocuments(ctx);
+          await panel.postMessage({ type: "recentDocuments", cwd, documents, library: true });
+        } else {
+          await rememberPanelRecentScope(ctx, panel, cwd, sessionId, spaceId);
+          const recent = await collectRecentDocuments(ctx, cwd, sessionId, spaceId);
+          await panel.postMessage({ type: "recentDocuments", cwd, documents: recent.documents, fallbackCwd: recent.fallbackCwd });
+        }
       } catch (error) {
         ctx.logger.warn(`Could not collect recent documents: ${String(error)}`);
-        await panel.postMessage({ type: "recentDocuments", cwd, documents: [] });
+        await panel.postMessage({ type: "recentDocuments", cwd, documents: [], library: panel.view === "appView" });
       }
       return;
     }
+    case "requestRewrite": {
+      await startRewriteSession(ctx, panel, message);
+      return;
+    }
     case "saveMarkdown": {
       const sourcePath = String(message.path ?? "").trim();
-      if (!path.isAbsolute(sourcePath)) return;
+      if (!path3.isAbsolute(sourcePath)) return;
       try {
-        await writeFile(sourcePath, String(message.markdown ?? ""), "utf8");
+        await writeFile2(sourcePath, String(message.markdown ?? ""), "utf8");
         cancelPendingDraftWrite(panel.id);
         await deleteDraft(ctx, sourcePath);
         await panel.postMessage({ type: "savedMarkdown", path: sourcePath, requestId: message.requestId });
@@ -651,14 +808,14 @@ async function handleMessage(ctx, panel, raw) {
     }
     case "saveDraft": {
       const sourcePath = String(message.path ?? "").trim();
-      if (!path.isAbsolute(sourcePath)) return;
+      if (!path3.isAbsolute(sourcePath)) return;
       const base = typeof message.base === "string" ? message.base : void 0;
       scheduleDraftWrite(ctx, panel.id, sourcePath, String(message.markdown ?? ""), base);
       return;
     }
     case "discardDraft": {
       const sourcePath = String(message.path ?? "").trim();
-      if (!path.isAbsolute(sourcePath)) return;
+      if (!path3.isAbsolute(sourcePath)) return;
       cancelPendingDraftWrite(panel.id);
       await deleteDraft(ctx, sourcePath);
       return;
@@ -694,14 +851,14 @@ async function handleMessage(ctx, panel, raw) {
     case "applyReplacement": {
       const sourcePath = String(message.path ?? "").trim();
       const markdown = String(message.markdown ?? "");
-      if (!sourcePath || !path.isAbsolute(sourcePath)) {
+      if (!sourcePath || !path3.isAbsolute(sourcePath)) {
         await panel.postMessage({ type: "error", message: "Pasted documents can be revised in the editor, but source-file apply needs an absolute path." });
         return;
       }
       try {
-        const current = await readFile(sourcePath, "utf8");
+        const current = await readFile2(sourcePath, "utf8");
         const appliedMarkdown = preserveTextEnvelope(current, markdown);
-        await writeFile(sourcePath, appliedMarkdown, "utf8");
+        await writeFile2(sourcePath, appliedMarkdown, "utf8");
         await rememberRecentPath(ctx, sourcePath, panel);
         await panel.postMessage({ type: "applied", path: sourcePath, title: documentTitle(appliedMarkdown, sourcePath) });
       } catch (error) {
@@ -727,12 +884,12 @@ async function handleMessage(ctx, panel, raw) {
       try {
         const ext = PASTE_IMAGE_EXT[String(message.mimeType ?? "").toLowerCase()] ?? "png";
         const buffer = Buffer.from(dataBase64, "base64");
-        const digest = createHash("sha256").update(buffer).digest("hex").slice(0, 20);
-        const dir = path.join(ctx.storagePath, "assets");
-        await mkdir(dir, { recursive: true });
-        const targetPath = path.join(dir, `${digest}.${ext}`);
+        const digest = createHash3("sha256").update(buffer).digest("hex").slice(0, 20);
+        const dir = path3.join(ctx.storagePath, "assets");
+        await mkdir2(dir, { recursive: true });
+        const targetPath = path3.join(dir, `${digest}.${ext}`);
         const alreadyExists = await stat(targetPath).then(() => true).catch(() => false);
-        if (!alreadyExists) await writeFile(targetPath, buffer);
+        if (!alreadyExists) await writeFile2(targetPath, buffer);
         const url = `finch-file://local?path=${encodeURIComponent(targetPath)}`;
         await panel.postMessage({ type: "pastedImage", requestId: message.requestId, url, path: targetPath });
       } catch (error) {
@@ -765,15 +922,15 @@ async function handleMessage(ctx, panel, raw) {
       }
       try {
         const sourcePath = String(message.path ?? "").trim();
-        let dir = path.isAbsolute(sourcePath) ? path.dirname(sourcePath) : "";
+        let dir = path3.isAbsolute(sourcePath) ? path3.dirname(sourcePath) : "";
         if (!dir) {
-          const downloads = path.join(os.homedir(), "Downloads");
+          const downloads = path3.join(os.homedir(), "Downloads");
           dir = await stat(downloads).then((s) => s.isDirectory()).catch(() => false) ? downloads : ctx.storagePath;
         }
         const rawName = String(message.fileName ?? "").trim() || documentTitle(String(message.markdown ?? ""), sourcePath || void 0);
         const safeName = rawName.replace(/[\\/:*?"<>|]/g, " ").trim().slice(0, 120) || "article";
-        const targetPath = path.join(dir, `${safeName}.${ext}`);
-        await writeFile(targetPath, Buffer.from(dataBase64, "base64"));
+        const targetPath = path3.join(dir, `${safeName}.${ext}`);
+        await writeFile2(targetPath, Buffer.from(dataBase64, "base64"));
         await panel.postMessage({ type: "exported", path: targetPath, requestId: message.requestId });
       } catch (error) {
         await panel.postMessage({ type: "error", message: `Could not export file: ${error instanceof Error ? error.message : String(error)}` });
@@ -873,7 +1030,7 @@ action:
       const action = String(input.action ?? "");
       if (action === "open" || action === "create" || action === "apply") {
         const sourcePath = String(input.path ?? "").trim();
-        if (!path.isAbsolute(sourcePath)) return result("`path` must be an absolute local path.", true);
+        if (!path3.isAbsolute(sourcePath)) return result("`path` must be an absolute local path.", true);
         if (action === "open") {
           try {
             const { markdown: markdown2, diskMarkdown, draftRestored, draftConflict } = await readFileWithDraft(ctx, sourcePath);
@@ -882,7 +1039,7 @@ action:
             watchSource(ctx, panel, sourcePath);
             await rememberLastPath(ctx, panel, sourcePath);
             await sendDocument(panel, { path: sourcePath, markdown: markdown2, title: documentTitle(markdown2, sourcePath), draftRestored, draftConflict, diskMarkdown });
-            return result(`Opened Markdown Editor for ${path.basename(sourcePath)}.`);
+            return result(`Opened Markdown Editor for ${path3.basename(sourcePath)}.`);
           } catch (error) {
             return result(`Could not read ${sourcePath}: ${error instanceof Error ? error.message : String(error)}`, true);
           }
@@ -892,14 +1049,14 @@ action:
           try {
             const alreadyExists = await stat(sourcePath).then(() => true).catch(() => false);
             if (alreadyExists) return result(`${sourcePath} already exists. Use action 'open' to view it or 'apply' to revise it instead.`, true);
-            await mkdir(path.dirname(sourcePath), { recursive: true });
-            await writeFile(sourcePath, markdown2, "utf8");
+            await mkdir2(path3.dirname(sourcePath), { recursive: true });
+            await writeFile2(sourcePath, markdown2, "utf8");
             const panel = ctx.ui.createPanel({ instanceMode: "single", payload: { path: sourcePath } });
             await panel.reveal();
             watchSource(ctx, panel, sourcePath);
             await rememberLastPath(ctx, panel, sourcePath);
             await sendDocument(panel, { path: sourcePath, markdown: markdown2, title: documentTitle(markdown2, sourcePath) });
-            return result(`Created ${path.basename(sourcePath)} and opened it in Markdown Editor.`);
+            return result(`Created ${path3.basename(sourcePath)} and opened it in Markdown Editor.`);
           } catch (error) {
             return result(`Could not create ${sourcePath}: ${error instanceof Error ? error.message : String(error)}`, true);
           }
@@ -915,12 +1072,12 @@ action:
             };
           });
           try {
-            const current = await readFile(sourcePath, "utf8");
+            const current = await readFile2(sourcePath, "utf8");
             const applied = applyEditSpecs(current, edits);
             if (!applied.ok) return result(applied.error, true);
-            await writeFile(sourcePath, applied.content, "utf8");
+            await writeFile2(sourcePath, applied.content, "utf8");
             await rememberRecentPath(ctx, sourcePath);
-            return result(`Applied ${edits.length} targeted edit${edits.length > 1 ? "s" : ""} to ${path.basename(sourcePath)}.`);
+            return result(`Applied ${edits.length} targeted edit${edits.length > 1 ? "s" : ""} to ${path3.basename(sourcePath)}.`);
           } catch (error) {
             return result(`Could not apply edits: ${error instanceof Error ? error.message : String(error)}`, true);
           }
@@ -928,10 +1085,10 @@ action:
         const markdown = String(input.markdown ?? "");
         if (!markdown) return result("`apply` requires either `edits` (targeted replacements) or non-empty `markdown` (full document).", true);
         try {
-          const current = await readFile(sourcePath, "utf8");
-          await writeFile(sourcePath, preserveTextEnvelope(current, markdown), "utf8");
+          const current = await readFile2(sourcePath, "utf8");
+          await writeFile2(sourcePath, preserveTextEnvelope(current, markdown), "utf8");
           await rememberRecentPath(ctx, sourcePath);
-          return result(`Applied reviewed Markdown to ${path.basename(sourcePath)}.`);
+          return result(`Applied reviewed Markdown to ${path3.basename(sourcePath)}.`);
         } catch (error) {
           return result(`Could not apply revision: ${error instanceof Error ? error.message : String(error)}`, true);
         }