ragcode-context-engine 0.1.0

package/dist/src/web/server.js

@@ -0,0 +1,375 @@
+import path from 'node:path';
+import express from 'express';
+import cors from 'cors';
+import { WebSocketServer } from 'ws';
+import { RagCodeEngine } from '../core/engine.js';
+import { createRuntimeComponentsForRepo, loadRuntimeConfig, readRuntimeConfigFile, redactRuntimeConfig, writeRuntimeConfigFile } from '../config/runtime-config.js';
+import { FileWatchDaemon } from '../watch/watch-daemon.js';
+import { readWatcherLiveness } from '../watch/watcher-liveness.js';
+const app = express();
+const port = process.env.RAGCODE_WEB_PORT ? parseInt(process.env.RAGCODE_WEB_PORT) : 3000;
+const defaultRepo = path.resolve(process.env.RAGCODE_REPO_ROOT ?? process.cwd());
+const configPath = path.join(defaultRepo, '.ragcode', 'config.json');
+app.use(cors());
+app.use(express.json({ limit: '4mb' }));
+// ===== Shared engine + watch daemon =====
+let engine = null;
+let activeRepo = null;
+let daemon = null;
+let lastDaemonStatus = null;
+const sockets = new Set();
+function broadcast(payload) {
+    const message = JSON.stringify(payload);
+    for (const ws of sockets) {
+        if (ws.readyState === ws.OPEN)
+            ws.send(message);
+    }
+}
+function buildEngine(repoPath = activeRepo ?? defaultRepo) {
+    const runtime = createRuntimeComponentsForRepo({ cwd: repoPath, overrides: { repoRoot: repoPath } });
+    return new RagCodeEngine({
+        cwd: repoPath,
+        graphStore: runtime.graphStore,
+        semanticStore: runtime.semanticStore,
+        embeddingProvider: runtime.embeddingProvider,
+    });
+}
+async function ensureEngine(repoPath) {
+    const target = repoPath ? path.resolve(repoPath) : (activeRepo ?? defaultRepo);
+    if (engine && activeRepo === target)
+        return engine;
+    engine = buildEngine();
+    await engine.indexRepo(target);
+    activeRepo = target;
+    return engine;
+}
+function requireEngine(res) {
+    if (!engine) {
+        res.status(409).json({ error: 'Engine not initialized. Index a repository first via POST /api/index.' });
+        return null;
+    }
+    return engine;
+}
+function fail(res, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    res.status(500).json({ error: message });
+}
+// ===== Config (persisted to .ragcode/config.json) =====
+app.get('/api/config', (_req, res) => {
+    const repoRoot = activeRepo ?? defaultRepo;
+    const runtime = redactRuntimeConfig(loadRuntimeConfig({ cwd: repoRoot, overrides: { repoRoot } }));
+    res.json(runtime);
+});
+app.post('/api/config', (req, res) => {
+    try {
+        const repoRoot = activeRepo ?? defaultRepo;
+        const body = req.body;
+        const merged = { ...readRuntimeConfigFile(path.join(repoRoot, '.ragcode', 'config.json')), ...body };
+        const writtenPath = writeRuntimeConfigFile(repoRoot, merged);
+        res.json({ success: true, configPath: writtenPath, note: 'Restart the server or re-index the repository for store/provider changes to take effect.' });
+    }
+    catch (error) {
+        fail(res, error);
+    }
+});
+// ===== Index management =====
+app.post('/api/index', async (req, res) => {
+    const repoPath = req.body?.repoPath ?? defaultRepo;
+    try {
+        const resolvedRepo = path.resolve(repoPath);
+        const eng = buildEngine(resolvedRepo);
+        await eng.indexRepo(resolvedRepo);
+        engine = eng;
+        activeRepo = resolvedRepo;
+        const status = await eng.indexStatus(undefined);
+        res.json({ success: true, repoRoot: activeRepo, status });
+    }
+    catch (error) {
+        fail(res, error);
+    }
+});
+app.post('/api/refresh', async (_req, res) => {
+    const eng = requireEngine(res);
+    if (!eng)
+        return;
+    try {
+        await eng.refreshIndex(undefined);
+        res.json({ success: true, status: await eng.indexStatus(undefined) });
+    }
+    catch (error) {
+        fail(res, error);
+    }
+});
+app.get('/api/status', async (_req, res) => {
+    const eng = requireEngine(res);
+    if (!eng)
+        return;
+    try {
+        const status = await eng.indexStatus(undefined);
+        res.json(status);
+    }
+    catch (error) {
+        fail(res, error);
+    }
+});
+app.get('/api/languages', async (_req, res) => {
+    const eng = requireEngine(res);
+    if (!eng)
+        return;
+    try {
+        const { symbols } = await eng.graphSnapshot(undefined);
+        const byLanguage = new Map();
+        for (const sym of symbols) {
+            byLanguage.set(sym.language, (byLanguage.get(sym.language) ?? 0) + 1);
+        }
+        res.json({ languages: [...byLanguage.entries()].map(([language, count]) => ({ language, count })) });
+    }
+    catch (error) {
+        fail(res, error);
+    }
+});
+// ===== Context retrieval (full ContextPack) =====
+app.post('/api/context', async (req, res) => {
+    const eng = requireEngine(res);
+    if (!eng)
+        return;
+    const { query, mode, budgetChars } = req.body;
+    if (!query?.trim())
+        return res.status(400).json({ error: 'query required' });
+    try {
+        const pack = await eng.getContext({
+            query,
+            mode: mode ?? 'auto',
+            budgetChars: budgetChars ?? 16000,
+        });
+        res.json(pack);
+    }
+    catch (error) {
+        fail(res, error);
+    }
+});
+// ===== Raw search hits =====
+app.post('/api/search', async (req, res) => {
+    const eng = requireEngine(res);
+    if (!eng)
+        return;
+    const { query, mode, limit } = req.body;
+    try {
+        const hits = await eng.searchCode({ query: query ?? '', mode, limit: limit ?? 30 });
+        res.json({ hits });
+    }
+    catch (error) {
+        fail(res, error);
+    }
+});
+// ===== Code graph (real nodes + edges) =====
+app.get('/api/graph', async (req, res) => {
+    const eng = requireEngine(res);
+    if (!eng)
+        return;
+    const language = req.query.language;
+    const kind = req.query.kind;
+    const limit = req.query.limit ? parseInt(req.query.limit) : 400;
+    try {
+        const { symbols, edges } = await eng.graphSnapshot(undefined);
+        let filtered = symbols;
+        if (language)
+            filtered = filtered.filter((s) => s.language === language);
+        if (kind)
+            filtered = filtered.filter((s) => s.kind === kind);
+        filtered = filtered.slice(0, limit);
+        const nodeIds = new Set(filtered.map((s) => s.id));
+        const nodes = filtered.map((s) => toGraphNode(s));
+        const scopedEdges = edges.filter((edge) => nodeIds.has(edge.sourceId) && nodeIds.has(edge.targetId));
+        res.json({ nodes, edges: scopedEdges, total: symbols.length, shown: nodes.length, totalEdges: edges.length });
+    }
+    catch (error) {
+        fail(res, error);
+    }
+});
+function toGraphNode(symbol) {
+    return {
+        id: symbol.id,
+        label: symbol.name,
+        kind: symbol.kind,
+        language: symbol.language,
+        filePath: symbol.filePath,
+        startLine: symbol.startLine,
+        endLine: symbol.endLine,
+        exported: symbol.exported ?? false,
+        signature: symbol.signature,
+    };
+}
+app.get('/api/symbol/:name', async (req, res) => {
+    const eng = requireEngine(res);
+    if (!eng)
+        return;
+    try {
+        res.json({ symbols: await eng.findSymbol(undefined, req.params.name) });
+    }
+    catch (error) {
+        fail(res, error);
+    }
+});
+app.get('/api/file', async (req, res) => {
+    const eng = requireEngine(res);
+    if (!eng)
+        return;
+    const filePath = req.query.path;
+    if (!filePath)
+        return res.status(400).json({ error: 'path required' });
+    try {
+        res.json(await eng.explainFile(undefined, filePath));
+    }
+    catch (error) {
+        fail(res, error);
+    }
+});
+// ===== Impact / trace / tests / reuse / subgraph =====
+app.post('/api/impact', async (req, res) => {
+    const eng = requireEngine(res);
+    if (!eng)
+        return;
+    const { target } = req.body;
+    if (!target?.trim())
+        return res.status(400).json({ error: 'target required' });
+    try {
+        res.json(await eng.impactAnalysis(undefined, target));
+    }
+    catch (error) {
+        fail(res, error);
+    }
+});
+app.post('/api/trace', async (req, res) => {
+    const eng = requireEngine(res);
+    if (!eng)
+        return;
+    const { entry, maxSteps } = req.body;
+    if (!entry?.trim())
+        return res.status(400).json({ error: 'entry required' });
+    try {
+        res.json(await eng.traceFlow(undefined, entry, maxSteps));
+    }
+    catch (error) {
+        fail(res, error);
+    }
+});
+app.post('/api/related-tests', async (req, res) => {
+    const eng = requireEngine(res);
+    if (!eng)
+        return;
+    const { target } = req.body;
+    if (!target?.trim())
+        return res.status(400).json({ error: 'target required' });
+    try {
+        res.json(await eng.relatedTests(undefined, target));
+    }
+    catch (error) {
+        fail(res, error);
+    }
+});
+app.post('/api/reuse', async (req, res) => {
+    const eng = requireEngine(res);
+    if (!eng)
+        return;
+    const { query, limit } = req.body;
+    if (!query?.trim())
+        return res.status(400).json({ error: 'query required' });
+    try {
+        res.json(await eng.findReuseCandidates({ query, limit: limit ?? 8 }));
+    }
+    catch (error) {
+        fail(res, error);
+    }
+});
+app.post('/api/subgraph', async (req, res) => {
+    const eng = requireEngine(res);
+    if (!eng)
+        return;
+    const { query, mode, maxHops, budgetChars } = req.body;
+    if (!query?.trim())
+        return res.status(400).json({ error: 'query required' });
+    try {
+        res.json(await eng.verifiedSubgraph({ query, mode: mode ?? 'impact', maxHops, budgetChars }));
+    }
+    catch (error) {
+        fail(res, error);
+    }
+});
+// ===== Watch daemon control =====
+app.get('/api/watch/status', async (_req, res) => {
+    // Report both the dashboard's in-process observation daemon (if started here) and the on-disk
+    // liveness of any OS-service watcher, so the UI shows freshness even when the watcher is owned by
+    // systemd/launchd/Task Scheduler rather than this process.
+    const liveness = await readWatcherLiveness(activeRepo ?? defaultRepo);
+    if (!daemon)
+        return res.json({ running: false, status: null, liveness });
+    res.json({ running: true, status: await daemon.status(), liveness });
+});
+app.post('/api/watch/start', async (_req, res) => {
+    const eng = requireEngine(res);
+    if (!eng)
+        return;
+    if (daemon)
+        return res.json({ success: true, alreadyRunning: true });
+    try {
+        daemon = new FileWatchDaemon(eng, activeRepo ?? defaultRepo, {
+            indexOnStart: false,
+            // This is an in-process observation daemon for the dashboard, not the canonical watcher. Don't
+            // acquire the per-repo lock or publish a heartbeat — that belongs to `ragcode watch` / the OS
+            // service. Without this, starting observation here would collide with a live service watcher.
+            manageLifecycleFiles: false,
+            onEvent: (event) => {
+                broadcast({ type: 'file-event', event: event.event, path: event.filePath, timestamp: event.observedAtMs });
+            },
+            onStatus: (status) => {
+                lastDaemonStatus = status;
+                broadcast({ type: 'watch-status', status, timestamp: Date.now() });
+            },
+        });
+        await daemon.start();
+        res.json({ success: true, status: await daemon.status() });
+    }
+    catch (error) {
+        daemon = null;
+        fail(res, error);
+    }
+});
+app.post('/api/watch/stop', async (_req, res) => {
+    if (!daemon)
+        return res.json({ success: true, alreadyStopped: true });
+    try {
+        await daemon.stop();
+        daemon = null;
+        broadcast({ type: 'watch-stopped', timestamp: Date.now() });
+        res.json({ success: true });
+    }
+    catch (error) {
+        fail(res, error);
+    }
+});
+// ===== Server bootstrap =====
+const server = app.listen(port, () => {
+    console.log(`RagCode Dashboard API running at http://localhost:${port}`);
+    // Auto-index the default repo so the dashboard has data on first load.
+    ensureEngine().catch((error) => {
+        console.error('Initial indexing failed:', error instanceof Error ? error.message : error);
+    });
+});
+const wss = new WebSocketServer({ server, path: '/ws' });
+wss.on('connection', (ws) => {
+    sockets.add(ws);
+    ws.send(JSON.stringify({ type: 'connected', timestamp: Date.now(), watchRunning: daemon !== null }));
+    if (lastDaemonStatus) {
+        ws.send(JSON.stringify({ type: 'watch-status', status: lastDaemonStatus, timestamp: Date.now() }));
+    }
+    ws.on('close', () => sockets.delete(ws));
+    ws.on('error', () => sockets.delete(ws));
+});
+async function shutdown() {
+    await daemon?.stop().catch(() => undefined);
+    engine?.close();
+    server.close(() => process.exit(0));
+}
+process.on('SIGTERM', () => void shutdown());
+process.on('SIGINT', () => void shutdown());

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "ragcode-context-engine",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "description": "Local code intelligence foundation: structural code graph, LanceDB semantic layer, retrieval, context packing, and MCP tools.",
+  "keywords": [
+    "code-intelligence",
+    "mcp",
+    "model-context-protocol",
+    "semantic-search",
+    "code-graph",
+    "lancedb",
+    "rag",
+    "ai-agents",
+    "claude",
+    "code-analysis"
+  ],
+  "author": "RagCode Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MarshallEriksen-Neura/ragcode.git"
+  },
+  "bugs": {
+    "url": "https://github.com/MarshallEriksen-Neura/ragcode/issues"
+  },
+  "homepage": "https://github.com/MarshallEriksen-Neura/ragcode#readme",
+  "bin": {
+    "ragcode": "dist/src/cli/index.js"
+  },
+  "files": [
+    "dist/src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run build",
+    "audit:plan": "tsx scripts/audit-plan.ts",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "test:watcher": "node --import tsx ./node_modules/vitest/vitest.mjs run tests/watcher-state.test.ts tests/watch-daemon.test.ts",
+    "eval:context": "tsx scripts/eval-context.ts",
+    "dev": "tsx src/cli/index.ts",
+    "web:server": "tsx src/web/server.ts",
+    "web:client": "cd web && npm run dev",
+    "benchmark": "tsx scripts/benchmark.ts",
+    "benchmark:assert": "tsx scripts/benchmark.ts --assert",
+    "benchmark:list": "tsx scripts/benchmark.ts --list",
+    "benchmark:all": "tsx scripts/benchmark.ts --all",
+    "benchmark:observation": "tsx scripts/benchmark.ts --suite observation",
+    "benchmark:perf-smoke": "tsx scripts/benchmark-perf-smoke.ts",
+    "benchmark:incremental-stress": "tsx scripts/benchmark-incremental-stress.ts",
+    "setup-mcp": "tsx scripts/setup-mcp.ts",
+    "init-config": "tsx scripts/init-config.ts"
+  },
+  "dependencies": {
+    "@lancedb/lancedb": "^0.30.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.6",
+    "@types/ws": "^8.18.1",
+    "apache-arrow": "^18.1.0",
+    "better-sqlite3": "^12.10.0",
+    "chokidar": "^5.0.0",
+    "commander": "^14.0.2",
+    "cors": "^2.8.6",
+    "express": "^4.22.2",
+    "ink": "^7.0.5",
+    "parse-diff": "^0.12.0",
+    "react": "^19.2.7",
+    "smol-toml": "^1.6.1",
+    "snowball-stemmers": "^0.6.0",
+    "tree-sitter": "^0.21.1",
+    "tree-sitter-go": "^0.23.4",
+    "tree-sitter-java": "^0.23.5",
+    "tree-sitter-python": "^0.21.0",
+    "tree-sitter-rust": "^0.21.0",
+    "typescript": "^5.9.3",
+    "ws": "^8.21.0",
+    "zod": "^4.1.13"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.2",
+    "@types/react": "^19.2.17",
+    "ink-testing-library": "^4.0.0",
+    "tsx": "^4.21.0",
+    "vitest": "^4.1.8"
+  },
+  "engines": {
+    "node": ">=24.0.0"
+  }
+}