@unerr-ai/unerr 0.2.0 → 0.2.2

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

@@ -1,259 +0,0 @@
-/**
- * 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

@@ -1,136 +0,0 @@
-/**
- * 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();
-    }
-}