kachow 0.1.0

package/_server/dist/services/graphService.js

@@ -0,0 +1,532 @@
+"use strict";
+/**
+ * Graph read service — Phase 2.
+ * Pure read queries against SQLite. No mutations here.
+ * All write paths live in ingestWorker.ts.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNodes = getNodes;
+exports.getEdges = getEdges;
+exports.getNodeDetail = getNodeDetail;
+exports.getCriticalIssues = getCriticalIssues;
+exports.getSystemHealth = getSystemHealth;
+exports.getSnapshot = getSnapshot;
+exports.saveSnapshot = saveSnapshot;
+const crypto_1 = require("crypto");
+const index_js_1 = require("../db/index.js");
+const graphLayout_js_1 = require("./graphLayout.js");
+// ── Helpers ───────────────────────────────────────────────────────────────────
+/**
+ * Parses a JSON endpoints string stored in the DB into a string array.
+ * Returns an empty array on any parse error.
+ *
+ * @param raw - JSON string from the DB or null
+ * @returns Parsed string array
+ */
+function parseEndpoints(raw) {
+    if (!raw)
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
+// ── Query functions ───────────────────────────────────────────────────────────
+/**
+ * Returns all service nodes with computed layout coordinates and connection counts.
+ * When teamName is supplied only that team's services + their external references are returned.
+ * When teamId is supplied, filters by FK team_id for multi-tenant isolation.
+ * Used by GET /api/graph/nodes.
+ *
+ * @param teamName - Optional team name (label) to filter services by
+ * @param teamId   - Optional team ID (FK) for multi-tenant scoping
+ * @returns Array of GraphNode objects sorted by health score descending
+ */
+function getNodes(teamName, teamId) {
+    const db = (0, index_js_1.getDb)();
+    let rows;
+    if (teamId) {
+        // Multi-tenant: filter by FK
+        rows = db.prepare(`
+            SELECT s.id, s.name, s.team, s.language, s.health_score, s.health_tier,
+              s.repo_url, s.doc_coverage, s.test_coverage, s.last_ingested,
+              (SELECT COUNT(*) FROM dependencies WHERE source_id = s.id) +
+              (SELECT COUNT(*) FROM dependencies WHERE target_id = s.id) AS connection_count
+            FROM services s WHERE s.is_external = 0 AND s.team_id = ?
+            ORDER BY s.health_score DESC
+        `).all(teamId);
+        if (rows.length === 0) {
+            // fallback to all
+            rows = db.prepare(`
+                SELECT s.id, s.name, s.team, s.language, s.health_score, s.health_tier,
+                  s.repo_url, s.doc_coverage, s.test_coverage, s.last_ingested,
+                  (SELECT COUNT(*) FROM dependencies WHERE source_id = s.id) +
+                  (SELECT COUNT(*) FROM dependencies WHERE target_id = s.id) AS connection_count
+                FROM services s WHERE s.is_external = 0
+                ORDER BY s.health_score DESC
+            `).all();
+        }
+    }
+    else if (teamName) {
+        rows = db.prepare(`
+            SELECT s.id, s.name, s.team, s.language, s.health_score, s.health_tier,
+              s.repo_url, s.doc_coverage, s.test_coverage, s.last_ingested,
+              (SELECT COUNT(*) FROM dependencies WHERE source_id = s.id) +
+              (SELECT COUNT(*) FROM dependencies WHERE target_id = s.id) AS connection_count
+            FROM services s WHERE s.is_external = 0 AND s.team = ?
+            ORDER BY s.health_score DESC
+        `).all(teamName);
+        if (rows.length === 0) {
+            rows = db.prepare(`
+                SELECT s.id, s.name, s.team, s.language, s.health_score, s.health_tier,
+                  s.repo_url, s.doc_coverage, s.test_coverage, s.last_ingested,
+                  (SELECT COUNT(*) FROM dependencies WHERE source_id = s.id) +
+                  (SELECT COUNT(*) FROM dependencies WHERE target_id = s.id) AS connection_count
+                FROM services s WHERE s.is_external = 0
+                ORDER BY s.health_score DESC
+            `).all();
+        }
+    }
+    else {
+        rows = db.prepare(`
+            SELECT s.id, s.name, s.team, s.language, s.health_score, s.health_tier,
+              s.repo_url, s.doc_coverage, s.test_coverage, s.last_ingested,
+              (SELECT COUNT(*) FROM dependencies WHERE source_id = s.id) +
+              (SELECT COUNT(*) FROM dependencies WHERE target_id = s.id) AS connection_count
+            FROM services s WHERE s.is_external = 0
+            ORDER BY s.health_score DESC
+        `).all();
+    }
+    const internalIds = rows.map(r => r.id);
+    const idPlaceholders = internalIds.length ? internalIds.map(() => '?').join(',') : "''";
+    // External nodes that are referenced by the (filtered) internal services
+    const externalRows = db.prepare(`
+    SELECT
+      s.id, s.name, s.team, s.language, s.health_score, s.health_tier,
+      s.repo_url, s.doc_coverage, s.test_coverage, s.last_ingested,
+      (SELECT COUNT(*) FROM dependencies WHERE source_id = s.id) +
+      (SELECT COUNT(*) FROM dependencies WHERE target_id = s.id) AS connection_count
+    FROM services s
+    WHERE s.is_external = 1
+      AND (
+        EXISTS (SELECT 1 FROM dependencies WHERE target_id = s.id AND source_id IN (${idPlaceholders}))
+        OR EXISTS (SELECT 1 FROM dependencies WHERE source_id = s.id AND target_id IN (${idPlaceholders}))
+      )
+    ORDER BY s.name
+  `).all(...internalIds, ...internalIds);
+    const edgeRows = db.prepare('SELECT source_id, target_id FROM dependencies').all();
+    const layout = (0, graphLayout_js_1.computeLayout)(rows, edgeRows);
+    // Position external nodes in a dedicated far-right column
+    const EXT_X = 1350;
+    const extStep = externalRows.length > 0 ? 700 / (externalRows.length + 1) : 350;
+    const result = rows.map((r) => ({
+        id: r.id,
+        name: r.name,
+        healthScore: r.health_score,
+        healthTier: r.health_tier,
+        team: r.team,
+        language: r.language,
+        connectionCount: r.connection_count,
+        x: layout.get(r.id)?.x ?? 700,
+        y: layout.get(r.id)?.y ?? 350,
+    }));
+    externalRows.forEach((r, i) => {
+        result.push({
+            id: r.id,
+            name: r.name,
+            healthScore: r.health_score,
+            healthTier: r.health_tier,
+            team: r.team,
+            language: r.language,
+            connectionCount: r.connection_count,
+            x: EXT_X,
+            y: Math.round(extStep * (i + 1)),
+            isExternal: true,
+        });
+    });
+    return result;
+}
+/**
+ * Returns all dependency edges in the graph.
+ * When teamName is supplied only edges where at least one endpoint belongs to
+ * that team are returned.
+ * Used by GET /api/graph/edges.
+ *
+ * @param teamName - Optional team name (label) to filter edges by
+ * @param teamId   - Optional team ID (FK) for multi-tenant scoping
+ * @returns Array of GraphEdge objects
+ */
+function getEdges(teamName, teamId) {
+    const db = (0, index_js_1.getDb)();
+    let rows;
+    if (teamId) {
+        rows = db.prepare(`
+            SELECT d.id, d.source_id, d.target_id, d.type, d.endpoints, d.strength
+            FROM dependencies d
+            WHERE d.source_id IN (SELECT id FROM services WHERE team_id = ?)
+               OR d.target_id IN (SELECT id FROM services WHERE team_id = ?)
+        `).all(teamId, teamId);
+        if (rows.length === 0) {
+            rows = db.prepare('SELECT id, source_id, target_id, type, endpoints, strength FROM dependencies').all();
+        }
+    }
+    else if (teamName) {
+        rows = db.prepare(`
+            SELECT d.id, d.source_id, d.target_id, d.type, d.endpoints, d.strength
+            FROM dependencies d
+            WHERE d.source_id IN (SELECT id FROM services WHERE team = ?)
+               OR d.target_id IN (SELECT id FROM services WHERE team = ?)
+        `).all(teamName, teamName);
+        if (rows.length === 0) {
+            rows = db.prepare('SELECT id, source_id, target_id, type, endpoints, strength FROM dependencies').all();
+        }
+    }
+    else {
+        rows = db.prepare('SELECT id, source_id, target_id, type, endpoints, strength FROM dependencies').all();
+    }
+    return rows.map((r) => ({
+        id: r.id,
+        sourceId: r.source_id,
+        targetId: r.target_id,
+        type: r.type,
+        endpoints: parseEndpoints(r.endpoints),
+        strength: r.strength,
+    }));
+}
+/**
+ * Returns full detail for a single service node.
+ * Includes endpoints, incidents, inbound/outbound dependencies, and recent activity.
+ * Used by GET /api/graph/node/:id.
+ *
+ * @param id - Service node ID
+ * @returns GraphNodeDetail or null if not found
+ */
+function getNodeDetail(id) {
+    const db = (0, index_js_1.getDb)();
+    const svcRow = db.prepare(`
+    SELECT s.*,
+      (SELECT COUNT(*) FROM dependencies WHERE source_id = s.id) +
+      (SELECT COUNT(*) FROM dependencies WHERE target_id = s.id) AS connection_count
+    FROM services s WHERE s.id = ?
+  `).get(id);
+    if (!svcRow)
+        return null;
+    const edgeRows = db.prepare('SELECT source_id, target_id FROM dependencies').all();
+    const layout = (0, graphLayout_js_1.computeLayout)(db.prepare('SELECT id FROM services').all(), edgeRows);
+    const endpoints = db.prepare('SELECT id, method, path, deprecated, has_spec FROM endpoints WHERE service_id = ?').all(id);
+    const incidents = db.prepare(`
+    SELECT id, severity, title, status, occurred_at, resolved_at
+    FROM incidents WHERE service_id = ? ORDER BY occurred_at DESC LIMIT 10
+  `).all(id);
+    const dependsOn = db.prepare(`
+    SELECT d.id, d.source_id, d.target_id, d.type, d.endpoints, d.strength,
+           s.id as peer_id, s.name as peer_name
+    FROM dependencies d JOIN services s ON s.id = d.target_id
+    WHERE d.source_id = ?
+  `).all(id);
+    const dependedOnBy = db.prepare(`
+    SELECT d.id, d.source_id, d.target_id, d.type, d.endpoints, d.strength,
+           s.id as peer_id, s.name as peer_name
+    FROM dependencies d JOIN services s ON s.id = d.source_id
+    WHERE d.target_id = ?
+  `).all(id);
+    const recentActivity = db.prepare(`
+    SELECT id, type, title, detail, created_at FROM activity_feed
+    WHERE service_id = ? ORDER BY created_at DESC LIMIT 10
+  `).all(id);
+    return {
+        service: {
+            id: svcRow.id, name: svcRow.name,
+            healthScore: svcRow.health_score, healthTier: svcRow.health_tier,
+            team: svcRow.team, language: svcRow.language,
+            connectionCount: svcRow.connection_count,
+            x: layout.get(id)?.x ?? 700, y: layout.get(id)?.y ?? 350,
+            repoUrl: svcRow.repo_url, docCoverage: svcRow.doc_coverage,
+            testCoverage: svcRow.test_coverage, lastIngested: svcRow.last_ingested,
+        },
+        endpoints: endpoints.map((e) => ({
+            id: e.id, method: e.method, path: e.path,
+            deprecated: e.deprecated === 1, hasSpec: e.has_spec === 1,
+        })),
+        incidents: incidents.map((i) => ({
+            id: i.id, severity: i.severity, title: i.title, status: i.status,
+            occurredAt: i.occurred_at, resolvedAt: i.resolved_at,
+        })),
+        dependsOn: dependsOn.map((d) => ({
+            serviceId: d.peer_id, serviceName: d.peer_name,
+            type: d.type, endpoints: parseEndpoints(d.endpoints),
+            strength: d.strength,
+        })),
+        dependedOnBy: dependedOnBy.map((d) => ({
+            serviceId: d.peer_id, serviceName: d.peer_name,
+            type: d.type, endpoints: parseEndpoints(d.endpoints),
+            strength: d.strength,
+        })),
+        recentActivity: recentActivity.map((a) => ({
+            id: a.id, type: a.type, title: a.title, detail: a.detail, createdAt: a.created_at,
+        })),
+    };
+}
+/**
+ * Aggregates critical issues from three sources:
+ *   1. Agent KG — healthIssues per node + selfHealingSuggestions
+ *   2. healing_prs table — issues detected by self-healing agents
+ *   3. incidents table — open incidents
+ *
+ * Returns a flat CriticalIssue[] sorted by severity (critical → warning → info).
+ */
+function getCriticalIssues(teamId) {
+    const db = (0, index_js_1.getDb)();
+    const issues = [];
+    // ── 1) Agent Knowledge Graph health issues + self-healing ─────────────────
+    // Service lookup for enrichment (scoped by team when provided)
+    const svcMap = new Map();
+    const svcQuery = teamId
+        ? 'SELECT id, name, health_score, health_tier FROM services WHERE is_external = 0 AND team_id = ?'
+        : 'SELECT id, name, health_score, health_tier FROM services WHERE is_external = 0';
+    const svcRows = teamId
+        ? db.prepare(svcQuery).all(teamId)
+        : db.prepare(svcQuery).all();
+    for (const s of svcRows)
+        svcMap.set(s.id, { name: s.name, healthScore: s.health_score, healthTier: s.health_tier });
+    // Also build a name→id reverse lookup (agent KG uses service names, not IDs)
+    const nameToId = new Map();
+    for (const s of svcRows)
+        nameToId.set(s.name.toLowerCase(), s.id);
+    // Read the latest agent KG from knowledge_graph table (team-scoped when provided)
+    const kgQuery = teamId
+        ? `SELECT nodes, self_healing FROM knowledge_graph WHERE team_id = ? ORDER BY created_at DESC LIMIT 1`
+        : `SELECT nodes, self_healing FROM knowledge_graph ORDER BY created_at DESC LIMIT 1`;
+    const kgRow = teamId
+        ? db.prepare(kgQuery).get(teamId)
+        : db.prepare(kgQuery).get();
+    if (kgRow) {
+        try {
+            const kgNodes = JSON.parse(kgRow.nodes);
+            const selfHealing = JSON.parse(kgRow.self_healing);
+            // Per-node health issues
+            for (const n of kgNodes) {
+                const svcId = n.id ?? nameToId.get(n.name.toLowerCase());
+                const svc = svcId ? svcMap.get(svcId) : undefined;
+                for (const issue of n.healthIssues ?? []) {
+                    const severity = classifySeverity(issue);
+                    issues.push({
+                        id: `agent-hi-${svcId ?? n.name}-${issues.length}`,
+                        serviceId: svcId ?? n.name,
+                        serviceName: svc?.name ?? n.name,
+                        healthScore: svc?.healthScore ?? 0,
+                        healthTier: svc?.healthTier ?? 'warning',
+                        severity,
+                        category: classifyCategory(issue),
+                        title: issue.length > 80 ? issue.slice(0, 77) + '…' : issue,
+                        description: issue,
+                        file: null,
+                        line: null,
+                        suggestedFix: null,
+                        source: 'agent',
+                    });
+                }
+            }
+            // Self-healing suggestions (richer — include file/line/fix)
+            for (const sh of selfHealing) {
+                const svcId = sh.serviceId ?? nameToId.get(sh.serviceName.toLowerCase());
+                const svc = svcId ? svcMap.get(svcId) : undefined;
+                issues.push({
+                    id: `agent-sh-${svcId ?? sh.serviceName}-${issues.length}`,
+                    serviceId: svcId ?? sh.serviceName,
+                    serviceName: svc?.name ?? sh.serviceName,
+                    healthScore: svc?.healthScore ?? 0,
+                    healthTier: svc?.healthTier ?? 'warning',
+                    severity: (sh.severity === 'critical' || sh.severity === 'warning' || sh.severity === 'info')
+                        ? sh.severity : 'warning',
+                    category: classifyCategory(sh.issue),
+                    title: sh.issue.length > 80 ? sh.issue.slice(0, 77) + '…' : sh.issue,
+                    description: sh.issue,
+                    file: sh.file || null,
+                    line: sh.line || null,
+                    suggestedFix: sh.suggestion || null,
+                    source: 'agent',
+                });
+            }
+        }
+        catch { /* ignore malformed KG */ }
+    }
+    const healingQuery = teamId
+        ? `SELECT id, service_id, issue_type, explanation, status
+           FROM healing_prs WHERE status IN ('detected', 'open') AND team_id = ?`
+        : `SELECT id, service_id, issue_type, explanation, status
+           FROM healing_prs WHERE status IN ('detected', 'open')`;
+    const healingRows = teamId
+        ? db.prepare(healingQuery).all(teamId)
+        : db.prepare(healingQuery).all();
+    for (const h of healingRows) {
+        const svc = svcMap.get(h.service_id);
+        // Avoid duplicate if agent KG already has the same issue text
+        const dup = issues.some(i => i.serviceId === h.service_id && i.description === h.explanation);
+        if (!dup) {
+            issues.push({
+                id: `heal-${h.id}`,
+                serviceId: h.service_id,
+                serviceName: svc?.name ?? h.service_id,
+                healthScore: svc?.healthScore ?? 0,
+                healthTier: svc?.healthTier ?? 'warning',
+                severity: classifySeverity(h.issue_type + ' ' + h.explanation),
+                category: classifyCategory(h.issue_type),
+                title: h.issue_type,
+                description: h.explanation,
+                file: null,
+                line: null,
+                suggestedFix: null,
+                source: 'healing',
+            });
+        }
+    }
+    // ── 3) Open incidents (scoped through service FK when teamId provided) ──
+    const incidentQuery = teamId
+        ? `SELECT i.id, i.service_id, i.severity, i.title, i.status, i.occurred_at
+           FROM incidents i
+           JOIN services s ON s.id = i.service_id
+           WHERE i.status != 'resolved' AND s.team_id = ?
+           ORDER BY i.occurred_at DESC LIMIT 30`
+        : `SELECT id, service_id, severity, title, status, occurred_at
+           FROM incidents WHERE status != 'resolved' ORDER BY occurred_at DESC LIMIT 30`;
+    const incidentRows = teamId
+        ? db.prepare(incidentQuery).all(teamId)
+        : db.prepare(incidentQuery).all();
+    for (const inc of incidentRows) {
+        const svc = svcMap.get(inc.service_id);
+        issues.push({
+            id: `inc-${inc.id}`,
+            serviceId: inc.service_id,
+            serviceName: svc?.name ?? inc.service_id,
+            healthScore: svc?.healthScore ?? 0,
+            healthTier: svc?.healthTier ?? 'warning',
+            severity: inc.severity === 'critical' ? 'critical' : inc.severity === 'warning' ? 'warning' : 'info',
+            category: 'reliability',
+            title: inc.title,
+            description: `${inc.title} — ${inc.status} since ${inc.occurred_at}`,
+            file: null,
+            line: null,
+            suggestedFix: null,
+            source: 'incident',
+        });
+    }
+    // ── Sort: critical first, then warning, then info ─────────────────────────
+    const ORDER = { critical: 0, warning: 1, info: 2 };
+    issues.sort((a, b) => (ORDER[a.severity] ?? 2) - (ORDER[b.severity] ?? 2));
+    return issues;
+}
+// Heuristic severity from free-text
+function classifySeverity(text) {
+    const t = text.toLowerCase();
+    if (/hardcoded.*(key|secret|password|token)|sql.?inject|xss|remote.?code|auth.?bypass|critical/i.test(t))
+        return 'critical';
+    if (/missing.*header|no.*(rate.?limit|input.?valid|error.?hand)|warning|deprecated/i.test(t))
+        return 'warning';
+    return 'info';
+}
+// Heuristic category from free-text
+function classifyCategory(text) {
+    const t = text.toLowerCase();
+    if (/secur|key|secret|token|inject|xss|auth|password|cors|header/i.test(t))
+        return 'security';
+    if (/perf|latency|cache|throughput|slow|memory|cpu/i.test(t))
+        return 'performance';
+    if (/reliab|error.?hand|circuit|retry|timeout|crash|incident|health/i.test(t))
+        return 'reliability';
+    return 'quality';
+}
+/**
+ * Returns aggregate health metrics for the entire system.
+ * Used by GET /api/graph/health — polled every 30s by the frontend.
+ *
+ * @returns SystemHealth object with score breakdown
+ */
+function getSystemHealth(teamId) {
+    const db = (0, index_js_1.getDb)();
+    const baseWhere = teamId
+        ? 'WHERE is_external = 0 AND team_id = ?'
+        : 'WHERE is_external = 0';
+    const params = teamId ? [teamId] : [];
+    const row = db.prepare(`
+    SELECT
+      ROUND(AVG(health_score), 1)                                        AS overall,
+      COUNT(*)                                                            AS total,
+      SUM(CASE WHEN health_tier = 'critical' THEN 1 ELSE 0 END)         AS critical,
+      SUM(CASE WHEN health_tier = 'warning'  THEN 1 ELSE 0 END)         AS warning,
+      SUM(CASE WHEN health_tier = 'healthy'  THEN 1 ELSE 0 END)         AS healthy,
+      MAX(last_ingested)                                                  AS last_updated
+    FROM services
+    ${baseWhere}
+  `).get(...params);
+    const edgeCount = teamId
+        ? (db.prepare(`SELECT COUNT(*) AS cnt FROM dependencies d
+             WHERE EXISTS (SELECT 1 FROM services s WHERE s.id = d.source_id AND s.team_id = ?)
+                OR EXISTS (SELECT 1 FROM services s WHERE s.id = d.target_id AND s.team_id = ?)`).get(teamId, teamId)?.cnt ?? 0)
+        : (db.prepare(`SELECT COUNT(*) AS cnt FROM dependencies`).get()?.cnt ?? 0);
+    return {
+        overallScore: row?.overall ?? 0,
+        totalServices: row?.total ?? 0,
+        critical: row?.critical ?? 0,
+        warning: row?.warning ?? 0,
+        healthy: row?.healthy ?? 0,
+        totalEdges: edgeCount,
+        lastUpdated: row?.last_updated ?? null,
+    };
+}
+/**
+ * Retrieves a stored graph snapshot by version string.
+ * Version 'latest' returns the most recently saved snapshot.
+ * Used by GET /api/graph/snapshot/:version.
+ *
+ * @param version - Git tag, ISO timestamp string, or 'latest'
+ * @returns GraphSnapshot or null if not found
+ */
+function getSnapshot(version) {
+    const db = (0, index_js_1.getDb)();
+    let row;
+    if (version === 'latest') {
+        row = db.prepare('SELECT nodes, edges, version, created_at FROM snapshots ORDER BY created_at DESC LIMIT 1').get();
+    }
+    else {
+        row = db.prepare('SELECT nodes, edges, version, created_at FROM snapshots WHERE version = ?').get(version);
+    }
+    if (!row)
+        return null;
+    try {
+        return {
+            nodes: JSON.parse(row.nodes),
+            edges: JSON.parse(row.edges),
+            version: row.version,
+            timestamp: row.created_at,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Saves the current graph state as a named snapshot.
+ * Called by the ingest worker after a successful full scan.
+ *
+ * @param version - Snapshot version label (git tag or ISO timestamp)
+ * @param teamId  - Optional team ID for multi-tenant scoping
+ * @returns void
+ */
+function saveSnapshot(version, teamId) {
+    const db = (0, index_js_1.getDb)();
+    const nodes = teamId ? getNodes(undefined, teamId) : getNodes();
+    const edges = getEdges();
+    db.prepare(`
+    INSERT INTO snapshots (id, version, team_id, nodes, edges)
+    VALUES (?, ?, ?, ?, ?)
+    ON CONFLICT(version, team_id) DO UPDATE SET
+      nodes = excluded.nodes,
+      edges = excluded.edges,
+      created_at = datetime('now')
+  `).run((0, crypto_1.randomUUID)(), version, teamId ?? null, JSON.stringify(nodes), JSON.stringify(edges));
+}
+//# sourceMappingURL=graphService.js.map