@imenam/mcp-documentor 1.0.38 → 1.0.41

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

@@ -164,6 +164,25 @@ export declare const RestoreDocVersionArgsSchema: z.ZodObject<{
     version: z.ZodNumber;
     project: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+export declare const ExportBundleSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    zipFilename: z.ZodString;
+    docs: z.ZodArray<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type ExportBundle = z.infer<typeof ExportBundleSchema>;
+export declare const PrepareExportBundleArgsSchema: z.ZodObject<{
+    name: z.ZodString;
+    zip_filename: z.ZodString;
+    docs: z.ZodArray<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const DeleteExportBundleArgsSchema: z.ZodObject<{
+    id: 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

@@ -109,6 +109,24 @@ export const RestoreDocVersionArgsSchema = z.object({
     version: z.number().int().positive(),
     project: z.string().optional(),
 });
+export const ExportBundleSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    zipFilename: z.string(),
+    docs: z.array(z.string()),
+    description: z.string().optional(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});
+export const PrepareExportBundleArgsSchema = z.object({
+    name: z.string().describe("Bundle name (becomes the identifier via slugify)"),
+    zip_filename: z.string().describe("ZIP filename to download, e.g. 'my-bundle.zip'"),
+    docs: z.array(z.string()).min(1).describe("Doc references: 'project:doc-id' or 'doc-id' for current project"),
+    description: z.string().optional().describe("Short description of the bundle"),
+});
+export const DeleteExportBundleArgsSchema = z.object({
+    id: z.string().describe("Bundle identifier to delete (slug)"),
+});
 export const IPCMessageSchema = z.object({
     type: z.string(),
     correlationId: z.string().optional(),

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

@@ -1,4 +1,4 @@
-import type { DocEntry, DocSummary } from "../../shared/schemas/doc.schema.js";
+import type { DocEntry, DocSummary, ExportBundle } from "../../shared/schemas/doc.schema.js";
 import type { HistoryStore } from "./history-store.js";
 interface GlobalConfig {
     currentProject: string;
@@ -28,6 +28,8 @@ export declare class StorageEngine {
     } | null>;
     deleteDoc(id: string, project?: string): Promise<boolean>;
     moveDoc(oldId: string, newId: string, project?: string): Promise<boolean>;
+    getBundles(): ExportBundle[];
+    saveBundles(bundles: ExportBundle[]): void;
     rewriteLinks(oldId: string, newId: string, project?: string): Promise<string[]>;
 }
 export {};

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

@@ -206,17 +206,37 @@ export class StorageEngine {
         logger.info(`Doc moved: ${oldFilePath} → ${newFilePath}`);
         return true;
     }
+    getBundles() {
+        const p = path.join(this.getDataDir(), "export-bundles.json");
+        if (!fs.existsSync(p))
+            return [];
+        try {
+            return JSON.parse(fs.readFileSync(p, "utf-8"));
+        }
+        catch {
+            return [];
+        }
+    }
+    saveBundles(bundles) {
+        const p = path.join(this.getDataDir(), "export-bundles.json");
+        fs.writeFileSync(p, JSON.stringify(bundles, null, 2), "utf-8");
+    }
     async rewriteLinks(oldId, newId, project) {
-        const docs = await this.listDocs(project);
+        const config = this.getConfig();
+        const proj = project ?? config.currentProject;
         const updated = [];
-        for (const summary of docs) {
+        // Within the same project: rewrite same-project refs and explicit self-cross-project refs
+        const sameProjDocs = await this.listDocs(proj);
+        for (const summary of sameProjDocs) {
             if (summary.id === newId)
                 continue;
-            const doc = await this.getDoc(summary.id, project);
+            const doc = await this.getDoc(summary.id, proj);
             if (!doc)
                 continue;
             let changed = false;
-            const newContent = doc.content.replace(new RegExp(`doc://${escapeRegex(oldId)}`, "g"), `doc://${newId}`);
+            let newContent = doc.content.replace(new RegExp(`doc://${escapeRegex(oldId)}`, "g"), `doc://${newId}`);
+            // Also rewrite explicit self cross-project refs (doc://proj:oldId → doc://proj:newId)
+            newContent = newContent.replace(new RegExp(`doc://${escapeRegex(proj)}:${escapeRegex(oldId)}`, "g"), `doc://${proj}:${newId}`);
             if (newContent !== doc.content) {
                 doc.content = newContent;
                 changed = true;
@@ -226,15 +246,49 @@ export class StorageEngine {
                     changed = true;
                     return newId;
                 }
+                if (ref === `${proj}:${oldId}`) {
+                    changed = true;
+                    return `${proj}:${newId}`;
+                }
                 return ref;
             });
             doc.related_docs = newRelated;
             if (changed) {
                 doc.updatedAt = new Date().toISOString();
-                await this.saveDoc(doc, project);
+                await this.saveDoc(doc, proj);
                 updated.push(summary.id);
             }
         }
+        // In other projects: rewrite cross-project refs pointing to this project
+        for (const otherProj of config.projects) {
+            if (otherProj === proj)
+                continue;
+            const otherDocs = await this.listDocs(otherProj);
+            for (const summary of otherDocs) {
+                const doc = await this.getDoc(summary.id, otherProj);
+                if (!doc)
+                    continue;
+                let changed = false;
+                const newContent = doc.content.replace(new RegExp(`doc://${escapeRegex(proj)}:${escapeRegex(oldId)}`, "g"), `doc://${proj}:${newId}`);
+                if (newContent !== doc.content) {
+                    doc.content = newContent;
+                    changed = true;
+                }
+                const newRelated = doc.related_docs.map((ref) => {
+                    if (ref === `${proj}:${oldId}`) {
+                        changed = true;
+                        return `${proj}:${newId}`;
+                    }
+                    return ref;
+                });
+                doc.related_docs = newRelated;
+                if (changed) {
+                    doc.updatedAt = new Date().toISOString();
+                    await this.saveDoc(doc, otherProj);
+                    updated.push(`${otherProj}:${summary.id}`);
+                }
+            }
+        }
         return updated;
     }
 }

package/dist/src/gui-worker.js

@@ -8,6 +8,8 @@ import path from "path";
 import fs from "fs";
 import { fileURLToPath } from "url";
 import { createLogger, setupLogging } from "@imenam/mcp-gui-interface";
+import matter from "gray-matter";
+import JSZip from "jszip";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 function findProjectRoot(startDir) {
     let current = startDir;
@@ -20,6 +22,7 @@ function findProjectRoot(startDir) {
     return startDir;
 }
 const rootDir = findProjectRoot(__dirname);
+const dataDir = process.env.MCP_DATA_DIR?.trim() || path.join(rootDir, ".docs-data");
 const staticRoot = path.join(rootDir, "gui/dist");
 const absoluteStaticRoot = path.resolve(staticRoot);
 setupLogging({ processLabel: "mcp-documentor:GUI", logDir: path.join(rootDir, ".docs-data", "logs") });
@@ -116,7 +119,7 @@ function setupIpcErrorHandlers() {
             });
             return;
         }
-        if (msg && (msg.type === "INITIAL_STATE" || msg.type === "CONFIG_UPDATED")) {
+        if (msg && (msg.type === "INITIAL_STATE" || msg.type === "CONFIG_UPDATED" || msg.type === "BUNDLES_UPDATED")) {
             for (const controller of sseControllers) {
                 try {
                     controller.writeSSE({ data: JSON.stringify(msg), event: "message" });
@@ -246,6 +249,13 @@ app.get("/api/projects", async (c) => {
         return c.json({ error: result.error }, 500);
     return c.json(result.data);
 });
+app.get("/api/folders", async (c) => {
+    const project = c.req.query("project");
+    const result = await ipcRequest("LIST_FOLDERS", project ? { project } : {});
+    if (result.error)
+        return c.json({ error: result.error }, 500);
+    return c.json(result.data);
+});
 app.put("/api/project", async (c) => {
     const { project } = await c.req.json();
     if (!project)
@@ -261,6 +271,27 @@ app.get("/api/docs", async (c) => {
         return c.json({ error: result.error }, 500);
     return c.json(result.data);
 });
+app.post("/api/doc", async (c) => {
+    try {
+        const body = await c.req.json();
+        if (!body.title || !body.content) {
+            return c.json({ error: "title and content are required" }, 400);
+        }
+        const result = await ipcRequest("CREATE_DOC", {
+            title: body.title,
+            content: body.content,
+            folder: body.folder,
+            tags: body.tags,
+            project: body.project,
+        }, 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/doc/*", async (c) => {
     const id = decodeURIComponent(c.req.path.slice("/api/doc/".length));
     const result = await ipcRequest("GET_DOC", { id });
@@ -324,6 +355,77 @@ app.post("/api/search", async (c) => {
         return c.json({ error: result.error }, 500);
     return c.json(result.data);
 });
+// Export bundles
+app.get("/api/export-bundles", (c) => {
+    const bundlesPath = path.join(dataDir, "export-bundles.json");
+    if (!fs.existsSync(bundlesPath))
+        return c.json([]);
+    try {
+        return c.json(JSON.parse(fs.readFileSync(bundlesPath, "utf-8")));
+    }
+    catch {
+        return c.json([]);
+    }
+});
+app.get("/api/export-zip/:id", async (c) => {
+    const id = c.req.param("id");
+    const bundlesPath = path.join(dataDir, "export-bundles.json");
+    let bundles = [];
+    try {
+        if (fs.existsSync(bundlesPath))
+            bundles = JSON.parse(fs.readFileSync(bundlesPath, "utf-8"));
+    }
+    catch {
+        return c.json({ error: "Failed to read bundles" }, 500);
+    }
+    const bundle = bundles.find((b) => b.id === id);
+    if (!bundle)
+        return c.json({ error: "Bundle not found" }, 404);
+    let currentProject = "default";
+    try {
+        const configPath = path.join(dataDir, "config.json");
+        if (fs.existsSync(configPath)) {
+            currentProject = JSON.parse(fs.readFileSync(configPath, "utf-8")).currentProject ?? "default";
+        }
+    }
+    catch { /* use default */ }
+    const zip = new JSZip();
+    for (const ref of bundle.docs) {
+        let project;
+        let docId;
+        if (ref.includes(":")) {
+            const colonIdx = ref.indexOf(":");
+            project = ref.slice(0, colonIdx);
+            docId = ref.slice(colonIdx + 1);
+        }
+        else {
+            project = currentProject;
+            docId = ref;
+        }
+        const docFilePath = path.join(dataDir, "projects", project, ...docId.split("/")) + ".md";
+        let content;
+        if (!fs.existsSync(docFilePath)) {
+            content = `# [Doc not found: ${ref}]\n`;
+        }
+        else {
+            try {
+                content = matter(fs.readFileSync(docFilePath, "utf-8")).content.trim();
+            }
+            catch {
+                content = `# [Read error: ${ref}]\n`;
+            }
+        }
+        zip.file(`${project}/${docId}.md`, content);
+    }
+    const zipBuffer = await zip.generateAsync({ type: "nodebuffer" });
+    return new Response(new Uint8Array(zipBuffer), {
+        status: 200,
+        headers: {
+            "Content-Type": "application/zip",
+            "Content-Disposition": `attachment; filename="${bundle.zipFilename}"`,
+        },
+    });
+});
 // Static files
 app.use("/assets/*", serveStatic({ root: path.relative(process.cwd(), absoluteStaticRoot) }));
 // SPA Fallback

package/dist/src/index.js

@@ -11,7 +11,7 @@ import { GuiLauncher, createLogger, setupLogging } from "@imenam/mcp-gui-interfa
 import { StorageEngine } from "./core/storage-engine.js";
 import { EmbeddingStore } from "./core/embedding-store.js";
 import { EmbeddingEngine } from "./core/embedding-engine.js";
-import { createDoc } from "./tools/create-doc.js";
+import { createDoc, slugify } from "./tools/create-doc.js";
 import { getDoc } from "./tools/get-doc.js";
 import { listDocs } from "./tools/list-docs.js";
 import { updateDoc } from "./tools/update-doc.js";
@@ -34,6 +34,8 @@ import { listDocVersions } from "./tools/list-doc-versions.js";
 import { getDocVersion } from "./tools/get-doc-version.js";
 import { restoreDocVersion } from "./tools/restore-doc-version.js";
 import { reindexEmbeddings } from "./tools/reindex-embeddings.js";
+import { prepareExportBundle } from "./tools/prepare-export-bundle.js";
+import { deleteExportBundle } from "./tools/delete-export-bundle.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 function findProjectRoot(startDir) {
@@ -126,6 +128,12 @@ function handleIPCMessage(msg) {
     else if (msg.type === "GET_DOC_VERSION") {
         handleGetDocVersionIPC(msg);
     }
+    else if (msg.type === "CREATE_DOC") {
+        handleCreateDocIPC(msg);
+    }
+    else if (msg.type === "LIST_FOLDERS") {
+        handleListFoldersIPC(msg);
+    }
     else if (msg.type === "UPDATE_DOC") {
         handleUpdateDocIPC(msg);
     }
@@ -144,10 +152,11 @@ async function handleGetInitialState(msg) {
                 doc.isStale = report.status === "stale";
             }
         }
+        const bundles = storageEngine.getBundles();
         broadcastToGUI({
             type: "INITIAL_STATE",
             correlationId: msg.correlationId,
-            data: { config, docs, projects: config.projects },
+            data: { config, docs, projects: config.projects, bundles },
             timestamp: new Date().toISOString(),
         });
     }
@@ -257,6 +266,89 @@ async function handleGetDoc(msg) {
         });
     }
 }
+async function handleListFoldersIPC(msg) {
+    try {
+        const project = msg.data?.project;
+        const docs = await storageEngine.listDocs(project);
+        const folders = new Set();
+        for (const doc of docs) {
+            if (doc.folder) {
+                const parts = doc.folder.split("/").filter(Boolean);
+                for (let i = 1; i <= parts.length; i++) {
+                    folders.add(parts.slice(0, i).join("/"));
+                }
+            }
+        }
+        broadcastToGUI({
+            type: "LIST_FOLDERS_RESPONSE",
+            correlationId: msg.correlationId,
+            data: { folders: Array.from(folders).sort() },
+            timestamp: new Date().toISOString(),
+        });
+    }
+    catch (err) {
+        broadcastToGUI({
+            type: "LIST_FOLDERS_RESPONSE",
+            correlationId: msg.correlationId,
+            error: err.message,
+            timestamp: new Date().toISOString(),
+        });
+    }
+}
+async function handleCreateDocIPC(msg) {
+    try {
+        const { title, content, folder, tags, project } = msg.data ?? {};
+        if (!title || !content)
+            throw new Error("title and content are required");
+        const result = await createDoc(storageEngine, embeddingEngine, {
+            title,
+            content,
+            ...(folder && { folder }),
+            ...(tags && { tags }),
+            ...(project && { project }),
+        });
+        if (result.isError) {
+            const text = result.content[0]?.type === "text" ? result.content[0].text : "Create failed";
+            broadcastToGUI({
+                type: "CREATE_DOC_RESPONSE",
+                correlationId: msg.correlationId,
+                error: text,
+                timestamp: new Date().toISOString(),
+            });
+            return;
+        }
+        const slug = slugify(title);
+        const id = folder ? `${folder}/${slug}` : slug;
+        broadcastToGUI({
+            type: "CREATE_DOC_RESPONSE",
+            correlationId: msg.correlationId,
+            data: { success: true, id },
+            timestamp: new Date().toISOString(),
+        });
+        const docs = await storageEngine.listDocs();
+        for (const doc of docs) {
+            const full = await storageEngine.getDoc(doc.id);
+            if (full && full.tracked_files.length > 0) {
+                const report = computeFreshness(full.tracked_files);
+                doc.isStale = report.status === "stale";
+            }
+        }
+        const config = storageEngine.getConfig();
+        broadcastToGUI({
+            type: "INITIAL_STATE",
+            data: { config, docs, projects: config.projects },
+            timestamp: new Date().toISOString(),
+        });
+    }
+    catch (err) {
+        broadcastToGUI({
+            type: "CREATE_DOC_RESPONSE",
+            correlationId: msg.correlationId,
+            error: err.message,
+            timestamp: new Date().toISOString(),
+        });
+    }
+}
 async function handleUpdateDocIPC(msg) {
     try {
         const result = await updateDoc(storageEngine, embeddingEngine, {
@@ -809,6 +901,35 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     required: [],
                 },
             },
+            {
+                name: "prepare_export_bundle",
+                description: "Create or update a named export bundle: a set of documentation references that the user can download as a ZIP from the GUI. The ZIP contains clean markdown content (no frontmatter). Existing bundle with the same name is replaced.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        name: { type: "string", description: "Bundle display name (becomes the identifier via slugify)" },
+                        zip_filename: { type: "string", description: "ZIP filename to download, e.g. 'my-bundle.zip'" },
+                        docs: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Doc references to include: 'project:doc-id' for cross-project, or 'doc-id' for current project",
+                        },
+                        description: { type: "string", description: "Short description of the bundle (optional)" },
+                    },
+                    required: ["name", "zip_filename", "docs"],
+                },
+            },
+            {
+                name: "delete_export_bundle",
+                description: "Delete an export bundle by its identifier (slug).",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        id: { type: "string", description: "Bundle identifier to delete (slug, e.g. 'my-bundle')" },
+                    },
+                    required: ["id"],
+                },
+            },
         ],
     };
 });
@@ -856,6 +977,28 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return await restoreDocVersion(historyStore, storageEngine, embeddingEngine, args);
             case "reindex_embeddings":
                 return await reindexEmbeddings(storageEngine, embeddingEngine, embeddingStore, args);
+            case "prepare_export_bundle": {
+                const result = await prepareExportBundle(storageEngine, args);
+                if (!result.isError) {
+                    broadcastToGUI({
+                        type: "BUNDLES_UPDATED",
+                        data: { bundles: storageEngine.getBundles() },
+                        timestamp: new Date().toISOString(),
+                    });
+                }
+                return result;
+            }
+            case "delete_export_bundle": {
+                const result = await deleteExportBundle(storageEngine, args);
+                if (!result.isError) {
+                    broadcastToGUI({
+                        type: "BUNDLES_UPDATED",
+                        data: { bundles: storageEngine.getBundles() },
+                        timestamp: new Date().toISOString(),
+                    });
+                }
+                return result;
+            }
             default:
                 throw new Error(`Tool not found: ${name}`);
         }

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

@@ -28,13 +28,31 @@ function extractDocLinks(content) {
     }
     return ids;
 }
+function parseCrossProjectRef(ref) {
+    const colonIdx = ref.indexOf(":");
+    if (colonIdx === -1)
+        return null;
+    return { project: ref.slice(0, colonIdx), docId: ref.slice(colonIdx + 1) };
+}
 export async function checkLinks(storageEngine, args) {
     try {
         const validated = CheckLinksArgsSchema.parse(args);
         const config = storageEngine.getConfig();
         const project = validated.project ?? config.currentProject;
+        const knownProjects = new Set(config.projects);
         const docs = await storageEngine.listDocs(project);
         const validIds = new Set(docs.map((d) => d.id));
+        // Cache of validIds per project to avoid re-fetching
+        const projectValidIds = new Map();
+        projectValidIds.set(project, validIds);
+        async function getValidIdsForProject(proj) {
+            if (projectValidIds.has(proj))
+                return projectValidIds.get(proj);
+            const projDocs = await storageEngine.listDocs(proj);
+            const ids = new Set(projDocs.map((d) => d.id));
+            projectValidIds.set(proj, ids);
+            return ids;
+        }
         const brokenRefs = [];
         const brokenDocLinks = [];
         const brokenAnchors = [];
@@ -43,13 +61,37 @@ export async function checkLinks(storageEngine, args) {
             if (!doc)
                 continue;
             for (const ref of doc.related_docs ?? []) {
-                if (!validIds.has(ref)) {
-                    brokenRefs.push({ sourceId: summary.id, brokenId: ref });
+                const cross = parseCrossProjectRef(ref);
+                if (cross) {
+                    if (!knownProjects.has(cross.project)) {
+                        brokenRefs.push({ sourceId: summary.id, brokenId: ref, reason: `project "${cross.project}" not found` });
+                    }
+                    else {
+                        const targetIds = await getValidIdsForProject(cross.project);
+                        if (!targetIds.has(cross.docId)) {
+                            brokenRefs.push({ sourceId: summary.id, brokenId: ref, reason: `doc "${cross.docId}" not found in project "${cross.project}"` });
+                        }
+                    }
+                }
+                else if (!validIds.has(ref)) {
+                    brokenRefs.push({ sourceId: summary.id, brokenId: ref, reason: "doc not found" });
                 }
             }
             for (const targetId of extractDocLinks(doc.content)) {
-                if (!validIds.has(targetId)) {
-                    brokenDocLinks.push({ sourceId: summary.id, targetId });
+                const cross = parseCrossProjectRef(targetId);
+                if (cross) {
+                    if (!knownProjects.has(cross.project)) {
+                        brokenDocLinks.push({ sourceId: summary.id, targetId, reason: `project "${cross.project}" not found` });
+                    }
+                    else {
+                        const targetIds = await getValidIdsForProject(cross.project);
+                        if (!targetIds.has(cross.docId)) {
+                            brokenDocLinks.push({ sourceId: summary.id, targetId, reason: `doc "${cross.docId}" not found in project "${cross.project}"` });
+                        }
+                    }
+                }
+                else if (!validIds.has(targetId)) {
+                    brokenDocLinks.push({ sourceId: summary.id, targetId, reason: "doc not found" });
                 }
             }
             const anchorLinks = extractAnchorLinks(doc.content);
@@ -75,10 +117,10 @@ export async function checkLinks(storageEngine, args) {
         }
         const lines = [];
         for (const b of brokenRefs) {
-            lines.push(`  [related_doc] ${b.sourceId} → ${b.brokenId} (doc not found)`);
+            lines.push(`  [related_doc] ${b.sourceId} → ${b.brokenId} (${b.reason})`);
         }
         for (const b of brokenDocLinks) {
-            lines.push(`  [doc://]      ${b.sourceId} → doc://${b.targetId} (doc not found)`);
+            lines.push(`  [doc://]      ${b.sourceId} → doc://${b.targetId} (${b.reason})`);
         }
         for (const b of brokenAnchors) {
             lines.push(`  [anchor]      ${b.sourceId} → #${b.anchor} (heading not found)`);

package/dist/src/tools/create-doc.d.ts

@@ -1,5 +1,6 @@
 import type { StorageEngine } from "../core/storage-engine.js";
 import type { EmbeddingEngine } from "../core/embedding-engine.js";
+export declare function slugify(title: string): string;
 export declare function createDoc(storageEngine: StorageEngine, embeddingEngine: EmbeddingEngine, args: unknown): Promise<{
     isError: boolean;
     content: {

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

@@ -3,7 +3,7 @@ import path from "path";
 import { CreateDocArgsSchema } from "../../shared/schemas/doc.schema.js";
 import { computeFileHash } from "./check-freshness.js";
 import { snapshotSection } from "../core/section-tracker.js";
-function slugify(title) {
+export function slugify(title) {
     return title
         .normalize("NFD")
         .replace(/[\u0300-\u036f]/g, "")

package/dist/src/tools/delete-export-bundle.d.ts

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

package/dist/src/tools/delete-export-bundle.js

@@ -0,0 +1,24 @@
+import { DeleteExportBundleArgsSchema } from "../../shared/schemas/doc.schema.js";
+export async function deleteExportBundle(storageEngine, args) {
+    try {
+        const validated = DeleteExportBundleArgsSchema.parse(args);
+        const bundles = storageEngine.getBundles();
+        const index = bundles.findIndex((b) => b.id === validated.id);
+        if (index < 0) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Bundle with id "${validated.id}" not found.` }],
+            };
+        }
+        const removed = bundles[index];
+        bundles.splice(index, 1);
+        storageEngine.saveBundles(bundles);
+        return {
+            content: [{ type: "text", text: `Export bundle "${removed.name}" (id: "${removed.id}") deleted.` }],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { isError: true, content: [{ type: "text", text: `Error deleting export bundle: ${message}` }] };
+    }
+}

package/dist/src/tools/prepare-export-bundle.d.ts

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