@unerr-ai/unerr 0.0.1 → 0.1.1

package/dist/intelligence/health-map-data.js

@@ -0,0 +1,259 @@
+/**
+ * HealthMapData — builds a hierarchical health map of the codebase.
+ *
+ * Combines CozoDB graph metrics (fan_in, fan_out, risk_level) with
+ * temporal facts (change frequency, coupling count, durability) to
+ * produce a per-file/per-directory health score.
+ *
+ * Part of Layer C of the Three-Layer Experience System.
+ */
+/**
+ * Compute health score from metrics.
+ *
+ * Formula: 0.3*(1-normalized_risk) + 0.2*durability + 0.2*convention_adherence
+ *        + 0.15*(1-normalized_coupling) + 0.15*(1-normalized_change_frequency)
+ */
+function computeHealthScore(metrics) {
+    const normalizedRisk = Math.min((metrics.fan_in + metrics.fan_out) / 40, 1.0);
+    const normalizedCoupling = Math.min(metrics.coupling_count / 10, 1.0);
+    const normalizedChangeFreq = Math.min(metrics.change_frequency / 10, 1.0);
+    return (0.3 * (1 - normalizedRisk) +
+        0.2 * metrics.durability +
+        0.2 * metrics.convention_adherence +
+        0.15 * (1 - normalizedCoupling) +
+        0.15 * (1 - normalizedChangeFreq));
+}
+/** Map health score to risk level. */
+function scoreToRisk(score) {
+    if (score >= 0.75)
+        return "low";
+    if (score >= 0.5)
+        return "medium";
+    if (score >= 0.25)
+        return "high";
+    return "critical";
+}
+export class HealthMapData {
+    localGraph;
+    factStore;
+    constructor(localGraph, factStore) {
+        this.localGraph = localGraph;
+        this.factStore = factStore;
+    }
+    /**
+     * Build a hierarchical health map tree for the codebase.
+     * Groups entities by directory, computes per-file and per-directory health.
+     */
+    async buildTree(rootPath) {
+        // Get all entities from graph
+        const stats = await this.localGraph.getLocalProjectStats();
+        const criticalNodes = await this.localGraph.getCriticalNodes(500);
+        // Build entity-to-file map
+        const fileEntities = new Map();
+        for (const entity of criticalNodes) {
+            const filePath = entity.file_path;
+            if (rootPath && !filePath.startsWith(rootPath))
+                continue;
+            const existing = fileEntities.get(filePath);
+            if (existing) {
+                existing.push(entity);
+            }
+            else {
+                fileEntities.set(filePath, [entity]);
+            }
+        }
+        // Get coupling facts for all files
+        const couplingCounts = new Map();
+        const changeCounts = new Map();
+        if (this.factStore) {
+            try {
+                const projectFacts = await this.factStore.recallByScope("project", 0.0);
+                for (const fact of projectFacts) {
+                    if (fact.subject.startsWith("coupling:")) {
+                        const pair = fact.subject.replace("coupling:", "");
+                        const files = pair.split("↔");
+                        for (const f of files) {
+                            if (f)
+                                couplingCounts.set(f, (couplingCounts.get(f) ?? 0) + 1);
+                        }
+                    }
+                }
+                // Count change frequency from episodic facts per file
+                for (const filePath of fileEntities.keys()) {
+                    try {
+                        const fileFacts = await this.factStore.recallForFile(filePath);
+                        const episodic = fileFacts.filter((f) => f.fact_type === "episodic");
+                        if (episodic.length > 0) {
+                            changeCounts.set(filePath, episodic.length);
+                        }
+                    }
+                    catch {
+                        // Non-critical
+                    }
+                }
+            }
+            catch {
+                // Non-critical — proceed with graph-only data
+            }
+        }
+        // Get convention adherence
+        let avgAdherence = 0.8; // Default
+        try {
+            const conventions = await this.localGraph.getConventions();
+            if (conventions && conventions.length > 0) {
+                avgAdherence =
+                    conventions.reduce((sum, c) => sum + c.adherence_rate, 0) /
+                        conventions.length /
+                        100;
+            }
+        }
+        catch {
+            // Non-critical
+        }
+        // Build file nodes
+        const fileNodes = [];
+        for (const [filePath, entities] of fileEntities) {
+            const totalFanIn = entities.reduce((s, e) => s + e.fan_in, 0);
+            const totalFanOut = entities.reduce((s, e) => s + e.fan_out, 0);
+            const highRiskCount = entities.filter((e) => e.risk_level === "high" || e.risk_level === "critical").length;
+            const metrics = {
+                fan_in: totalFanIn,
+                fan_out: totalFanOut,
+                durability: highRiskCount > 0 ? Math.max(0.2, 1 - highRiskCount * 0.15) : 0.8,
+                convention_adherence: avgAdherence,
+                change_frequency: changeCounts.get(filePath) ?? 0,
+                coupling_count: couplingCounts.get(filePath) ?? 0,
+            };
+            const healthScore = computeHealthScore(metrics);
+            const name = filePath.split("/").pop() ?? filePath;
+            fileNodes.push({
+                path: filePath,
+                name,
+                health_score: Math.round(healthScore * 100) / 100,
+                risk_level: scoreToRisk(healthScore),
+                metrics,
+                entity_count: entities.length,
+            });
+        }
+        // Group into directory tree
+        const dirMap = new Map();
+        for (const node of fileNodes) {
+            const dir = node.path.split("/").slice(0, -1).join("/") || ".";
+            const existing = dirMap.get(dir);
+            if (existing) {
+                existing.push(node);
+            }
+            else {
+                dirMap.set(dir, [node]);
+            }
+        }
+        // Build directory nodes
+        const dirNodes = [];
+        for (const [dirPath, children] of dirMap) {
+            const dirHealth = children.reduce((s, c) => s + c.health_score, 0) / children.length;
+            const totalEntities = children.reduce((s, c) => s + c.entity_count, 0);
+            const aggregatedMetrics = {
+                fan_in: children.reduce((s, c) => s + c.metrics.fan_in, 0),
+                fan_out: children.reduce((s, c) => s + c.metrics.fan_out, 0),
+                durability: children.reduce((s, c) => s + c.metrics.durability, 0) /
+                    children.length,
+                convention_adherence: children.reduce((s, c) => s + c.metrics.convention_adherence, 0) /
+                    children.length,
+                change_frequency: children.reduce((s, c) => s + c.metrics.change_frequency, 0),
+                coupling_count: children.reduce((s, c) => s + c.metrics.coupling_count, 0),
+            };
+            dirNodes.push({
+                path: dirPath,
+                name: dirPath.split("/").pop() ?? dirPath,
+                health_score: Math.round(dirHealth * 100) / 100,
+                risk_level: scoreToRisk(dirHealth),
+                metrics: aggregatedMetrics,
+                entity_count: totalEntities,
+                children: children.sort((a, b) => a.health_score - b.health_score),
+            });
+        }
+        // Root node
+        const rootHealth = dirNodes.length > 0
+            ? dirNodes.reduce((s, d) => s + d.health_score, 0) / dirNodes.length
+            : 0.5;
+        const totalEntities = dirNodes.reduce((s, d) => s + d.entity_count, 0);
+        return {
+            path: rootPath ?? ".",
+            name: rootPath?.split("/").pop() ?? "project",
+            health_score: Math.round(rootHealth * 100) / 100,
+            risk_level: scoreToRisk(rootHealth),
+            metrics: {
+                fan_in: dirNodes.reduce((s, d) => s + d.metrics.fan_in, 0),
+                fan_out: dirNodes.reduce((s, d) => s + d.metrics.fan_out, 0),
+                durability: dirNodes.length > 0
+                    ? dirNodes.reduce((s, d) => s + d.metrics.durability, 0) /
+                        dirNodes.length
+                    : 0.5,
+                convention_adherence: avgAdherence,
+                change_frequency: dirNodes.reduce((s, d) => s + d.metrics.change_frequency, 0),
+                coupling_count: dirNodes.reduce((s, d) => s + d.metrics.coupling_count, 0),
+            },
+            entity_count: totalEntities,
+            children: dirNodes.sort((a, b) => a.health_score - b.health_score),
+        };
+    }
+    /**
+     * Get health data for a single file.
+     */
+    async getFileHealth(filePath) {
+        const entities = await this.localGraph.getEntitiesByFile(filePath);
+        if (entities.length === 0)
+            return null;
+        const totalFanIn = entities.reduce((s, e) => s + e.fan_in, 0);
+        const totalFanOut = entities.reduce((s, e) => s + e.fan_out, 0);
+        const highRiskCount = entities.filter((e) => e.risk_level === "high" || e.risk_level === "critical").length;
+        let couplingCount = 0;
+        let changeFrequency = 0;
+        if (this.factStore) {
+            try {
+                const projectFacts = await this.factStore.recallByScope("project", 0.0);
+                for (const fact of projectFacts) {
+                    if (fact.subject.startsWith("coupling:") &&
+                        fact.subject.includes(filePath)) {
+                        couplingCount++;
+                    }
+                }
+                const fileFacts = await this.factStore.recallForFile(filePath);
+                changeFrequency = fileFacts.filter((f) => f.fact_type === "episodic").length;
+            }
+            catch {
+                // Non-critical
+            }
+        }
+        let conventionAdherence = 0.8;
+        try {
+            const conventions = await this.localGraph.getConventions();
+            if (conventions && conventions.length > 0) {
+                conventionAdherence =
+                    conventions.reduce((s, c) => s + c.adherence_rate, 0) /
+                        conventions.length /
+                        100;
+            }
+        }
+        catch {
+            // Non-critical
+        }
+        const metrics = {
+            fan_in: totalFanIn,
+            fan_out: totalFanOut,
+            durability: highRiskCount > 0 ? Math.max(0.2, 1 - highRiskCount * 0.15) : 0.8,
+            convention_adherence: conventionAdherence,
+            change_frequency: changeFrequency,
+            coupling_count: couplingCount,
+        };
+        const healthScore = computeHealthScore(metrics);
+        return {
+            path: filePath,
+            name: filePath.split("/").pop() ?? filePath,
+            health_score: Math.round(healthScore * 100) / 100,
+            risk_level: scoreToRisk(healthScore),
+            metrics,
+            entity_count: entities.length,
+        };
+    }
+}

package/dist/intelligence/import-symbols.js

@@ -0,0 +1,136 @@
+/**
+ * Lightweight, regex-based import-symbol extractor for the `get_imports` MCP
+ * tool. The graph stores file→file import edges but does NOT persist the
+ * imported symbol names; capturing them at the entity level would require a
+ * schema change. This module reads the source file on demand and pairs each
+ * resolved module path with the symbols imported from it.
+ *
+ * Languages covered: TypeScript / JavaScript (ESM `import` and CommonJS
+ * `require`). For other languages the call returns an empty map and the
+ * handler falls back to path-only output — identical to legacy behavior.
+ */
+import { promises as fs } from "node:fs";
+import { isAbsolute, resolve } from "node:path";
+const ESM_IMPORT_RE = /import\s+(?:type\s+)?(?:([^"';]*?)\s+from\s+)?["']([^"']+)["']/g;
+const REQUIRE_RE = /(?:const|let|var)\s+([^=]+?)\s*=\s*require\s*\(\s*["']([^"']+)["']\s*\)/g;
+function parseClause(clause) {
+    // clause can be:
+    //   "X"                       — default import
+    //   "* as X"                  — namespace import
+    //   "{ a, b as c }"           — named imports
+    //   "X, { a, b }"             — default + named
+    //   "X, * as Ns"              — default + namespace
+    const symbols = [];
+    const trimmed = clause.trim();
+    if (!trimmed)
+        return symbols;
+    // Split off the named-imports block if present.
+    const braceStart = trimmed.indexOf("{");
+    let head = trimmed;
+    let braced = "";
+    if (braceStart !== -1) {
+        const braceEnd = trimmed.indexOf("}", braceStart);
+        if (braceEnd !== -1) {
+            head = trimmed.slice(0, braceStart).replace(/,\s*$/, "").trim();
+            braced = trimmed.slice(braceStart + 1, braceEnd);
+        }
+    }
+    if (head) {
+        for (const part of head.split(",")) {
+            const piece = part.trim();
+            if (!piece)
+                continue;
+            const nsMatch = piece.match(/^\*\s+as\s+(\w+)$/);
+            if (nsMatch)
+                symbols.push(`* as ${nsMatch[1]}`);
+            else if (/^\w+$/.test(piece))
+                symbols.push(piece);
+        }
+    }
+    if (braced) {
+        for (const item of braced.split(",")) {
+            const piece = item.trim().replace(/^type\s+/, "");
+            if (!piece)
+                continue;
+            // "a as b" — record the original (exported) name.
+            const original = piece.split(/\s+as\s+/)[0]?.trim();
+            if (original && /^\w+$/.test(original))
+                symbols.push(original);
+        }
+    }
+    return symbols;
+}
+function parseRequireClause(clause) {
+    // Patterns:
+    //   "X"                — const X = require(...)
+    //   "{ a, b: c }"      — destructured
+    //   "{ a, b: c } = ..." — already trimmed by caller
+    const symbols = [];
+    const trimmed = clause.trim();
+    if (!trimmed)
+        return symbols;
+    if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+        for (const item of trimmed.slice(1, -1).split(",")) {
+            const piece = item.trim();
+            if (!piece)
+                continue;
+            const original = piece.split(/\s*:\s*/)[0]?.trim();
+            if (original && /^\w+$/.test(original))
+                symbols.push(original);
+        }
+    }
+    else if (/^\w+$/.test(trimmed)) {
+        symbols.push(trimmed);
+    }
+    return symbols;
+}
+/**
+ * Parse import statements from a TS/JS source string. Returns a map keyed by
+ * the literal source path/module specifier exactly as written. Comments and
+ * strings outside import statements are tolerated; the regex anchors on
+ * `import ... from "..."` and `require("...")` so false positives are rare.
+ */
+export function parseImportSymbols(source) {
+    const out = new Map();
+    const append = (key, syms) => {
+        const existing = out.get(key);
+        if (existing)
+            existing.push(...syms);
+        else
+            out.set(key, syms.slice());
+    };
+    // Strip line and block comments so they can't trigger the regex (cheap pass).
+    const stripped = source
+        .replace(/\/\*[\s\S]*?\*\//g, "")
+        .replace(/^\s*\/\/.*$/gm, "");
+    for (const m of stripped.matchAll(ESM_IMPORT_RE)) {
+        const clause = m[1] ?? "";
+        const src = m[2];
+        if (!src)
+            continue;
+        append(src, parseClause(clause));
+    }
+    for (const m of stripped.matchAll(REQUIRE_RE)) {
+        const clause = m[1] ?? "";
+        const src = m[2];
+        if (!src)
+            continue;
+        append(src, parseRequireClause(clause));
+    }
+    return out;
+}
+/**
+ * Best-effort load of a source file and parse its imports. Returns an empty
+ * map on any IO/parse failure — get_imports must remain useful even when the
+ * file moved or the language isn't TS/JS.
+ */
+export async function loadImportSymbols(projectRoot, filePath) {
+    const abs = isAbsolute(filePath) ? filePath : resolve(projectRoot, filePath);
+    try {
+        const text = await fs.readFile(abs, "utf8");
+        return parseImportSymbols(text);
+    }
+    catch {
+        return new Map();
+    }
+}