codesearch-mcp 0.0.1-alpha

package/dist/src/env-loader.js

@@ -0,0 +1,41 @@
+"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 });
+const dotenv = __importStar(require("dotenv"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+// Global config first, then local .env overrides (for development)
+dotenv.config({ path: path.join(os.homedir(), '.config', 'codesearch-mcp', '.env') });
+dotenv.config();

package/dist/src/file-utils.d.ts

@@ -0,0 +1,12 @@
+import ignore from 'ignore';
+export type Relations = Record<string, string | string[]>;
+export interface ProjectMeta {
+    description: string | null;
+    stack: string | null;
+    notes: string | null;
+    relations: Relations | null;
+}
+export declare function readRagMeta(projectDir: string): ProjectMeta | null;
+export declare const IGNORE_DIRS: Set<string>;
+export declare function loadIgnore(projectDir: string): ReturnType<typeof ignore>;
+export declare function collectFiles(dir: string, ig: ReturnType<typeof ignore>, rootDir: string): string[];

package/dist/src/file-utils.js

@@ -0,0 +1,97 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IGNORE_DIRS = void 0;
+exports.readRagMeta = readRagMeta;
+exports.loadIgnore = loadIgnore;
+exports.collectFiles = collectFiles;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ignore_1 = __importDefault(require("ignore"));
+// Returns null if file is missing or contains invalid JSON.
+// Returns ProjectMeta (fields may be null) if file exists and parses correctly.
+function readRagMeta(projectDir) {
+    const metaPath = path.join(projectDir, '.ragmeta.json');
+    if (!fs.existsSync(metaPath))
+        return null;
+    try {
+        const raw = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+        return {
+            description: raw.description ?? null,
+            stack: raw.stack ?? null,
+            notes: raw.notes ?? null,
+            relations: raw.relations ?? null,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+exports.IGNORE_DIRS = new Set([
+    'node_modules', '.git', 'dist', 'build', '.next', 'out',
+    'coverage', '.cache', '.turbo', 'migrations', '__generated__',
+    '.idea', '.vscode', 'public', 'uploads',
+]);
+const SOURCE_EXTENSIONS = /\.(ts|tsx|js|jsx|prisma|graphql|gql)$/;
+const IGNORE_EXTENSIONS = /\.d\.ts$/;
+function loadIgnore(projectDir) {
+    const ig = (0, ignore_1.default)();
+    const ragIgnorePath = path.join(projectDir, '.ragignore');
+    if (fs.existsSync(ragIgnorePath)) {
+        ig.add(fs.readFileSync(ragIgnorePath, 'utf-8'));
+    }
+    return ig;
+}
+function collectFiles(dir, ig, rootDir) {
+    const result = [];
+    for (const file of fs.readdirSync(dir)) {
+        const fullPath = path.join(dir, file);
+        const relPath = path.relative(rootDir, fullPath);
+        if (ig.ignores(relPath))
+            continue;
+        const stat = fs.statSync(fullPath);
+        if (stat.isDirectory()) {
+            if (!exports.IGNORE_DIRS.has(file))
+                result.push(...collectFiles(fullPath, ig, rootDir));
+        }
+        else if (SOURCE_EXTENSIONS.test(file) && !IGNORE_EXTENSIONS.test(file)) {
+            result.push(fullPath);
+        }
+    }
+    return result;
+}

package/dist/src/graph.d.ts

@@ -0,0 +1,4 @@
+export declare function generateProjectGraph(projects: {
+    name: string;
+    path: string;
+}[], workspacePath: string): void;

package/dist/src/graph.js

@@ -0,0 +1,259 @@
+"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.generateProjectGraph = generateProjectGraph;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const file_utils_1 = require("./file-utils");
+function buildEdges(nodes) {
+    const edges = [];
+    for (const node of nodes) {
+        if (!node.relations)
+            continue;
+        for (const [label, targets] of Object.entries(node.relations)) {
+            const list = Array.isArray(targets) ? targets : [targets];
+            for (const to of list)
+                edges.push({ from: node.name, to, label });
+        }
+    }
+    return edges;
+}
+function escHtml(s) {
+    return s.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+function printConsole(nodes, edges, workspacePath) {
+    if (edges.length === 0)
+        return;
+    console.log('\n=== Project Relations ===');
+    const grouped = new Map();
+    for (const e of edges) {
+        if (!grouped.has(e.from))
+            grouped.set(e.from, []);
+        grouped.get(e.from).push(e);
+    }
+    for (const [from, fromEdges] of grouped) {
+        const byLabel = new Map();
+        for (const e of fromEdges) {
+            if (!byLabel.has(e.label))
+                byLabel.set(e.label, []);
+            byLabel.get(e.label).push(e);
+        }
+        for (const [label, labelEdges] of byLabel) {
+            const targets = labelEdges.map(e => e.to).join(', ');
+            console.log(`  ${from.padEnd(30)} → ${targets.padEnd(30)} [${label}]`);
+        }
+    }
+    console.log(`\n  Full graph: file://${path.join(workspacePath, 'project-graph.html')}`);
+}
+function buildHtml(nodes, edges) {
+    const visNodes = nodes.map(n => ({
+        id: n.name,
+        label: n.name,
+        title: [n.description, n.stack].filter(Boolean).join('\n') || n.name,
+        color: n.relations ? '#4A90D9' : '#A8C7E8',
+    }));
+    const known = new Set(nodes.map(n => n.name));
+    for (const e of edges) {
+        if (!known.has(e.to)) {
+            visNodes.push({ id: e.to, label: e.to, title: e.to, color: '#E8A838' });
+            known.add(e.to);
+        }
+    }
+    const visEdges = edges.map((e, i) => ({ id: i, from: e.from, to: e.to, label: e.label, arrows: 'to' }));
+    const allLabels = [...new Set(edges.map(e => e.label))].sort();
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>Project Graph</title>
+  <script src="https://unpkg.com/vis-network@9.1.9/standalone/umd/vis-network.min.js"></script>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body { font-family: system-ui, sans-serif; background: #1a1a2e; color: #eee; display: flex; flex-direction: column; height: 100vh; }
+    #header { padding: 14px 20px; background: #16213e; border-bottom: 1px solid #0f3460; display: flex; align-items: center; gap: 20px; flex-shrink: 0; }
+    #header h1 { font-size: 16px; font-weight: 600; white-space: nowrap; }
+    #header p  { font-size: 12px; color: #888; }
+    #filters  { display: flex; gap: 8px; flex-wrap: wrap; margin-left: auto; }
+    .filter-btn {
+      padding: 4px 10px; border-radius: 12px; border: 1px solid #4A90D9;
+      background: #4A90D9; color: #fff; font-size: 11px; cursor: pointer; user-select: none; transition: opacity .15s;
+    }
+    .filter-btn.off { background: transparent; color: #4A90D9; opacity: .6; }
+    #main { display: flex; flex: 1; overflow: hidden; }
+    #network { flex: 1; }
+    #legend { width: 200px; background: #16213e; border-left: 1px solid #0f3460; padding: 16px 14px; font-size: 12px; flex-shrink: 0; overflow-y: auto; }
+    #legend h3 { font-size: 11px; text-transform: uppercase; color: #888; margin-bottom: 10px; letter-spacing: .5px; }
+    .dot { display: inline-block; width: 10px; height: 10px; border-radius: 50%; margin-right: 6px; vertical-align: middle; }
+    #legend .entry { margin-bottom: 8px; }
+    #hint { margin-top: 16px; padding-top: 12px; border-top: 1px solid #0f3460; color: #666; line-height: 1.5; }
+    #project-list { margin-top: 16px; padding-top: 12px; border-top: 1px solid #0f3460; }
+    .proj-btn {
+      display: flex; align-items: center; gap: 7px; width: 100%; padding: 5px 6px;
+      border-radius: 5px; border: none; background: none; color: #ccc;
+      font-size: 12px; cursor: pointer; text-align: left; transition: background .1s;
+    }
+    .proj-btn:hover { background: #0f3460; }
+    .proj-btn.off { opacity: .35; text-decoration: line-through; }
+    .proj-dot { width: 8px; height: 8px; border-radius: 50%; flex-shrink: 0; }
+  </style>
+</head>
+<body>
+  <div id="header">
+    <div>
+      <h1>Project Graph</h1>
+      <p>${nodes.length} projects · ${edges.length} edges · ${new Date().toLocaleString()}</p>
+    </div>
+    <div id="filters">
+      ${allLabels.map(l => `<button class="filter-btn" data-label="${escHtml(l)}">${escHtml(l)}</button>`).join('\n      ')}
+    </div>
+  </div>
+  <div id="main">
+    <div id="network"></div>
+    <div id="legend">
+      <h3>Nodes</h3>
+      <div class="entry"><span class="dot" style="background:#4A90D9"></span>has .ragmeta.json</div>
+      <div class="entry"><span class="dot" style="background:#5a5a7a"></span>no .ragmeta.json</div>
+      <div class="entry"><span class="dot" style="background:#E8A838"></span>not indexed</div>
+      <div id="hint">Drag to rearrange.<br>Edge buttons — toggle type.<br>Projects — toggle node.</div>
+      <div id="project-list">
+        <h3>Projects</h3>
+        ${visNodes.map(n => `<button class="proj-btn" data-node="${escHtml(n.id)}"><span class="proj-dot" style="background:${escHtml(n.color)}"></span>${escHtml(n.label)}</button>`).join('\n        ')}
+      </div>
+    </div>
+  </div>
+  <script>
+    const allEdges = ${JSON.stringify(visEdges)};
+    const nodesDs = new vis.DataSet(${JSON.stringify(visNodes)});
+    const edgesDs = new vis.DataSet(allEdges);
+
+    const network = new vis.Network(
+      document.getElementById('network'),
+      { nodes: nodesDs, edges: edgesDs },
+      {
+        nodes: {
+          shape: 'box',
+          font: { color: '#fff', size: 13 },
+          borderWidth: 2,
+          shadow: true,
+          margin: { top: 8, bottom: 8, left: 12, right: 12 },
+        },
+        edges: {
+          font: { color: '#aaa', size: 11, align: 'middle', strokeWidth: 0, background: '#1a1a2e' },
+          color: { color: '#4A90D9', highlight: '#7eb8f7', hover: '#7eb8f7' },
+          smooth: { type: 'curvedCW', roundness: 0.2 },
+          arrows: { to: { scaleFactor: 0.6 } },
+          selectionWidth: 2,
+        },
+        physics: {
+          solver: 'barnesHut',
+          barnesHut: {
+            gravitationalConstant: -18000,
+            springConstant:        0.025,
+            springLength:          280,
+            damping:               0.25,
+          },
+          stabilization: { iterations: 400, updateInterval: 25 },
+        },
+        interaction: { hover: true, tooltipDelay: 80, dragNodes: true },
+      }
+    );
+
+    network.on('stabilizationIterationsDone', () => {
+      network.fit({ animation: { duration: 600, easingFunction: 'easeInOutQuad' } });
+      setTimeout(() => network.setOptions({ physics: { enabled: false } }), 650);
+    });
+
+    network.on('hoverEdge', ({ edge }) => {
+      edgesDs.update({ id: edge, font: { color: '#fff', size: 16, background: '#16213e', strokeWidth: 0 } });
+    });
+    network.on('blurEdge', ({ edge }) => {
+      edgesDs.update({ id: edge, font: { color: '#aaa', size: 11, background: '#1a1a2e', strokeWidth: 0 } });
+    });
+
+    const activeLabels = new Set(${JSON.stringify(allLabels)});
+    const hiddenNodes  = new Set();
+
+    function refreshEdges() {
+      const visible = allEdges.filter(e =>
+        activeLabels.has(e.label) && !hiddenNodes.has(e.from) && !hiddenNodes.has(e.to)
+      );
+      edgesDs.clear();
+      edgesDs.add(visible);
+    }
+
+    document.querySelectorAll('.filter-btn').forEach(btn => {
+      btn.addEventListener('click', () => {
+        const label = btn.dataset.label;
+        if (activeLabels.has(label)) { activeLabels.delete(label); btn.classList.add('off'); }
+        else                         { activeLabels.add(label);    btn.classList.remove('off'); }
+        refreshEdges();
+      });
+    });
+
+    document.querySelectorAll('.proj-btn').forEach(btn => {
+      btn.addEventListener('click', () => {
+        const id = btn.dataset.node;
+        if (hiddenNodes.has(id)) {
+          hiddenNodes.delete(id);
+          nodesDs.update({ id, hidden: false });
+          btn.classList.remove('off');
+        } else {
+          hiddenNodes.add(id);
+          nodesDs.update({ id, hidden: true });
+          btn.classList.add('off');
+        }
+        refreshEdges();
+      });
+    });
+  </script>
+</body>
+</html>`;
+}
+// Single entry point — reads meta once, prints console summary and writes HTML
+function generateProjectGraph(projects, workspacePath) {
+    const nodes = projects.map(p => ({
+        name: p.name,
+        ...((0, file_utils_1.readRagMeta)(p.path) ?? { description: null, stack: null, notes: null, relations: null }),
+    }));
+    const edges = buildEdges(nodes);
+    printConsole(nodes, edges, workspacePath);
+    const htmlPath = path.join(workspacePath, 'project-graph.html');
+    try {
+        fs.writeFileSync(htmlPath, buildHtml(nodes, edges), 'utf-8');
+    }
+    catch (err) {
+        console.error(`  ⚠ Could not write project-graph.html: ${err.message}`);
+    }
+}

package/dist/src/indexer.d.ts

@@ -0,0 +1,13 @@
+export interface IndexStats {
+    serviceName: string;
+    indexed: number;
+    skipped: number;
+    failed: number;
+    chunks: number;
+    elapsedSec: number;
+}
+export declare function discoverProjects(rootDir: string): {
+    name: string;
+    path: string;
+}[];
+export declare function scanAndIndex(dir: string, serviceName: string, force?: boolean, signal?: AbortSignal): Promise<IndexStats>;

package/dist/src/indexer.js

@@ -0,0 +1,217 @@
+"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.discoverProjects = discoverProjects;
+exports.scanAndIndex = scanAndIndex;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const textsplitters_1 = require("@langchain/textsplitters");
+const ollama_1 = require("ollama");
+const cli_progress_1 = require("cli-progress");
+const db_1 = require("./db");
+const ast_1 = require("./ast");
+const config_1 = require("./config");
+const file_utils_1 = require("./file-utils");
+const ollama = new ollama_1.Ollama({ host: config_1.config.ollama.host });
+// JS/TS splitter uses language-aware separators (functions, classes, blocks)
+const jsSplitter = textsplitters_1.RecursiveCharacterTextSplitter.fromLanguage('js', {
+    chunkSize: config_1.config.indexer.chunkSize,
+    chunkOverlap: config_1.config.indexer.chunkOverlap,
+});
+// Schema splitter uses generic separators — better for Prisma/GraphQL block structure
+const schemaSplitter = new textsplitters_1.RecursiveCharacterTextSplitter({
+    chunkSize: config_1.config.indexer.chunkSize,
+    chunkOverlap: config_1.config.indexer.chunkOverlap,
+    separators: ['\n\n', '\n', ' '],
+});
+const SCHEMA_EXTENSIONS = /\.(prisma|graphql|gql)$/;
+function getSplitter(filePath) {
+    return SCHEMA_EXTENSIONS.test(filePath) ? schemaSplitter : jsSplitter;
+}
+// Detect JS/TS projects by the presence of package.json in their root
+function discoverProjects(rootDir) {
+    return fs.readdirSync(rootDir, { withFileTypes: true })
+        .filter(d => d.isDirectory() && !file_utils_1.IGNORE_DIRS.has(d.name))
+        .map(d => ({ name: d.name, path: path.join(rootDir, d.name) }))
+        .filter(p => fs.existsSync(path.join(p.path, 'package.json')));
+}
+// Embed a pre-formatted prompt (caller is responsible for prefix and context)
+async function embedText(prompt) {
+    const { embedding } = await ollama.embeddings({
+        model: config_1.config.ollama.model,
+        prompt,
+    });
+    return embedding;
+}
+// Ingest a single file: skip if unchanged, otherwise delete old chunks and re-index.
+// Returns status and chunk count. Never throws — failures are caught and reported.
+async function ingestFile(filePath, serviceName, mtimeMs, projectRoot) {
+    try {
+        const repo = db_1.db.getRepository(db_1.CodeChunk);
+        const relFilePath = path.relative(config_1.config.workspaceRoot, filePath);
+        // Incremental check: if mtime matches what's stored, the file hasn't changed
+        const existing = await repo.findOne({
+            select: ['id', 'lastModified'],
+            where: { serviceName, filePath: relFilePath },
+        });
+        if (existing?.lastModified === mtimeMs) {
+            return { status: 'skipped', chunks: 0 };
+        }
+        // Extract import edges before the transaction — disk I/O must not hold a DB connection open
+        const rawEdges = await (0, ast_1.extractImportEdges)(filePath, serviceName);
+        const edges = rawEdges
+            .filter(e => e.toFile.startsWith(config_1.config.workspaceRoot))
+            .map(e => ({
+            ...e,
+            fromFile: path.relative(config_1.config.workspaceRoot, e.fromFile),
+            toFile: path.relative(config_1.config.workspaceRoot, e.toFile),
+        }));
+        // Read and embed outside the transaction — Ollama calls must not hold a DB transaction open
+        const code = fs.readFileSync(filePath, 'utf-8');
+        const chunks = await getSplitter(filePath).createDocuments([code]);
+        const relPath = path.relative(projectRoot, filePath); // project-relative for embedding header
+        const records = [];
+        for (let i = 0; i < chunks.length; i += config_1.config.indexer.batchSize) {
+            const batch = chunks.slice(i, i + config_1.config.indexer.batchSize);
+            const embedded = await Promise.all(batch.map(async (chunk) => {
+                const startLine = (chunk.metadata?.loc?.lines?.from ?? 1);
+                const prompt = `Project: ${serviceName} | Path: ${relPath}\n${chunk.pageContent}`;
+                const embedding = await embedText(prompt);
+                return repo.create({
+                    serviceName, filePath: relFilePath, startLine,
+                    content: chunk.pageContent,
+                    embedding: `[${embedding}]`,
+                    lastModified: mtimeMs,
+                });
+            }));
+            records.push(...embedded);
+        }
+        // Atomic replace: delete stale chunks + dependency edges, insert new ones in a single transaction.
+        // Prevents partial index if the process crashes mid-write.
+        await db_1.db.transaction(async (manager) => {
+            await manager.delete(db_1.CodeChunk, { serviceName, filePath: relFilePath });
+            for (let i = 0; i < records.length; i += config_1.config.indexer.batchSize) {
+                await manager.createQueryBuilder()
+                    .insert()
+                    .into(db_1.CodeChunk)
+                    .values(records.slice(i, i + config_1.config.indexer.batchSize))
+                    .execute();
+            }
+            await manager.delete(db_1.CodeDependency, { project: serviceName, fromFile: relFilePath });
+            if (edges.length > 0) {
+                await manager.createQueryBuilder()
+                    .insert()
+                    .into(db_1.CodeDependency)
+                    .values(edges)
+                    .execute();
+            }
+        });
+        return { status: 'indexed', chunks: chunks.length };
+    }
+    catch (err) {
+        console.error(`\n[indexer] Failed: ${filePath} — ${err.message}`);
+        return { status: 'failed', chunks: 0 };
+    }
+}
+// Index a project directory incrementally.
+// Removes chunks for deleted files, skips unchanged files, re-indexes modified ones.
+// Pass force=true to invalidate all cached mtimes and force full re-index (e.g. after embedding strategy change).
+// Pass signal to support graceful interruption — stops between files, never mid-transaction.
+async function scanAndIndex(dir, serviceName, force = false, signal) {
+    const startTime = Date.now();
+    const repo = db_1.db.getRepository(db_1.CodeChunk);
+    // Clean up chunks whose source files no longer exist on disk
+    const dbPaths = await db_1.db.query(`SELECT DISTINCT "filePath" FROM code_chunk WHERE "serviceName" = $1`, [serviceName]);
+    for (const { filePath } of dbPaths) {
+        if (!fs.existsSync(path.join(config_1.config.workspaceRoot, filePath))) {
+            await repo.delete({ serviceName, filePath });
+            // Remove dependency edges on both sides — this file no longer exists as importer or target
+            await db_1.db.query(`DELETE FROM code_dependency WHERE project = $1 AND "fromFile" = $2`, [serviceName, filePath]);
+            await db_1.db.query(`DELETE FROM code_dependency WHERE project = $1 AND "toFile" = $2`, [serviceName, filePath]);
+            console.log(`  Removed stale: ${path.basename(filePath)}`);
+        }
+    }
+    // Force mode: wipe lastModified so all files are treated as changed
+    if (force) {
+        await db_1.db.query(`UPDATE code_chunk SET "lastModified" = NULL WHERE "serviceName" = $1`, [serviceName]);
+    }
+    const ig = (0, file_utils_1.loadIgnore)(dir);
+    const files = (0, file_utils_1.collectFiles)(dir, ig, dir);
+    const bar = new cli_progress_1.SingleBar({
+        format: `{serviceName} {bar} {percentage}% | {value}/{total} | {filename}`,
+        barCompleteChar: '█',
+        barIncompleteChar: '░',
+        hideCursor: true,
+        clearOnComplete: false,
+    }, cli_progress_1.Presets.shades_grey);
+    console.log(`\nIndexing ${serviceName}: ${files.length} files`);
+    const meta = (0, file_utils_1.readRagMeta)(dir);
+    if (meta === null && fs.existsSync(path.join(dir, '.ragmeta.json'))) {
+        console.log(`  ⚠ .ragmeta.json found but invalid JSON`);
+    }
+    else if (meta) {
+        const parts = [meta.description, meta.stack && `[${meta.stack}]`].filter(Boolean).join(' ');
+        console.log(`  ✓ .ragmeta.json: ${parts || '(no fields)'}`);
+    }
+    else {
+        console.log(`  ⚠ No .ragmeta.json — add {"description":"...","stack":"...","notes":"..."} so list_projects can describe this project`);
+    }
+    bar.start(files.length, 0, { serviceName, filename: '' });
+    const stats = {
+        serviceName, indexed: 0, skipped: 0, failed: 0, chunks: 0, elapsedSec: 0,
+    };
+    for (const filePath of files) {
+        if (signal?.aborted) {
+            bar.stop();
+            console.log(`\n  Interrupted — ${serviceName}`);
+            stats.elapsedSec = Math.round((Date.now() - startTime) / 100) / 10;
+            return stats;
+        }
+        bar.update({ filename: path.basename(filePath) });
+        const mtimeMs = fs.statSync(filePath).mtimeMs;
+        const result = await ingestFile(filePath, serviceName, mtimeMs, dir);
+        if (result.status === 'indexed')
+            stats.indexed++;
+        else if (result.status === 'skipped')
+            stats.skipped++;
+        else
+            stats.failed++;
+        stats.chunks += result.chunks;
+        bar.increment();
+    }
+    bar.stop();
+    stats.elapsedSec = Math.round((Date.now() - startTime) / 100) / 10;
+    return stats;
+}

package/dist/src/interrupt.d.ts

@@ -0,0 +1,3 @@
+export declare const signal: AbortSignal;
+export declare function setupInterrupt(): void;
+export declare function teardownInterrupt(): void;

package/dist/src/interrupt.js

@@ -0,0 +1,27 @@
+"use strict";
+// Graceful interruption signal for long-running CLI operations.
+// Listens for ESC or Ctrl+C on stdin and aborts the shared controller.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signal = void 0;
+exports.setupInterrupt = setupInterrupt;
+exports.teardownInterrupt = teardownInterrupt;
+const controller = new AbortController();
+exports.signal = controller.signal;
+function setupInterrupt() {
+    if (!process.stdin.isTTY)
+        return;
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (key) => {
+        if (key === '\x1b' || key === '\x03')
+            controller.abort();
+    });
+    console.log('Press ESC or Ctrl+C to interrupt.\n');
+}
+function teardownInterrupt() {
+    if (!process.stdin.isTTY)
+        return;
+    process.stdin.setRawMode(false);
+    process.stdin.pause();
+}