@monoes/monograph 1.3.0 → 1.4.0

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 }[];