@imenam/mcp-documentor 1.0.23

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

@@ -0,0 +1,191 @@
+import fs from "fs";
+import path from "path";
+import matter from "gray-matter";
+import { createLogger } from "@imenam/mcp-gui-interface";
+const logger = createLogger("StorageEngine");
+export class StorageEngine {
+    rootDir;
+    constructor(rootDir) {
+        this.rootDir = rootDir;
+    }
+    getDataDir() {
+        const envDir = process.env.MCP_DATA_DIR;
+        return envDir && envDir.trim() !== "" ? envDir : path.join(this.rootDir, ".docs-data");
+    }
+    getProjectDir(project) {
+        const config = this.getConfig();
+        const proj = project ?? config.currentProject;
+        return path.join(this.getDataDir(), "projects", proj);
+    }
+    getConfigPath() {
+        return path.join(this.getDataDir(), "config.json");
+    }
+    getConfig() {
+        const configPath = this.getConfigPath();
+        if (fs.existsSync(configPath)) {
+            try {
+                return JSON.parse(fs.readFileSync(configPath, "utf-8"));
+            }
+            catch {
+                logger.warn("Failed to parse config.json, using defaults");
+            }
+        }
+        return { currentProject: "default", projects: ["default"] };
+    }
+    saveConfig(config) {
+        const configPath = this.getConfigPath();
+        fs.mkdirSync(path.dirname(configPath), { recursive: true });
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+    }
+    ensureProject(project) {
+        const projectDir = path.join(this.getDataDir(), "projects", project);
+        fs.mkdirSync(projectDir, { recursive: true });
+        const config = this.getConfig();
+        if (!config.projects.includes(project)) {
+            config.projects.push(project);
+            this.saveConfig(config);
+        }
+        logger.info(`Project "${project}" ensured at ${projectDir}`);
+    }
+    walkMdFiles(dir) {
+        if (!fs.existsSync(dir))
+            return [];
+        const results = [];
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                results.push(...this.walkMdFiles(fullPath));
+            }
+            else if (entry.isFile() && entry.name.endsWith(".md")) {
+                results.push(fullPath);
+            }
+        }
+        return results;
+    }
+    docIdToFilePath(id, projectDir) {
+        const parts = id.split("/");
+        return path.join(projectDir, ...parts.slice(0, -1), parts[parts.length - 1] + ".md");
+    }
+    cleanEmptyDirs(dir, stopAt) {
+        if (dir === stopAt || !dir.startsWith(stopAt))
+            return;
+        try {
+            if (fs.readdirSync(dir).length === 0) {
+                fs.rmdirSync(dir);
+                this.cleanEmptyDirs(path.dirname(dir), stopAt);
+            }
+        }
+        catch {
+            // ignore — dir may have been removed already
+        }
+    }
+    async saveDoc(doc, project) {
+        const projectDir = this.getProjectDir(project);
+        const targetPath = this.docIdToFilePath(doc.id, projectDir);
+        fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+        const frontmatter = {
+            title: doc.title,
+            tracked_files: doc.tracked_files,
+            tags: doc.tags,
+            ...(doc.related_docs?.length && { related_docs: doc.related_docs }),
+            createdAt: doc.createdAt,
+            updatedAt: doc.updatedAt,
+        };
+        const output = matter.stringify(doc.content, frontmatter);
+        fs.writeFileSync(targetPath, output, "utf-8");
+        logger.debug(`Doc saved: ${targetPath}`);
+    }
+    async getDoc(id, project) {
+        const projectDir = this.getProjectDir(project);
+        const filePath = this.docIdToFilePath(id, projectDir);
+        if (!fs.existsSync(filePath))
+            return null;
+        const raw = fs.readFileSync(filePath, "utf-8");
+        const { data, content } = matter(raw);
+        const parts = id.split("/");
+        const folder = parts.length > 1 ? parts.slice(0, -1).join("/") : undefined;
+        return {
+            id,
+            title: data.title ?? "",
+            content: content.trim(),
+            tracked_files: (data.tracked_files ?? []),
+            tags: (data.tags ?? []),
+            folder,
+            related_docs: (data.related_docs ?? []),
+            createdAt: data.createdAt ?? "",
+            updatedAt: data.updatedAt ?? "",
+        };
+    }
+    async listDocs(project) {
+        const projectDir = this.getProjectDir(project);
+        if (!fs.existsSync(projectDir))
+            return [];
+        const files = this.walkMdFiles(projectDir);
+        const summaries = [];
+        for (const filePath of files) {
+            try {
+                const raw = fs.readFileSync(filePath, "utf-8");
+                const { data } = matter(raw);
+                const stat = fs.statSync(filePath);
+                const relPath = path.relative(projectDir, filePath);
+                const id = relPath.replace(/\.md$/, "").split(path.sep).join("/");
+                const folder = id.includes("/") ? id.split("/").slice(0, -1).join("/") : undefined;
+                summaries.push({
+                    id,
+                    title: data.title ?? "",
+                    createdAt: stat.birthtime.toISOString(),
+                    updatedAt: data.updatedAt ?? "",
+                    tags: (data.tags ?? []),
+                    folder,
+                    isStale: false,
+                });
+            }
+            catch (err) {
+                logger.warn(`Failed to read doc ${filePath}: ${err}`);
+            }
+        }
+        return summaries;
+    }
+    async resolveDoc(id) {
+        const config = this.getConfig();
+        for (const project of config.projects) {
+            const doc = await this.getDoc(id, project);
+            if (doc)
+                return { doc, project };
+        }
+        return null;
+    }
+    async deleteDoc(id, project) {
+        const projectDir = this.getProjectDir(project);
+        const filePath = this.docIdToFilePath(id, projectDir);
+        if (!fs.existsSync(filePath))
+            return false;
+        fs.unlinkSync(filePath);
+        this.cleanEmptyDirs(path.dirname(filePath), projectDir);
+        logger.info(`Doc deleted: ${filePath}`);
+        return true;
+    }
+    async moveDoc(oldId, newId, project) {
+        const projectDir = this.getProjectDir(project);
+        const oldFilePath = this.docIdToFilePath(oldId, projectDir);
+        if (!fs.existsSync(oldFilePath))
+            return false;
+        const newFilePath = this.docIdToFilePath(newId, projectDir);
+        if (fs.existsSync(newFilePath)) {
+            throw new Error(`A document already exists at path "${newId}".`);
+        }
+        const doc = await this.getDoc(oldId, project);
+        if (!doc)
+            return false;
+        const newParts = newId.split("/");
+        doc.id = newId;
+        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);
+        fs.unlinkSync(oldFilePath);
+        this.cleanEmptyDirs(path.dirname(oldFilePath), projectDir);
+        logger.info(`Doc moved: ${oldFilePath} → ${newFilePath}`);
+        return true;
+    }
+}

package/dist/src/gui-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/gui-worker.js

@@ -0,0 +1,349 @@
+import { serve } from "@hono/node-server";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+import { ProxyClient } from "@imenam/mcp-gui-interface";
+import { IPCMessageSchema } from "../shared/schemas/doc.schema.js";
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+import { createLogger, setupLogging } from "@imenam/mcp-gui-interface";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+function findProjectRoot(startDir) {
+    let current = startDir;
+    while (current !== path.dirname(current)) {
+        if (fs.existsSync(path.join(current, "gui")) || fs.existsSync(path.join(current, "package.json"))) {
+            return current;
+        }
+        current = path.dirname(current);
+    }
+    return startDir;
+}
+const rootDir = findProjectRoot(__dirname);
+const staticRoot = path.join(rootDir, "gui/dist");
+const absoluteStaticRoot = path.resolve(staticRoot);
+setupLogging({ processLabel: "GUI-WORKER", logDir: path.join(rootDir, ".docs-data", "logs") });
+const logger = createLogger("GUI-WORKER");
+process.on("uncaughtException", (err) => {
+    logger.error(`Uncaught Exception: ${err.message}`);
+    logger.error(err.stack || "No stack trace");
+    process.exit(1);
+});
+process.on("unhandledRejection", (reason) => {
+    logger.error(`Unhandled Rejection: ${reason}`);
+    process.exit(1);
+});
+const parentPid = process.ppid;
+const parentCheckInterval = setInterval(() => {
+    try {
+        process.kill(parentPid, 0);
+    }
+    catch {
+        logger.info(`Parent process (PID ${parentPid}) is gone. Exiting.`);
+        clearInterval(parentCheckInterval);
+        process.exit(0);
+    }
+}, 2000);
+const app = new Hono();
+let proxyClient = null;
+const sseControllers = new Set();
+const pendingRequests = new Map();
+function safeSend(message) {
+    if (process.send && process.connected) {
+        try {
+            return process.send(message);
+        }
+        catch (err) {
+            logger.error(`[IPC] Failed to send message: ${err.message}`);
+            return false;
+        }
+    }
+    return false;
+}
+function ipcRequest(type, data, timeout = 5000) {
+    const correlationId = Math.random().toString(36).substring(7);
+    const message = { type, correlationId, data, timestamp: new Date().toISOString() };
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            if (pendingRequests.has(correlationId)) {
+                pendingRequests.delete(correlationId);
+                resolve({ error: "Request timed out" });
+            }
+        }, timeout);
+        pendingRequests.set(correlationId, {
+            resolve: (msg) => {
+                clearTimeout(timer);
+                resolve(msg);
+            },
+            reject: (err) => {
+                clearTimeout(timer);
+                resolve({ error: err.message });
+            },
+        });
+        const sent = safeSend(message);
+        if (!sent) {
+            clearTimeout(timer);
+            pendingRequests.delete(correlationId);
+            resolve({ error: "IPC not available" });
+        }
+    });
+}
+function setupIpcErrorHandlers() {
+    process.on("error", (err) => {
+        if (err.code === "ERR_IPC_CHANNEL_CLOSED")
+            return;
+        logger.error(`Process error: ${err.message}`);
+    });
+    process.on("disconnect", () => {
+        logger.debug("Disconnected from parent, exiting.");
+        process.exit(0);
+    });
+    process.on("message", (msg) => {
+        if (msg && msg.correlationId && pendingRequests.has(msg.correlationId)) {
+            const { resolve } = pendingRequests.get(msg.correlationId);
+            pendingRequests.delete(msg.correlationId);
+            resolve(msg);
+            return;
+        }
+        if (msg && msg.type === "GET_HEALTH") {
+            const memory = process.memoryUsage();
+            safeSend({
+                type: "HEALTH_RESPONSE",
+                correlationId: msg.correlationId,
+                data: { status: "ok", uptime: process.uptime(), memory: { rss: memory.rss, heapUsed: memory.heapUsed } },
+                timestamp: new Date().toISOString(),
+            });
+            return;
+        }
+        if (msg && (msg.type === "INITIAL_STATE" || msg.type === "CONFIG_UPDATED")) {
+            for (const controller of sseControllers) {
+                try {
+                    controller.writeSSE({ data: JSON.stringify(msg), event: "message" });
+                }
+                catch {
+                    sseControllers.delete(controller);
+                }
+            }
+        }
+    });
+}
+// --- HTTP Routes ---
+app.get("/proxy/health", (c) => {
+    const memory = process.memoryUsage();
+    return c.json({
+        status: "ok",
+        proxy: proxyClient ? proxyClient.getStatus() : process.env.PROXY_URL ? "error" : "standalone",
+        uptime: process.uptime(),
+        memory: { rss: memory.rss, heapUsed: memory.heapUsed },
+        ipc: process.connected ? "connected" : "disconnected",
+        timestamp: new Date().toISOString(),
+    });
+});
+app.get("/api/events", (c) => {
+    return streamSSE(c, async (stream) => {
+        sseControllers.add(stream);
+        stream.onAbort(() => { sseControllers.delete(stream); });
+        safeSend({ type: "GET_INITIAL_STATE", timestamp: new Date().toISOString() });
+        await stream.writeSSE({ data: "connected", event: "ping" });
+        while (true) {
+            await stream.sleep(30000);
+            try {
+                await stream.writeSSE({ data: "ping", event: "ping" });
+            }
+            catch {
+                sseControllers.delete(stream);
+                break;
+            }
+        }
+    });
+});
+app.get("/api/configurations", async (c) => {
+    const configRes = await ipcRequest("GET_CONFIG");
+    if (configRes.error)
+        return c.json([]);
+    const currentDataDir = configRes.data?.dataDir || "";
+    const currentModel = configRes.data?.model || "text-embedding-3-small";
+    return c.json([
+        {
+            key: "MCP_DATA_DIR",
+            label: "Data Directory",
+            type: "text",
+            description: "Répertoire de stockage des documentations",
+            current: currentDataDir,
+        },
+        {
+            key: "MCP_DOCUMENTOR_OPENAI_API_KEY",
+            label: "OpenAI API Key",
+            type: "password",
+            description: "Clé API OpenAI pour la génération d'embeddings",
+            current: "***",
+        },
+        {
+            key: "MCP_DOCUMENTOR_OPENAI_MODEL",
+            label: "Embedding Model",
+            type: "text",
+            description: "Modèle OpenAI pour les embeddings (défaut: text-embedding-3-small)",
+            current: currentModel,
+        },
+    ]);
+});
+app.post("/api/configurations/apply", async (c) => {
+    try {
+        const { key, value } = await c.req.json();
+        if (!key || value === undefined) {
+            return c.json({ success: false, error: "key and value are required" }, 400);
+        }
+        const result = await ipcRequest("UPDATE_CONFIG", { key, value });
+        if (result.error)
+            return c.json({ success: false, error: result.error }, 500);
+        return c.json({ success: true });
+    }
+    catch (err) {
+        return c.json({ success: false, error: err.message }, 500);
+    }
+});
+app.get("/api/config", async (c) => {
+    const result = await ipcRequest("GET_CONFIG");
+    if (result.error)
+        return c.json({ error: result.error }, 500);
+    return c.json(result.data);
+});
+app.get("/api/projects", async (c) => {
+    const result = await ipcRequest("LIST_PROJECTS");
+    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)
+        return c.json({ error: "project is required" }, 400);
+    const result = await ipcRequest("UPDATE_PROJECT", { project });
+    if (result.error)
+        return c.json({ error: result.error }, 500);
+    return c.json(result.data);
+});
+app.get("/api/docs", async (c) => {
+    const result = await ipcRequest("LIST_DOCS");
+    if (result.error)
+        return c.json({ error: result.error }, 500);
+    return c.json(result.data);
+});
+app.get("/api/doc/*", async (c) => {
+    const id = decodeURIComponent(c.req.path.slice("/api/doc/".length));
+    const result = await ipcRequest("GET_DOC", { id });
+    if (result.error)
+        return c.json({ error: result.error }, 400);
+    return c.json(result.data);
+});
+app.get("/api/freshness/*", async (c) => {
+    const id = decodeURIComponent(c.req.path.slice("/api/freshness/".length));
+    const result = await ipcRequest("CHECK_FRESHNESS", { id });
+    if (result.error)
+        return c.json({ error: result.error }, 400);
+    return c.json(result.data);
+});
+app.get("/api/git-diff/*", async (c) => {
+    const id = decodeURIComponent(c.req.path.slice("/api/git-diff/".length));
+    const result = await ipcRequest("GIT_DIFF", { id }, 15000);
+    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)
+        return c.json({ error: "query is required" }, 400);
+    const result = await ipcRequest("SEARCH_DOCS", { query, top_k: top_k || 5, all_projects: !!all_projects });
+    if (result.error)
+        return c.json({ error: result.error }, 500);
+    return c.json(result.data);
+});
+// Static files
+app.use("/assets/*", serveStatic({ root: path.relative(process.cwd(), absoluteStaticRoot) }));
+// SPA Fallback
+app.get("/*", (c, next) => {
+    const urlPath = c.req.path;
+    if (urlPath.startsWith("/api") || urlPath.startsWith("/proxy") || urlPath.startsWith("/assets")) {
+        return next();
+    }
+    try {
+        const indexPath = path.join(absoluteStaticRoot, "index.html");
+        if (fs.existsSync(indexPath)) {
+            const html = fs.readFileSync(indexPath, "utf8");
+            return c.html(html);
+        }
+        return c.text("GUI Build not found at " + absoluteStaticRoot, 404);
+    }
+    catch {
+        return next();
+    }
+});
+async function startServer() {
+    if (!process.env.PROXY_URL) {
+        process.stderr.write('[GUI] PROXY_URL non défini — arrêt.\n');
+        process.exit(0);
+    }
+    const proxyUrl = process.env.PROXY_URL;
+    const appPath = process.env.APP_PATH || "/documentor-gui";
+    const appName = process.env.APP_NAME || "MCP Documentor GUI";
+    logger.info(`Starting server with proxyUrl=${proxyUrl}`);
+    proxyClient = new ProxyClient(proxyUrl);
+    let result;
+    try {
+        // Second arg: fallbackPort (required by published @imenam/mcp-gui-interface API); unused when proxy assigns the port.
+        result = await proxyClient.register({ path: appPath, name: appName }, 0);
+    }
+    catch (e) {
+        process.stderr.write('[GUI] Enregistrement proxy échoué — arrêt.\n');
+        logger.error(`Proxy registration error: ${e.message}`);
+        process.exit(1);
+        return;
+    }
+    if (result.error === "HTTP 409") {
+        logger.info("Another GUI instance already registered.");
+        safeSend(IPCMessageSchema.parse({
+            type: "ALREADY_RUNNING",
+            data: { url: `${proxyUrl}${appPath}` },
+            timestamp: new Date().toISOString(),
+        }));
+        process.exit(0);
+        return;
+    }
+    if (!result.success) {
+        process.stderr.write('[GUI] Enregistrement proxy échoué — arrêt.\n');
+        logger.error(`Proxy registration failed: ${result.error}`);
+        process.exit(1);
+        return;
+    }
+    const finalPort = result.port;
+    const publicUrl = result.url || `${proxyUrl}${appPath}`;
+    logger.info(`Registered with proxy. Public URL: ${publicUrl}, Local Port: ${finalPort}`);
+    const cleanupProxy = async () => {
+        if (proxyClient)
+            await proxyClient.unregister();
+        process.exit(0);
+    };
+    process.on("SIGTERM", cleanupProxy);
+    process.on("SIGINT", cleanupProxy);
+    setupIpcErrorHandlers();
+    logger.info(`Starting Hono server on port ${finalPort}...`);
+    const serverInstance = serve({ fetch: app.fetch, port: finalPort, hostname: "0.0.0.0" }, (info) => {
+        logger.info(`Dashboard server listening on port ${info.port}`);
+        safeSend(IPCMessageSchema.parse({
+            type: "READY",
+            data: { port: info.port, isProxied: true, url: publicUrl },
+            timestamp: new Date().toISOString(),
+        }));
+    });
+    serverInstance.on("error", (err) => {
+        logger.error(`Server error: ${err.message}`);
+        process.exit(1);
+    });
+}
+startServer().catch((err) => {
+    logger.error(`Failed to start GUI Worker: ${err.message}`);
+    if (err.stack)
+        logger.error(err.stack);
+    process.exit(1);
+});

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};