@unerr-ai/unerr 0.2.1 → 0.2.3

package/dist/intelligence/convention-learner.js

@@ -1,205 +0,0 @@
-/**
- * Convention Learning — detects developer correction patterns from
- * sequential shadow ledger entries and generates convention rules.
- *
- * Patterns detected:
- *   1. Rename: getData → fetchData → convention "use fetch prefix for data operations"
- *   2. Import reorganization: scattered → grouped → convention "group imports by type"
- *   3. Repeated structural changes → convention candidates
- *
- * Runs at session end or via `unerr learn` — never during active MCP serving.
- *
- * Temporal intelligence note: conventions are procedural memory (Section 13.2)
- * that mature through stages: tentative → emerging → established → stale.
- */
-/**
- * Analyze ledger entries for convention patterns.
- * Returns newly detected conventions.
- */
-export function learnConventions(entries) {
-    const conventions = [];
-    const renameConventions = detectRenamePatterns(entries);
-    conventions.push(...renameConventions);
-    const structuralConventions = detectStructuralPatterns(entries);
-    conventions.push(...structuralConventions);
-    return conventions;
-}
-function detectRenamePatterns(entries) {
-    const syncEntries = entries.filter((e) => e.tool === "sync_local_diff");
-    if (syncEntries.length < 2)
-        return [];
-    const renameGroups = new Map();
-    for (let i = 1; i < syncEntries.length; i++) {
-        const prev = syncEntries[i - 1];
-        const curr = syncEntries[i];
-        const prevFiles = extractFiles(prev.args_summary);
-        const currFiles = extractFiles(curr.args_summary);
-        const sameFiles = prevFiles.filter((f) => currFiles.includes(f));
-        for (const file of sameFiles) {
-            const prevContent = extractContent(prev.args_summary, file);
-            const currContent = extractContent(curr.args_summary, file);
-            if (!prevContent || !currContent)
-                continue;
-            const renames = detectNameChanges(prevContent, currContent);
-            for (const rename of renames) {
-                const pattern = extractNamingPattern(rename.fromName, rename.toName);
-                if (pattern) {
-                    const key = pattern;
-                    const group = renameGroups.get(key) ?? [];
-                    group.push({ ...rename, file, ts: curr.ts });
-                    renameGroups.set(key, group);
-                }
-            }
-        }
-    }
-    const conventions = [];
-    for (const [pattern, observations] of renameGroups) {
-        if (observations.length >= 2) {
-            conventions.push({
-                id: `rename:${pattern}:${Date.now()}`,
-                name: `Naming: ${pattern}`,
-                pattern,
-                evidence: observations.map((o) => `${o.fromName} → ${o.toName} in ${o.file}`),
-                confidence: Math.min(0.9, 0.5 + observations.length * 0.1),
-                detectedAt: new Date().toISOString(),
-                observationCount: observations.length,
-            });
-        }
-    }
-    return conventions;
-}
-function detectStructuralPatterns(entries) {
-    const fileModCounts = new Map();
-    for (const entry of entries) {
-        if (entry.tool !== "sync_local_diff")
-            continue;
-        const files = extractFiles(entry.args_summary);
-        for (const f of files) {
-            fileModCounts.set(f, (fileModCounts.get(f) ?? 0) + 1);
-        }
-    }
-    const conventions = [];
-    const coChangeGroups = detectCoChanges(entries);
-    for (const [key, files] of coChangeGroups) {
-        if (files.count >= 3) {
-            conventions.push({
-                id: `cochange:${key}:${Date.now()}`,
-                name: `Co-change: ${files.files.slice(0, 2).join(" + ")}`,
-                pattern: "co-change",
-                evidence: files.files,
-                confidence: Math.min(0.8, 0.4 + files.count * 0.1),
-                detectedAt: new Date().toISOString(),
-                observationCount: files.count,
-            });
-        }
-    }
-    return conventions;
-}
-function detectCoChanges(entries) {
-    const groups = new Map();
-    const syncEntries = entries.filter((e) => e.tool === "sync_local_diff");
-    for (const entry of syncEntries) {
-        const files = extractFiles(entry.args_summary).sort();
-        if (files.length < 2)
-            continue;
-        for (let i = 0; i < files.length - 1; i++) {
-            for (let j = i + 1; j < files.length && j < i + 4; j++) {
-                const key = `${files[i]}+${files[j]}`;
-                const existing = groups.get(key) ?? {
-                    files: [files[i], files[j]],
-                    count: 0,
-                };
-                existing.count++;
-                groups.set(key, existing);
-            }
-        }
-    }
-    return groups;
-}
-function extractFiles(args) {
-    const files = args.files;
-    if (!Array.isArray(files))
-        return [];
-    return files
-        .map((f) => typeof f === "string" ? f : (f?.path ?? ""))
-        .filter(Boolean);
-}
-function extractContent(args, filePath) {
-    const files = args.files;
-    if (!Array.isArray(files))
-        return null;
-    for (const f of files) {
-        if (typeof f === "object" && f !== null) {
-            const obj = f;
-            if (obj.path === filePath && obj.content)
-                return obj.content;
-        }
-    }
-    return null;
-}
-function detectNameChanges(prevContent, currContent) {
-    const prevNames = extractIdentifiers(prevContent);
-    const currNames = extractIdentifiers(currContent);
-    const removed = prevNames.filter((n) => !currNames.includes(n));
-    const added = currNames.filter((n) => !prevNames.includes(n));
-    const renames = [];
-    for (const from of removed) {
-        for (const to of added) {
-            if (similarity(from, to) > 0.5) {
-                renames.push({ fromName: from, toName: to });
-                break;
-            }
-        }
-    }
-    return renames;
-}
-function extractIdentifiers(content) {
-    const matches = content.match(/\b[a-zA-Z_$][a-zA-Z0-9_$]*\b/g) ?? [];
-    return [...new Set(matches)].filter((n) => n.length > 2);
-}
-function similarity(a, b) {
-    if (a === b)
-        return 1;
-    const maxLen = Math.max(a.length, b.length);
-    if (maxLen === 0)
-        return 1;
-    let common = 0;
-    const shorter = a.length <= b.length ? a : b;
-    const longer = a.length > b.length ? a : b;
-    for (const char of shorter) {
-        if (longer.includes(char))
-            common++;
-    }
-    return common / maxLen;
-}
-function extractNamingPattern(from, to) {
-    const prefixes = [
-        "get",
-        "set",
-        "fetch",
-        "load",
-        "create",
-        "update",
-        "delete",
-        "remove",
-        "handle",
-        "on",
-    ];
-    for (const prefix of prefixes) {
-        if (from.startsWith(prefix) && !to.startsWith(prefix)) {
-            const toPrefix = prefixes.find((p) => to.startsWith(p));
-            if (toPrefix)
-                return `use ${toPrefix} prefix instead of ${prefix}`;
-        }
-        if (!from.startsWith(prefix) && to.startsWith(prefix)) {
-            return `use ${prefix} prefix for ${from.slice(0, 1).toLowerCase() + from.slice(1)} operations`;
-        }
-    }
-    if (from.includes("_") && !to.includes("_") && to.match(/[A-Z]/)) {
-        return "use camelCase instead of snake_case";
-    }
-    if (!from.includes("_") && to.includes("_")) {
-        return "use snake_case instead of camelCase";
-    }
-    return null;
-}

package/dist/intelligence/convention-matcher.js

@@ -1,205 +0,0 @@
-/**
- * Sprint 3.2: Local Convention Pattern Matching — structural checks without LLM.
- *
- * Three convention types evaluated locally:
- * 1. Naming conventions — regex patterns from CozoDB `patterns` table
- * 2. File structure conventions — expected sibling files (e.g., *.test.ts)
- * 3. Import direction conventions — forbidden dependency directions
- *
- * All checks complete in <5ms per file.
- *
- * Design authority: PHASE_CLI_ENHANCEMENT §3.2
- */
-/** Default naming conventions derived from common TypeScript patterns. */
-const DEFAULT_NAMING_CONVENTIONS = [
-    {
-        kind: "class",
-        pattern: /^[A-Z][a-zA-Z0-9]*$/,
-        name: "PascalCase classes",
-        message: "Class names must be PascalCase",
-    },
-    {
-        kind: "function",
-        pattern: /^[a-z_][a-zA-Z0-9]*$/,
-        name: "camelCase functions",
-        message: "Function names must be camelCase or snake_case",
-    },
-    {
-        kind: "interface",
-        pattern: /^[A-Z][a-zA-Z0-9]*$/,
-        name: "PascalCase interfaces",
-        message: "Interface names must be PascalCase",
-    },
-];
-/** Default file structure conventions. */
-const DEFAULT_FILE_STRUCTURE_CONVENTIONS = [
-    {
-        sourceGlob: "src/**/*.ts",
-        siblingSuffix: ".test.ts",
-        name: "Test file sibling",
-        message: "Source files should have a corresponding .test.ts file",
-    },
-];
-/** Default import direction conventions. */
-const DEFAULT_IMPORT_DIRECTION_CONVENTIONS = [
-    {
-        fromLayer: "/services/",
-        toLayer: "/controllers/",
-        name: "Services cannot import controllers",
-        message: "Service layer should not depend on controller layer",
-    },
-    {
-        fromLayer: "/utils/",
-        toLayer: "/services/",
-        name: "Utils cannot import services",
-        message: "Utility layer should not depend on service layer",
-    },
-];
-/**
- * Check naming conventions against entities in a file.
- */
-export function checkNamingConventions(entities, conventions) {
-    const rules = conventions ?? DEFAULT_NAMING_CONVENTIONS;
-    const violations = [];
-    for (const entity of entities) {
-        for (const rule of rules) {
-            if (entity.kind === rule.kind && !rule.pattern.test(entity.name)) {
-                violations.push({
-                    type: "naming",
-                    severity: "warn",
-                    entity: entity.key,
-                    file: entity.file_path,
-                    message: `${rule.message}: "${entity.name}"`,
-                    suggestion: `Rename to match ${rule.pattern.source}`,
-                });
-            }
-        }
-    }
-    return violations;
-}
-/**
- * Check file structure conventions (sibling file existence).
- * Uses the graph's file index to check for expected sibling files.
- */
-export async function checkFileStructure(filePath, graph, conventions) {
-    const rules = conventions ?? DEFAULT_FILE_STRUCTURE_CONVENTIONS;
-    const violations = [];
-    for (const rule of rules) {
-        // Check if file matches source glob (simple suffix check for performance)
-        const sourceExt = rule.sourceGlob.split("*").pop() ?? "";
-        if (!filePath.endsWith(sourceExt))
-            continue;
-        // Skip if this IS a test/sibling file
-        if (filePath.endsWith(rule.siblingSuffix))
-            continue;
-        // Check for expected sibling
-        const basePath = filePath.slice(0, -sourceExt.length);
-        const expectedSibling = basePath + rule.siblingSuffix;
-        const siblingEntities = await graph.getEntitiesByFile(expectedSibling);
-        if (siblingEntities.length === 0) {
-            violations.push({
-                type: "file_structure",
-                severity: "warn",
-                file: filePath,
-                message: `${rule.message}: missing ${expectedSibling}`,
-                suggestion: `Create ${expectedSibling}`,
-            });
-        }
-    }
-    return violations;
-}
-/**
- * Check import direction conventions.
- * Uses the graph's import data to detect forbidden dependency directions.
- */
-export async function checkImportDirection(filePath, graph, conventions) {
-    const rules = conventions ?? DEFAULT_IMPORT_DIRECTION_CONVENTIONS;
-    const violations = [];
-    for (const rule of rules) {
-        // Only check files in the source layer
-        if (!filePath.includes(rule.fromLayer))
-            continue;
-        // Get imports for this file
-        const imports = await graph.getImports(filePath);
-        for (const imp of imports) {
-            const importPath = imp.imported_file;
-            if (importPath?.includes(rule.toLayer)) {
-                violations.push({
-                    type: "import_direction",
-                    severity: "error",
-                    file: filePath,
-                    message: `${rule.message}: ${filePath} imports from ${importPath}`,
-                    suggestion: "Move shared logic to a common layer or invert the dependency",
-                });
-            }
-        }
-    }
-    return violations;
-}
-/**
- * Run all convention checks for a file. <5ms per file.
- */
-export async function matchConventions(filePath, graph, options) {
-    const entities = await graph.getEntitiesByFile(filePath);
-    const violations = [];
-    violations.push(...checkNamingConventions(entities, options?.namingConventions));
-    violations.push(...(await checkFileStructure(filePath, graph, options?.fileStructureConventions)));
-    violations.push(...(await checkImportDirection(filePath, graph, options?.importDirectionConventions)));
-    return violations;
-}
-/** Map naming style keywords to regex patterns. */
-const NAMING_STYLE_REGEX = {
-    camelcase: /^[a-z][a-zA-Z0-9]*$/,
-    pascalcase: /^[A-Z][a-zA-Z0-9]*$/,
-    snake_case: /^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$/,
-    screaming_snake: /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/,
-    kebab: /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/,
-};
-/** Resolve regex from a pattern name like "camelCase functions" or "PascalCase classes". */
-function resolveNamingRegex(patternName) {
-    const lower = patternName.toLowerCase();
-    for (const [key, regex] of Object.entries(NAMING_STYLE_REGEX)) {
-        if (lower.includes(key))
-            return regex;
-    }
-    // Try partial matches: "pascal" → PascalCase, "camel" → camelCase
-    if (lower.includes("pascal"))
-        return NAMING_STYLE_REGEX.pascalcase ?? null;
-    if (lower.includes("camel"))
-        return NAMING_STYLE_REGEX.camelcase ?? null;
-    if (lower.includes("snake") && lower.includes("scream"))
-        return NAMING_STYLE_REGEX.screaming_snake ?? null;
-    if (lower.includes("snake"))
-        return NAMING_STYLE_REGEX.snake_case ?? null;
-    if (lower.includes("kebab"))
-        return NAMING_STYLE_REGEX.kebab ?? null;
-    return null;
-}
-/**
- * Derive naming conventions from CozoDB patterns table.
- * Converts pattern entries with kind="naming" into regex-based naming checks,
- * mapping pattern names to the correct regex (camelCase, PascalCase, snake_case, etc.).
- */
-export async function deriveNamingConventionsFromPatterns(graph) {
-    const patterns = await graph.getPatterns();
-    const conventions = [];
-    for (const p of patterns) {
-        if (p.kind === "naming" && p.confidence >= 0.7) {
-            // Extract entity kind (class, function, interface, etc.)
-            const kindMatch = p.name.match(/\b(class|function|interface|method|variable|type|enum|constant)\b/i);
-            if (!kindMatch)
-                continue;
-            // Resolve the correct regex from the pattern name
-            const regex = resolveNamingRegex(p.name);
-            if (!regex)
-                continue;
-            conventions.push({
-                kind: kindMatch[1].toLowerCase(),
-                pattern: regex,
-                name: p.name,
-                message: `Convention: ${p.name} (${Math.round(p.confidence * 100)}% confidence, ${p.frequency} occurrences)`,
-            });
-        }
-    }
-    return conventions.length > 0 ? conventions : DEFAULT_NAMING_CONVENTIONS;
-}