@imenam/mcp-documentor 1.0.40 → 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,6 +206,21 @@ 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 config = this.getConfig();
         const proj = project ?? config.currentProject;

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" });
@@ -352,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

@@ -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) {
@@ -150,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(),
         });
     }
@@ -898,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"],
+                },
+            },
         ],
     };
 });
@@ -945,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/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;
+    }[];
+}>;

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

@@ -0,0 +1,40 @@
+import { PrepareExportBundleArgsSchema } from "../../shared/schemas/doc.schema.js";
+import { slugify } from "./create-doc.js";
+export async function prepareExportBundle(storageEngine, args) {
+    try {
+        const validated = PrepareExportBundleArgsSchema.parse(args);
+        const id = slugify(validated.name);
+        const now = new Date().toISOString();
+        const bundles = storageEngine.getBundles();
+        const existingIndex = bundles.findIndex((b) => b.id === id);
+        const bundle = {
+            id,
+            name: validated.name,
+            zipFilename: validated.zip_filename.endsWith(".zip")
+                ? validated.zip_filename
+                : `${validated.zip_filename}.zip`,
+            docs: validated.docs,
+            ...(validated.description && { description: validated.description }),
+            createdAt: existingIndex >= 0 ? bundles[existingIndex].createdAt : now,
+            updatedAt: now,
+        };
+        if (existingIndex >= 0) {
+            bundles[existingIndex] = bundle;
+        }
+        else {
+            bundles.push(bundle);
+        }
+        storageEngine.saveBundles(bundles);
+        const action = existingIndex >= 0 ? "updated" : "created";
+        return {
+            content: [{
+                    type: "text",
+                    text: `Export bundle "${validated.name}" (id: "${id}") ${action} with ${validated.docs.length} doc(s). ZIP filename: "${bundle.zipFilename}".`,
+                }],
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { isError: true, content: [{ type: "text", text: `Error preparing export bundle: ${message}` }] };
+    }
+}

package/dist/src/version.d.ts

@@ -1 +1 @@
-export declare const APP_VERSION = "1.0.40";
+export declare const APP_VERSION = "1.0.41";

package/dist/src/version.js

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