code-kg 0.1.0

package/dist/config/defaults.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_EDGE_TYPES = exports.DEFAULT_NODE_TYPES = exports.DEFAULT_GRAPH_OUTPUT = exports.DEFAULT_CLI_NAME = void 0;
+const edge_1 = require("../model/edge");
+const node_1 = require("../model/node");
+exports.DEFAULT_CLI_NAME = "codekg";
+exports.DEFAULT_GRAPH_OUTPUT = "codekg.graph.json";
+exports.DEFAULT_NODE_TYPES = [
+    node_1.NodeType.File,
+    node_1.NodeType.Directory,
+    node_1.NodeType.Function,
+    node_1.NodeType.Class,
+    node_1.NodeType.Interface,
+    node_1.NodeType.Variable,
+    node_1.NodeType.Route,
+    node_1.NodeType.EntryPoint
+];
+exports.DEFAULT_EDGE_TYPES = [
+    edge_1.EdgeType.CONTAINS,
+    edge_1.EdgeType.IMPORTS,
+    edge_1.EdgeType.EXPORTS,
+    edge_1.EdgeType.DEFINES,
+    edge_1.EdgeType.REFERENCES,
+    edge_1.EdgeType.CALLS,
+    edge_1.EdgeType.EXTENDS,
+    edge_1.EdgeType.IMPLEMENTS,
+    edge_1.EdgeType.HANDLES_ROUTE,
+    edge_1.EdgeType.DEPENDS_ON
+];
+//# sourceMappingURL=defaults.js.map

package/dist/config/defaults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.js","sourceRoot":"","sources":["../../src/config/defaults.ts"],"names":[],"mappings":";;;AAAA,wCAAyC;AACzC,wCAAyC;AAE5B,QAAA,gBAAgB,GAAG,QAAQ,CAAC;AAC5B,QAAA,oBAAoB,GAAG,mBAAmB,CAAC;AAE3C,QAAA,kBAAkB,GAA4B;IACzD,eAAQ,CAAC,IAAI;IACb,eAAQ,CAAC,SAAS;IAClB,eAAQ,CAAC,QAAQ;IACjB,eAAQ,CAAC,KAAK;IACd,eAAQ,CAAC,SAAS;IAClB,eAAQ,CAAC,QAAQ;IACjB,eAAQ,CAAC,KAAK;IACd,eAAQ,CAAC,UAAU;CACpB,CAAC;AAEW,QAAA,kBAAkB,GAA4B;IACzD,eAAQ,CAAC,QAAQ;IACjB,eAAQ,CAAC,OAAO;IAChB,eAAQ,CAAC,OAAO;IAChB,eAAQ,CAAC,OAAO;IAChB,eAAQ,CAAC,UAAU;IACnB,eAAQ,CAAC,KAAK;IACd,eAAQ,CAAC,OAAO;IAChB,eAAQ,CAAC,UAAU;IACnB,eAAQ,CAAC,aAAa;IACtB,eAAQ,CAAC,UAAU;CACpB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+export declare function writeJsonOutput(value: unknown, outputPath?: string): Promise<void>;
+export interface IndexCommandOptions {
+    path?: string;
+}
+export interface ServeCommandOptions extends IndexCommandOptions {
+    port: number;
+}
+export interface RunCommandOptions extends IndexCommandOptions {
+    port: number;
+    open?: boolean;
+}
+export interface InsightsCommandOptions extends IndexCommandOptions {
+    limit?: number;
+    output?: string;
+}
+export interface GraphCommandOptions extends IndexCommandOptions {
+    view?: string;
+    nodeTypes?: string[];
+    edgeTypes?: string[];
+    q?: string;
+    limit?: number;
+    output?: string;
+}
+export interface PathCommandOptions extends IndexCommandOptions {
+    from: string;
+    to: string;
+    maxDepth?: number;
+    edgeTypes?: string[];
+    output?: string;
+}
+export interface IndexResult {
+    projectRoot: string;
+    dbPath: string;
+}
+export interface ServeResult {
+    dbPath: string;
+    port: number;
+}
+export interface RunResult extends ServeResult {
+    projectRoot: string;
+}
+export declare function indexProjectToSqlite(projectRoot: string, dbPath: string): Promise<void>;
+export declare function serveUsingDatabase(dbPath: string, port: number): Promise<void>;
+export declare function runInit(options?: IndexCommandOptions): Promise<IndexResult>;
+export declare function runReindex(options?: IndexCommandOptions): Promise<IndexResult>;
+export declare function runServe(options: ServeCommandOptions): Promise<ServeResult>;
+export declare function runDefault(options: RunCommandOptions): Promise<RunResult>;
+export declare function runInsights(options?: InsightsCommandOptions): Promise<unknown>;
+export declare function runGraphQuery(options?: GraphCommandOptions): Promise<unknown>;
+export declare function runPathQuery(options: PathCommandOptions): Promise<unknown>;
+export declare function main(argv?: string[]): Promise<void>;

package/dist/index.js

@@ -0,0 +1,602 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeJsonOutput = writeJsonOutput;
+exports.indexProjectToSqlite = indexProjectToSqlite;
+exports.serveUsingDatabase = serveUsingDatabase;
+exports.runInit = runInit;
+exports.runReindex = runReindex;
+exports.runServe = runServe;
+exports.runDefault = runDefault;
+exports.runInsights = runInsights;
+exports.runGraphQuery = runGraphQuery;
+exports.runPathQuery = runPathQuery;
+exports.main = main;
+const node_child_process_1 = require("node:child_process");
+const promises_1 = require("node:fs/promises");
+const codekg_config_1 = require("./codekg-config");
+const app_1 = require("./server/app");
+const sqlite_store_1 = require("./store/sqlite-store");
+const INDEXER_MODULE_CANDIDATES = [
+    "./indexer",
+    "./indexer.js",
+    "./indexer/index",
+    "./indexer/index.js",
+    "./indexer/indexer",
+    "./indexer/indexer.js",
+    "./application/indexer",
+    "./application/indexer.js",
+    "./core/indexer",
+    "./core/indexer.js",
+];
+const INDEXER_EXPORT_CANDIDATES = [
+    "indexProject",
+    "runIndexer",
+    "indexCodebase",
+    "buildCodeGraph",
+    "buildGraph",
+];
+const MAX_RESULT_WINDOW = 1_000_000;
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}
+function asString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function asProps(value) {
+    const record = asRecord(value);
+    return record ?? {};
+}
+function readFunction(moduleRecord, exportNames) {
+    for (const exportName of exportNames) {
+        const direct = moduleRecord[exportName];
+        if (typeof direct === "function") {
+            return direct;
+        }
+    }
+    const defaultExport = moduleRecord.default;
+    if (typeof defaultExport === "function") {
+        return defaultExport;
+    }
+    const defaultRecord = asRecord(defaultExport);
+    if (!defaultRecord) {
+        return undefined;
+    }
+    for (const exportName of exportNames) {
+        const candidate = defaultRecord[exportName];
+        if (typeof candidate === "function") {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+async function importFirstAvailable(candidates, label) {
+    let lastError;
+    for (const candidate of candidates) {
+        try {
+            return (await Promise.resolve(`${candidate}`).then(s => __importStar(require(s))));
+        }
+        catch (error) {
+            const nodeError = error;
+            if (nodeError.code !== "ERR_MODULE_NOT_FOUND" && nodeError.code !== "MODULE_NOT_FOUND") {
+                throw error;
+            }
+            lastError = error;
+        }
+    }
+    const suffix = lastError instanceof Error ? ` Last error: ${lastError.message}` : "";
+    throw new Error(`Unable to import ${label}. Tried: ${candidates.join(", ")}.${suffix}`);
+}
+function toQueryNode(value, index) {
+    const record = asRecord(value);
+    if (!record) {
+        return null;
+    }
+    const id = asString(record.id);
+    const type = asString(record.type);
+    if (!id || !type) {
+        return null;
+    }
+    const rawName = asString(record.name);
+    const rawPath = asString(record.path);
+    const props = asProps(record.props ?? record.json_props);
+    return {
+        id,
+        type,
+        name: rawName ?? `node_${index}`,
+        path: rawPath ?? null,
+        props,
+    };
+}
+function toQueryEdge(value, index) {
+    const record = asRecord(value);
+    if (!record) {
+        return null;
+    }
+    const id = asString(record.id) ?? `edge_${index}`;
+    const fromId = asString(record.fromId) ??
+        asString(record.from_id) ??
+        asString(record.from) ??
+        asString(record.source);
+    const toId = asString(record.toId) ??
+        asString(record.to_id) ??
+        asString(record.to) ??
+        asString(record.target);
+    const type = asString(record.type);
+    if (!fromId || !toId || !type) {
+        return null;
+    }
+    const props = asProps(record.props ?? record.json_props);
+    return {
+        id,
+        fromId,
+        toId,
+        type,
+        props,
+    };
+}
+function selectGraphPayload(payload) {
+    const root = asRecord(payload);
+    if (!root) {
+        return payload;
+    }
+    if (Array.isArray(root.nodes) && Array.isArray(root.edges)) {
+        return root;
+    }
+    for (const key of ["graph", "snapshot", "data", "result"]) {
+        const nested = asRecord(root[key]);
+        if (nested && Array.isArray(nested.nodes) && Array.isArray(nested.edges)) {
+            return nested;
+        }
+    }
+    return payload;
+}
+function normalizeGraphSnapshot(rawGraph) {
+    const payload = asRecord(selectGraphPayload(rawGraph));
+    const rawNodes = payload && Array.isArray(payload.nodes) ? payload.nodes : [];
+    const rawEdges = payload && Array.isArray(payload.edges) ? payload.edges : [];
+    const nodes = rawNodes
+        .map((value, index) => toQueryNode(value, index))
+        .filter((node) => Boolean(node));
+    const edges = rawEdges
+        .map((value, index) => toQueryEdge(value, index))
+        .filter((edge) => Boolean(edge));
+    return { nodes, edges };
+}
+function asGraphNode(node) {
+    return {
+        id: node.id,
+        type: node.type,
+        name: node.name ?? node.id,
+        path: node.path ?? undefined,
+        props: node.props,
+    };
+}
+function asGraphEdge(edge) {
+    return {
+        id: edge.id,
+        from: edge.fromId,
+        to: edge.toId,
+        type: edge.type,
+        props: edge.props,
+    };
+}
+function collectAllNodes(store) {
+    return store.searchNodes("", MAX_RESULT_WINDOW);
+}
+function collectAllEdges(store, nodes) {
+    const edgeById = new Map();
+    for (const node of nodes) {
+        for (const edge of store.getOutgoingEdges(node.id)) {
+            edgeById.set(edge.id, edge);
+        }
+    }
+    return [...edgeById.values()];
+}
+function normalizeRouteDependencies(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((item) => typeof item === "string");
+}
+function createRouteMap(routes) {
+    return routes.map((routeNode) => {
+        const method = asString(routeNode.props.method)?.toUpperCase() ?? "GET";
+        const routePath = asString(routeNode.props.routePath) ??
+            asString(routeNode.props.path) ??
+            routeNode.path ??
+            routeNode.name ??
+            routeNode.id;
+        return {
+            id: routeNode.id,
+            method,
+            path: routePath,
+            handler: asString(routeNode.props.handler) ?? routeNode.name ?? routeNode.id,
+            file: routeNode.path ?? undefined,
+            dependencies: normalizeRouteDependencies(routeNode.props.dependencies),
+        };
+    });
+}
+function computeSeverity(size) {
+    if (size >= 5) {
+        return "high";
+    }
+    if (size >= 3) {
+        return "medium";
+    }
+    return "low";
+}
+function createGraphQueryEngine(store) {
+    return {
+        async getMeta() {
+            const nodes = collectAllNodes(store);
+            const edges = collectAllEdges(store, nodes);
+            const routeCount = store.getRoutes().length;
+            const fileCount = nodes.filter((node) => node.type.toLowerCase() === "file").length;
+            const symbolCount = nodes.filter((node) => ["function", "class", "interface", "variable"].includes(node.type.toLowerCase())).length;
+            const insights = store.getRefactorInsights(5);
+            return {
+                project: "codekg",
+                version: "0.1.0",
+                generatedAt: new Date().toISOString(),
+                counts: {
+                    nodes: nodes.length,
+                    edges: edges.length,
+                    files: fileCount,
+                    symbols: symbolCount,
+                    routes: routeCount,
+                },
+                hotspots: insights.hotspots,
+            };
+        },
+        async search(query) {
+            const nodes = store.searchNodes(query, 50);
+            return {
+                query,
+                results: nodes.map((node) => ({
+                    nodeId: node.id,
+                    type: node.type,
+                    name: node.name ?? node.id,
+                    path: node.path ?? undefined,
+                    score: 1,
+                })),
+            };
+        },
+        async getNode(id) {
+            const node = store.getNodeById(id);
+            if (!node) {
+                return null;
+            }
+            const inbound = store.getIncomingEdges(id).map(asGraphEdge);
+            const outbound = store.getOutgoingEdges(id).map(asGraphEdge);
+            return {
+                node: asGraphNode(node),
+                inbound,
+                outbound,
+            };
+        },
+        async getGraph(options) {
+            const graph = store.getGraph({
+                view: options.view,
+                nodeTypes: options.nodeTypes,
+                edgeTypes: options.edgeTypes,
+                q: options.q,
+                limit: options.limit,
+            });
+            const view = options.view || "fileDeps";
+            return {
+                view,
+                nodes: graph.nodes.map(asGraphNode),
+                edges: graph.edges.map(asGraphEdge),
+            };
+        },
+        async getSubgraph(seed, depth, direction) {
+            const graph = store.getSubgraph(seed, depth, direction);
+            return {
+                seed,
+                depth,
+                direction,
+                nodes: graph.nodes.map(asGraphNode),
+                edges: graph.edges.map(asGraphEdge),
+            };
+        },
+        async getPath(from, to, maxDepth, edgeTypes) {
+            const result = store.findShortestPath(from, to, maxDepth, edgeTypes);
+            return {
+                from: result.from,
+                to: result.to,
+                maxDepth: result.maxDepth,
+                found: result.found,
+                length: result.length,
+                nodeIds: result.nodeIds,
+                edgeIds: result.edgeIds,
+                nodes: result.nodes.map(asGraphNode),
+                edges: result.edges.map(asGraphEdge),
+            };
+        },
+        async getRoutes() {
+            return {
+                routes: createRouteMap(store.getRoutes()),
+            };
+        },
+        async getCycles() {
+            const cycleInfo = store.getCycles();
+            return {
+                cycles: cycleInfo.cycles.map((cycle, index) => {
+                    const nodeIds = cycle.nodes.map((node) => node.id);
+                    return {
+                        id: `cycle:${index + 1}`,
+                        nodes: nodeIds,
+                        size: nodeIds.length,
+                        severity: computeSeverity(nodeIds.length),
+                    };
+                }),
+            };
+        },
+        async runQuery(query) {
+            if (typeof query.type === "string" && query.type === "path") {
+                const from = asString(query.from);
+                const to = asString(query.to);
+                const maxDepth = typeof query.maxDepth === "number" ? Math.max(1, Math.floor(query.maxDepth)) : 12;
+                const edgeTypes = Array.isArray(query.edgeTypes) && query.edgeTypes.every((entry) => typeof entry === "string")
+                    ? query.edgeTypes
+                    : undefined;
+                if (!from || !to) {
+                    throw new Error("Path query requires `from` and `to`.");
+                }
+                return {
+                    query,
+                    result: store.findShortestPath(from, to, maxDepth, edgeTypes),
+                };
+            }
+            if (typeof query.type === "string" && query.type === "refactorInsights") {
+                const rawLimit = query.limit;
+                const limit = typeof rawLimit === "number" && Number.isFinite(rawLimit)
+                    ? Math.max(1, Math.min(50, Math.floor(rawLimit)))
+                    : 5;
+                return {
+                    query,
+                    result: store.getRefactorInsights(limit),
+                };
+            }
+            return {
+                query,
+                result: store.runQuery(query),
+            };
+        },
+    };
+}
+async function loadIndexerRunner() {
+    const moduleRecord = await importFirstAvailable(INDEXER_MODULE_CANDIDATES, "indexer module");
+    const runner = readFunction(moduleRecord, INDEXER_EXPORT_CANDIDATES);
+    if (!runner) {
+        throw new Error(`Indexer module loaded, but no supported export was found. Expected one of: ${INDEXER_EXPORT_CANDIDATES.join(", ")}.`);
+    }
+    return runner;
+}
+async function runIndexer(projectRoot) {
+    const runner = await loadIndexerRunner();
+    try {
+        const rawGraph = await runner(projectRoot);
+        return normalizeGraphSnapshot(rawGraph);
+    }
+    catch (error) {
+        if (!(error instanceof TypeError)) {
+            throw error;
+        }
+    }
+    const fallbackGraph = await runner({ path: projectRoot, rootPath: projectRoot, projectRoot });
+    return normalizeGraphSnapshot(fallbackGraph);
+}
+async function persistIndexedGraph(projectRoot, dbPath) {
+    const snapshot = await runIndexer(projectRoot);
+    const store = new sqlite_store_1.SqliteStore(dbPath);
+    try {
+        store.initSchema();
+        store.replaceGraph(snapshot);
+    }
+    finally {
+        store.close();
+    }
+}
+async function listenOnPort(app, port) {
+    return await new Promise((resolve, reject) => {
+        const server = app.listen(port, () => resolve(server));
+        server.once("error", reject);
+    });
+}
+function attachStoreCleanup(server, store) {
+    let closed = false;
+    const closeStore = () => {
+        if (closed) {
+            return;
+        }
+        closed = true;
+        store.close();
+    };
+    server.once("close", closeStore);
+    process.once("exit", closeStore);
+}
+function openInBrowser(url) {
+    const platform = process.platform;
+    if (platform === "darwin") {
+        const child = (0, node_child_process_1.spawn)("open", [url], { stdio: "ignore", detached: true });
+        child.unref();
+        return;
+    }
+    if (platform === "win32") {
+        const child = (0, node_child_process_1.spawn)("cmd", ["/c", "start", "", url], { stdio: "ignore", detached: true });
+        child.unref();
+        return;
+    }
+    const child = (0, node_child_process_1.spawn)("xdg-open", [url], { stdio: "ignore", detached: true });
+    child.unref();
+}
+async function writeJsonOutput(value, outputPath) {
+    const serialized = `${JSON.stringify(value, null, 2)}\n`;
+    if (outputPath && outputPath.trim().length > 0) {
+        await (0, promises_1.writeFile)(outputPath, serialized, "utf8");
+        return;
+    }
+    process.stdout.write(serialized);
+}
+async function indexProjectToSqlite(projectRoot, dbPath) {
+    await persistIndexedGraph(projectRoot, dbPath);
+}
+async function serveUsingDatabase(dbPath, port) {
+    const store = new sqlite_store_1.SqliteStore(dbPath);
+    store.initSchema();
+    const app = (0, app_1.createApp)({ engine: createGraphQueryEngine(store) });
+    const server = await listenOnPort(app, port);
+    attachStoreCleanup(server, store);
+}
+async function runInit(options = {}) {
+    const { projectRoot, resolvedDbPath } = await (0, codekg_config_1.loadOrCreateCodekgConfig)(options.path ?? ".");
+    await (0, codekg_config_1.ensureDbDirectory)(resolvedDbPath);
+    await persistIndexedGraph(projectRoot, resolvedDbPath);
+    return { projectRoot, dbPath: resolvedDbPath };
+}
+async function runReindex(options = {}) {
+    const { projectRoot, resolvedDbPath } = await (0, codekg_config_1.loadOrCreateCodekgConfig)(options.path ?? ".");
+    await (0, codekg_config_1.ensureDbDirectory)(resolvedDbPath);
+    await persistIndexedGraph(projectRoot, resolvedDbPath);
+    return { projectRoot, dbPath: resolvedDbPath };
+}
+async function runServe(options) {
+    const { resolvedDbPath } = await (0, codekg_config_1.loadOrCreateCodekgConfig)(options.path ?? ".");
+    await serveUsingDatabase(resolvedDbPath, options.port);
+    return { dbPath: resolvedDbPath, port: options.port };
+}
+async function runDefault(options) {
+    const initResult = await runInit({ path: options.path });
+    const port = options.port;
+    await serveUsingDatabase(initResult.dbPath, port);
+    const uiUrl = `http://localhost:${port}`;
+    if (options.open) {
+        try {
+            openInBrowser(uiUrl);
+        }
+        catch {
+            // Best effort only.
+        }
+    }
+    process.stdout.write(`CodeKG UI: ${uiUrl}\n`);
+    process.stdout.write(`Graph DB: ${initResult.dbPath}\n`);
+    return {
+        projectRoot: initResult.projectRoot,
+        dbPath: initResult.dbPath,
+        port,
+    };
+}
+async function withReadOnlyStore(projectPath, handler) {
+    const { resolvedDbPath } = await (0, codekg_config_1.loadOrCreateCodekgConfig)(projectPath ?? ".");
+    const store = new sqlite_store_1.SqliteStore(resolvedDbPath);
+    try {
+        store.initSchema();
+        return await handler(store, resolvedDbPath);
+    }
+    finally {
+        store.close();
+    }
+}
+async function runInsights(options = {}) {
+    const limit = typeof options.limit === "number" ? Math.max(1, Math.floor(options.limit)) : 5;
+    return await withReadOnlyStore(options.path, async (store, dbPath) => ({
+        dbPath,
+        generatedAt: new Date().toISOString(),
+        result: store.getRefactorInsights(limit),
+    }));
+}
+async function runGraphQuery(options = {}) {
+    const view = options.view ?? "fileDeps";
+    return await withReadOnlyStore(options.path, async (store, dbPath) => {
+        const graph = store.getGraph({
+            view,
+            nodeTypes: options.nodeTypes,
+            edgeTypes: options.edgeTypes,
+            q: options.q,
+            limit: options.limit,
+        });
+        return {
+            dbPath,
+            generatedAt: new Date().toISOString(),
+            view,
+            filters: {
+                nodeTypes: options.nodeTypes ?? [],
+                edgeTypes: options.edgeTypes ?? [],
+                q: options.q ?? "",
+                limit: options.limit ?? 0,
+            },
+            nodes: graph.nodes,
+            edges: graph.edges,
+        };
+    });
+}
+async function runPathQuery(options) {
+    const maxDepth = typeof options.maxDepth === "number" ? Math.max(1, Math.floor(options.maxDepth)) : 12;
+    return await withReadOnlyStore(options.path, async (store, dbPath) => {
+        const pathResult = store.findShortestPath(options.from, options.to, maxDepth, options.edgeTypes);
+        return {
+            dbPath,
+            generatedAt: new Date().toISOString(),
+            result: pathResult,
+        };
+    });
+}
+async function main(argv = process.argv) {
+    const { runCli } = await Promise.resolve().then(() => __importStar(require("./cli/index.js")));
+    await runCli(argv, {
+        runInit,
+        runReindex,
+        runServe,
+        runDefault,
+        runInsights,
+        runGraphQuery,
+        runPathQuery,
+        writeJsonOutput,
+    });
+}
+if (typeof require !== "undefined" && require.main === module) {
+    void main().catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`${message}\n`);
+        process.exitCode = 1;
+    });
+}
+//# sourceMappingURL=index.js.map