@imenam/mcp-documentor 1.0.35 → 1.0.37

package/dist/shared/schemas/doc.schema.d.ts

@@ -81,6 +81,7 @@ export declare const FreshnessReportSchema: z.ZodObject<{
     modified: z.ZodArray<z.ZodString>;
     missing: z.ZodArray<z.ZodString>;
     unchanged: z.ZodArray<z.ZodString>;
+    anchors_lost: z.ZodDefault<z.ZodArray<z.ZodString>>;
     total: z.ZodNumber;
 }, z.core.$strip>;
 export type FreshnessReport = z.infer<typeof FreshnessReportSchema>;

package/dist/shared/schemas/doc.schema.js

@@ -39,6 +39,7 @@ export const FreshnessReportSchema = z.object({
     modified: z.array(z.string()),
     missing: z.array(z.string()),
     unchanged: z.array(z.string()),
+    anchors_lost: z.array(z.string()).default([]),
     total: z.number(),
 });
 export const CreateDocArgsSchema = z.object({

package/dist/src/gui-worker.js

@@ -268,6 +268,22 @@ app.get("/api/doc/*", async (c) => {
         return c.json({ error: result.error }, 400);
     return c.json(result.data);
 });
+app.put("/api/doc/*", async (c) => {
+    try {
+        const id = decodeURIComponent(c.req.path.slice("/api/doc/".length));
+        const body = await c.req.json();
+        if (body.content === undefined) {
+            return c.json({ error: "content is required" }, 400);
+        }
+        const result = await ipcRequest("UPDATE_DOC", { id, content: body.content, title: body.title }, 15000);
+        if (result.error)
+            return c.json({ error: result.error }, 500);
+        return c.json(result.data ?? { success: true });
+    }
+    catch (err) {
+        return c.json({ error: err.message }, 500);
+    }
+});
 app.get("/api/freshness/*", async (c) => {
     const id = decodeURIComponent(c.req.path.slice("/api/freshness/".length));
     const result = await ipcRequest("CHECK_FRESHNESS", { id });

package/dist/src/index.js

@@ -126,6 +126,9 @@ function handleIPCMessage(msg) {
     else if (msg.type === "GET_DOC_VERSION") {
         handleGetDocVersionIPC(msg);
     }
+    else if (msg.type === "UPDATE_DOC") {
+        handleUpdateDocIPC(msg);
+    }
     else {
         logger.debug(`Unhandled message from GUI: ${msg.type}`);
     }
@@ -254,6 +257,40 @@ async function handleGetDoc(msg) {
         });
     }
 }
+async function handleUpdateDocIPC(msg) {
+    try {
+        const result = await updateDoc(storageEngine, embeddingEngine, {
+            path: msg.data.id,
+            content: msg.data.content,
+            ...(msg.data.title !== undefined && { title: msg.data.title }),
+        });
+        if (result.isError) {
+            const text = result.content[0]?.type === "text" ? result.content[0].text : "Update failed";
+            broadcastToGUI({
+                type: "UPDATE_DOC_RESPONSE",
+                correlationId: msg.correlationId,
+                error: text,
+                timestamp: new Date().toISOString(),
+            });
+            return;
+        }
+        const message = result.content[0]?.type === "text" ? result.content[0].text : undefined;
+        broadcastToGUI({
+            type: "UPDATE_DOC_RESPONSE",
+            correlationId: msg.correlationId,
+            data: { success: true, message },
+            timestamp: new Date().toISOString(),
+        });
+    }
+    catch (err) {
+        broadcastToGUI({
+            type: "UPDATE_DOC_RESPONSE",
+            correlationId: msg.correlationId,
+            error: err.message,
+            timestamp: new Date().toISOString(),
+        });
+    }
+}
 async function handleCheckFreshness(msg) {
     try {
         const resolved = await storageEngine.resolveDoc(msg.data.id ?? msg.data.path);

package/dist/src/tools/check-freshness.js

@@ -8,11 +8,12 @@ export function computeFileHash(absolutePath) {
 }
 export function computeFreshness(trackedFiles) {
     if (!trackedFiles || trackedFiles.length === 0) {
-        return { status: "no_tracking", modified: [], missing: [], unchanged: [], total: 0 };
+        return { status: "no_tracking", modified: [], missing: [], unchanged: [], anchors_lost: [], total: 0 };
     }
     const modified = [];
     const missing = [];
     const unchanged = [];
+    const anchors_lost = [];
     for (const tracked of trackedFiles) {
         const absolutePath = path.resolve(process.cwd(), tracked.path);
         if (!fs.existsSync(absolutePath)) {
@@ -21,15 +22,26 @@ export function computeFreshness(trackedFiles) {
         }
         if (tracked.sections && tracked.sections.length > 0) {
             let sectionStale = false;
+            let anchorLost = false;
             for (const section of tracked.sections) {
                 const result = findAndHashSection(absolutePath, section);
-                if (!result.found || result.currentHash !== section.sectionHash) {
+                if (!result.found) {
+                    sectionStale = true;
+                    anchorLost = true;
+                    break;
+                }
+                else if (result.currentHash !== section.sectionHash) {
                     sectionStale = true;
                     break;
                 }
             }
             if (sectionStale) {
-                modified.push(tracked.path);
+                if (anchorLost) {
+                    anchors_lost.push(tracked.path);
+                }
+                else {
+                    modified.push(tracked.path);
+                }
             }
             else {
                 unchanged.push(tracked.path);
@@ -56,12 +68,13 @@ export function computeFreshness(trackedFiles) {
             }
         }
     }
-    const isStale = modified.length > 0 || missing.length > 0;
+    const isStale = modified.length > 0 || missing.length > 0 || anchors_lost.length > 0;
     return {
         status: isStale ? "stale" : "up_to_date",
         modified,
         missing,
         unchanged,
+        anchors_lost,
         total: trackedFiles.length,
     };
 }
@@ -72,13 +85,19 @@ export function formatFreshnessReport(title, report) {
     let text = report.status === "stale"
         ? `STALE: "${title}" — tracked files have changed since the documentation was last updated.\n`
         : `UP TO DATE: "${title}" — no tracked files have been modified.\n`;
-    text += `\nSummary: ${report.modified.length} modified, ${report.missing.length} missing, ${report.unchanged.length} unchanged out of ${report.total} tracked file(s).`;
+    const anchorLostCount = report.anchors_lost?.length ?? 0;
+    text += `\nSummary: ${report.modified.length} modified, ${report.missing.length} missing, ${anchorLostCount} with lost anchors, ${report.unchanged.length} unchanged out of ${report.total} tracked file(s).`;
     if (report.modified.length > 0) {
-        text += `\n\nModified files:\n${report.modified.map((f) => `  - ${f}`).join("\n")}`;
+        text += `\n\nModified files (call refresh_file_snapshot to acknowledge):\n${report.modified.map((f) => `  - ${f}`).join("\n")}`;
     }
     if (report.missing.length > 0) {
         text += `\n\nMissing files:\n${report.missing.map((f) => `  - ${f}`).join("\n")}`;
     }
+    if (anchorLostCount > 0) {
+        text += `\n\n⚠ Files with lost anchors — refresh_file_snapshot cannot fix this:\n${report.anchors_lost.map((f) => `  - ${f}`).join("\n")}`;
+        text += `\n  → The tracked section(s) could not be located in the current file content (anchors were likely modified by a recent commit).`;
+        text += `\n  → Required action: call update_doc with the new line numbers to re-establish section tracking.`;
+    }
     return text;
 }
 export async function checkFreshness(storageEngine, args) {
@@ -113,6 +132,7 @@ export async function checkFreshness(storageEngine, args) {
                     const details = [
                         ...report.modified.map((f) => `    • modified: ${f}`),
                         ...report.missing.map((f) => `    • missing: ${f}`),
+                        ...(report.anchors_lost ?? []).map((f) => `    • ⚠ anchors lost (needs update_doc): ${f}`),
                     ].join("\n");
                     stale.push(`  - **${doc.title}** [${doc.id}]\n${details}`);
                 }
@@ -153,6 +173,7 @@ export async function checkFreshness(storageEngine, args) {
                     const details = [
                         ...report.modified.map((f) => `    • modified: ${f}`),
                         ...report.missing.map((f) => `    • missing: ${f}`),
+                        ...(report.anchors_lost ?? []).map((f) => `    • ⚠ anchors lost (needs update_doc): ${f}`),
                     ].join("\n");
                     stale.push(`  - **${doc.title}** [${doc.id}]\n${details}`);
                 }

package/dist/src/tools/refresh-file-snapshot.js

@@ -16,6 +16,7 @@ export async function refreshFileSnapshot(storageEngine, historyStore, args) {
             const refreshed = [];
             const missing = [];
             const skipped = [];
+            const anchorsLost = [];
             for (const tracked of doc.tracked_files) {
                 if (validated.file_paths && !validated.file_paths.includes(tracked.path)) {
                     skipped.push(tracked.path);
@@ -27,24 +28,38 @@ export async function refreshFileSnapshot(storageEngine, historyStore, args) {
                 }
                 tracked.lastModifiedAt = fs.statSync(tracked.path).mtime.toISOString();
                 if (tracked.sections && tracked.sections.length > 0) {
+                    let hasLostAnchors = false;
                     const refreshedSections = tracked.sections.map((section) => {
                         const result = relocateAndRefreshSection(tracked.path, section);
+                        if (!result.found)
+                            hasLostAnchors = true;
                         return result.found ? result.refreshed : section;
                     });
                     tracked.sections = refreshedSections;
+                    if (hasLostAnchors) {
+                        anchorsLost.push(tracked.path);
+                    }
+                    else {
+                        refreshed.push(tracked.path);
+                    }
                 }
                 else {
                     tracked.contentHash = computeFileHash(tracked.path);
+                    refreshed.push(tracked.path);
                 }
-                refreshed.push(tracked.path);
             }
             await storageEngine.saveDoc(doc, resolvedProject);
             historyStore.record(resolvedProject, doc, "snapshot");
-            let section = `**${doc.title}** [${docPath}]: refreshed ${refreshed.length}, missing ${missing.length}, skipped ${skipped.length}`;
+            let section = `**${doc.title}** [${docPath}]: refreshed ${refreshed.length}, anchors lost ${anchorsLost.length}, missing ${missing.length}, skipped ${skipped.length}`;
             if (refreshed.length > 0)
                 section += `\n${refreshed.map((f) => `  ✓ ${f}`).join("\n")}`;
             if (missing.length > 0)
-                section += `\n${missing.map((f) => `  ✗ ${f}`).join("\n")}`;
+                section += `\n${missing.map((f) => `  ✗ missing: ${f}`).join("\n")}`;
+            if (anchorsLost.length > 0) {
+                section += `\n${anchorsLost.map((f) => `  ⚠ anchors lost: ${f}`).join("\n")}`;
+                section += `\n  → refresh_file_snapshot cannot fix this. The tracked section(s) could not be located in the current file content.`;
+                section += `\n  → Required action: call update_doc with the new line numbers to re-establish section tracking.`;
+            }
             docSections.push(section);
         }
         return { content: [{ type: "text", text: docSections.join("\n\n") }] };

package/dist/src/version.d.ts

@@ -1 +1 @@
-export declare const APP_VERSION = "1.0.35";
+export declare const APP_VERSION = "1.0.37";

package/dist/src/version.js

@@ -1,2 +1,2 @@
 // Auto-generated version file - do not edit manually
-export const APP_VERSION = '1.0.35';
+export const APP_VERSION = '1.0.37';