@unerr-ai/unerr 0.2.0 → 0.2.2

package/dist/behaviors/session-continuity.js

@@ -1,208 +0,0 @@
-/**
- * Session Continuity Protocol — BA-1.2
- *
- * On session start (first tool call), queries the shadow ledger for
- * the previous session's entries, identifies incomplete work chains,
- * and injects structured resume context into the response.
- *
- * Incomplete work detection:
- *   - Entities modified but callers not updated (from blast radius)
- *   - Files with uncommitted changes at session end
- *   - Entities that were being actively worked on (high tool call count)
- *
- * For complex resumes (>50 ledger entries), generates an agent-as-LLM
- * sub-prompt requesting the host agent summarize the raw data.
- */
-import { Behavior, } from "./framework.js";
-const AGENT_LLM_THRESHOLD = 50;
-const MAX_RESUME_ITEMS = 5;
-export class SessionContinuityBehavior extends Behavior {
-    id = "session_continuity";
-    hooks = ["session_start"];
-    defaultLevel = "suggestion";
-    ledger = null;
-    continuityConfig;
-    constructor(config) {
-        super(config, "suggestion");
-        this.continuityConfig = {
-            enabled: true,
-            level: "suggestion",
-            includeIncompleteWork: true,
-            maxResumeItems: MAX_RESUME_ITEMS,
-            ...config,
-        };
-    }
-    attachLedger(ledger) {
-        this.ledger = ledger;
-    }
-    async onSessionStart(ctx) {
-        if (!this.ledger)
-            return null;
-        const allEntries = this.ledger.readAllEntries();
-        if (allEntries.length === 0)
-            return null;
-        const previousSessionEntries = extractPreviousSession(allEntries, ctx.sessionId);
-        if (previousSessionEntries.length === 0)
-            return null;
-        const resume = buildResumePayload(previousSessionEntries, this.continuityConfig.maxResumeItems);
-        if (previousSessionEntries.length > AGENT_LLM_THRESHOLD) {
-            resume.use_agent_llm = true;
-            resume.agent_llm_prompt = buildAgentLlmPrompt(resume);
-        }
-        return {
-            behaviorId: this.id,
-            level: this.level,
-            relatedSkillId: "session-context-preservation",
-            _meta: {
-                behavior: this.id,
-                previous_session_entries: previousSessionEntries.length,
-                incomplete_items: resume.incomplete_work.length,
-            },
-            _context: {
-                session_resume: resume,
-            },
-        };
-    }
-}
-function extractPreviousSession(allEntries, currentSessionId) {
-    const sessionIds = new Set();
-    for (const entry of allEntries) {
-        if (entry.session_id !== currentSessionId) {
-            sessionIds.add(entry.session_id);
-        }
-    }
-    if (sessionIds.size === 0)
-        return [];
-    let lastSessionId = null;
-    let lastTimestamp = 0;
-    for (const entry of allEntries) {
-        if (entry.session_id === currentSessionId)
-            continue;
-        const ts = new Date(entry.ts).getTime();
-        if (ts > lastTimestamp) {
-            lastTimestamp = ts;
-            lastSessionId = entry.session_id;
-        }
-    }
-    if (!lastSessionId)
-        return [];
-    return allEntries.filter((e) => e.session_id === lastSessionId);
-}
-function buildResumePayload(entries, maxItems) {
-    const firstTs = new Date(entries[0]?.ts ?? 0).getTime();
-    const lastTs = new Date(entries[entries.length - 1]?.ts ?? 0).getTime();
-    const durationMs = lastTs - firstTs;
-    const elapsedSinceMs = Date.now() - lastTs;
-    const filesModified = new Set();
-    const entityModifications = new Map();
-    const committedEntities = new Set();
-    const toolsUsed = new Map();
-    let lastBranch = null;
-    for (const entry of entries) {
-        toolsUsed.set(entry.tool, (toolsUsed.get(entry.tool) ?? 0) + 1);
-        if (entry.branch)
-            lastBranch = entry.branch;
-        const args = entry.args_summary;
-        if (args.files && Array.isArray(args.files)) {
-            for (const f of args.files) {
-                const path = typeof f === "string" ? f : f.path;
-                if (path)
-                    filesModified.add(path);
-            }
-        }
-        if (typeof args.key === "string" && args.key.includes("/")) {
-            const entityKey = args.key;
-            filesModified.add(entityKey.includes("::") ? entityKey.split("::")[0] : entityKey);
-            entityModifications.set(entityKey, (entityModifications.get(entityKey) ?? 0) + 1);
-        }
-        if (entry.result_summary?.commit_sha) {
-            for (const [key] of entityModifications) {
-                committedEntities.add(key);
-            }
-        }
-    }
-    const incompleteEntities = [...entityModifications.entries()]
-        .filter(([key]) => !committedEntities.has(key) && key !== "")
-        .sort(([, a], [, b]) => b - a);
-    const incompleteWork = incompleteEntities
-        .slice(0, maxItems)
-        .map(([entity, modCount]) => ({
-        entity,
-        status: `Modified ${modCount} time(s), not committed`,
-        remaining: [],
-        risk: modCount >= 3
-            ? "high"
-            : modCount >= 2
-                ? "medium"
-                : "low",
-    }));
-    const uncommittedFiles = [...filesModified]
-        .filter((f) => !committedEntities.has(f))
-        .slice(0, 10);
-    const topTool = [...toolsUsed.entries()].sort(([, a], [, b]) => b - a)[0];
-    const summaryParts = [];
-    if (topTool)
-        summaryParts.push(`Primary activity: ${topTool[0]} (${topTool[1]}x)`);
-    if (filesModified.size > 0)
-        summaryParts.push(`${filesModified.size} file(s) touched`);
-    if (incompleteWork.length > 0)
-        summaryParts.push(`${incompleteWork.length} incomplete item(s)`);
-    const suggestedNext = incompleteWork.length > 0
-        ? `Complete outstanding work on ${incompleteWork[0]?.entity} (${incompleteWork[0]?.status})`
-        : "No outstanding items from last session — ready for new work.";
-    return {
-        last_session: {
-            when: formatElapsed(elapsedSinceMs),
-            duration: formatDuration(durationMs),
-            summary: summaryParts.join(". "),
-            tool_calls: entries.length,
-        },
-        incomplete_work: incompleteWork,
-        working_state: {
-            last_branch: lastBranch,
-            files_modified: filesModified.size,
-            uncommitted_files: uncommittedFiles,
-        },
-        suggested_next: suggestedNext,
-    };
-}
-function buildAgentLlmPrompt(resume) {
-    const parts = [
-        "Summarize the following session state for the developer in 2-3 natural sentences.",
-        "Focus on: what was being worked on, what's incomplete, and what to do next.",
-        "",
-        `Last session: ${resume.last_session.when} (${resume.last_session.duration}, ${resume.last_session.tool_calls} tool calls)`,
-        `Summary: ${resume.last_session.summary}`,
-    ];
-    if (resume.incomplete_work.length > 0) {
-        parts.push("", "Incomplete items:");
-        for (const item of resume.incomplete_work) {
-            parts.push(`  - ${item.entity}: ${item.status} (risk: ${item.risk})`);
-        }
-    }
-    parts.push("", `Suggested next: ${resume.suggested_next}`);
-    return parts.join("\n");
-}
-function formatElapsed(ms) {
-    const seconds = Math.floor(ms / 1000);
-    if (seconds < 60)
-        return `${seconds}s ago`;
-    const minutes = Math.floor(seconds / 60);
-    if (minutes < 60)
-        return `${minutes}m ago`;
-    const hours = Math.floor(minutes / 60);
-    if (hours < 24)
-        return `${hours}h ago`;
-    const days = Math.floor(hours / 24);
-    return `${days}d ago`;
-}
-function formatDuration(ms) {
-    if (ms < 60_000)
-        return `${Math.round(ms / 1000)}s`;
-    const minutes = Math.round(ms / 60_000);
-    if (minutes < 60)
-        return `${minutes} min`;
-    const hours = Math.floor(minutes / 60);
-    const remainingMinutes = minutes % 60;
-    return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}m` : `${hours}h`;
-}

package/dist/commands/branches.js

@@ -1,97 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { gitQuery } from "../utils/exec.js";
-export async function listLocalBranches(cwd) {
-    const raw = await gitQuery([
-        "branch",
-        "-a",
-        "--format=%(HEAD)|%(refname:short)|%(upstream:track)|%(committerdate:relative)",
-    ], cwd);
-    if (!raw)
-        return [];
-    const driftCounts = loadBranchDriftCounts(cwd);
-    const branches = [];
-    for (const line of raw.split("\n")) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            continue;
-        const parts = trimmed.split("|");
-        const isCurrent = parts[0] === "*";
-        const name = parts[1] ?? "";
-        const tracking = parts[2] ?? "";
-        const lastCommit = parts[3] ?? "";
-        if (!name)
-            continue;
-        branches.push({
-            name,
-            isCurrent,
-            lastCommit,
-            tracking,
-            driftEntityCount: driftCounts.get(name) ?? 0,
-        });
-    }
-    return branches;
-}
-function loadBranchDriftCounts(cwd) {
-    const counts = new Map();
-    const branchDir = path.join(cwd, ".unerr", "state", "branch-overlays");
-    if (!fs.existsSync(branchDir))
-        return counts;
-    try {
-        const entries = fs.readdirSync(branchDir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (!entry.isDirectory())
-                continue;
-            const overlayPath = path.join(branchDir, entry.name, "overlay_snapshot.json");
-            if (!fs.existsSync(overlayPath))
-                continue;
-            try {
-                const raw = fs.readFileSync(overlayPath, "utf-8");
-                const snapshot = JSON.parse(raw);
-                if (snapshot.branch && snapshot.entities) {
-                    counts.set(snapshot.branch, snapshot.entities.length);
-                }
-            }
-            catch {
-                // Skip corrupt snapshots
-            }
-        }
-    }
-    catch {
-        // Non-blocking
-    }
-    return counts;
-}
-export function registerBranchesCommand(program) {
-    program
-        .command("branches")
-        .description("Show branches for this repository")
-        .action(async () => {
-        try {
-            const cwd = process.cwd();
-            const branches = await listLocalBranches(cwd);
-            if (branches.length === 0) {
-                process.stderr.write("[unerr] No branches found.\n");
-                return;
-            }
-            let withDrift = 0;
-            process.stderr.write("\n");
-            for (const branch of branches) {
-                const marker = branch.isCurrent ? "* " : "  ";
-                const trackingSuffix = branch.tracking ? ` ${branch.tracking}` : "";
-                let driftSuffix = "";
-                if (branch.driftEntityCount > 0) {
-                    driftSuffix = ` (${branch.driftEntityCount} drift entities)`;
-                    withDrift++;
-                }
-                process.stderr.write(`${marker}${branch.name.padEnd(30)} ${branch.lastCommit}${trackingSuffix}${driftSuffix}\n`);
-            }
-            process.stderr.write(`\n  ${branches.length} branches · ${withDrift} with drift overlays\n\n`);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            console.error(`Error: ${message}`);
-            process.exit(1);
-        }
-    });
-}

package/dist/commands/check-commit.js

@@ -1,225 +0,0 @@
-/**
- * unerr check-commit — Pre-commit convention validation.
- *
- * Called by the pre-commit git hook to check staged changes
- * against project conventions. Non-blocking by default.
- *
- * Sprint 4 (Task 4.2): Full convention checking implementation.
- *
- * Flow:
- *   1. Load CozoDB graph from local snapshot
- *   2. Get staged files from git
- *   3. Evaluate rules against each staged file
- *   4. Display violations with formatted output
- *   5. Exit 1 if blocking mode and violations found
- *
- * Exit codes:
- *   0 — All checks pass (or no checks available)
- *   1 — Violations found (only when blocking mode is enabled)
- */
-import { existsSync, readFileSync } from "node:fs";
-import { extname, join } from "node:path";
-import { gunzipSync } from "node:zlib";
-import pc from "picocolors";
-import { getStagedFiles } from "../utils/git.js";
-import { logInfo } from "../utils/log.js";
-import { detail, fail, info, section, success, warn } from "../utils/ui.js";
-/** File extensions we can evaluate rules against. */
-const SUPPORTED_EXTENSIONS = new Set([
-    ".ts",
-    ".tsx",
-    ".js",
-    ".jsx",
-    ".py",
-    ".go",
-]);
-export function registerCheckCommitCommand(program) {
-    program
-        .command("check-commit")
-        .description("Check staged changes against project conventions (pre-commit hook)")
-        .option("--blocking", "Exit with code 1 on violations (default: non-blocking)")
-        .option("--verbose", "Show detailed output including passing files")
-        .action(async (opts) => {
-        const cwd = process.cwd();
-        // ── Blocking mode detection ──────────────────────────────────
-        let blockingMode = opts.blocking ?? false;
-        const settingsPath = join(cwd, ".unerr", "settings.json");
-        if (!blockingMode && existsSync(settingsPath)) {
-            try {
-                const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
-                blockingMode = settings.hooks?.precommit?.blocking ?? false;
-            }
-            catch {
-                /* ignore malformed settings */
-            }
-        }
-        logInfo("check-commit invoked", { blocking: blockingMode });
-        // ── Config gating ────────────────────────────────────────────
-        const configPath = join(cwd, ".unerr", "config.json");
-        if (!existsSync(configPath)) {
-            logInfo("check-commit: no .unerr/config.json, skipping");
-            return;
-        }
-        let repoId;
-        try {
-            const config = JSON.parse(readFileSync(configPath, "utf-8"));
-            if (!config.repoId) {
-                logInfo("check-commit: no repoId in config, skipping");
-                return;
-            }
-            repoId = config.repoId;
-        }
-        catch {
-            logInfo("check-commit: invalid config.json, skipping");
-            return;
-        }
-        // ── Get staged files ─────────────────────────────────────────
-        const stagedFiles = await getStagedFiles(cwd);
-        if (stagedFiles.length === 0) {
-            logInfo("check-commit: no staged files");
-            return;
-        }
-        // Filter to supported file types
-        const checkableFiles = stagedFiles.filter((f) => SUPPORTED_EXTENSIONS.has(extname(f)));
-        if (checkableFiles.length === 0) {
-            if (opts.verbose) {
-                section("unerr pre-commit check");
-                detail(`${stagedFiles.length} staged file${stagedFiles.length !== 1 ? "s" : ""} — none with supported extensions`);
-            }
-            return;
-        }
-        // ── Load graph ───────────────────────────────────────────────
-        const snapshotsDir = join(cwd, ".unerr", "snapshots");
-        const manifestsDir = join(cwd, ".unerr", "manifests");
-        const localGraph = await loadGraphForCheckCommit(repoId, snapshotsDir, manifestsDir);
-        if (!localGraph) {
-            if (opts.verbose) {
-                section("unerr pre-commit check");
-                detail("No local graph available — skipping convention checks");
-            }
-            logInfo("check-commit: no graph available, skipping");
-            return;
-        }
-        // Check if any rules exist
-        if (!(await localGraph.hasRules())) {
-            if (opts.verbose) {
-                section("unerr pre-commit check");
-                detail("No rules defined — skipping convention checks");
-            }
-            logInfo("check-commit: no rules in graph, skipping");
-            return;
-        }
-        // ── Evaluate rules per file ──────────────────────────────────
-        const { evaluateRules } = await import("../intelligence/rule-evaluator.js");
-        const allFileViolations = [];
-        let totalRulesEvaluated = 0;
-        let filesChecked = 0;
-        for (const filePath of checkableFiles) {
-            const absPath = join(cwd, filePath);
-            if (!existsSync(absPath))
-                continue;
-            let content;
-            try {
-                content = readFileSync(absPath, "utf-8");
-            }
-            catch {
-                continue; // Skip unreadable files
-            }
-            const rules = await localGraph.getRules(filePath);
-            if (rules.length === 0)
-                continue;
-            filesChecked++;
-            totalRulesEvaluated += rules.length;
-            try {
-                const result = await evaluateRules(rules, filePath, content, localGraph);
-                if (result.violations.length > 0) {
-                    allFileViolations.push({
-                        filePath,
-                        violations: result.violations,
-                    });
-                }
-            }
-            catch (err) {
-                logInfo(`check-commit: rule evaluation failed for ${filePath}`, err);
-            }
-        }
-        const totalViolations = allFileViolations.reduce((sum, fv) => sum + fv.violations.length, 0);
-        // ── Display results ──────────────────────────────────────────
-        section("unerr pre-commit check");
-        if (totalViolations === 0) {
-            success(`${filesChecked} file${filesChecked !== 1 ? "s" : ""} checked, ${totalRulesEvaluated} rules evaluated — all clear`);
-            process.exitCode = 0;
-            return;
-        }
-        // Display violations grouped by file
-        for (const fv of allFileViolations) {
-            fail(`${fv.filePath}`);
-            for (const v of fv.violations) {
-                const location = v.line ? `:${v.line}` : "";
-                const severityColor = v.severity === "error"
-                    ? pc.red
-                    : v.severity === "warning"
-                        ? pc.yellow
-                        : pc.dim;
-                info(`${severityColor(`[${v.severity}]`)} ${v.message}${location ? pc.dim(` (line ${v.line})`) : ""}`);
-                if (v.matchedCode && opts.verbose) {
-                    detail(`  → ${v.matchedCode.slice(0, 80)}`);
-                }
-            }
-        }
-        // Summary line
-        const errorCount = allFileViolations.reduce((sum, fv) => sum + fv.violations.filter((v) => v.severity === "error").length, 0);
-        const warningCount = totalViolations - errorCount;
-        const errorSuffix = errorCount > 0
-            ? ` (${errorCount} error${errorCount !== 1 ? "s" : ""})`
-            : "";
-        const warnSuffix = warningCount > 0
-            ? ` (${warningCount} warning${warningCount !== 1 ? "s" : ""})`
-            : "";
-        warn(`${totalViolations} violation${totalViolations !== 1 ? "s" : ""} found${errorSuffix}${warnSuffix}`);
-        if (blockingMode) {
-            fail("Commit blocked — fix violations or use --no-verify to bypass");
-            process.exitCode = 1;
-        }
-        else {
-            detail("Non-blocking mode — commit will proceed");
-            detail("Enable blocking: set hooks.precommit.blocking=true in .unerr/settings.json");
-            process.exitCode = 0;
-        }
-    });
-}
-// ── Graph Loading ────────────────────────────────────────────────────
-/**
- * Load CozoDB graph for standalone check-commit (proxy may not be running).
- * Returns null if no snapshot available.
- */
-async function loadGraphForCheckCommit(repoId, snapshotsDir, manifestsDir) {
-    // Check manifest exists
-    const manifestPath = join(manifestsDir, `${repoId}.json`);
-    if (!existsSync(manifestPath))
-        return null;
-    // Find snapshot file
-    let snapshotPath = join(snapshotsDir, `${repoId}.msgpack.gz`);
-    if (!existsSync(snapshotPath)) {
-        snapshotPath = join(snapshotsDir, `${repoId}.msgpack`);
-    }
-    if (!existsSync(snapshotPath))
-        return null;
-    try {
-        // Dynamic imports to keep cold start fast when no check needed
-        const { default: CozoDbConstructor } = await import("cozo-node");
-        const { CozoGraphStore } = await import("../intelligence/local-graph.js");
-        const { unpack } = await import("msgpackr");
-        const db = new CozoDbConstructor();
-        const localGraph = await CozoGraphStore.create(db);
-        const raw = readFileSync(snapshotPath);
-        const buffer = snapshotPath.endsWith(".gz") ? gunzipSync(raw) : raw;
-        const envelope = unpack(buffer);
-        await localGraph.loadSnapshot(envelope);
-        return localGraph;
-    }
-    catch (err) {
-        logInfo("check-commit: failed to load graph", err);
-        return null;
-    }
-}

package/dist/commands/compress-output.js

@@ -1,64 +0,0 @@
-/**
- * `unerr compress-output` — stdin→stdout compression for CLI hooks.
- *
- * S6.4: Reads text from stdin, compresses with the output compressor,
- * writes compressed output to stdout. When graph is available, passes
- * entity risk map for graph-aware prioritization.
- *
- * Usage (in hooks): echo "$OUTPUT" | unerr compress-output
- */
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { compressOutput, } from "../proxy/output-compressor.js";
-/**
- * Load entity risk map from the local graph state if available.
- * Returns empty map if graph is not initialized.
- */
-function loadEntityRiskMap(cwd) {
-    const riskMap = new Map();
-    try {
-        const unerrDir = join(cwd, ".unerr");
-        const configPath = join(unerrDir, "config.json");
-        if (!existsSync(configPath))
-            return riskMap;
-        const config = JSON.parse(readFileSync(configPath, "utf-8"));
-        if (!config.repoId)
-            return riskMap;
-        const riskCachePath = join(unerrDir, "state", "entity_risk_cache.json");
-        if (!existsSync(riskCachePath))
-            return riskMap;
-        const data = JSON.parse(readFileSync(riskCachePath, "utf-8"));
-        for (const [key, info] of Object.entries(data)) {
-            riskMap.set(key, info);
-        }
-    }
-    catch {
-        // Risk map loading is best-effort — compression works without it
-    }
-    return riskMap;
-}
-export function registerCompressOutputCommand(program) {
-    program
-        .command("compress-output")
-        .description("Compress text from stdin using graph-aware compression (for hooks)")
-        .option("--budget <tokens>", "Token budget", "2000")
-        .option("--no-graph", "Skip loading graph risk map")
-        .action(async (opts) => {
-        const budget = Number.parseInt(opts.budget, 10) || 2000;
-        let input = "";
-        for await (const chunk of process.stdin) {
-            input += chunk;
-        }
-        if (input.length === 0) {
-            process.exit(0);
-            return;
-        }
-        // S6.4: Load entity risk map from graph when available
-        const entityRiskMap = opts.graph !== false ? loadEntityRiskMap(process.cwd()) : undefined;
-        const result = compressOutput(input, {
-            tokenBudget: budget,
-            entityRiskMap: entityRiskMap && entityRiskMap.size > 0 ? entityRiskMap : undefined,
-        });
-        process.stdout.write(result.output);
-    });
-}