@bynlk/codeomnivis 0.0.0-bootstrap.0

package/dist/dist-YNCI4IFF.js

@@ -0,0 +1,462 @@
+import {
+  DataFlowTracer,
+  OmniDatabase,
+  getDbPath,
+  hasDbCache,
+  isJsonObject,
+  isNodeOfType,
+  isTestFramework,
+  projectTestView,
+  runFullAnalysis
+} from "./chunk-D2FE2QSJ.js";
+
+// ../mcp/dist/index.js
+import { pathToFileURL } from "url";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+var API_NODE_TYPES = [
+  "api_route",
+  "trpc_procedure",
+  "express_route",
+  "tsrpc_api",
+  "tsrpc_service"
+];
+var API_DOWNSTREAM_EDGE_TYPES = ["handles", "calls_service", "queries_db"];
+var API_CALLER_EDGE_TYPES = ["calls_api"];
+var CALL_CHAIN_EDGE_TYPES = ["calls_api", "handles", "calls_service", "queries_db"];
+var RENDERS_EDGE_TYPE = "renders";
+var DB_MODEL_NODE_TYPE = "db_model";
+var MAX_COMPONENT_TREE_DEPTH = 100;
+function stringArg(args, key) {
+  if (!isJsonObject(args)) return void 0;
+  const value = args[key];
+  return typeof value === "string" ? value : void 0;
+}
+function validateDepth(args, fallback) {
+  const raw = isJsonObject(args) ? args.depth : void 0;
+  if (raw === void 0 || raw === null) return { ok: true, value: fallback };
+  let value;
+  if (typeof raw === "number") {
+    value = raw;
+  } else if (typeof raw === "string" && raw.trim() !== "") {
+    value = Number(raw);
+  } else {
+    return {
+      ok: false,
+      message: `depth must be a non-negative integer, got: ${JSON.stringify(raw)}`
+    };
+  }
+  if (!Number.isFinite(value) || !Number.isInteger(value)) {
+    return { ok: false, message: `depth must be a finite integer, got: ${JSON.stringify(raw)}` };
+  }
+  if (value < 0) return { ok: false, message: `depth must be >= 0, got: ${value}` };
+  if (value > MAX_COMPONENT_TREE_DEPTH) {
+    return {
+      ok: false,
+      message: `depth exceeds maximum ${MAX_COMPONENT_TREE_DEPTH}, got: ${value}`
+    };
+  }
+  return { ok: true, value };
+}
+function getRouteDisplay(node) {
+  if (isNodeOfType(node, "api_route")) {
+    return { method: node.metadata.method, path: node.metadata.route };
+  }
+  if (isNodeOfType(node, "express_route")) {
+    return { method: node.metadata.method, path: node.metadata.route };
+  }
+  if (isNodeOfType(node, "trpc_procedure")) {
+    return { method: node.metadata.procedureType.toUpperCase(), path: node.name };
+  }
+  if (isNodeOfType(node, "tsrpc_api")) {
+    return { method: node.metadata.transport.toUpperCase(), path: node.metadata.apiPath };
+  }
+  if (isNodeOfType(node, "tsrpc_service")) {
+    return { method: node.metadata.transport.toUpperCase(), path: node.metadata.servicePath };
+  }
+  return { method: "UNKNOWN", path: node.name };
+}
+function getNodeRoute(node) {
+  if (isNodeOfType(node, "page")) return node.metadata.route;
+  if (isNodeOfType(node, "api_route")) return node.metadata.route;
+  if (isNodeOfType(node, "express_route")) return node.metadata.route;
+  return node.name;
+}
+function success(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+function errorResponse(message) {
+  return {
+    content: [{ type: "text", text: JSON.stringify({ error: message }) }],
+    isError: true
+  };
+}
+function handleGetApiRoutes(db, args) {
+  const filter = stringArg(args, "filter")?.toLowerCase();
+  const apiNodes = db.getNodesByTypes(API_NODE_TYPES);
+  const filtered = filter ? apiNodes.filter((node) => {
+    if (node.name.toLowerCase().includes(filter)) return true;
+    return getRouteDisplay(node).path.toLowerCase().includes(filter);
+  }) : apiNodes;
+  const routes = filtered.map((node) => {
+    const { method, path } = getRouteDisplay(node);
+    const downstream = db.getDownstreamNodes(node.id, API_DOWNSTREAM_EDGE_TYPES);
+    const callers = db.getUpstreamNodes(node.id, API_CALLER_EDGE_TYPES);
+    return {
+      id: node.id,
+      method,
+      path,
+      file: node.filePath,
+      line: node.line,
+      calledBy: callers.map((caller) => ({ id: caller.id, name: caller.name, type: caller.type })),
+      dbOperations: downstream.filter((candidate) => candidate.type === "db_model").map((model) => ({ model: model.name, file: model.filePath }))
+    };
+  });
+  return success({ routes, totalCount: routes.length });
+}
+function handleGetComponentTree(db, args) {
+  const rootPath = stringArg(args, "rootPath");
+  if (!rootPath) return errorResponse("rootPath is required");
+  const depthResult = validateDepth(args, 3);
+  if (!depthResult.ok) return errorResponse(depthResult.message);
+  const rootNode = db.findNodeByRoute(rootPath) ?? db.findNodeByFilePath(rootPath);
+  if (!rootNode) {
+    return success({
+      error: `No node found for: ${rootPath}`,
+      suggestion: 'Try with a file path like "app/booking/page.tsx" or a route like "/booking"'
+    });
+  }
+  const tree = db.getSubtree(rootNode.id, RENDERS_EDGE_TYPE, depthResult.value);
+  if (tree === null) {
+    return success({
+      error: `No node found for: ${rootPath}`,
+      suggestion: 'Try with a file path like "app/booking/page.tsx" or a route like "/booking"'
+    });
+  }
+  if (tree.children.length === 0) {
+    return success({ root: rootNode.name, children: [], message: "No child components found" });
+  }
+  return success(tree);
+}
+function handleFindCallers(db, args) {
+  const target = stringArg(args, "target");
+  if (!target) return errorResponse("target is required");
+  const targetNode = db.findNodeByAny(target);
+  if (!targetNode) {
+    return success({
+      error: `Not found: ${target}`,
+      suggestion: 'Try with a model name like "User" or a route like "/api/booking"'
+    });
+  }
+  const callers = db.getUpstreamNodes(targetNode.id, CALL_CHAIN_EDGE_TYPES);
+  const affectedPages = db.getAffectedPages(targetNode.id);
+  return success({
+    target: targetNode.name,
+    targetType: targetNode.type,
+    file: targetNode.filePath,
+    callers: callers.map((caller) => ({
+      id: caller.id,
+      type: caller.type,
+      name: caller.name,
+      file: caller.filePath
+    })),
+    affectedFrontendPages: affectedPages.map((page) => ({
+      name: page.name,
+      route: getNodeRoute(page),
+      file: page.filePath
+    }))
+  });
+}
+function handleListDbModels(db) {
+  const models = db.getNodesByType(DB_MODEL_NODE_TYPE);
+  return success({
+    models: models.map((model) => ({
+      id: model.id,
+      name: model.name,
+      file: model.filePath,
+      tableName: isNodeOfType(model, "db_model") ? model.metadata.tableName : model.name,
+      fieldCount: isNodeOfType(model, "db_model") ? model.metadata.fieldCount : 0
+    })),
+    totalCount: models.length
+  });
+}
+function handleGetDataFlow(db, args) {
+  const graph = db.loadGraph();
+  const tracer = new DataFlowTracer(graph);
+  const modelName = stringArg(args, "model");
+  if (modelName) {
+    const modelNode = graph.nodes.find(
+      (node) => node.type === "db_model" && node.name.toLowerCase() === modelName.toLowerCase()
+    );
+    if (!modelNode) {
+      return success({
+        error: `Model not found: ${modelName}`,
+        availableModels: graph.nodes.filter((node) => node.type === "db_model").map((node) => node.name)
+      });
+    }
+    const path = tracer.traceModelFlow(modelNode);
+    return success({
+      model: modelNode.name,
+      routes: path.apiNodes.map((node) => ({ name: node.name, file: node.filePath })),
+      components: path.componentNodes.map((node) => ({ name: node.name, file: node.filePath })),
+      summary: `${modelNode.name} \u2192 ${path.apiNodes.length} routes \u2192 ${path.componentNodes.length} components`
+    });
+  }
+  const results = tracer.traceAllModels();
+  return success({
+    models: results.map((result) => ({
+      name: result.modelName,
+      routes: result.totalRoutes,
+      components: result.totalComponents,
+      summary: `${result.modelName} \u2192 ${result.totalRoutes} routes \u2192 ${result.totalComponents} components`
+    })),
+    totalCount: results.length
+  });
+}
+function handleGetTestCoverage(db, args) {
+  const frameworkValue = isJsonObject(args) ? args.framework : void 0;
+  const framework = typeof frameworkValue === "string" && isTestFramework(frameworkValue) ? frameworkValue : void 0;
+  const targetValue = isJsonObject(args) ? args.target : void 0;
+  const target = typeof targetValue === "string" ? targetValue : void 0;
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(projectTestView(db.loadGraph(), { framework, target }), null, 2)
+      }
+    ]
+  };
+}
+var MCP_TOOL_NAMES = {
+  getApiRoutes: "get_api_routes",
+  getComponentTree: "get_component_tree",
+  findCallers: "find_callers",
+  listDbModels: "list_db_models",
+  getDataflow: "get_dataflow",
+  getTestCoverage: "get_test_coverage"
+};
+var PUBLIC_TOOL_NAMES = Object.freeze(Object.values(MCP_TOOL_NAMES));
+var TOOL_DEFINITIONS = [
+  {
+    name: MCP_TOOL_NAMES.getApiRoutes,
+    description: "Get all API routes and their downstream database dependencies",
+    inputSchema: {
+      type: "object",
+      properties: {
+        filter: {
+          type: "string",
+          description: "Optional case-insensitive route or path filter"
+        }
+      }
+    }
+  },
+  {
+    name: MCP_TOOL_NAMES.getComponentTree,
+    description: "Get the component tree starting from a source path or route",
+    inputSchema: {
+      type: "object",
+      properties: {
+        rootPath: { type: "string", description: "Component file path or route" },
+        depth: { type: "number", description: "Maximum traversal depth; default 3" }
+      },
+      required: ["rootPath"]
+    }
+  },
+  {
+    name: MCP_TOOL_NAMES.findCallers,
+    description: "Find callers and affected pages for a node, route, or source path",
+    inputSchema: {
+      type: "object",
+      properties: {
+        target: { type: "string", description: "Node name, route, or source path" }
+      },
+      required: ["target"]
+    }
+  },
+  {
+    name: MCP_TOOL_NAMES.listDbModels,
+    description: "List database models discovered in the project",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: MCP_TOOL_NAMES.getDataflow,
+    description: "Trace data flow from database models through APIs to components",
+    inputSchema: {
+      type: "object",
+      properties: {
+        model: { type: "string", description: "Optional database model name" }
+      }
+    }
+  },
+  {
+    name: MCP_TOOL_NAMES.getTestCoverage,
+    description: "Get discovered test suites, cases, fixtures and static production coverage",
+    inputSchema: {
+      type: "object",
+      properties: {
+        target: { type: "string", description: "Optional production target filter" },
+        framework: { type: "string", description: "Optional test framework filter" }
+      }
+    }
+  }
+];
+function attachSnapshot(result, db) {
+  const snapshot = db.loadSnapshot();
+  const first = result.content[0];
+  if (!snapshot || first?.type !== "text") return result;
+  try {
+    const parsed = JSON.parse(first.text);
+    const body = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? { ...parsed, snapshot } : { data: parsed, snapshot };
+    return { ...result, content: [{ type: "text", text: JSON.stringify(body, null, 2) }] };
+  } catch {
+    return result;
+  }
+}
+function executeMcpTool(db, name, args) {
+  let result;
+  switch (name) {
+    case MCP_TOOL_NAMES.getApiRoutes:
+      result = handleGetApiRoutes(db, args);
+      break;
+    case MCP_TOOL_NAMES.getComponentTree:
+      result = handleGetComponentTree(db, args);
+      break;
+    case MCP_TOOL_NAMES.findCallers:
+      result = handleFindCallers(db, args);
+      break;
+    case MCP_TOOL_NAMES.listDbModels:
+      result = handleListDbModels(db);
+      break;
+    case MCP_TOOL_NAMES.getDataflow:
+      result = handleGetDataFlow(db, args);
+      break;
+    case MCP_TOOL_NAMES.getTestCoverage:
+      result = handleGetTestCoverage(db, args);
+      break;
+    default:
+      result = errorResponse(`Unknown tool: ${name}`);
+  }
+  return attachSnapshot(result, db);
+}
+function createMcpServer(options) {
+  const log = options.log ?? (() => {
+  });
+  const server = new Server(
+    { name: "codeomnivis", version: "0.0.1" },
+    { capabilities: { tools: {} } }
+  );
+  let cachedDb = null;
+  let dbInitPromise = null;
+  let closed = false;
+  async function getDb() {
+    if (cachedDb) return cachedDb;
+    if (dbInitPromise) return dbInitPromise;
+    dbInitPromise = (async () => {
+      const dbPath = getDbPath(options.projectRoot);
+      if (!hasDbCache(options.projectRoot)) {
+        log("No cache found, running full analysis");
+        await runFullAnalysis({ projectRoot: options.projectRoot, dbPath });
+      }
+      const db = new OmniDatabase(dbPath);
+      await db.ready();
+      cachedDb = db;
+      log("Database ready");
+      return db;
+    })();
+    try {
+      return await dbInitPromise;
+    } catch (err) {
+      dbInitPromise = null;
+      throw err;
+    }
+  }
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOL_DEFINITIONS }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+      const db = await getDb();
+      return executeMcpTool(db, name, args);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      log(`Tool "${name}" failed: ${message}`);
+      return errorResponse(message);
+    }
+  });
+  return {
+    server,
+    close: async () => {
+      if (closed) return;
+      closed = true;
+      await server.close();
+      cachedDb?.close();
+      cachedDb = null;
+      dbInitPromise = null;
+    }
+  };
+}
+function logToStderr(message) {
+  process.stderr.write(`[codeomnivis-mcp] ${message}
+`);
+}
+async function startMcpServer(options) {
+  const log = options.log ?? logToStderr;
+  const runtime = createMcpServer({ projectRoot: options.projectRoot, log });
+  const transport = new StdioServerTransport();
+  try {
+    await runtime.server.connect(transport);
+    log("MCP Server running on stdio");
+    return { close: runtime.close };
+  } catch (err) {
+    await runtime.close().catch(() => {
+    });
+    throw err;
+  }
+}
+function isMainModule(entry, moduleUrl) {
+  return entry !== void 0 && moduleUrl === pathToFileURL(entry).href;
+}
+function runMcpProcess(runtime = process, start = startMcpServer) {
+  let handle;
+  let stopRequested = false;
+  let stopping = false;
+  const stop = () => {
+    stopRequested = true;
+    if (!handle || stopping) return;
+    stopping = true;
+    void handle.close().then(() => runtime.exit(0)).catch((err) => {
+      runtime.stderr.write(`[codeomnivis-mcp] Shutdown failed: ${String(err)}
+`);
+      runtime.exit(1);
+    });
+  };
+  runtime.once("SIGINT", stop);
+  runtime.once("SIGTERM", stop);
+  void start({ projectRoot: runtime.env.CODEOMNIVIS_PROJECT ?? runtime.cwd() }).then((started) => {
+    handle = started;
+    if (stopRequested) stop();
+  }).catch((err) => {
+    runtime.stderr.write(`[codeomnivis-mcp] Fatal: ${String(err)}
+`);
+    runtime.exit(1);
+  });
+}
+if (isMainModule(process.argv[1], import.meta.url)) runMcpProcess();
+export {
+  MCP_TOOL_NAMES,
+  PUBLIC_TOOL_NAMES,
+  createMcpServer,
+  errorResponse,
+  executeMcpTool,
+  handleFindCallers,
+  handleGetApiRoutes,
+  handleGetComponentTree,
+  handleGetDataFlow,
+  handleGetTestCoverage,
+  handleListDbModels,
+  isMainModule,
+  logToStderr,
+  runMcpProcess,
+  startMcpServer,
+  validateDepth
+};