@unerr-ai/unerr 0.2.1 → 0.2.2

package/dist/behaviors/convention-drift.js

@@ -1,290 +0,0 @@
-/**
- * Convention Drift Prevention — BA-2.2
- *
- * PostToolUse: checks changed code regions against detected project conventions.
- * Detects naming violations (camelCase vs snake_case), structural violations
- * (barrel imports, file organization), and suggests or auto-fixes.
- *
- * Learning loop: developer corrections (accepted/dismissed) adjust
- * confidence thresholds per convention.
- *
- * Auto-fix only applied when confidence > 0.9.
- */
-import { Behavior, } from "./framework.js";
-const AUTO_FIX_CONFIDENCE_THRESHOLD = 0.9;
-const CAMEL_CASE = /^[a-z][a-zA-Z0-9]*$/;
-const PASCAL_CASE = /^[A-Z][a-zA-Z0-9]*$/;
-const SNAKE_CASE = /^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$/;
-const NAMING_RULES = [
-    { id: "camelCase", pattern: CAMEL_CASE, label: "camelCase" },
-    { id: "PascalCase", pattern: PASCAL_CASE, label: "PascalCase" },
-    { id: "snake_case", pattern: SNAKE_CASE, label: "snake_case" },
-];
-const EDIT_TOOLS = new Set([
-    "file_write",
-    "write_file",
-    "edit_file",
-    "str_replace_editor",
-    "insert_code",
-    "replace_code",
-]);
-export class ConventionDriftPrevention extends Behavior {
-    id = "convention_drift";
-    hooks = ["post_tool_use"];
-    defaultLevel = "suggestion";
-    graph = null;
-    driftConfig;
-    violationsThisSession = 0;
-    autoFixesThisSession = 0;
-    constructor(config) {
-        super(config, "suggestion");
-        this.driftConfig = {
-            enabled: true,
-            level: "suggestion",
-            autoFixHighConfidence: true,
-            confidenceThreshold: AUTO_FIX_CONFIDENCE_THRESHOLD,
-            ...config,
-        };
-    }
-    attachGraph(graph) {
-        this.graph = graph;
-    }
-    async onPostToolUse(ctx) {
-        if (!EDIT_TOOLS.has(ctx.toolName))
-            return null;
-        if (!ctx.filePath)
-            return null;
-        if (!isCodeFile(ctx.filePath))
-            return null;
-        const newContent = extractNewContent(ctx.args);
-        if (!newContent)
-            return null;
-        const violations = [];
-        const namingViolations = await this.checkNamingConventions(ctx.filePath, newContent);
-        violations.push(...namingViolations);
-        const importViolations = await this.checkImportConventions(ctx.filePath, newContent);
-        violations.push(...importViolations);
-        if (violations.length === 0)
-            return null;
-        this.violationsThisSession += violations.length;
-        const autoFixCount = violations.filter((v) => v.autoFixed).length;
-        this.autoFixesThisSession += autoFixCount;
-        return {
-            behaviorId: this.id,
-            level: this.level,
-            relatedSkillId: "convention-aware-generation",
-            _meta: {
-                behavior: this.id,
-                violations: violations.length,
-                auto_fixed: autoFixCount,
-            },
-            _context: {
-                convention_violations: violations,
-            },
-        };
-    }
-    getSessionStats() {
-        return {
-            violationsDetected: this.violationsThisSession,
-            autoFixes: this.autoFixesThisSession,
-        };
-    }
-    /**
-     * Check naming conventions in new content against project-wide patterns.
-     * Uses the graph's convention data to determine the dominant style.
-     */
-    async checkNamingConventions(filePath, content) {
-        const projectConvention = await this.detectDominantNamingConvention(filePath);
-        if (!projectConvention)
-            return [];
-        const newNames = extractDefinedNames(content);
-        const violations = [];
-        for (const name of newNames) {
-            if (name.length <= 1)
-                continue;
-            if (isAllCaps(name))
-                continue;
-            if (!projectConvention.pattern.test(name)) {
-                const expected = suggestFix(name, projectConvention.id);
-                const confidence = projectConvention.confidence;
-                const canAutoFix = this.driftConfig.autoFixHighConfidence &&
-                    confidence >= this.driftConfig.confidenceThreshold &&
-                    expected !== null;
-                violations.push({
-                    rule: `naming:${projectConvention.id}_for_identifiers`,
-                    violation: `${name} (should be ${expected ?? projectConvention.label})`,
-                    file: filePath,
-                    confidence,
-                    autoFixed: canAutoFix,
-                    evidence: `${Math.round(projectConvention.confidence * 100)}% of identifiers in this context use ${projectConvention.label}`,
-                });
-            }
-        }
-        return violations;
-    }
-    /**
-     * Check import conventions — barrel exports, relative vs absolute, etc.
-     */
-    async checkImportConventions(filePath, content) {
-        if (!this.graph)
-            return [];
-        const conventions = await this.graph.getConventionsForEntity(filePath, 5);
-        const importConventions = conventions.filter((c) => c.name.toLowerCase().includes("import") ||
-            c.name.toLowerCase().includes("barrel"));
-        if (importConventions.length === 0)
-            return [];
-        const violations = [];
-        const importLines = extractImportLines(content);
-        for (const convention of importConventions) {
-            const adherence = convention.adherence_pct / 100;
-            if (adherence < 0.6)
-                continue;
-            if (convention.name.toLowerCase().includes("barrel")) {
-                for (const imp of importLines) {
-                    if (isDeepImport(imp)) {
-                        violations.push({
-                            rule: "import:barrel_exports",
-                            violation: `Deep import "${imp}" — project convention uses barrel exports`,
-                            file: filePath,
-                            confidence: adherence,
-                            autoFixed: false,
-                            evidence: convention.rule ||
-                                `${convention.adherence_pct}% of imports follow barrel pattern`,
-                        });
-                    }
-                }
-            }
-        }
-        return violations;
-    }
-    async detectDominantNamingConvention(filePath) {
-        if (!this.graph)
-            return null;
-        const conventions = await this.graph.getConventionsForEntity(filePath, 5);
-        const namingConvention = conventions.find((c) => c.name.toLowerCase().includes("naming") ||
-            c.name.toLowerCase().includes("camel") ||
-            c.name.toLowerCase().includes("pascal") ||
-            c.name.toLowerCase().includes("snake"));
-        if (namingConvention) {
-            const rule = NAMING_RULES.find((r) => namingConvention.name.toLowerCase().includes(r.id.toLowerCase()));
-            if (rule) {
-                return { ...rule, confidence: namingConvention.adherence_pct / 100 };
-            }
-        }
-        const entities = await this.graph.getEntitiesByFile(filePath);
-        if (entities.length < 3)
-            return null;
-        const counts = new Map();
-        for (const entity of entities) {
-            if (entity.kind !== "function" && entity.kind !== "variable")
-                continue;
-            for (const rule of NAMING_RULES) {
-                if (rule.pattern.test(entity.name)) {
-                    counts.set(rule.id, (counts.get(rule.id) ?? 0) + 1);
-                    break;
-                }
-            }
-        }
-        let best = null;
-        for (const [id, count] of counts) {
-            if (!best || count > best.count)
-                best = { id, count };
-        }
-        if (!best)
-            return null;
-        const total = [...counts.values()].reduce((a, b) => a + b, 0);
-        const confidence = best.count / total;
-        if (confidence < 0.6)
-            return null;
-        const rule = NAMING_RULES.find((r) => r.id === best?.id);
-        if (!rule)
-            return null;
-        return { ...rule, confidence };
-    }
-}
-function isCodeFile(filePath) {
-    return /\.[jt]sx?$|\.vue$|\.svelte$/.test(filePath);
-}
-function extractNewContent(args) {
-    if (typeof args.new_str === "string")
-        return args.new_str;
-    if (typeof args.new_string === "string")
-        return args.new_string;
-    if (typeof args.content === "string")
-        return args.content;
-    if (typeof args.after === "string")
-        return args.after;
-    return null;
-}
-/**
- * Extract names defined in code (function names, variable names, class names).
- * Lightweight regex-based extraction — not full AST, but fast and sufficient.
- */
-function extractDefinedNames(content) {
-    const names = [];
-    const patterns = [
-        /(?:export\s+)?(?:async\s+)?function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g,
-        /(?:export\s+)?(?:const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=/g,
-        /(?:export\s+)?class\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g,
-        /(?:export\s+)?interface\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g,
-        /(?:export\s+)?type\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=/g,
-        /(?:export\s+)?enum\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g,
-    ];
-    for (const pattern of patterns) {
-        let match;
-        match = pattern.exec(content);
-        while (match !== null) {
-            if (match[1])
-                names.push(match[1]);
-            match = pattern.exec(content);
-        }
-    }
-    return [...new Set(names)];
-}
-function extractImportLines(content) {
-    const imports = [];
-    const pattern = /import\s+.*?from\s+['"]([^'"]+)['"]/g;
-    let match;
-    match = pattern.exec(content);
-    while (match !== null) {
-        if (match[1])
-            imports.push(match[1]);
-        match = pattern.exec(content);
-    }
-    return imports;
-}
-function isDeepImport(importPath) {
-    if (!importPath.startsWith("."))
-        return false;
-    const segments = importPath.split("/").filter(Boolean);
-    const nonDots = segments.filter((s) => s !== "." && s !== "..");
-    return nonDots.length >= 3;
-}
-function isAllCaps(name) {
-    return /^[A-Z_][A-Z0-9_]*$/.test(name);
-}
-function suggestFix(name, targetConvention) {
-    const words = splitIntoWords(name);
-    if (words.length === 0)
-        return null;
-    switch (targetConvention) {
-        case "camelCase":
-            return words[0]?.toLowerCase() + words.slice(1).map(capitalize).join("");
-        case "PascalCase":
-            return words.map(capitalize).join("");
-        case "snake_case":
-            return words.map((w) => w.toLowerCase()).join("_");
-        default:
-            return null;
-    }
-}
-function splitIntoWords(name) {
-    if (name.includes("_"))
-        return name.split("_").filter(Boolean);
-    if (name.includes("-"))
-        return name.split("-").filter(Boolean);
-    return name.split(/(?=[A-Z])/).filter(Boolean);
-}
-function capitalize(word) {
-    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
-}

package/dist/behaviors/framework.js

@@ -1,235 +0,0 @@
-/**
- * Behavior Framework — registration, dispatch, assertiveness levels,
- * learning loop, and $0.50 gate integration for Layer 4 behavioral automation.
- *
- * Every behavior has a lifecycle hook (pre_tool_use, post_tool_use,
- * session_start, session_end) and an assertiveness level that determines
- * whether it silently enriches, suggests, or enforces.
- */
-import { formatGuardMoment, shouldFireGuard, } from "./guard-formatter.js";
-/**
- * Abstract base for all behavioral automations.
- * Subclasses implement one or more hook methods.
- */
-export class Behavior {
-    config;
-    learningLog = [];
-    acceptCount = 0;
-    dismissCount = 0;
-    overrideCount = 0;
-    constructor(config, defaultLevel = "suggestion") {
-        this.config = {
-            enabled: true,
-            level: defaultLevel,
-            ...config,
-        };
-    }
-    get level() {
-        return this.config.level;
-    }
-    get enabled() {
-        return this.config.enabled;
-    }
-    /**
-     * PreToolUse — fires BEFORE the agent's tool call executes.
-     * Return a BehaviorOutput with halt=true to block execution.
-     */
-    async onPreToolUse(_ctx) {
-        return null;
-    }
-    /**
-     * PostToolUse — fires AFTER the agent's tool call executes.
-     * Can inject _context into the response for the agent.
-     */
-    async onPostToolUse(_ctx) {
-        return null;
-    }
-    /**
-     * SessionStart — fires on the first tool call of a new session.
-     */
-    async onSessionStart(_ctx) {
-        return null;
-    }
-    /**
-     * SessionEnd — fires on proxy shutdown or extended inactivity.
-     */
-    async onSessionEnd(_ctx) {
-        return null;
-    }
-    recordFeedback(action, entityKey) {
-        switch (action) {
-            case "accepted":
-                this.acceptCount++;
-                break;
-            case "dismissed":
-                this.dismissCount++;
-                break;
-            case "overridden":
-                this.overrideCount++;
-                break;
-        }
-        this.learningLog.push({
-            behaviorId: this.id,
-            action,
-            entityKey,
-            timestamp: Date.now(),
-        });
-    }
-    /**
-     * Confidence score: ratio of accepted / total feedback.
-     * Starts at 1.0 (no feedback = full confidence).
-     */
-    getConfidence() {
-        const total = this.acceptCount + this.dismissCount + this.overrideCount;
-        if (total === 0)
-            return 1.0;
-        return this.acceptCount / total;
-    }
-    getLearningStats() {
-        return {
-            accepted: this.acceptCount,
-            dismissed: this.dismissCount,
-            overridden: this.overrideCount,
-            confidence: this.getConfidence(),
-        };
-    }
-}
-/**
- * Centralized dispatcher: registers behaviors, routes hook events,
- * merges outputs, and enforces the $0.50 gate.
- */
-export class BehaviorDispatcher {
-    behaviors = [];
-    sessionStartFired = false;
-    guardMoments = [];
-    register(behavior) {
-        this.behaviors.push(behavior);
-    }
-    /**
-     * Fire all pre-tool-use behaviors. Returns merged output.
-     * If ANY enforcement behavior returns halt=true, the entire call is halted.
-     */
-    async firePreToolUse(ctx) {
-        const outputs = [];
-        if (!this.sessionStartFired) {
-            this.sessionStartFired = true;
-            const startOutputs = await this.fireSessionStart(ctx);
-            if (startOutputs)
-                outputs.push(startOutputs);
-        }
-        for (const b of this.behaviors) {
-            if (!b.enabled || !b.hooks.includes("pre_tool_use"))
-                continue;
-            const output = await b.onPreToolUse(ctx);
-            if (output)
-                outputs.push(output);
-        }
-        return this.mergeOutputs(outputs);
-    }
-    /**
-     * Fire all post-tool-use behaviors. Returns merged output.
-     */
-    async firePostToolUse(ctx) {
-        const outputs = [];
-        for (const b of this.behaviors) {
-            if (!b.enabled || !b.hooks.includes("post_tool_use"))
-                continue;
-            const output = await b.onPostToolUse(ctx);
-            if (output)
-                outputs.push(output);
-        }
-        return this.mergeOutputs(outputs);
-    }
-    /**
-     * Fire session start behaviors (called once, on first tool call).
-     */
-    async fireSessionStart(ctx) {
-        const outputs = [];
-        for (const b of this.behaviors) {
-            if (!b.enabled || !b.hooks.includes("session_start"))
-                continue;
-            const output = await b.onSessionStart(ctx);
-            if (output)
-                outputs.push(output);
-        }
-        return this.mergeOutputs(outputs);
-    }
-    /**
-     * Fire session end behaviors (called on shutdown).
-     */
-    async fireSessionEnd(ctx) {
-        const outputs = [];
-        for (const b of this.behaviors) {
-            if (!b.enabled || !b.hooks.includes("session_end"))
-                continue;
-            const output = await b.onSessionEnd(ctx);
-            if (output)
-                outputs.push(output);
-        }
-        return this.mergeOutputs(outputs);
-    }
-    getGuardMoments() {
-        return [...this.guardMoments];
-    }
-    getRegisteredBehaviors() {
-        return [...this.behaviors];
-    }
-    resetSession() {
-        this.sessionStartFired = false;
-        this.guardMoments = [];
-    }
-    mergeOutputs(outputs) {
-        if (outputs.length === 0)
-            return null;
-        const merged = {
-            behaviorId: outputs.map((o) => o.behaviorId).join("+"),
-            level: "invisible",
-            _meta: {},
-            _context: {},
-        };
-        let shouldHalt = false;
-        const relatedSkills = [];
-        for (const output of outputs) {
-            if (output.halt)
-                shouldHalt = true;
-            if (output.level === "enforcement")
-                merged.level = "enforcement";
-            else if (output.level === "suggestion" && merged.level !== "enforcement")
-                merged.level = "suggestion";
-            if (output._meta)
-                Object.assign(merged._meta, output._meta);
-            if (output._context)
-                Object.assign(merged._context, output._context);
-            if (output.guardMoment) {
-                this.guardMoments.push(output.guardMoment);
-            }
-            if (output.relatedSkillId) {
-                relatedSkills.push(output.relatedSkillId);
-            }
-        }
-        // Surface related skills in _context so agent knows which skills to invoke
-        if (relatedSkills.length > 0) {
-            merged._context["dev.unerr/suggested_skills"] = relatedSkills;
-        }
-        merged.halt = shouldHalt;
-        return merged;
-    }
-}
-/**
- * Evaluate $0.50 gate for a behavior output.
- * Used by behaviors to decide whether to surface a guard moment.
- */
-export function evaluateGate(tokensPrevented, description, modelId, entityKey) {
-    if (!shouldFireGuard(tokensPrevented, modelId)) {
-        return { passes: false, guardMoment: null };
-    }
-    const moment = formatGuardMoment(description, tokensPrevented, modelId, entityKey);
-    return { passes: true, guardMoment: moment };
-}
-/**
- * Estimate tokens that would be wasted by N more retry attempts.
- * Based on empirical data: average failed attempt ≈ 2-5K tokens.
- */
-export function estimateWastedTokens(attemptsRemaining, avgTokensPerAttempt = 3500) {
-    return attemptsRemaining * avgTokensPerAttempt;
-}

package/dist/behaviors/guard-formatter.js

@@ -1,44 +0,0 @@
-/**
- * Guard Moment Formatter — formats behavioral guard outputs with
- * counterfactual framing and $0.50 gate enforcement.
- *
- * VS.4: Guard moments only fire when >$0.50 would be saved.
- * Format: "[unerr] ⚠ Prevented: {description}. Est. cost: ${amount}"
- */
-import { calculateDollarSavings } from "../proxy/model-pricing.js";
-import { frameGuardMoment } from "../utils/counterfactual.js";
-const DOLLAR_GATE = 0.5;
-/**
- * Evaluate whether a guard moment passes the $0.50 threshold.
- */
-export function shouldFireGuard(tokensPrevented, modelId) {
-    const dollars = calculateDollarSavings(tokensPrevented, modelId);
-    return dollars >= DOLLAR_GATE;
-}
-/**
- * Format and emit a guard moment to stderr.
- * Only fires if the $0.50 gate is passed.
- */
-export function formatGuardMoment(description, tokensPrevented, modelId, entityKey) {
-    const dollars = calculateDollarSavings(tokensPrevented, modelId);
-    if (dollars < DOLLAR_GATE) {
-        return null;
-    }
-    const formatted = frameGuardMoment(description, dollars);
-    process.stderr.write(`${formatted}\n`);
-    return {
-        id: `guard-${Date.now()}`,
-        description,
-        tokensPrevented,
-        dollarsPrevented: dollars,
-        entityKey,
-        timestamp: Date.now(),
-        passed: true,
-    };
-}
-/**
- * Get the current dollar gate threshold.
- */
-export function getDollarGate() {
-    return DOLLAR_GATE;
-}