@unerr-ai/unerr 0.2.0 → 0.2.2

package/dist/proxy/startup-renderer.js

@@ -1,158 +0,0 @@
-/**
- * Startup renderer — bridge between proxy boot sequence and Ink display.
- *
- * The proxy calls StartupRenderer methods during boot steps.
- * The renderer drives the Ink StartupDisplay component on stderr.
- *
- * Handles first_boot_shown flag persistence in .unerr/state/graph_version.json.
- */
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import React from "react";
-import { StartupDisplay, } from "../components/StartupDisplay.js";
-import { ThemeProvider } from "../components/Theme.js";
-import { renderToStderr } from "../components/render.js";
-import { buildDeepLink } from "../utils/deep-link.js";
-export class StartupRenderer {
-    state;
-    instance = null;
-    stepMap = new Map();
-    repoId;
-    constructor() {
-        this.state = {
-            steps: [],
-            firstBoot: false,
-            ready: false,
-            localMode: false,
-        };
-    }
-    /** Start the Ink display on stderr. */
-    mount() {
-        this.instance = renderToStderr(this.renderElement());
-    }
-    /** Add a step to the sequence. Returns step index for updates. */
-    addStep(label, status = "pending", value) {
-        this.stepMap.set(label, this.state.steps.length);
-        this.state.steps.push({ label, value, status });
-        this.rerender();
-    }
-    /** Update a step's status and optional value. */
-    updateStep(label, status, value) {
-        const idx = this.stepMap.get(label);
-        if (idx === undefined)
-            return;
-        const step = this.state.steps[idx];
-        if (!step)
-            return;
-        step.status = status;
-        if (value !== undefined)
-            step.value = value;
-        this.rerender();
-    }
-    /** Set the health grade result for Act 2 display. */
-    setHealth(health, repoId) {
-        this.repoId = repoId;
-        this.state.health = health;
-        this.state.firstBoot = this.isFirstBoot();
-        // Pick most interesting entity for invitation
-        if (health.highRiskEntities.length > 0) {
-            this.state.invitationEntity = health.highRiskEntities[0]?.name;
-        }
-        // Set deep link — NEVER in Local Mode (TL-18)
-        if (repoId && !this.state.localMode) {
-            this.state.deepLink = buildDeepLink(repoId, {
-                view: "health",
-                utm_source: this.state.firstBoot ? "cli_first_boot" : "cli_startup",
-            });
-        }
-        // Mark first boot as shown
-        if (this.state.firstBoot) {
-            this.markFirstBootShown();
-        }
-        this.rerender();
-    }
-    /** Mark proxy as ready (Act 3). */
-    setReady(proxyMode) {
-        this.state.ready = true;
-        this.state.proxyMode = proxyMode;
-        // If no health data, still show deep link — NEVER in Local Mode (TL-18)
-        if (!this.state.deepLink && this.repoId && !this.state.localMode) {
-            this.state.deepLink = buildDeepLink(this.repoId, {
-                utm_source: "cli_startup",
-            });
-        }
-        this.rerender();
-    }
-    // ── Local Mode Methods ────────────────────────────────────────────
-    /** Enable Local Mode rendering. Must be called before setHealth/setReady. */
-    setLocalMode(enabled) {
-        this.state.localMode = enabled;
-        if (enabled) {
-            this.state.deepLink = undefined;
-        }
-        this.rerender();
-    }
-    /** Set Local Mode indexing statistics for Act 1. */
-    setLocalIndexStats(indexStats) {
-        this.state.localIndexStats = indexStats;
-        this.rerender();
-    }
-    /** Set BYO-LLM connection status for startup display. */
-    setByoLlmStatus(status, provider, model) {
-        this.state.byoLlmStatus = status;
-        if (provider)
-            this.state.byoLlmProvider = provider;
-        if (model)
-            this.state.byoLlmModel = model;
-        this.rerender();
-    }
-    /** Set the total tool count for Act 3. */
-    setToolCount(count) {
-        this.state.toolCount = count;
-        this.rerender();
-    }
-    /** Unmount the Ink display (after startup completes). */
-    unmount() {
-        this.instance?.unmount();
-        this.instance = null;
-    }
-    // ── First boot tracking ──────────────────────────────────────────
-    isFirstBoot() {
-        const versionPath = join(process.cwd(), ".unerr", "state", "graph_version.json");
-        if (!existsSync(versionPath))
-            return true;
-        try {
-            const data = JSON.parse(readFileSync(versionPath, "utf-8"));
-            return !data.first_boot_shown;
-        }
-        catch {
-            return true;
-        }
-    }
-    markFirstBootShown() {
-        const stateDir = join(process.cwd(), ".unerr", "state");
-        const versionPath = join(stateDir, "graph_version.json");
-        try {
-            let data = {};
-            if (existsSync(versionPath)) {
-                data = JSON.parse(readFileSync(versionPath, "utf-8"));
-            }
-            data.first_boot_shown = true;
-            writeFileSync(versionPath, JSON.stringify(data, null, 2));
-        }
-        catch {
-            // Non-critical
-        }
-    }
-    // ── Ink rendering ────────────────────────────────────────────────
-    renderElement() {
-        return React.createElement(ThemeProvider, null, React.createElement(StartupDisplay, {
-            state: this.state,
-        }));
-    }
-    rerender() {
-        if (this.instance) {
-            this.instance.rerender(this.renderElement());
-        }
-    }
-}

package/dist/proxy/task-token-display.js

@@ -1,38 +0,0 @@
-/**
- * Task Token Display — formats tokens-per-task for session summary.
- *
- * T.12: Consumes intent-level grouping data and produces formatted display.
- * Shows top 3 most expensive tasks with entity lists and efficiency.
- */
-import { calculateDollarSavings, formatDollars } from "./model-pricing.js";
-/**
- * Build task cost summaries from intent group data.
- */
-export function buildTaskCostSummaries(intentGroups, modelId) {
-    const tasks = intentGroups
-        .filter((g) => g.toolCalls > 0)
-        .map((g) => {
-        const total = g.tokensConsumed + g.tokensSaved;
-        const efficiency = total > 0 ? Math.round((g.tokensSaved / total) * 100) : 0;
-        return {
-            taskDescription: g.prompt ?? `Task ${g.intentId}`,
-            toolCalls: g.toolCalls,
-            tokensConsumed: g.tokensConsumed,
-            tokensSaved: g.tokensSaved,
-            dollarCost: calculateDollarSavings(g.tokensConsumed, modelId),
-            efficiency,
-            entities: g.entitiesModified,
-        };
-    })
-        .sort((a, b) => b.tokensConsumed - a.tokensConsumed);
-    const top3 = tasks.slice(0, 3);
-    const totalCalls = tasks.reduce((s, t) => s + t.toolCalls, 0);
-    const totalSaved = tasks.reduce((s, t) => s + t.tokensSaved, 0);
-    const totalWithout = tasks.reduce((s, t) => s + t.tokensConsumed + t.tokensSaved, 0);
-    const formattedLines = [
-        "Tasks this session:",
-        ...top3.map((t, i) => `  ${i + 1}. "${t.taskDescription.slice(0, 50)}" — ${t.toolCalls} calls, ${formatDollars(t.dollarCost)} (${t.efficiency}% optimized)`),
-        `  Total: ${totalCalls} calls, ${formatDollars(calculateDollarSavings(totalSaved, modelId))} saved (${formatDollars(calculateDollarSavings(totalWithout, modelId))} without unerr)`,
-    ];
-    return { tasks, totalCalls, totalSaved, totalWithout, formattedLines };
-}

package/dist/proxy/token-counter.js

@@ -1,61 +0,0 @@
-/**
- * Live Token Counter — accumulates tokens_saved across the session.
- *
- * Emits to stderr every N tool calls with a formatted summary.
- * Uses character/4 estimation (Sprint G upgrades to tiktoken).
- *
- * Design: pure accumulator with configurable emit interval and sink.
- * The sink defaults to process.stderr but can be injected for testing.
- */
-function formatTokens(n) {
-    if (n >= 1_000_000)
-        return `${(n / 1_000_000).toFixed(1)}M`;
-    if (n >= 1_000)
-        return `${(n / 1_000).toFixed(1)}K`;
-    return String(n);
-}
-export function createTokenCounter(options = {}) {
-    const emitEveryN = options.emitEveryN ?? 10;
-    const sink = options.sink ?? ((msg) => process.stderr.write(msg));
-    let totalSaved = 0;
-    let totalProcessed = 0;
-    let callCount = 0;
-    function record(tokensSaved, totalTokens) {
-        totalSaved += tokensSaved;
-        totalProcessed += totalTokens;
-        callCount++;
-        if (callCount > 0 && callCount % emitEveryN === 0) {
-            const efficiency = totalProcessed > 0
-                ? Math.round((totalSaved / totalProcessed) * 100)
-                : 0;
-            sink(`[unerr] ${formatTokens(totalSaved)} tokens saved (efficiency: ${efficiency}%)\n`);
-        }
-    }
-    function getTotalSaved() {
-        return totalSaved;
-    }
-    function getTotalProcessed() {
-        return totalProcessed;
-    }
-    function getCallCount() {
-        return callCount;
-    }
-    function getEfficiency() {
-        return totalProcessed > 0
-            ? Math.round((totalSaved / totalProcessed) * 100)
-            : 0;
-    }
-    function reset() {
-        totalSaved = 0;
-        totalProcessed = 0;
-        callCount = 0;
-    }
-    return {
-        record,
-        getTotalSaved,
-        getTotalProcessed,
-        getCallCount,
-        getEfficiency,
-        reset,
-    };
-}

package/dist/proxy/tool-clusters.js

@@ -1,273 +0,0 @@
-/**
- * Semantic Tool Clusters — groups tools by task domain.
- *
- * When agents call tools/list, we return ALL tools (MCP spec requires it)
- * but REORDER them so the most relevant cluster appears first. Agents
- * tend to use tools listed earlier — reordering is a soft adoption boost.
- *
- * Based on RAG-MCP research: presenting relevant subset first → 3x accuracy.
- * We can't filter (agents may need any tool) but we CAN prioritize.
- */
-/**
- * Semantic tool clusters — ordered from most to least commonly needed.
- * Default ordering (no context): navigation first, then file-access, quality, persistence, shell.
- */
-export const TOOL_CLUSTERS = [
-    {
-        id: "navigation",
-        name: "Code Navigation",
-        tools: [
-            "search_code",
-            "get_entity",
-            "get_references",
-            "get_file",
-            "get_imports",
-        ],
-        triggerKeywords: [
-            "find",
-            "search",
-            "where",
-            "who calls",
-            "callers",
-            "callees",
-            "references",
-            "imports",
-            "depends",
-            "usage",
-        ],
-    },
-    {
-        id: "file-access",
-        name: "File Access",
-        tools: ["file_outline", "file_read"],
-        triggerKeywords: [
-            "read",
-            "file",
-            "outline",
-            "structure",
-            "show me",
-            "open",
-            "look at",
-        ],
-    },
-    {
-        id: "quality",
-        name: "Quality & Conventions",
-        tools: ["get_conventions"],
-        triggerKeywords: [
-            "rules",
-            "conventions",
-            "lint",
-            "style",
-            "validate",
-            "check",
-            "standard",
-            "pattern",
-        ],
-    },
-    {
-        id: "structural",
-        name: "Structural Analysis",
-        tools: [
-            "get_critical_nodes",
-            "get_cross_boundary_links",
-            "file_connections",
-            "get_test_coverage",
-            "get_project_stats",
-        ],
-        triggerKeywords: [
-            "chokepoint",
-            "critical",
-            "coupling",
-            "boundary",
-            "connections",
-            "test coverage",
-            "stats",
-            "overview",
-            "risk",
-            "fan_in",
-            "blast radius",
-            "dependencies",
-        ],
-    },
-    {
-        id: "persistence",
-        name: "Persistent Intelligence",
-        tools: ["record_fact", "recall_facts"],
-        triggerKeywords: [
-            "remember",
-            "fact",
-            "convention",
-            "anti-pattern",
-            "record",
-            "recall",
-        ],
-    },
-    {
-        id: "session-narrative",
-        name: "Session Narrative",
-        tools: ["mark_intent", "mark_decision", "mark_blocker", "mark_resolution"],
-        triggerKeywords: [
-            "intent",
-            "decision",
-            "blocker",
-            "stuck",
-            "resolved",
-            "fixed",
-            "starting",
-            "planning",
-        ],
-    },
-];
-/**
- * Map from tool name → cluster id for fast lookup.
- */
-const TOOL_TO_CLUSTER = new Map();
-for (const cluster of TOOL_CLUSTERS) {
-    for (const tool of cluster.tools) {
-        TOOL_TO_CLUSTER.set(tool, cluster.id);
-    }
-}
-/**
- * Get the cluster ID for a tool name.
- */
-export function getToolCluster(toolName) {
-    return TOOL_TO_CLUSTER.get(toolName);
-}
-/**
- * Recent tool usage tracker — determines which clusters are "hot".
- *
- * Tracks last N tool calls with timestamps. Clusters with recent calls
- * get a priority boost in tools/list ordering.
- */
-export class ToolUsageTracker {
-    /** Ring buffer of recent tool calls: [toolName, timestamp]. */
-    history = [];
-    maxHistory;
-    constructor(maxHistory = 50) {
-        this.maxHistory = maxHistory;
-    }
-    /**
-     * Record a tool call.
-     */
-    record(toolName) {
-        this.history.push({ tool: toolName, ts: Date.now() });
-        if (this.history.length > this.maxHistory) {
-            this.history.shift();
-        }
-    }
-    /**
-     * Get cluster priority scores based on recent usage.
-     * Higher score = more recently/frequently used cluster.
-     *
-     * Scoring: each tool call contributes 1/(age_in_calls + 1) to its cluster.
-     * Recent calls score higher than older ones.
-     */
-    getClusterScores() {
-        const scores = new Map();
-        const len = this.history.length;
-        for (let i = 0; i < len; i++) {
-            const entry = this.history[i];
-            const clusterId = TOOL_TO_CLUSTER.get(entry.tool);
-            if (!clusterId)
-                continue;
-            // Recency weight: more recent = higher weight
-            const recencyWeight = 1 / (len - i);
-            scores.set(clusterId, (scores.get(clusterId) ?? 0) + recencyWeight);
-        }
-        return scores;
-    }
-    /**
-     * Get the number of recorded tool calls.
-     */
-    getCallCount() {
-        return this.history.length;
-    }
-    /**
-     * Get the most recently used cluster ID, or null if no history.
-     */
-    getMostRecentCluster() {
-        if (this.history.length === 0)
-            return null;
-        const lastEntry = this.history[this.history.length - 1];
-        if (!lastEntry)
-            return null;
-        const lastTool = lastEntry.tool;
-        return TOOL_TO_CLUSTER.get(lastTool) ?? null;
-    }
-}
-/**
- * Reorder tool definitions by cluster priority.
- *
- * All tools are always returned (MCP spec compliance). The order changes
- * based on which clusters scored highest from recent usage.
- *
- * @param tools - Original tool definitions array
- * @param tracker - Usage tracker (null = use default order)
- * @returns Reordered tool definitions (same tools, different order)
- */
-export function reorderToolsByCluster(tools, tracker) {
-    if (!tracker || tracker.getCallCount() === 0) {
-        // No usage data — use default cluster order
-        return reorderByDefaultClusters(tools);
-    }
-    const scores = tracker.getClusterScores();
-    // Sort clusters by score (descending), keeping default order for unscored
-    const sortedClusterIds = TOOL_CLUSTERS.map((c) => c.id).sort((a, b) => {
-        const scoreA = scores.get(a) ?? 0;
-        const scoreB = scores.get(b) ?? 0;
-        if (scoreA !== scoreB)
-            return scoreB - scoreA;
-        // Stable: preserve default order for ties
-        return (TOOL_CLUSTERS.findIndex((c) => c.id === a) -
-            TOOL_CLUSTERS.findIndex((c) => c.id === b));
-    });
-    // Build ordered tool list: clustered tools first (in priority order), unclustered tools last
-    const toolMap = new Map(tools.map((t) => [t.name, t]));
-    const result = [];
-    const added = new Set();
-    for (const clusterId of sortedClusterIds) {
-        const cluster = TOOL_CLUSTERS.find((c) => c.id === clusterId);
-        if (!cluster)
-            continue;
-        for (const toolName of cluster.tools) {
-            const tool = toolMap.get(toolName);
-            if (tool && !added.has(toolName)) {
-                result.push(tool);
-                added.add(toolName);
-            }
-        }
-    }
-    // Append any tools not in any cluster (future-proofing)
-    for (const tool of tools) {
-        if (!added.has(tool.name)) {
-            result.push(tool);
-            added.add(tool.name);
-        }
-    }
-    return result;
-}
-/**
- * Reorder tools by default cluster ordering (no usage data).
- */
-function reorderByDefaultClusters(tools) {
-    const toolMap = new Map(tools.map((t) => [t.name, t]));
-    const result = [];
-    const added = new Set();
-    for (const cluster of TOOL_CLUSTERS) {
-        for (const toolName of cluster.tools) {
-            const tool = toolMap.get(toolName);
-            if (tool && !added.has(toolName)) {
-                result.push(tool);
-                added.add(toolName);
-            }
-        }
-    }
-    for (const tool of tools) {
-        if (!added.has(tool.name)) {
-            result.push(tool);
-            added.add(tool.name);
-        }
-    }
-    return result;
-}