codesearch-mcp 0.0.17-alpha.1 → 0.1.0-alpha

package/dist/src/config.js

@@ -34,10 +34,10 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Config = exports.ConfigError = void 0;
+exports.resolveEnvRef = resolveEnvRef;
 const os = __importStar(require("os"));
 const zod_1 = require("zod");
 const config_store_1 = require("./config-store");
-const constants_1 = require("./constants");
 class ConfigError extends Error {
     constructor(message) {
         super(message);
@@ -45,37 +45,80 @@ class ConfigError extends Error {
     }
 }
 exports.ConfigError = ConfigError;
+/**
+ * Resolve a config value that may reference an environment variable. A value of
+ * the form `env:VAR_NAME` resolves to `process.env.VAR_NAME`; any other string
+ * (including empty) is returned verbatim. A referenced-but-unset variable throws
+ * a clear error naming the variable and the `.env` file. Pure aside from the
+ * injected env map. See `src/app.ts` for how `.env` is loaded into the process.
+ */
+function resolveEnvRef(value, env = process.env) {
+    if (!value.startsWith('env:'))
+        return value;
+    const name = value.slice(4).trim();
+    const resolved = name ? env[name] : undefined;
+    if (resolved == null || resolved === '') {
+        throw new ConfigError(`Config references environment variable "${name}" (as "env:${name}") but it is not set. ` +
+            `Define ${name} in ${config_store_1.ENV_FILE} or export it in the environment.`);
+    }
+    return resolved;
+}
+const DEFAULT_BASE_URLS = {
+    'ollama': 'http://localhost:11434',
+    'openai-compatible': 'https://api.openai.com/v1',
+    'voyage': 'https://api.voyageai.com/v1',
+    'infinity': 'http://localhost:7997',
+};
+function defaultBaseURL(provider) {
+    return DEFAULT_BASE_URLS[provider] ?? DEFAULT_BASE_URLS.ollama;
+}
+// Reranking is served only by OpenAI-compatible `/rerank` endpoints (Infinity,
+// TEI, vLLM, Jina/Cohere-shape). Ollama has no rerank API, so there is a single
+// endpoint shape. Normalize a trailing `/embeddings` or `/v1` to the server root
+// so a baseURL written with an OpenAI-style suffix still yields `<root>/rerank`.
+function deriveRerankUrl(baseURL) {
+    const root = baseURL.replace(/\/+$/, '').replace(/\/(embeddings|v1)$/, '');
+    return `${root}/rerank`;
+}
 const resolvedSchema = zod_1.z.object({
     db: zod_1.z.object({
         host: zod_1.z.string().min(1, 'required — run rag-setup'),
-        port: zod_1.z.number().int().positive().default(5433),
+        port: zod_1.z.number().int().positive().default(config_store_1.CONFIG_DEFAULTS['db.port']),
         username: zod_1.z.string().min(1, 'required — run rag-setup'),
         password: zod_1.z.string().min(1, 'required — run rag-setup'),
         database: zod_1.z.string().min(1),
     }),
-    ollama: zod_1.z.object({
-        host: zod_1.z.string().min(1).default('http://localhost:11434'),
-        model: zod_1.z.string().min(1).default(constants_1.DEFAULT_EMBED_MODEL),
-        rerankerModel: zod_1.z.string().default(''),
-        rerankerUrl: zod_1.z.string().min(1),
+    embedding: zod_1.z.object({
+        provider: zod_1.z.enum(['ollama', 'openai-compatible', 'voyage', 'infinity']).default(config_store_1.CONFIG_DEFAULTS['embedding.provider']),
+        baseURL: zod_1.z.string().min(1),
+        apiKey: zod_1.z.string().default(config_store_1.CONFIG_DEFAULTS['embedding.apiKey']),
+        model: zod_1.z.string().min(1).default(config_store_1.CONFIG_DEFAULTS['embedding.model']),
+        dimensions: zod_1.z.number().int().positive().nullable().default(null),
+        batchSize: zod_1.z.number().int().positive().default(config_store_1.CONFIG_DEFAULTS['embedding.batchSize']),
+    }),
+    reranker: zod_1.z.object({
+        enabled: zod_1.z.boolean().default(config_store_1.CONFIG_DEFAULTS['reranker.enabled']),
+        provider: zod_1.z.enum(['openai-compatible']).default(config_store_1.CONFIG_DEFAULTS['reranker.provider']),
+        baseURL: zod_1.z.string().min(1),
+        apiKey: zod_1.z.string().default(config_store_1.CONFIG_DEFAULTS['reranker.apiKey']),
+        model: zod_1.z.string().default(config_store_1.CONFIG_DEFAULTS['reranker.model']),
+        url: zod_1.z.string().min(1),
+        overfetch: zod_1.z.number().int().min(1).max(20).default(config_store_1.CONFIG_DEFAULTS['reranker.overfetch']),
     }),
     indexer: zod_1.z.object({
-        chunkSize: zod_1.z.number().int().positive().default(1500),
-        chunkOverlap: zod_1.z.number().int().min(0).default(200),
-        batchSize: zod_1.z.number().int().positive().default(5),
-        astBatchSize: zod_1.z.number().int().positive().default(3000),
+        chunkSize: zod_1.z.number().int().positive().default(config_store_1.CONFIG_DEFAULTS['indexing.chunkSize']),
+        chunkOverlap: zod_1.z.number().int().min(0).default(config_store_1.CONFIG_DEFAULTS['indexing.chunkOverlap']),
+        batchSize: zod_1.z.number().int().positive().default(config_store_1.CONFIG_DEFAULTS['indexing.embedBatchSize']),
+        astBatchSize: zod_1.z.number().int().positive().default(config_store_1.CONFIG_DEFAULTS['indexing.astBatchSize']),
+        chunkStrategy: zod_1.z.enum(['ast', 'character']).default(config_store_1.CONFIG_DEFAULTS['indexing.chunkStrategy']),
     }),
     search: zod_1.z.object({
-        similarityThreshold: zod_1.z.number().min(0).max(1).default(0.6),
-        defaultLimit: zod_1.z.number().int().positive().default(5),
-        maxLimit: zod_1.z.number().int().positive().default(20),
-        autoTranslate: zod_1.z.boolean().default(false),
-        translateModel: zod_1.z.string().default('llama3.2'),
-        rerankerEnabled: zod_1.z.boolean().default(false),
-        rerankerOverfetch: zod_1.z.number().int().min(1).max(20).default(3),
+        similarityThreshold: zod_1.z.number().min(0).max(1).default(config_store_1.CONFIG_DEFAULTS['search.similarityThreshold']),
+        defaultLimit: zod_1.z.number().int().positive().default(config_store_1.CONFIG_DEFAULTS['search.defaultLimit']),
+        maxLimit: zod_1.z.number().int().positive().default(config_store_1.CONFIG_DEFAULTS['search.maxLimit']),
     }),
     logging: zod_1.z.object({
-        level: zod_1.z.enum(['debug', 'info', 'warn', 'error']).default('error'),
+        level: zod_1.z.enum(['debug', 'info', 'warn', 'error']).default(config_store_1.CONFIG_DEFAULTS['logging.level']),
         dir: zod_1.z.string().optional(),
     }),
     workspaceRoot: zod_1.z.string().default(''),
@@ -83,7 +126,16 @@ const resolvedSchema = zod_1.z.object({
 class Config {
     data;
     get db() { return this.data.db; }
-    get ollama() { return this.data.ollama; }
+    /**
+     * Embedding config. `apiKey` is returned **raw** (possibly an `env:VAR` ref) —
+     * callers resolve it lazily via `resolveEnvRef` at the moment they build a
+     * request, so an unset referenced variable fails only when the key is actually
+     * needed (during embed/search) rather than crashing container construction and
+     * locking the user out of `rag-web`/`rag-mcp`.
+     */
+    get embedding() { return this.data.embedding; }
+    /** Reranker config. `apiKey` is raw — resolve lazily with `resolveEnvRef`. */
+    get reranker() { return this.data.reranker; }
     get indexer() { return this.data.indexer; }
     get search() { return this.data.search; }
     get logging() { return this.data.logging; }
@@ -92,7 +144,10 @@ class Config {
         const raw = (0, config_store_1.readConfigJson)();
         if (!raw)
             throw new ConfigError('Config not found. Run rag-setup.');
-        const ollamaHost = raw.ollama?.host ?? 'http://localhost:11434';
+        const embProvider = (raw.embedding?.provider ?? config_store_1.CONFIG_DEFAULTS['embedding.provider']);
+        const embBaseURL = raw.embedding?.baseURL ?? defaultBaseURL(embProvider);
+        const rerankBaseURL = raw.reranker?.baseURL ?? embBaseURL;
+        const rerankUrl = raw.reranker?.url ?? deriveRerankUrl(rerankBaseURL);
         const result = resolvedSchema.safeParse({
             db: {
                 host: raw.db?.host,
@@ -101,26 +156,34 @@ class Config {
                 password: raw.db?.password,
                 database: raw.db?.name ?? this.deriveDbName(),
             },
-            ollama: {
-                host: raw.ollama?.host,
-                model: raw.ollama?.model,
-                rerankerModel: raw.reranker?.model,
-                rerankerUrl: raw.reranker?.url ?? `${ollamaHost}/api/rerank`,
+            embedding: {
+                provider: raw.embedding?.provider,
+                baseURL: embBaseURL,
+                apiKey: raw.embedding?.apiKey,
+                model: raw.embedding?.model,
+                dimensions: raw.embedding?.dimensions,
+                batchSize: raw.embedding?.batchSize,
+            },
+            reranker: {
+                enabled: raw.reranker?.enabled,
+                provider: raw.reranker?.provider,
+                baseURL: rerankBaseURL,
+                apiKey: raw.reranker?.apiKey,
+                model: raw.reranker?.model,
+                url: rerankUrl,
+                overfetch: raw.reranker?.overfetch,
             },
             indexer: {
                 chunkSize: raw.indexing?.chunkSize,
                 chunkOverlap: raw.indexing?.chunkOverlap,
                 batchSize: raw.indexing?.embedBatchSize,
                 astBatchSize: raw.indexing?.astBatchSize,
+                chunkStrategy: raw.indexing?.chunkStrategy,
             },
             search: {
                 similarityThreshold: raw.search?.similarityThreshold,
                 defaultLimit: raw.search?.defaultLimit,
                 maxLimit: raw.search?.maxLimit,
-                autoTranslate: raw.search?.autoTranslate,
-                translateModel: raw.search?.translateModel,
-                rerankerEnabled: raw.reranker?.enabled,
-                rerankerOverfetch: raw.reranker?.overfetch,
             },
             logging: {
                 level: raw.logging?.level,

package/dist/src/constants.d.ts

@@ -1 +1,36 @@
+export type EmbeddingProvider = 'ollama' | 'openai-compatible' | 'voyage' | 'infinity';
+/**
+ * pgvector's HNSW / IVFFlat index hard limit. The effective embedding dimension
+ * must not exceed this; larger cloud models must reduce via the Matryoshka
+ * `dimensions` request parameter (`embedding.dimensions`).
+ */
+export declare const MAX_EMBED_DIM = 2000;
+export interface ModelInfo {
+    provider: EmbeddingProvider;
+    /** Native / default output width. */
+    dimensions: number;
+    /** Model supports Matryoshka dimension reduction via a request parameter. */
+    dimConfigurable?: boolean;
+    /** Max width that can be indexed under the pgvector cap (advisory). */
+    maxIndexable?: number;
+    /** Max width the model itself can emit (advisory). */
+    maxDim?: number;
+}
+/**
+ * Advisory (NOT exhaustive) registry of known embedding models. Used to resolve
+ * a model's dimension without a runtime probe and to suggest models in the
+ * dashboard. Models absent here still work — their dimension is probed at index
+ * time (see `resolveDimension`).
+ */
+export declare const MODEL_REGISTRY: Record<string, ModelInfo>;
 export declare const DEFAULT_EMBED_MODEL = "bge-m3";
+/** Advisory dimension for a model, or `undefined` when the model is unknown. */
+export declare function registryDimension(model: string): number | undefined;
+/**
+ * Resolve the effective vector dimension: explicit override → registry → probe.
+ * Validates the result is ≤ MAX_EMBED_DIM, throwing an error that names
+ * `embedding.dimensions` as the fix. `probeFn` embeds a short string once and
+ * returns the observed length; only called when neither override nor registry
+ * yields a value. Pure aside from the injected probe.
+ */
+export declare function resolveDimension(override: number | null | undefined, model: string, probeFn: () => Promise<number>, registry?: Record<string, ModelInfo>): Promise<number>;

package/dist/src/constants.js

@@ -1,7 +1,60 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_EMBED_MODEL = void 0;
-// Embedding model is tied to the vector column dimension (bge-m3 → 1024).
-// Change both together: update this constant, drop/recreate the `embedding` column,
-// and re-run indexing.
+exports.DEFAULT_EMBED_MODEL = exports.MODEL_REGISTRY = exports.MAX_EMBED_DIM = void 0;
+exports.registryDimension = registryDimension;
+exports.resolveDimension = resolveDimension;
+/**
+ * pgvector's HNSW / IVFFlat index hard limit. The effective embedding dimension
+ * must not exceed this; larger cloud models must reduce via the Matryoshka
+ * `dimensions` request parameter (`embedding.dimensions`).
+ */
+exports.MAX_EMBED_DIM = 2000;
+/**
+ * Advisory (NOT exhaustive) registry of known embedding models. Used to resolve
+ * a model's dimension without a runtime probe and to suggest models in the
+ * dashboard. Models absent here still work — their dimension is probed at index
+ * time (see `resolveDimension`).
+ */
+exports.MODEL_REGISTRY = {
+    'bge-m3': { provider: 'ollama', dimensions: 1024 },
+    'nomic-embed-text': { provider: 'ollama', dimensions: 768 },
+    'mxbai-embed-large': { provider: 'ollama', dimensions: 1024 },
+    'text-embedding-3-small': { provider: 'openai-compatible', dimensions: 1536, dimConfigurable: true },
+    'text-embedding-3-large': { provider: 'openai-compatible', dimensions: 3072, dimConfigurable: true, maxIndexable: 2000 },
+    'text-embedding-ada-002': { provider: 'openai-compatible', dimensions: 1536 },
+    'voyage-code-3': { provider: 'voyage', dimensions: 1024, dimConfigurable: true, maxDim: 2048 },
+    'voyage-3': { provider: 'voyage', dimensions: 1024, dimConfigurable: true },
+    'voyage-3-lite': { provider: 'voyage', dimensions: 512 },
+    'BAAI/bge-m3': { provider: 'infinity', dimensions: 1024 },
+    'jinaai/jina-embeddings-v2-base-code': { provider: 'infinity', dimensions: 768 },
+};
 exports.DEFAULT_EMBED_MODEL = 'bge-m3';
+/** Advisory dimension for a model, or `undefined` when the model is unknown. */
+function registryDimension(model) {
+    return exports.MODEL_REGISTRY[model]?.dimensions;
+}
+/**
+ * Resolve the effective vector dimension: explicit override → registry → probe.
+ * Validates the result is ≤ MAX_EMBED_DIM, throwing an error that names
+ * `embedding.dimensions` as the fix. `probeFn` embeds a short string once and
+ * returns the observed length; only called when neither override nor registry
+ * yields a value. Pure aside from the injected probe.
+ */
+async function resolveDimension(override, model, probeFn, registry = exports.MODEL_REGISTRY) {
+    let dim;
+    if (override != null) {
+        dim = override;
+    }
+    else {
+        const known = registry[model]?.dimensions;
+        dim = known != null ? known : await probeFn();
+    }
+    if (!Number.isInteger(dim) || dim <= 0) {
+        throw new Error(`Could not resolve a valid embedding dimension for model "${model}" (got ${dim}). Set embedding.dimensions explicitly.`);
+    }
+    if (dim > exports.MAX_EMBED_DIM) {
+        throw new Error(`Embedding dimension ${dim} for model "${model}" exceeds the pgvector limit of ${exports.MAX_EMBED_DIM}. ` +
+            `Set embedding.dimensions to a value ≤ ${exports.MAX_EMBED_DIM} to request dimension-reduced (Matryoshka) vectors.`);
+    }
+    return dim;
+}

package/dist/src/container.d.ts

@@ -1,15 +1,19 @@
 import { Config } from './config';
-import { DatabaseService } from './services/DatabaseService';
 import { IndexerService } from './services/IndexerService';
-import { SearcherService } from './services/SearcherService';
 import { McpServer } from './services/McpServer';
-import { LoggerService } from './services/LoggerService';
+import type { IDatabase } from './interfaces';
+import type { IEmbedder } from './interfaces';
+import type { ISearcher } from './interfaces';
+import type { ILogger } from './interfaces';
+import type { IProjectDiscovery } from './interfaces';
 export interface Container {
     config: Config;
-    db: DatabaseService;
+    db: IDatabase;
+    embedder: IEmbedder;
     indexer: IndexerService;
-    searcher: SearcherService;
+    searcher: ISearcher;
     mcp: McpServer;
-    logger: LoggerService;
+    logger: ILogger;
+    discovery: IProjectDiscovery;
 }
 export declare function createContainer(loggerName?: string): Container;

package/dist/src/container.js

@@ -3,20 +3,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createContainer = createContainer;
 const config_1 = require("./config");
 const DatabaseService_1 = require("./services/DatabaseService");
-const OllamaEmbedder_1 = require("./services/OllamaEmbedder");
+const EmbedderFactory_1 = require("./services/EmbedderFactory");
 const AstParserService_1 = require("./services/AstParserService");
+const AstChunker_1 = require("./services/AstChunker");
 const IndexerService_1 = require("./services/IndexerService");
 const SearcherService_1 = require("./services/SearcherService");
 const McpServer_1 = require("./services/McpServer");
 const LoggerService_1 = require("./services/LoggerService");
+const MonorepoAwareDiscoveryService_1 = require("./services/MonorepoAwareDiscoveryService");
+const NxMonorepoResolver_1 = require("./services/NxMonorepoResolver");
 function createContainer(loggerName) {
     const config = new config_1.Config();
     const logger = LoggerService_1.LoggerService.fromConfig(config.logging, loggerName);
     const db = new DatabaseService_1.DatabaseService(config);
-    const embedder = new OllamaEmbedder_1.OllamaEmbedder(config);
+    const embedder = (0, EmbedderFactory_1.createEmbedder)(config, logger);
     const ast = new AstParserService_1.AstParserService(logger);
-    const indexer = new IndexerService_1.IndexerService(db, embedder, ast, config, logger);
-    const searcher = new SearcherService_1.SearcherService(db, embedder, config, logger);
+    const chunker = new AstChunker_1.AstChunker(config);
+    const discovery = new MonorepoAwareDiscoveryService_1.MonorepoAwareDiscoveryService([new NxMonorepoResolver_1.NxMonorepoResolver(logger)], logger);
+    const indexer = new IndexerService_1.IndexerService(db, embedder, ast, chunker, config, logger);
+    const searcher = new SearcherService_1.SearcherService(db, embedder, discovery, config, logger);
     const mcp = new McpServer_1.McpServer(searcher, config, logger);
-    return { config, db, indexer, searcher, mcp, logger };
+    return { config, db, embedder, indexer, searcher, mcp, logger, discovery };
 }

package/dist/src/db/index.d.ts

@@ -1,2 +1,2 @@
-export { codeChunk, codeDependency, codeSymbol, codeCall } from './schema';
+export { codeChunk, codeDependency, codeSymbol, codeCall, indexMeta } from './schema';
 export type { CodeChunkInsert } from './schema';

package/dist/src/db/index.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.codeCall = exports.codeSymbol = exports.codeDependency = exports.codeChunk = void 0;
+exports.indexMeta = exports.codeCall = exports.codeSymbol = exports.codeDependency = exports.codeChunk = void 0;
 var schema_1 = require("./schema");
 Object.defineProperty(exports, "codeChunk", { enumerable: true, get: function () { return schema_1.codeChunk; } });
 Object.defineProperty(exports, "codeDependency", { enumerable: true, get: function () { return schema_1.codeDependency; } });
 Object.defineProperty(exports, "codeSymbol", { enumerable: true, get: function () { return schema_1.codeSymbol; } });
 Object.defineProperty(exports, "codeCall", { enumerable: true, get: function () { return schema_1.codeCall; } });
+Object.defineProperty(exports, "indexMeta", { enumerable: true, get: function () { return schema_1.indexMeta; } });

package/dist/src/db/schema.d.ts

@@ -142,6 +142,25 @@ export declare const codeChunk: import("drizzle-orm/pg-core").PgTableWithColumns
         }, {}, {
             length: 64;
         }>;
+        ownerPath: import("drizzle-orm/pg-core").PgColumn<{
+            name: "ownerPath";
+            tableName: "code_chunk";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
     };
     dialect: "pg";
 }>;
@@ -574,4 +593,96 @@ export declare const codeCall: import("drizzle-orm/pg-core").PgTableWithColumns<
     };
     dialect: "pg";
 }>;
+export declare const indexMeta: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "index_meta";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "index_meta";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        provider: import("drizzle-orm/pg-core").PgColumn<{
+            name: "provider";
+            tableName: "index_meta";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        model: import("drizzle-orm/pg-core").PgColumn<{
+            name: "model";
+            tableName: "index_meta";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        dimensions: import("drizzle-orm/pg-core").PgColumn<{
+            name: "dimensions";
+            tableName: "index_meta";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        indexedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "indexedAt";
+            tableName: "index_meta";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
 export type CodeChunkInsert = typeof codeChunk.$inferInsert;

package/dist/src/db/schema.js

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.codeCall = exports.codeSymbol = exports.codeDependency = exports.codeChunk = void 0;
+exports.indexMeta = exports.codeCall = exports.codeSymbol = exports.codeDependency = exports.codeChunk = void 0;
 const pg_core_1 = require("drizzle-orm/pg-core");
+// NOTE: the `dimensions` literal below is nominal only. `dataType()` is invoked
+// solely by drizzle-kit DDL generation, which this project does not use — the
+// `code_chunk` table is created by raw SQL in DatabaseService at the dimension
+// resolved from the active model, and the real width is recorded in index_meta.
 const vector = (0, pg_core_1.customType)({
     dataType(config) { return `vector(${config?.dimensions ?? 1024})`; },
 });
@@ -14,6 +18,7 @@ exports.codeChunk = (0, pg_core_1.pgTable)('code_chunk', {
     embedding: vector('embedding', { dimensions: 1024 }).notNull(),
     lastModified: (0, pg_core_1.doublePrecision)('lastModified'),
     contentHash: (0, pg_core_1.varchar)('contentHash', { length: 64 }),
+    ownerPath: (0, pg_core_1.varchar)('ownerPath'),
 });
 exports.codeDependency = (0, pg_core_1.pgTable)('code_dependency', {
     id: (0, pg_core_1.uuid)('id').primaryKey().defaultRandom(),
@@ -45,3 +50,12 @@ exports.codeCall = (0, pg_core_1.pgTable)('code_call', {
     line: (0, pg_core_1.integer)('line'),
     col: (0, pg_core_1.integer)('col'),
 });
+// Single-row source of truth for which model built the current index. The
+// `id` column is a boolean pinned to `true` so at most one row can exist.
+exports.indexMeta = (0, pg_core_1.pgTable)('index_meta', {
+    id: (0, pg_core_1.boolean)('id').primaryKey().default(true),
+    provider: (0, pg_core_1.text)('provider').notNull(),
+    model: (0, pg_core_1.text)('model').notNull(),
+    dimensions: (0, pg_core_1.integer)('dimensions').notNull(),
+    indexedAt: (0, pg_core_1.timestamp)('indexedAt', { withTimezone: true }).defaultNow().notNull(),
+});

package/dist/src/graph.d.ts

@@ -1,4 +1,64 @@
+import { type ProjectMeta } from './file-utils';
+type ProjectNode = {
+    name: string;
+    nxRepo?: boolean;
+} & ProjectMeta;
+type Edge = {
+    from: string;
+    to: string;
+    label: string;
+};
+export interface GraphData {
+    nodes: ProjectNode[];
+    edges: Edge[];
+}
+/** A single named graph tab (Workspace, or one per nested Nx repo). */
+export interface GraphView {
+    name: string;
+    nodes: ProjectNode[];
+    edges: Edge[];
+}
+/**
+ * Build the project graph data (nodes + relation edges) from a project list.
+ * Pure apart from reading each project's `.ragmeta.json`. Shared by the console
+ * graph, the graph views, and the web dashboard's `/api/graph`.
+ */
+export declare function buildGraphData(projects: {
+    name: string;
+    path: string;
+}[]): GraphData;
+/**
+ * Split a project list into graph tabs. A project whose name contains a `/`
+ * belongs to a nested Nx repo (`<repo>/<sub-project>`); everything else is a
+ * flat top-level project.
+ *
+ * - **Workspace** tab: flat projects + one node per Nx repo (collapsed to a
+ *   single `nxRepo` node); edges from `.ragmeta.json` relations.
+ * - **One tab per Nx repo**: its sub-projects as nodes, with edges between them
+ *   taken from real import dependencies (`projectEdges`, from `code_dependency`).
+ *
+ * Returns the Workspace view first, then repo views sorted by name.
+ */
+export declare function buildGraphViews(projects: {
+    name: string;
+    path: string;
+}[], projectEdges: {
+    from: string;
+    to: string;
+}[], workspaceRoot: string): GraphView[];
+/**
+ * Render the full interactive graph page (vis-network + inner tabs, edge-type
+ * filters, legend, project toggle list). Used for the standalone
+ * `project-graph.html` and served by the web dashboard at `GET /graph` (embedded
+ * via iframe) so both share one implementation. Tab 0 is the Workspace view;
+ * double-clicking an Nx-repo node opens that repo's tab.
+ */
+export declare function buildHtml(views: GraphView[]): string;
 export declare function generateProjectGraph(projects: {
     name: string;
     path: string;
+}[], projectEdges: {
+    from: string;
+    to: string;
 }[], workspacePath: string): void;
+export {};