@monoes/monograph 1.2.10 → 1.4.0

package/src/pipeline/phases/suggest.ts

@@ -11,6 +11,7 @@ export const suggestPhase: PipelinePhase<SuggestOutput> = {
   name: 'suggest',
   deps: ['parse', 'cross-file', 'mro', 'communities', 'god-nodes', 'surprises'],
   async execute(_ctx, deps) {
+    if (_ctx.allFilesCached) return { questions: [] };
     const { allEdges, symbolNodes } = deps.get('parse') as ParseOutput;
     const { memberships } = deps.get('communities') as CommunitiesOutput;
     const questions: SuggestedQuestion[] = [];

package/src/pipeline/phases/tools.ts

@@ -42,6 +42,7 @@ export const toolsPhase: PipelinePhase<ToolsOutput> = {
   name: 'tools',
   deps: ['parse', 'structure'],
   async execute(ctx, deps) {
+    if (ctx.allFilesCached) return { toolDefs: [], toolNodes: [], handlesEdges: [] };
     const { fileNodes } = deps.get('structure') as StructureOutput;
     const toolDefs: ToolDef[] = [];
     const toolNodes: MonographNode[] = [];

package/src/pipeline/phases/variables-phase.ts

@@ -10,6 +10,7 @@ export const variablesPhase: PipelinePhase<VariablesOutput> = {
   name: 'variables',
   deps: ['parse'],
   async execute(ctx: PipelineContext, deps: Map<string, unknown>): Promise<VariablesOutput> {
+    if (ctx.allFilesCached) return { variableCount: 0 };
     const { fileContents } = deps.get('parse') as ParseOutput;
 
     const stmt = ctx.db.prepare(`

package/src/pipeline/phases/wildcard-phase.ts

@@ -12,6 +12,7 @@ export const wildcardSynthesisPhase: PipelinePhase<WildcardSynthesisOutput> = {
   name: 'wildcard-synthesis',
   deps: ['parse', 'cross-file'],
   async execute(ctx: PipelineContext, deps: Map<string, unknown>): Promise<WildcardSynthesisOutput> {
+    if (ctx.allFilesCached) return { synthesizedCount: 0 };
     const { symbolNodes: allNodes, allEdges, fileContents } = deps.get('parse') as ParseOutput;
     const { resolvedEdges } = deps.get('cross-file') as CrossFileOutput;
 

package/src/pipeline/types.ts

@@ -8,6 +8,8 @@ export interface PipelineContext {
   graph: Graph;
   onProgress: (p: PipelineProgress) => void;
   options: PipelineOptions;
+  /** Set by parse phase when all files hit the extraction cache (0 misses). */
+  allFilesCached?: boolean;
 }
 
 export interface PipelineOptions {

package/src/reporting/graph-report.ts

@@ -54,16 +54,15 @@ function queryEdgesByRelation(db: MonographDb): EdgeRelationStat[] {
 
 function queryTopNodesByDegree(db: MonographDb, limit = 10): TopDegreeNode[] {
   const rows = db.prepare(`
-    SELECT
-      n.id,
-      n.name,
-      n.label,
-      (
-        SELECT COUNT(*) FROM edges WHERE source_id = n.id
-      ) + (
-        SELECT COUNT(*) FROM edges WHERE target_id = n.id
-      ) AS degree
+    SELECT n.id, n.name, n.label, COALESCE(d.degree, 0) AS degree
     FROM nodes n
+    LEFT JOIN (
+      SELECT node_id, SUM(cnt) AS degree FROM (
+        SELECT source_id AS node_id, COUNT(*) AS cnt FROM edges GROUP BY source_id
+        UNION ALL
+        SELECT target_id AS node_id, COUNT(*) AS cnt FROM edges GROUP BY target_id
+      ) GROUP BY node_id
+    ) d ON d.node_id = n.id
     ORDER BY degree DESC
     LIMIT ?
   `).all(limit) as TopDegreeNode[];

package/src/staleness/git-staleness.ts

@@ -28,10 +28,13 @@ export function checkStaleness(db: MonographDb, repoPath: string): StalenessRepo
   const indexedCommitShort = indexedCommitFull ? indexedCommitFull.slice(0, 7) : null;
   const currentCommitShort = currentCommit ? currentCommit.slice(0, 7) : null;
 
-  // 3. If no stored commit or short SHAs match, not stale
-  if (!indexedCommitFull || indexedCommitShort === currentCommitShort) {
+  // 3. If SHAs match → fresh. If no stored commit → staleness unknown (not "fresh").
+  if (indexedCommitShort === currentCommitShort) {
     return { isStale: false, indexedAt: null, indexedCommit: indexedCommitShort, currentCommit: currentCommitShort, changedSince: [], staleSince: null };
   }
+  if (!indexedCommitFull) {
+    return { isStale: true, indexedAt: null, indexedCommit: null, currentCommit: currentCommitShort, changedSince: [], staleSince: null };
+  }
 
   // Guard: indexedCommitFull is read from SQLite — validate before shell interpolation
   if (!/^[0-9a-f]{7,40}$/i.test(indexedCommitFull)) {

package/src/storage/db.ts

@@ -5,6 +5,9 @@ import {
   CREATE_NODES, CREATE_EDGES, CREATE_COMMUNITIES,
   CREATE_INDEX_META, CREATE_NODES_FTS, CREATE_INDEXES, FTS_SYNC_TRIGGERS,
   CREATE_EMBEDDINGS, CREATE_WIKI_PAGES,
+  CREATE_AGENT_INTERACTIONS, CREATE_AGENT_INTERACTIONS_IDX,
+  CREATE_AGENT_INTERACTIONS_ORG_IDX, CREATE_AGENT_INTERACTIONS_TYPE_IDX,
+  CREATE_AGENT_INTERACTIONS_TS_IDX,
 } from './schema.js';
 import { MonographError } from '../types.js';
 
@@ -45,6 +48,11 @@ function applyMigrations(db: MonographDb): void {
   db.exec(FTS_SYNC_TRIGGERS);
   db.exec(CREATE_EMBEDDINGS);
   db.exec(CREATE_WIKI_PAGES);
+  db.exec(CREATE_AGENT_INTERACTIONS);
+  db.exec(CREATE_AGENT_INTERACTIONS_IDX);
+  db.exec(CREATE_AGENT_INTERACTIONS_ORG_IDX);
+  db.exec(CREATE_AGENT_INTERACTIONS_TYPE_IDX);
+  db.exec(CREATE_AGENT_INTERACTIONS_TS_IDX);
 
   // Schema version table — tracks incremental column additions.
   db.exec(`CREATE TABLE IF NOT EXISTS schema_version (version INTEGER PRIMARY KEY)`);

package/src/storage/schema.ts

@@ -72,10 +72,14 @@ export const CREATE_INDEXES = [
   `CREATE INDEX IF NOT EXISTS idx_nodes_file ON nodes(file_path)`,
   `CREATE INDEX IF NOT EXISTS idx_nodes_label ON nodes(label)`,
   `CREATE INDEX IF NOT EXISTS idx_nodes_norm ON nodes(norm_label)`,
+  `CREATE INDEX IF NOT EXISTS idx_nodes_name ON nodes(name)`,
+  `CREATE INDEX IF NOT EXISTS idx_nodes_name_nocase ON nodes(name COLLATE NOCASE)`,
+  `CREATE INDEX IF NOT EXISTS idx_nodes_name_label ON nodes(name, label) WHERE file_path IS NOT NULL`,
   `CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source_id)`,
   `CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target_id)`,
   `CREATE INDEX IF NOT EXISTS idx_edges_relation ON edges(relation)`,
   `CREATE INDEX IF NOT EXISTS idx_edges_confidence ON edges(confidence)`,
+  `CREATE INDEX IF NOT EXISTS idx_edges_calls_lookup ON edges(source_id, target_id, relation) WHERE relation = 'CALLS'`,
 ];
 
 export const CREATE_NODE_PROPERTIES = `
@@ -120,6 +124,36 @@ export const CREATE_FILE_CACHE = `
   )
 `;
 
+export const CREATE_AGENT_INTERACTIONS = `
+CREATE TABLE IF NOT EXISTS agent_interactions (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL,
+  org_name TEXT,
+  agent_type TEXT NOT NULL,
+  parent_agent TEXT,
+  prompt_summary TEXT,
+  result_summary TEXT,
+  tokens_in INTEGER NOT NULL DEFAULT 0,
+  tokens_out INTEGER NOT NULL DEFAULT 0,
+  cost_usd REAL NOT NULL DEFAULT 0,
+  success INTEGER NOT NULL DEFAULT 1,
+  duration_ms INTEGER NOT NULL DEFAULT 0,
+  timestamp INTEGER NOT NULL,
+  metadata TEXT
+)`;
+
+export const CREATE_AGENT_INTERACTIONS_IDX = `
+CREATE INDEX IF NOT EXISTS idx_agent_interactions_session ON agent_interactions(session_id)`;
+
+export const CREATE_AGENT_INTERACTIONS_ORG_IDX = `
+CREATE INDEX IF NOT EXISTS idx_agent_interactions_org ON agent_interactions(org_name)`;
+
+export const CREATE_AGENT_INTERACTIONS_TYPE_IDX = `
+CREATE INDEX IF NOT EXISTS idx_agent_interactions_type ON agent_interactions(agent_type)`;
+
+export const CREATE_AGENT_INTERACTIONS_TS_IDX = `
+CREATE INDEX IF NOT EXISTS idx_agent_interactions_ts ON agent_interactions(timestamp)`;
+
 export const FTS_SYNC_TRIGGERS = `
 CREATE TRIGGER IF NOT EXISTS nodes_fts_insert AFTER INSERT ON nodes BEGIN
   INSERT INTO nodes_fts(rowid, id, name, norm_label, file_path, label)

package/src/web/analyze-api.ts

@@ -52,11 +52,13 @@ async function handleAnalyze(req: IncomingMessage, res: ServerResponse): Promise
   }
 
   // Set SSE headers
+  const origin = req.headers['origin'] ?? '';
+  const allowedOrigin = /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/.test(origin) ? origin : '';
   res.writeHead(200, {
     'Content-Type': 'text/event-stream',
     'Cache-Control': 'no-cache',
     'Connection': 'keep-alive',
-    'Access-Control-Allow-Origin': 'http://localhost',
+    ...(allowedOrigin && { 'Access-Control-Allow-Origin': allowedOrigin }),
   });
 
   const dbPath = resolve(join(repoPath, '.monomind', 'monograph.db'));

package/src/web/api.ts

@@ -1,10 +1,19 @@
 import type { Application } from 'express';
 import type Database from 'better-sqlite3';
 import { readFileSync } from 'fs';
-import { resolve, sep } from 'path';
+import { resolve, sep, dirname, join } from 'path';
+import { fileURLToPath } from 'url';
 import { ftsSearch } from '../storage/fts-store.js';
 import { globalJobRegistry } from './async-jobs.js';
 
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PKG_VERSION = (() => {
+  try {
+    const pkg = JSON.parse(readFileSync(join(__dirname, '..', '..', 'package.json'), 'utf8'));
+    return pkg.version ?? '0.0.0';
+  } catch { return '0.0.0'; }
+})();
+
 // ── Types ─────────────────────────────────────────────────────────────────────
 
 export interface ApiNode {
@@ -28,6 +37,9 @@ export interface GraphData {
   nodes: ApiNode[];
   edges: ApiEdge[];
   communities: Record<string, string[]>;
+  totalNodeCount: number;
+  totalEdgeCount: number;
+  truncated: boolean;
 }
 
 export interface NodeDetail {
@@ -58,9 +70,23 @@ export function rowToApiNode(row: Record<string, unknown>): ApiNode {
 }
 
 export function queryGraphData(db: Database.Database): GraphData {
+  const totalNodeCount = (db.prepare('SELECT COUNT(*) as c FROM nodes').get() as { c: number }).c;
+  const totalEdgeCount = (db.prepare('SELECT COUNT(*) as c FROM edges').get() as { c: number }).c;
+
+  // Select the most connected nodes for a representative visualization
   const nodeRows = db
     .prepare(
-      'SELECT id, name, label, file_path, start_line, end_line, community_id FROM nodes LIMIT 2000',
+      `SELECT n.id, n.name, n.label, n.file_path, n.start_line, n.end_line, n.community_id
+       FROM nodes n
+       LEFT JOIN (
+         SELECT node_id, SUM(cnt) AS deg FROM (
+           SELECT source_id AS node_id, COUNT(*) AS cnt FROM edges GROUP BY source_id
+           UNION ALL
+           SELECT target_id AS node_id, COUNT(*) AS cnt FROM edges GROUP BY target_id
+         ) GROUP BY node_id
+       ) d ON d.node_id = n.id
+       ORDER BY d.deg DESC NULLS LAST
+       LIMIT 2000`,
     )
     .all() as Record<string, unknown>[];
 
@@ -69,23 +95,23 @@ export function queryGraphData(db: Database.Database): GraphData {
 
   const edges: ApiEdge[] = [];
   if (nodeIds.size > 0) {
-    // Use a subquery instead of IN(?,...) to avoid SQLite's SQLITE_MAX_VARIABLE_NUMBER limit
+    // Scan edges and keep those where at least one endpoint is a visible node
     const edgeRows = db
-      .prepare(
-        `SELECT e.source_id, e.target_id, e.relation, e.confidence_score
-         FROM edges e
-         JOIN (SELECT id FROM nodes LIMIT 2000) n ON e.source_id = n.id
-         LIMIT 10000`,
-      )
+      .prepare('SELECT source_id, target_id, relation, confidence_score FROM edges')
       .all() as Record<string, unknown>[];
 
     for (const r of edgeRows) {
-      edges.push({
-        sourceId: r['source_id'] as string,
-        targetId: r['target_id'] as string,
-        relation: r['relation'] as string,
-        confidenceScore: r['confidence_score'] as number,
-      });
+      const src = r['source_id'] as string;
+      const tgt = r['target_id'] as string;
+      if (nodeIds.has(src) && nodeIds.has(tgt)) {
+        edges.push({
+          sourceId: src,
+          targetId: tgt,
+          relation: r['relation'] as string,
+          confidenceScore: r['confidence_score'] as number,
+        });
+        if (edges.length >= 10000) break;
+      }
     }
   }
 
@@ -98,7 +124,7 @@ export function queryGraphData(db: Database.Database): GraphData {
     }
   }
 
-  return { nodes, edges, communities };
+  return { nodes, edges, communities, totalNodeCount, totalEdgeCount, truncated: totalNodeCount > nodes.length };
 }
 
 export function queryNode(db: Database.Database, id: string): NodeDetail {
@@ -140,8 +166,8 @@ export function querySearch(db: Database.Database, q: string): ApiNode[] {
     name: r.name,
     label: r.label,
     filePath: r.filePath,
-    startLine: null,
-    endLine: null,
+    startLine: r.startLine ?? null,
+    endLine: r.endLine ?? null,
     communityId: null,
   }));
 }
@@ -294,7 +320,7 @@ export interface ServerInfo {
 export function getServerInfo(): ServerInfo {
   return {
     name: 'monograph',
-    version: '1.0.0',
+    version: PKG_VERSION,
     nodeVersion: process.version,
     uptimeSeconds: process.uptime(),
   };
@@ -409,16 +435,30 @@ export function setupApiRoutes(app: Application, db: Database.Database): void {
 
   // Async analyze job API
   app.post('/api/analyze', (req, res) => {
-    const { repoPath } = req.body as { repoPath?: string };
+    const { repoPath, codeOnly, force } = req.body as { repoPath?: string; codeOnly?: boolean; force?: boolean };
     if (!repoPath) {
       res.status(400).json({ error: 'repoPath is required' });
       return;
     }
     const job = globalJobRegistry.create('analyze', { repoPath });
     globalJobRegistry.update(job.id, { status: 'running' });
-    setImmediate(() => {
-      globalJobRegistry.update(job.id, { status: 'done', result: { message: 'ok' } });
+
+    import('../pipeline/orchestrator.js').then(({ buildAsync }) => {
+      buildAsync(repoPath, {
+        codeOnly,
+        force,
+        onProgress: (p) => {
+          globalJobRegistry.emitProgress(job.id, { phase: p.phase ?? '', message: p.message });
+        },
+      }).then(() => {
+        globalJobRegistry.update(job.id, { status: 'done', result: { message: 'Build complete' } });
+      }).catch((err) => {
+        globalJobRegistry.update(job.id, { status: 'failed', result: { error: String(err) } });
+      });
+    }).catch((err) => {
+      globalJobRegistry.update(job.id, { status: 'failed', result: { error: String(err) } });
     });
+
     res.status(202).json({ jobId: job.id });
   });
 

package/src/web/async-jobs.ts

@@ -31,12 +31,26 @@ export interface JobRegistry {
   getProgress(id: string): ProgressEvent[];
 }
 
+const MAX_COMPLETED_JOBS = 50;
+
 export function createJobRegistry(): JobRegistry {
   const jobs = new Map<string, Job>();
   const progressMap = new Map<string, ProgressEvent[]>();
 
   function now(): string { return new Date().toISOString(); }
 
+  function evictOldCompleted(): void {
+    const completed = [...jobs.entries()]
+      .filter(([, j]) => j.status === 'done' || j.status === 'failed' || j.status === 'cancelled');
+    if (completed.length <= MAX_COMPLETED_JOBS) return;
+    completed.sort((a, b) => a[1].updatedAt.localeCompare(b[1].updatedAt));
+    const toEvict = completed.slice(0, completed.length - MAX_COMPLETED_JOBS);
+    for (const [id] of toEvict) {
+      jobs.delete(id);
+      progressMap.delete(id);
+    }
+  }
+
   return {
     create(type, payload) {
       const job: Job = {
@@ -60,6 +74,7 @@ export function createJobRegistry(): JobRegistry {
       if (!j) return false;
       if (j.status === 'done' || j.status === 'failed' || j.status === 'cancelled') return false;
       Object.assign(j, patch, { updatedAt: now() });
+      if (patch.status === 'done' || patch.status === 'failed') evictOldCompleted();
       return true;
     },
     cancel(id) {

package/src/web/react-ui.ts

@@ -29,9 +29,9 @@ export function getReactUiHtml(): string {
 
       async function search() {
         if (!query.trim()) return;
-        const res = await fetch('/api/query?q=' + encodeURIComponent(query));
+        const res = await fetch('/api/search?q=' + encodeURIComponent(query));
         const data = await res.json();
-        setResults(data.results ?? data ?? []);
+        setResults(Array.isArray(data) ? data : data.results ?? []);
       }
 
       async function analyze() {

package/src/wiki/wiki-generator.ts

@@ -104,14 +104,17 @@ export async function generateWikiPage(
 
   // 2. Get top 5 symbols by degree (count of connected edges, since no centrality column)
   const symbolRows = db.prepare(`
-    SELECT n.name, n.label, n.file_path,
-           COUNT(DISTINCT e1.id) + COUNT(DISTINCT e2.id) AS degree
+    SELECT n.name, n.label, n.file_path
     FROM nodes n
-    LEFT JOIN edges e1 ON e1.source_id = n.id
-    LEFT JOIN edges e2 ON e2.target_id = n.id
+    LEFT JOIN (
+      SELECT node_id, SUM(cnt) AS deg FROM (
+        SELECT source_id AS node_id, COUNT(*) AS cnt FROM edges GROUP BY source_id
+        UNION ALL
+        SELECT target_id AS node_id, COUNT(*) AS cnt FROM edges GROUP BY target_id
+      ) GROUP BY node_id
+    ) d ON d.node_id = n.id
     WHERE n.community_id = ?
-    GROUP BY n.id
-    ORDER BY degree DESC, n.name ASC
+    ORDER BY d.deg DESC NULLS LAST, n.name ASC
     LIMIT 5
   `).all(Number(communityIdStr)) as { name: string; label: string; file_path: string | null }[];
 

package/__tests__/search/embed-batch-config.test.ts

@@ -1,62 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { embedBatch } from '../../src/search/embed-batch.js';
-import { HttpEmbedder } from '../../src/search/http-embedder.js';
-
-// Spy on the prototype method instead of mocking the whole module via a
-// factory: constructing a class through a vi.mock() factory's returned
-// vi.fn() doesn't reliably preserve the factory's `mockImplementation`
-// return value under this vitest/tinyspy version — `new MockedClass()`
-// silently produces an empty auto-mock instance instead. Spying on the real
-// prototype method keeps the real constructor (harmless — it only assigns
-// config, no network call) and avoids that pitfall entirely.
-let embedBatchSpy: ReturnType<typeof vi.spyOn>;
-
-beforeEach(() => {
-  embedBatchSpy = vi
-    .spyOn(HttpEmbedder.prototype, 'embedBatch')
-    .mockResolvedValue([[0.1, 0.2], [0.3, 0.4]]);
-});
-
-afterEach(() => {
-  embedBatchSpy.mockRestore();
-});
-
-describe('embedBatch with remote config', () => {
-  it('uses HttpEmbedder when remote config is provided', async () => {
-    const result = await embedBatch(['hello', 'world'], {
-      remote: { endpoint: 'http://localhost:1234/embed' },
-    });
-    expect(embedBatchSpy).toHaveBeenCalledWith(['hello', 'world']);
-    const instance = embedBatchSpy.mock.contexts[0] as InstanceType<typeof HttpEmbedder> & {
-      config: { endpoint: string };
-    };
-    expect(instance.config.endpoint).toBe('http://localhost:1234/embed');
-    expect(result).toEqual([[0.1, 0.2], [0.3, 0.4]]);
-  });
-
-  it('passes all remote config fields to HttpEmbedder', async () => {
-    await embedBatch(['text'], {
-      remote: { endpoint: 'http://host/embed', apiKey: 'sk-test', model: 'nomic' },
-    });
-    const instance = embedBatchSpy.mock.contexts[0] as InstanceType<typeof HttpEmbedder> & {
-      config: { endpoint: string; apiKey: string; model: string };
-    };
-    expect(instance.config).toMatchObject({
-      endpoint: 'http://host/embed',
-      apiKey: 'sk-test',
-      model: 'nomic',
-    });
-  });
-});
-
-describe('embedBatch without remote config', () => {
-  it('does not instantiate HttpEmbedder when no remote config', async () => {
-    // Local embedder may fail or hang in test env — race against a short timeout
-    // so we just verify HttpEmbedder.embedBatch was NOT called regardless of outcome.
-    await Promise.race([
-      embedBatch(['hello']).catch(() => { /* expected in CI without a real local model */ }),
-      new Promise(resolve => setTimeout(resolve, 500)),
-    ]);
-    expect(embedBatchSpy).not.toHaveBeenCalled();
-  }, 2000);
-});