finch-markdown-editor 0.1.7 → 0.1.9

package/dist/index.js

@@ -64,6 +64,57 @@ var STYLE_SLOT_COUNT = 3;
 function result(message, isError = false) {
   return { content: [{ type: "text", text: message }], isError };
 }
+function unwrapTextEnvelope(content) {
+  const bom = content.startsWith("\uFEFF") ? "\uFEFF" : "";
+  const text = bom ? content.slice(1) : content;
+  const firstCrLf = text.indexOf("\r\n");
+  const firstLf = text.indexOf("\n");
+  const lineEnding = firstCrLf !== -1 && (firstLf === -1 || firstCrLf <= firstLf) ? "\r\n" : "\n";
+  return { bom, lineEnding, text: text.replace(/\r\n/g, "\n").replace(/\r/g, "\n") };
+}
+function normalizeToLf(text) {
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function rewrapTextEnvelope(envelope, normalizedText) {
+  const restored = envelope.lineEnding === "\r\n" ? normalizedText.replace(/\n/g, "\r\n") : normalizedText;
+  return envelope.bom + restored;
+}
+function preserveTextEnvelope(existingContent, replacement) {
+  const envelope = unwrapTextEnvelope(existingContent);
+  return rewrapTextEnvelope(envelope, normalizeToLf(replacement.replace(/^\ufeff/, "")));
+}
+function applyEditSpecs(content, edits) {
+  const envelope = unwrapTextEnvelope(content);
+  let working = envelope.text;
+  for (let i = 0; i < edits.length; i++) {
+    const { old_string: rawOldString, new_string: rawNewString, replace_all: replaceAll } = edits[i];
+    if (typeof rawOldString !== "string" || rawOldString.length === 0) {
+      return { ok: false, error: `edits[${i}]: 'old_string' must be a non-empty string.` };
+    }
+    if (typeof rawNewString !== "string") {
+      return { ok: false, error: `edits[${i}]: 'new_string' must be a string.` };
+    }
+    const oldString = normalizeToLf(rawOldString);
+    const newString = normalizeToLf(rawNewString);
+    if (oldString === newString) {
+      return { ok: false, error: `edits[${i}]: 'old_string' and 'new_string' are identical \u2014 nothing to change.` };
+    }
+    const occurrences = working.split(oldString).length - 1;
+    if (occurrences === 0) {
+      return { ok: false, error: `edits[${i}]: 'old_string' was not found in the file's current content. Check the exact text (including whitespace/line breaks) \u2014 the file may differ from what you last saw.` };
+    }
+    if (occurrences > 1 && !replaceAll) {
+      return { ok: false, error: `edits[${i}]: 'old_string' matches ${occurrences} places in the file. Include more surrounding context to make it unique, or set 'replace_all: true' to replace every match.` };
+    }
+    if (replaceAll) {
+      working = working.split(oldString).join(newString);
+    } else {
+      const index = working.indexOf(oldString);
+      working = working.slice(0, index) + newString + working.slice(index + oldString.length);
+    }
+  }
+  return { ok: true, content: rewrapTextEnvelope(envelope, working) };
+}
 function documentTitle(markdown, filePath) {
   const heading = markdown.match(/^#\s+(.+)$/m)?.[1]?.trim();
   return heading || (filePath ? path.basename(filePath, path.extname(filePath)) : "Untitled article");
@@ -176,19 +227,64 @@ async function readLastPathState(ctx) {
     return {};
   }
 }
+function resolveRecentScope(state, cwd, sessionId, spaceId) {
+  if (path.isAbsolute(cwd)) {
+    if (sessionId && !spaceId) state.homePath = cwd;
+    return { scope: cwd };
+  }
+  if (!cwd && !sessionId && !spaceId && path.isAbsolute(state.homePath ?? "")) {
+    return { scope: state.homePath, fallbackCwd: state.homePath };
+  }
+  return {};
+}
+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)
+  };
+}
+async function rememberPanelRecentScope(ctx, panel, cwd, sessionId, spaceId) {
+  try {
+    await mkdir(ctx.storagePath, { recursive: true });
+    const state = await readLastPathState(ctx);
+    const resolved = resolveRecentScope(state, cwd, sessionId, spaceId);
+    if (resolved.scope) {
+      state.panelRecentScopes = { ...state.panelRecentScopes, [panel.id]: resolved.scope };
+      const panelPath = state.panels?.[panel.id];
+      if (panelPath) addRecentPath(state, resolved.scope, panelPath);
+    }
+    await writeFile(stateFile(ctx), JSON.stringify(state), "utf8");
+    return resolved;
+  } catch (error) {
+    ctx.logger.warn(`Could not persist panel recent scope: ${String(error)}`);
+    return {};
+  }
+}
 async function rememberLastPath(ctx, panel, sourcePath) {
   try {
     await mkdir(ctx.storagePath, { recursive: true });
     const state = await readLastPathState(ctx);
-    const legacyPaths = [...Object.values(state.panels ?? {}), ...Object.values(state.sessions ?? {})];
-    state.recentPaths = [sourcePath, ...state.recentPaths ?? [], ...legacyPaths].filter((value, index, values) => path.isAbsolute(value) && values.indexOf(value) === index).slice(0, 50);
     state.panels = { ...state.panels, [panel.id]: sourcePath };
     state.sessions = { ...state.sessions, [sessionBucketKey(panel)]: sourcePath };
+    const scope = state.panelRecentScopes?.[panel.id];
+    if (scope) addRecentPath(state, scope, sourcePath);
     await writeFile(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 });
+    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");
+  } catch (error) {
+    ctx.logger.warn(`Could not persist recent path: ${String(error)}`);
+  }
+}
 async function readLastPath(ctx, panel) {
   const state = await readLastPathState(ctx);
   const perPanel = state.panels?.[panel.id];
@@ -204,10 +300,6 @@ var RECENT_PREVIEW_CHARS = 220;
 function isMarkdownPath(filePath) {
   return /\.(md|markdown|mdown|mkd)$/i.test(filePath);
 }
-function isInsideDirectory(filePath, directory) {
-  const relative = path.relative(directory, filePath);
-  return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative);
-}
 function deriveTitle(markdown, fallback) {
   for (const line of markdown.split("\n", 60)) {
     const heading = line.match(/^\s{0,3}#{1,6}\s+(.*\S)\s*$/);
@@ -222,15 +314,14 @@ function deriveTitle(markdown, fallback) {
 function derivePreview(markdown) {
   return markdown.replace(/^---\n[\s\S]*?\n---\n/, "").replace(/```[\s\S]*?```/g, " ").replace(/!\[[^\]]*\]\([^)]*\)/g, " ").replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/^\s{0,3}#{1,6}\s+/gm, "").replace(/[*_`>~]/g, "").replace(/\s+/g, " ").trim().slice(0, RECENT_PREVIEW_CHARS);
 }
-async function collectRecentDocuments(ctx, cwd) {
-  if (!cwd || !path.isAbsolute(cwd)) return [];
+async function collectRecentDocuments(ctx, requestedCwd, sessionId, spaceId) {
+  const cwd = requestedCwd;
   const state = await readLastPathState(ctx);
-  const candidates = [
-    ...state.recentPaths ?? [],
-    ...Object.values(state.panels ?? {}),
-    ...Object.values(state.sessions ?? {})
-  ].filter(
-    (value, index, values) => typeof value === "string" && path.isAbsolute(value) && isMarkdownPath(value) && isInsideDirectory(value, cwd) && values.indexOf(value) === index
+  const resolved = resolveRecentScope(state, cwd, 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
   );
   const documents = await Promise.all(
     candidates.map(async (filePath) => {
@@ -241,7 +332,7 @@ async function collectRecentDocuments(ctx, cwd) {
         const fileName = path.basename(filePath);
         return {
           path: filePath,
-          relativePath: path.relative(cwd, filePath),
+          relativePath: path.relative(scope, filePath),
           fileName,
           title: deriveTitle(markdown, fileName.replace(/\.[^.]+$/, "")),
           preview: derivePreview(markdown),
@@ -252,7 +343,10 @@ async function collectRecentDocuments(ctx, cwd) {
       }
     })
   );
-  return documents.filter((entry) => Boolean(entry)).sort((a, b) => b.modifiedAt - a.modifiedAt).slice(0, RECENT_LIMIT);
+  return {
+    documents: documents.filter((entry) => Boolean(entry)).sort((a, b) => b.modifiedAt - a.modifiedAt).slice(0, RECENT_LIMIT),
+    fallbackCwd: resolved.fallbackCwd
+  };
 }
 var livePanelDocuments = /* @__PURE__ */ new Map();
 async function sendDocument(panel, state) {
@@ -530,8 +624,12 @@ async function handleMessage(ctx, panel, raw) {
     }
     case "requestRecentDocuments": {
       const cwd = String(message.cwd ?? "").trim();
+      const sessionId = String(message.sessionId ?? "").trim();
+      const spaceId = String(message.spaceId ?? "").trim();
       try {
-        await panel.postMessage({ type: "recentDocuments", cwd, documents: await collectRecentDocuments(ctx, cwd) });
+        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: [] });
@@ -601,8 +699,11 @@ async function handleMessage(ctx, panel, raw) {
         return;
       }
       try {
-        await writeFile(sourcePath, markdown, "utf8");
-        await panel.postMessage({ type: "applied", path: sourcePath, title: documentTitle(markdown, sourcePath) });
+        const current = await readFile(sourcePath, "utf8");
+        const appliedMarkdown = preserveTextEnvelope(current, markdown);
+        await writeFile(sourcePath, appliedMarkdown, "utf8");
+        await rememberRecentPath(ctx, sourcePath, panel);
+        await panel.postMessage({ type: "applied", path: sourcePath, title: documentTitle(appliedMarkdown, sourcePath) });
       } catch (error) {
         await panel.postMessage({ type: "error", message: `Could not apply revision: ${error instanceof Error ? error.message : String(error)}` });
       }
@@ -706,6 +807,12 @@ function activate(ctx) {
     },
     "swatch-book": {
       svg: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M11 17a4 4 0 0 1-8 0V5a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2Z"/><path d="M16.7 13H19a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2H7"/><path d="M 7 17h.01"/><path d="m11 8 2.3-2.3a2.4 2.4 0 0 1 3.404.004L18.6 7.6a2.4 2.4 0 0 1 .026 3.434L9.9 19.8"/></svg>'
+    },
+    // Static hourglass shown on the Preview button while bm.md rendering is
+    // in flight — a plain status hint, deliberately not animated (SMIL does
+    // not run on host-rendered SVGs and frame-swapping felt janky).
+    "hourglass": {
+      svg: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M5 22h14"/><path d="M5 2h14"/><path d="M17 22v-4.172a2 2 0 0 0-.586-1.414L12 12l-4.414 4.414A2 2 0 0 0 7 17.828V22"/><path d="M7 2v4.172a2 2 0 0 0 .586 1.414L12 12l4.414-4.414A2 2 0 0 0 17 6.172V2"/></svg>'
     }
   }));
   ctx.subscriptions.push(ctx.ui.onDidOpenPanel((panel) => {
@@ -733,15 +840,28 @@ function activate(ctx) {
     description: `Open, create, revise, or restyle a Markdown document in Markdown Editor.
 action:
   open \u2014 read an absolute local Markdown path and open it as an editable WeChat article preview
-  create \u2014 write brand-new Markdown content to an absolute path that does not exist yet, then open it in Markdown Editor. Use this whenever the user asks to create/draft a new Markdown file (Markdown Editor's own UI has no "new file" button on purpose \u2014 this tool action is the intended way to start a new document)
-  apply \u2014 replace a source document with reviewed Markdown (requires path and markdown); the open panel refreshes in place, no Diff window
+  create \u2014 write brand-new Markdown content to an absolute path that does not exist yet, then open it in Markdown Editor. Use this whenever the user asks to write an article, start writing, write a post, create, or draft a new document \u2014 even if they do not mention Markdown. If title/topic or destination is missing, guide the user to provide it; once known, create and open the document rather than returning prose only. If they only want to begin, create a minimal titled starter document. Markdown Editor's own UI has no "new file" button on purpose \u2014 this tool action is the intended way to start a new document
+  apply \u2014 revise a source document (requires path). For a small, targeted change, pass edits instead of markdown: an array of {old_string, new_string} replacements matched against the file's current on-disk content, the same find-and-replace contract as a code editor's Edit tool \u2014 this avoids resending the whole document and keeps the on-screen highlight scoped to what actually changed. Reserve markdown (the full updated document) for a genuine full rewrite. Once this conversation has started editing a .md document through Markdown Editor, always use this apply/edits path for subsequent changes to that same file before considering the built-in Edit tool: it refreshes the panel and highlights the exact change. Fall back to the built-in Edit tool only after this apply actually fails. The open panel refreshes in place, no Diff window. Whenever you propose a rewrite and wait for approval before applying it, calling Session action=suggest with 1-3 one-tap confirmations is MANDATORY, not optional, and part of that same turn \u2014 sending the proposal text alone does not complete the confirmation step, so do not end the turn without also calling it
   set_style \u2014 apply an AI-designed custom CSS layout to the currently open Markdown Editor preview (requires css). Write plain CSS scoped under #bm-md using tag/id selectors (no classes), use !important where needed to override the base style, and take inspiration from bm.md's built-in styles: kami (warm paper), bauhaus (geometric primary colors), blueprint (technical grid), botanical (soft green), newsprint (editorial serif), retro (nostalgic), sketch (hand-drawn), terminal (monospace dark).`,
     inputSchema: {
       type: "object",
       properties: {
         action: { type: "string", enum: ["open", "create", "apply", "set_style"], description: "Operation to perform." },
         path: { type: "string", description: "Absolute path to the Markdown file. Required for open, create, and apply. For create, the file must not already exist." },
-        markdown: { type: "string", description: "Full Markdown content, required for create and apply." },
+        markdown: { type: "string", description: "Full Markdown content. Required for create. For apply, use this only for a genuine full rewrite \u2014 prefer `edits` for a small, targeted change." },
+        edits: {
+          type: "array",
+          description: "For apply only: targeted local replacements instead of resending the whole document. Each old_string is matched against the file's current on-disk content (already reflecting earlier items in this same array) and must match exactly once unless replace_all is set. Prefer this over `markdown` for anything short of a full rewrite.",
+          items: {
+            type: "object",
+            properties: {
+              old_string: { type: "string", description: "Exact existing text to replace; must be unique in the file unless replace_all is true." },
+              new_string: { type: "string", description: "Replacement text." },
+              replace_all: { type: "boolean", description: "Replace every occurrence of old_string instead of requiring it to be unique." }
+            },
+            required: ["old_string", "new_string"]
+          }
+        },
         css: { type: "string", description: "Custom CSS to layer on top of the current base style, required for set_style." },
         label: { type: "string", description: "Short label describing the custom style, optional for set_style." },
         slot: { type: "number", enum: [1, 2, 3], description: "Required for AI-designed styles: user-selected reusable custom style slot to overwrite." }
@@ -784,10 +904,33 @@ action:
             return result(`Could not create ${sourcePath}: ${error instanceof Error ? error.message : String(error)}`, true);
           }
         }
+        const rawEdits = Array.isArray(input.edits) ? input.edits : void 0;
+        if (rawEdits && rawEdits.length > 0) {
+          const edits = rawEdits.map((entry) => {
+            const item = entry && typeof entry === "object" ? entry : {};
+            return {
+              old_string: typeof item.old_string === "string" ? item.old_string : "",
+              new_string: typeof item.new_string === "string" ? item.new_string : "",
+              replace_all: Boolean(item.replace_all)
+            };
+          });
+          try {
+            const current = await readFile(sourcePath, "utf8");
+            const applied = applyEditSpecs(current, edits);
+            if (!applied.ok) return result(applied.error, true);
+            await writeFile(sourcePath, applied.content, "utf8");
+            await rememberRecentPath(ctx, sourcePath);
+            return result(`Applied ${edits.length} targeted edit${edits.length > 1 ? "s" : ""} to ${path.basename(sourcePath)}.`);
+          } catch (error) {
+            return result(`Could not apply edits: ${error instanceof Error ? error.message : String(error)}`, true);
+          }
+        }
         const markdown = String(input.markdown ?? "");
-        if (!markdown) return result("`apply` requires non-empty `markdown`.", true);
+        if (!markdown) return result("`apply` requires either `edits` (targeted replacements) or non-empty `markdown` (full document).", true);
         try {
-          await writeFile(sourcePath, markdown, "utf8");
+          const current = await readFile(sourcePath, "utf8");
+          await writeFile(sourcePath, preserveTextEnvelope(current, markdown), "utf8");
+          await rememberRecentPath(ctx, sourcePath);
           return result(`Applied reviewed Markdown to ${path.basename(sourcePath)}.`);
         } catch (error) {
           return result(`Could not apply revision: ${error instanceof Error ? error.message : String(error)}`, true);