@imenam/mcp-documentor 1.0.28 → 1.0.29

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

@@ -103,6 +103,20 @@ export declare const GitDiffDocArgsSchema: z.ZodObject<{
 export declare const SetProjectArgsSchema: z.ZodObject<{
     project: z.ZodString;
 }, z.core.$strip>;
+export declare const ListDocVersionsArgsSchema: z.ZodObject<{
+    path: z.ZodString;
+    project: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const GetDocVersionArgsSchema: z.ZodObject<{
+    path: z.ZodString;
+    version: z.ZodNumber;
+    project: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const RestoreDocVersionArgsSchema: z.ZodObject<{
+    path: z.ZodString;
+    version: z.ZodNumber;
+    project: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 export declare const IPCMessageSchema: z.ZodObject<{
     type: z.ZodString;
     correlationId: z.ZodOptional<z.ZodString>;

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

@@ -75,6 +75,20 @@ export const GitDiffDocArgsSchema = z.object({
 export const SetProjectArgsSchema = z.object({
     project: z.string().describe("Project name to switch to (created if it does not exist)"),
 });
+export const ListDocVersionsArgsSchema = z.object({
+    path: z.string(),
+    project: z.string().optional(),
+});
+export const GetDocVersionArgsSchema = z.object({
+    path: z.string(),
+    version: z.number().int().positive(),
+    project: z.string().optional(),
+});
+export const RestoreDocVersionArgsSchema = z.object({
+    path: z.string(),
+    version: z.number().int().positive(),
+    project: z.string().optional(),
+});
 export const IPCMessageSchema = z.object({
     type: z.string(),
     correlationId: z.string().optional(),

package/dist/src/core/history-store.d.ts

@@ -0,0 +1,25 @@
+import type { DocEntry, TrackedFile } from "../../shared/schemas/doc.schema.js";
+export interface DocHistoryEntry {
+    id: number;
+    project: string;
+    docId: string;
+    version: number;
+    content?: string;
+    metadata: {
+        title: string;
+        tags: string[];
+        tracked_files: TrackedFile[];
+        related_docs: string[];
+    };
+    changedAt: string;
+    changeType: "create" | "update" | "patch" | "delete";
+}
+export declare class HistoryStore {
+    private db;
+    init(dataDir: string): void;
+    private getDb;
+    record(project: string, doc: DocEntry, changeType: "create" | "update" | "patch" | "delete"): void;
+    listVersions(project: string, docId: string): DocHistoryEntry[];
+    getVersion(project: string, docId: string, version: number): DocHistoryEntry | null;
+    deleteForDoc(project: string, docId: string): void;
+}

package/dist/src/core/history-store.js

@@ -0,0 +1,92 @@
+import { createRequire } from "module";
+import path from "path";
+import fs from "fs";
+import { createLogger } from "@imenam/mcp-gui-interface";
+const require = createRequire(import.meta.url);
+const Database = require("better-sqlite3");
+const logger = createLogger("HistoryStore");
+const DB_FILENAME = "history.db";
+export class HistoryStore {
+    db = null;
+    init(dataDir) {
+        if (this.db)
+            return;
+        fs.mkdirSync(dataDir, { recursive: true });
+        this.db = new Database(path.join(dataDir, DB_FILENAME));
+        this.db.pragma("journal_mode = WAL");
+        this.db.pragma("synchronous = NORMAL");
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS doc_history (
+        id          INTEGER PRIMARY KEY AUTOINCREMENT,
+        project     TEXT    NOT NULL,
+        doc_id      TEXT    NOT NULL,
+        version     INTEGER NOT NULL,
+        content     TEXT    NOT NULL,
+        metadata    TEXT    NOT NULL,
+        changed_at  TEXT    NOT NULL,
+        change_type TEXT    NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_doc_history_lookup
+        ON doc_history(project, doc_id, version DESC);
+    `);
+        logger.info("HistoryStore initialized");
+    }
+    getDb() {
+        if (!this.db)
+            throw new Error("HistoryStore not initialized. Call init() first.");
+        return this.db;
+    }
+    record(project, doc, changeType) {
+        const db = this.getDb();
+        const row = db
+            .prepare("SELECT COALESCE(MAX(version), 0) + 1 AS next FROM doc_history WHERE project = ? AND doc_id = ?")
+            .get(project, doc.id);
+        const version = row.next;
+        const metadata = JSON.stringify({
+            title: doc.title,
+            tags: doc.tags,
+            tracked_files: doc.tracked_files,
+            related_docs: doc.related_docs,
+        });
+        db.prepare("INSERT INTO doc_history (project, doc_id, version, content, metadata, changed_at, change_type) VALUES (?, ?, ?, ?, ?, ?, ?)").run(project, doc.id, version, doc.content, metadata, new Date().toISOString(), changeType);
+        logger.debug(`History recorded: [${project}] ${doc.id} v${version} (${changeType})`);
+    }
+    listVersions(project, docId) {
+        const rows = this.getDb()
+            .prepare("SELECT id, project, doc_id, version, metadata, changed_at, change_type FROM doc_history WHERE project = ? AND doc_id = ? ORDER BY version DESC")
+            .all(project, docId);
+        return rows.map((r) => ({
+            id: r.id,
+            project: r.project,
+            docId: r.doc_id,
+            version: r.version,
+            metadata: JSON.parse(r.metadata),
+            changedAt: r.changed_at,
+            changeType: r.change_type,
+        }));
+    }
+    getVersion(project, docId, version) {
+        const row = this.getDb()
+            .prepare("SELECT id, project, doc_id, version, content, metadata, changed_at, change_type FROM doc_history WHERE project = ? AND doc_id = ? AND version = ?")
+            .get(project, docId, version);
+        if (!row)
+            return null;
+        return {
+            id: row.id,
+            project: row.project,
+            docId: row.doc_id,
+            version: row.version,
+            content: row.content,
+            metadata: JSON.parse(row.metadata),
+            changedAt: row.changed_at,
+            changeType: row.change_type,
+        };
+    }
+    deleteForDoc(project, docId) {
+        this.getDb()
+            .prepare("DELETE FROM doc_history WHERE project = ? AND doc_id = ?")
+            .run(project, docId);
+        logger.debug(`History deleted for: [${project}] ${docId}`);
+    }
+}

package/dist/src/core/storage-engine.d.ts

@@ -1,4 +1,5 @@
 import type { DocEntry, DocSummary } from "../../shared/schemas/doc.schema.js";
+import type { HistoryStore } from "./history-store.js";
 interface GlobalConfig {
     currentProject: string;
     projects: string[];
@@ -6,7 +7,9 @@ interface GlobalConfig {
 }
 export declare class StorageEngine {
     private rootDir;
+    private historyStore?;
     constructor(rootDir: string);
+    setHistoryStore(store: HistoryStore): void;
     getDataDir(): string;
     getProjectDir(project?: string): string;
     private getConfigPath;
@@ -16,7 +19,7 @@ export declare class StorageEngine {
     private walkMdFiles;
     private docIdToFilePath;
     private cleanEmptyDirs;
-    saveDoc(doc: DocEntry, project?: string): Promise<void>;
+    saveDoc(doc: DocEntry, project?: string, changeType?: "create" | "update" | "patch"): Promise<void>;
     getDoc(id: string, project?: string): Promise<DocEntry | null>;
     listDocs(project?: string): Promise<DocSummary[]>;
     resolveDoc(id: string): Promise<{

package/dist/src/core/storage-engine.js

@@ -8,9 +8,13 @@ function escapeRegex(s) {
 }
 export class StorageEngine {
     rootDir;
+    historyStore;
     constructor(rootDir) {
         this.rootDir = rootDir;
     }
+    setHistoryStore(store) {
+        this.historyStore = store;
+    }
     getDataDir() {
         const envDir = process.env.MCP_DATA_DIR;
         return envDir && envDir.trim() !== "" ? envDir : path.join(this.rootDir, ".docs-data");
@@ -82,7 +86,9 @@ export class StorageEngine {
             // ignore — dir may have been removed already
         }
     }
-    async saveDoc(doc, project) {
+    async saveDoc(doc, project, changeType = "update") {
+        const config = this.getConfig();
+        const proj = project ?? config.currentProject;
         const projectDir = this.getProjectDir(project);
         const targetPath = this.docIdToFilePath(doc.id, projectDir);
         fs.mkdirSync(path.dirname(targetPath), { recursive: true });
@@ -97,6 +103,7 @@ export class StorageEngine {
         const output = matter.stringify(doc.content, frontmatter);
         fs.writeFileSync(targetPath, output, "utf-8");
         logger.debug(`Doc saved: ${targetPath}`);
+        this.historyStore?.record(proj, doc, changeType);
     }
     async getDoc(id, project) {
         const projectDir = this.getProjectDir(project);
@@ -159,10 +166,18 @@ export class StorageEngine {
         return null;
     }
     async deleteDoc(id, project) {
+        const config = this.getConfig();
+        const proj = project ?? config.currentProject;
         const projectDir = this.getProjectDir(project);
         const filePath = this.docIdToFilePath(id, projectDir);
         if (!fs.existsSync(filePath))
             return false;
+        if (this.historyStore) {
+            const doc = await this.getDoc(id, project);
+            if (doc) {
+                this.historyStore.record(proj, doc, "delete");
+            }
+        }
         fs.unlinkSync(filePath);
         this.cleanEmptyDirs(path.dirname(filePath), projectDir);
         logger.info(`Doc deleted: ${filePath}`);
@@ -185,7 +200,7 @@ export class StorageEngine {
         doc.folder = newParts.length > 1 ? newParts.slice(0, -1).join("/") : undefined;
         doc.updatedAt = new Date().toISOString();
         fs.mkdirSync(path.dirname(newFilePath), { recursive: true });
-        await this.saveDoc(doc, project);
+        await this.saveDoc(doc, project, "update");
         fs.unlinkSync(oldFilePath);
         this.cleanEmptyDirs(path.dirname(oldFilePath), projectDir);
         logger.info(`Doc moved: ${oldFilePath} → ${newFilePath}`);

package/dist/src/gui-worker.js

@@ -282,6 +282,23 @@ app.get("/api/git-diff/*", async (c) => {
         return c.json({ error: result.error }, 400);
     return c.json(result.data);
 });
+app.get("/api/history/*", async (c) => {
+    const id = decodeURIComponent(c.req.path.slice("/api/history/".length));
+    const result = await ipcRequest("GET_DOC_HISTORY", { id });
+    if (result.error)
+        return c.json({ error: result.error }, 400);
+    return c.json(result.data);
+});
+app.get("/api/history-version/*", async (c) => {
+    const rest = decodeURIComponent(c.req.path.slice("/api/history-version/".length));
+    const lastSlash = rest.lastIndexOf("/");
+    const id = rest.slice(0, lastSlash);
+    const version = parseInt(rest.slice(lastSlash + 1), 10);
+    const result = await ipcRequest("GET_DOC_VERSION", { id, version });
+    if (result.error)
+        return c.json({ error: result.error }, 400);
+    return c.json(result.data);
+});
 app.post("/api/search", async (c) => {
     const { query, top_k, all_projects } = await c.req.json();
     if (!query)

package/dist/src/index.js

@@ -29,6 +29,10 @@ import { moveDoc } from "./tools/move-doc.js";
 import { getDocTree } from "./tools/get-doc-tree.js";
 import { migrateFolders } from "./core/migrate-folders.js";
 import { migrateEmbeddings } from "./core/migrate-embeddings.js";
+import { HistoryStore } from "./core/history-store.js";
+import { listDocVersions } from "./tools/list-doc-versions.js";
+import { getDocVersion } from "./tools/get-doc-version.js";
+import { restoreDocVersion } from "./tools/restore-doc-version.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 function findProjectRoot(startDir) {
@@ -61,6 +65,9 @@ const embeddingEngine = new EmbeddingEngine(embeddingStore);
 storageEngine.ensureProject(storageEngine.getConfig().currentProject);
 const openaiModel = process.env.MCP_DOCUMENTOR_OPENAI_MODEL || "text-embedding-3-small";
 embeddingStore.init(storageEngine.getDataDir(), openaiModel);
+const historyStore = new HistoryStore();
+historyStore.init(storageEngine.getDataDir());
+storageEngine.setHistoryStore(historyStore);
 const server = new Server({ name: "mcp-documentor", version: APP_VERSION }, { capabilities: { tools: {} } });
 let guiLauncher;
 const sseControllers = new Set();
@@ -112,6 +119,12 @@ function handleIPCMessage(msg) {
     else if (msg.type === "GIT_DIFF") {
         handleGitDiff(msg);
     }
+    else if (msg.type === "GET_DOC_HISTORY") {
+        handleGetDocHistory(msg);
+    }
+    else if (msg.type === "GET_DOC_VERSION") {
+        handleGetDocVersionIPC(msg);
+    }
     else {
         logger.debug(`Unhandled message from GUI: ${msg.type}`);
     }
@@ -361,6 +374,52 @@ async function handleUpdateConfig(msg) {
         });
     }
 }
+async function handleGetDocHistory(msg) {
+    try {
+        const id = msg.data?.id ?? msg.data?.path;
+        const config = storageEngine.getConfig();
+        const project = msg.data?.project ?? config.currentProject;
+        const versions = historyStore.listVersions(project, id);
+        broadcastToGUI({
+            type: "GET_DOC_HISTORY_RESPONSE",
+            correlationId: msg.correlationId,
+            data: { versions },
+            timestamp: new Date().toISOString(),
+        });
+    }
+    catch (err) {
+        broadcastToGUI({
+            type: "GET_DOC_HISTORY_RESPONSE",
+            correlationId: msg.correlationId,
+            error: err.message,
+            timestamp: new Date().toISOString(),
+        });
+    }
+}
+async function handleGetDocVersionIPC(msg) {
+    try {
+        const id = msg.data?.id ?? msg.data?.path;
+        const version = msg.data?.version;
+        const config = storageEngine.getConfig();
+        const project = msg.data?.project ?? config.currentProject;
+        const entry = historyStore.getVersion(project, id, version);
+        broadcastToGUI({
+            type: "GET_DOC_VERSION_RESPONSE",
+            correlationId: msg.correlationId,
+            data: entry ?? null,
+            error: entry ? undefined : "Version not found",
+            timestamp: new Date().toISOString(),
+        });
+    }
+    catch (err) {
+        broadcastToGUI({
+            type: "GET_DOC_VERSION_RESPONSE",
+            correlationId: msg.correlationId,
+            error: err.message,
+            timestamp: new Date().toISOString(),
+        });
+    }
+}
 guiLauncher = new GuiLauncher({
     guiPath: path.join(__dirname, "gui-worker.js"),
     env: { ...process.env },
@@ -612,6 +671,44 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     },
                 },
             },
+            {
+                name: "list_doc_versions",
+                description: "List all saved versions of a documentation entry, with date and change type.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: { type: "string", description: "Path of the documentation entry, e.g. 'backend/auth/authentication'" },
+                        project: { type: "string", description: "Project to look in (defaults to current project)" },
+                    },
+                    required: ["path"],
+                },
+            },
+            {
+                name: "get_doc_version",
+                description: "Retrieve the full content of a specific version of a documentation entry.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: { type: "string", description: "Path of the documentation entry, e.g. 'backend/auth/authentication'" },
+                        version: { type: "number", description: "Version number to retrieve" },
+                        project: { type: "string", description: "Project to look in (defaults to current project)" },
+                    },
+                    required: ["path", "version"],
+                },
+            },
+            {
+                name: "restore_doc_version",
+                description: "Restore a documentation entry to a previous version. The current state is saved as a new version before overwriting.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: { type: "string", description: "Path of the documentation entry, e.g. 'backend/auth/authentication'" },
+                        version: { type: "number", description: "Version number to restore" },
+                        project: { type: "string", description: "Project to look in (defaults to current project)" },
+                    },
+                    required: ["path", "version"],
+                },
+            },
         ],
     };
 });
@@ -651,6 +748,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return await moveDoc(storageEngine, embeddingEngine, args);
             case "get_doc_tree":
                 return await getDocTree(storageEngine, args);
+            case "list_doc_versions":
+                return await listDocVersions(historyStore, storageEngine, args);
+            case "get_doc_version":
+                return await getDocVersion(historyStore, storageEngine, args);
+            case "restore_doc_version":
+                return await restoreDocVersion(historyStore, storageEngine, embeddingEngine, args);
             default:
                 throw new Error(`Tool not found: ${name}`);
         }

package/dist/src/tools/create-doc.js

@@ -55,7 +55,7 @@ export async function createDoc(storageEngine, embeddingEngine, args) {
             updatedAt: now,
         };
         const resolvedProject = project ?? storageEngine.getConfig().currentProject;
-        await storageEngine.saveDoc(doc, resolvedProject);
+        await storageEngine.saveDoc(doc, resolvedProject, "create");
         if (embeddingEngine.isConfigured()) {
             const embedding = await embeddingEngine.generateEmbedding(validated.content);
             if (embedding) {

package/dist/src/tools/get-doc-version.d.ts

@@ -0,0 +1,15 @@
+import type { HistoryStore } from "../core/history-store.js";
+import type { StorageEngine } from "../core/storage-engine.js";
+export declare function getDocVersion(historyStore: HistoryStore, storageEngine: StorageEngine, args: unknown): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: string;
+    }[];
+} | {
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError?: undefined;
+}>;

package/dist/src/tools/get-doc-version.js

@@ -0,0 +1,45 @@
+import { GetDocVersionArgsSchema } from "../../shared/schemas/doc.schema.js";
+export async function getDocVersion(historyStore, storageEngine, args) {
+    try {
+        const validated = GetDocVersionArgsSchema.parse(args);
+        const config = storageEngine.getConfig();
+        const project = validated.project ?? config.currentProject;
+        const entry = historyStore.getVersion(project, validated.path, validated.version);
+        if (!entry) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: "text",
+                        text: `Version ${validated.version} of "${validated.path}" not found in project "${project}".`,
+                    },
+                ],
+            };
+        }
+        const date = new Date(entry.changedAt).toLocaleString();
+        const meta = entry.metadata;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: [
+                        `# ${meta.title} (v${entry.version})`,
+                        `**Date:** ${date}`,
+                        `**Change type:** ${entry.changeType}`,
+                        `**Tags:** ${meta.tags.join(", ") || "none"}`,
+                        `**Related docs:** ${meta.related_docs.join(", ") || "none"}`,
+                        `**Tracked files:** ${meta.tracked_files.map((f) => f.path).join(", ") || "none"}`,
+                        "",
+                        "---",
+                        "",
+                        entry.content,
+                    ].join("\n"),
+                },
+            ],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { isError: true, content: [{ type: "text", text: `Error getting version: ${message}` }] };
+    }
+}

package/dist/src/tools/list-doc-versions.d.ts

@@ -0,0 +1,15 @@
+import type { HistoryStore } from "../core/history-store.js";
+import type { StorageEngine } from "../core/storage-engine.js";
+export declare function listDocVersions(historyStore: HistoryStore, storageEngine: StorageEngine, args: unknown): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError?: undefined;
+} | {
+    isError: boolean;
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/src/tools/list-doc-versions.js

@@ -0,0 +1,35 @@
+import { ListDocVersionsArgsSchema } from "../../shared/schemas/doc.schema.js";
+export async function listDocVersions(historyStore, storageEngine, args) {
+    try {
+        const validated = ListDocVersionsArgsSchema.parse(args);
+        const config = storageEngine.getConfig();
+        const project = validated.project ?? config.currentProject;
+        const versions = historyStore.listVersions(project, validated.path);
+        if (versions.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No version history found for "${validated.path}" in project "${project}".`,
+                    },
+                ],
+            };
+        }
+        const lines = versions.map((v) => {
+            const date = new Date(v.changedAt).toLocaleString();
+            return `v${v.version} — ${date} — ${v.changeType} — "${v.metadata.title}"`;
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Version history for "${validated.path}" in project "${project}" (${versions.length} version(s)):\n\n${lines.join("\n")}`,
+                },
+            ],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { isError: true, content: [{ type: "text", text: `Error listing versions: ${message}` }] };
+    }
+}

package/dist/src/tools/patch-doc.js

@@ -19,7 +19,7 @@ export async function patchDoc(storageEngine, embeddingEngine, args) {
         }
         doc.content = doc.content.replace(validated.search, validated.replacement);
         doc.updatedAt = new Date().toISOString();
-        await storageEngine.saveDoc(doc, resolvedProject);
+        await storageEngine.saveDoc(doc, resolvedProject, "patch");
         if (embeddingEngine.isConfigured()) {
             const embedding = await embeddingEngine.generateEmbedding(doc.content);
             if (embedding) {

package/dist/src/tools/restore-doc-version.d.ts

@@ -0,0 +1,16 @@
+import type { HistoryStore } from "../core/history-store.js";
+import type { StorageEngine } from "../core/storage-engine.js";
+import type { EmbeddingEngine } from "../core/embedding-engine.js";
+export declare function restoreDocVersion(historyStore: HistoryStore, storageEngine: StorageEngine, embeddingEngine: EmbeddingEngine, args: unknown): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: string;
+    }[];
+} | {
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError?: undefined;
+}>;

package/dist/src/tools/restore-doc-version.js

@@ -0,0 +1,54 @@
+import { RestoreDocVersionArgsSchema } from "../../shared/schemas/doc.schema.js";
+export async function restoreDocVersion(historyStore, storageEngine, embeddingEngine, args) {
+    try {
+        const validated = RestoreDocVersionArgsSchema.parse(args);
+        const config = storageEngine.getConfig();
+        const project = validated.project ?? config.currentProject;
+        const entry = historyStore.getVersion(project, validated.path, validated.version);
+        if (!entry || entry.content === undefined) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: "text",
+                        text: `Version ${validated.version} of "${validated.path}" not found in project "${project}".`,
+                    },
+                ],
+            };
+        }
+        const meta = entry.metadata;
+        const now = new Date().toISOString();
+        const currentDoc = await storageEngine.getDoc(validated.path, project);
+        const doc = {
+            id: validated.path,
+            title: meta.title,
+            content: entry.content,
+            tracked_files: meta.tracked_files,
+            tags: meta.tags,
+            related_docs: meta.related_docs,
+            createdAt: currentDoc?.createdAt ?? now,
+            updatedAt: now,
+        };
+        await storageEngine.saveDoc(doc, project, "update");
+        const newVersions = historyStore.listVersions(project, validated.path);
+        const newVersion = newVersions[0]?.version ?? "?";
+        if (embeddingEngine.isConfigured()) {
+            const embedding = await embeddingEngine.generateEmbedding(doc.content);
+            if (embedding) {
+                await embeddingEngine.saveEmbedding(validated.path, embedding, project);
+            }
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Documentation entry "${validated.path}" restored to version ${validated.version}.\nA new version (v${newVersion}) has been recorded in history.`,
+                },
+            ],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { isError: true, content: [{ type: "text", text: `Error restoring version: ${message}` }] };
+    }
+}

package/dist/src/tools/update-doc.js

@@ -40,7 +40,7 @@ export async function updateDoc(storageEngine, embeddingEngine, args) {
             doc.related_docs = validated.related_docs;
         }
         doc.updatedAt = new Date().toISOString();
-        await storageEngine.saveDoc(doc, resolvedProject);
+        await storageEngine.saveDoc(doc, resolvedProject, "update");
         if (validated.content !== undefined && embeddingEngine.isConfigured()) {
             const embedding = await embeddingEngine.generateEmbedding(validated.content);
             if (embedding) {

package/dist/src/version.d.ts

@@ -1 +1 @@
-export declare const APP_VERSION = "1.0.28";
+export declare const APP_VERSION = "1.0.29";

package/dist/src/version.js

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