@unerr-ai/unerr 0.2.1 → 0.2.2

package/dist/tracking/durability-tracker.js

@@ -1,94 +0,0 @@
-/**
- * Durability Tracker — tracks AI modifications and their survival time.
- *
- * U.7: Records when AI modifies an entity and whether it survives 24h.
- * U.8: Computes durability score = survived / total modifications.
- *
- * A modification "survives" if the entity's body_hash is unchanged 24h later.
- * Entities with low durability (<0.5) trigger warnings surfaced as `ur|wrn` prefix lines.
- */
-const SURVIVAL_WINDOW_MS = 24 * 60 * 60 * 1000;
-export function createDurabilityTracker() {
-    const records = new Map();
-    function recordModification(entityKey, sessionId, bodyHash) {
-        if (!records.has(entityKey))
-            records.set(entityKey, []);
-        records.get(entityKey)?.push({
-            entityKey,
-            modifiedAt: Date.now(),
-            sessionId,
-            bodyHashAtModification: bodyHash,
-            survived: null,
-            evaluatedAt: null,
-        });
-    }
-    function evaluateSurvival(entityKey, currentBodyHash) {
-        const mods = records.get(entityKey);
-        if (!mods)
-            return;
-        const now = Date.now();
-        for (const mod of mods) {
-            if (mod.survived !== null)
-                continue;
-            if (now - mod.modifiedAt < SURVIVAL_WINDOW_MS)
-                continue;
-            mod.survived = mod.bodyHashAtModification === currentBodyHash;
-            mod.evaluatedAt = now;
-        }
-    }
-    function getScore(entityKey) {
-        const mods = records.get(entityKey);
-        if (!mods || mods.length === 0)
-            return null;
-        let survived = 0;
-        let reverted = 0;
-        let pending = 0;
-        for (const mod of mods) {
-            if (mod.survived === null)
-                pending++;
-            else if (mod.survived)
-                survived++;
-            else
-                reverted++;
-        }
-        const evaluated = survived + reverted;
-        const score = evaluated > 0 ? survived / evaluated : 0.5;
-        return {
-            entityKey,
-            score: Math.round(score * 100) / 100,
-            totalModifications: mods.length,
-            survived,
-            reverted,
-            pending,
-            lastModified: mods[mods.length - 1]?.modifiedAt ?? 0,
-        };
-    }
-    function getLowDurabilityEntities(threshold = 0.5) {
-        const results = [];
-        for (const entityKey of records.keys()) {
-            const result = getScore(entityKey);
-            if (result &&
-                result.score < threshold &&
-                result.totalModifications >= 2) {
-                results.push(result);
-            }
-        }
-        return results.sort((a, b) => a.score - b.score);
-    }
-    function getAllScores() {
-        const scores = new Map();
-        for (const entityKey of records.keys()) {
-            const result = getScore(entityKey);
-            if (result)
-                scores.set(entityKey, result);
-        }
-        return scores;
-    }
-    return {
-        recordModification,
-        evaluateSurvival,
-        getScore,
-        getLowDurabilityEntities,
-        getAllScores,
-    };
-}

package/dist/tracking/entity-rewind.js

@@ -1,200 +0,0 @@
-/**
- * Sprint 7.4: Entity-level rewind — surgically restore a single entity to its base state.
- *
- * Flow:
- *   1. Look up entity in drift_overlay by name (+ optional file_path)
- *   2. Read current file content
- *   3. Replace the entity's current body with previous_body at its line range
- *   4. Write the file back
- *   5. Remove drift_overlay entry
- *
- * For ADDED entities (no previous_body): delete the entity lines from the file.
- * For DELETED entities: restore previous_body at the original line position.
- * For MODIFIED entities: replace current lines with previous_body.
- */
-import { readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-/**
- * Revert a single entity to its base (pre-drift) state.
- */
-export async function revertEntity(entityName, localGraph, projectRoot, filePath) {
-    // Find the drift entity by name
-    const driftEntity = await findDriftEntity(localGraph, entityName, filePath);
-    if (!driftEntity) {
-        return {
-            reverted: false,
-            file: filePath ?? "",
-            lines: "",
-            drift_status: "",
-            error: `No drifted entity found: "${entityName}"${filePath ? ` in ${filePath}` : ""}`,
-        };
-    }
-    const absPath = join(projectRoot, driftEntity.file_path);
-    if (driftEntity.drift_status === "added") {
-        // Entity was added locally — remove it from the file
-        return removeAddedEntity(absPath, driftEntity, localGraph);
-    }
-    if (driftEntity.drift_status === "deleted") {
-        // Entity was deleted locally — restore previous_body
-        return restoreDeletedEntity(absPath, driftEntity, localGraph);
-    }
-    if (driftEntity.drift_status === "modified") {
-        // Entity was modified — replace current body with previous_body
-        return restoreModifiedEntity(absPath, driftEntity, localGraph);
-    }
-    // dependency_changed — nothing to revert in the file itself
-    await localGraph.removeDriftEntity(driftEntity.key);
-    return {
-        reverted: true,
-        file: driftEntity.file_path,
-        lines: "",
-        drift_status: driftEntity.drift_status,
-    };
-}
-/**
- * Find a drift entity by name, optionally filtered by file path.
- */
-async function findDriftEntity(localGraph, entityName, filePath) {
-    // Query drift_overlay for entities matching the name
-    const result = await localGraph.db.run(filePath
-        ? `?[key, name, kind, sig, body, fp, ls, le, ch, ds, iid, ma, origin, pb, ps] :=
-          *drift_overlay[key, name, kind, sig, body, fp, ls, le, ch, ds, iid, ma, origin, pb, ps],
-          name = $name, fp = $fp`
-        : `?[key, name, kind, sig, body, fp, ls, le, ch, ds, iid, ma, origin, pb, ps] :=
-          *drift_overlay[key, name, kind, sig, body, fp, ls, le, ch, ds, iid, ma, origin, pb, ps],
-          name = $name`, filePath ? { name: entityName, fp: filePath } : { name: entityName });
-    if (result.rows.length === 0)
-        return null;
-    const [key, name, kind, signature, body, file_path, line_start, line_end, content_hash, drift_status, intent_id, modified_at, origin, previous_body, previous_signature,] = result.rows[0];
-    return {
-        key,
-        name,
-        kind,
-        signature,
-        body,
-        file_path,
-        line_start,
-        line_end,
-        content_hash,
-        drift_status: drift_status,
-        intent_id,
-        modified_at,
-        origin: origin,
-        previous_body,
-        previous_signature,
-    };
-}
-/**
- * Remove an ADDED entity from the file (it didn't exist in base).
- */
-async function removeAddedEntity(absPath, entity, localGraph) {
-    try {
-        const content = readFileSync(absPath, "utf-8");
-        const lines = content.split("\n");
-        // Remove the entity's lines (1-indexed → 0-indexed)
-        const startIdx = entity.line_start - 1;
-        const endIdx = entity.line_end;
-        lines.splice(startIdx, endIdx - startIdx);
-        writeFileSync(absPath, lines.join("\n"), "utf-8");
-        await localGraph.removeDriftEntity(entity.key);
-        return {
-            reverted: true,
-            file: entity.file_path,
-            lines: `${entity.line_start}-${entity.line_end}`,
-            drift_status: "added",
-        };
-    }
-    catch (err) {
-        return {
-            reverted: false,
-            file: entity.file_path,
-            lines: "",
-            drift_status: "added",
-            error: `Failed to remove added entity: ${err instanceof Error ? err.message : String(err)}`,
-        };
-    }
-}
-/**
- * Restore a DELETED entity by inserting previous_body back into the file.
- */
-async function restoreDeletedEntity(absPath, entity, localGraph) {
-    if (!entity.previous_body) {
-        // No previous body stored — can't restore
-        await localGraph.removeDriftEntity(entity.key);
-        return {
-            reverted: false,
-            file: entity.file_path,
-            lines: "",
-            drift_status: "deleted",
-            error: "No previous body available for restoration",
-        };
-    }
-    try {
-        const content = readFileSync(absPath, "utf-8");
-        const lines = content.split("\n");
-        const previousLines = entity.previous_body.split("\n");
-        // Insert at the original line position (or end of file if beyond current length)
-        const insertIdx = Math.min(entity.line_start - 1, lines.length);
-        lines.splice(insertIdx, 0, ...previousLines);
-        writeFileSync(absPath, lines.join("\n"), "utf-8");
-        await localGraph.removeDriftEntity(entity.key);
-        const endLine = insertIdx + previousLines.length;
-        return {
-            reverted: true,
-            file: entity.file_path,
-            lines: `${insertIdx + 1}-${endLine}`,
-            drift_status: "deleted",
-        };
-    }
-    catch (err) {
-        return {
-            reverted: false,
-            file: entity.file_path,
-            lines: "",
-            drift_status: "deleted",
-            error: `Failed to restore deleted entity: ${err instanceof Error ? err.message : String(err)}`,
-        };
-    }
-}
-/**
- * Restore a MODIFIED entity by replacing current lines with previous_body.
- */
-async function restoreModifiedEntity(absPath, entity, localGraph) {
-    if (!entity.previous_body) {
-        await localGraph.removeDriftEntity(entity.key);
-        return {
-            reverted: false,
-            file: entity.file_path,
-            lines: "",
-            drift_status: "modified",
-            error: "No previous body available for restoration",
-        };
-    }
-    try {
-        const content = readFileSync(absPath, "utf-8");
-        const lines = content.split("\n");
-        const previousLines = entity.previous_body.split("\n");
-        // Replace the entity's current lines with the previous body
-        const startIdx = entity.line_start - 1;
-        const deleteCount = entity.line_end - entity.line_start + 1;
-        lines.splice(startIdx, deleteCount, ...previousLines);
-        writeFileSync(absPath, lines.join("\n"), "utf-8");
-        await localGraph.removeDriftEntity(entity.key);
-        const endLine = startIdx + previousLines.length;
-        return {
-            reverted: true,
-            file: entity.file_path,
-            lines: `${entity.line_start}-${endLine}`,
-            drift_status: "modified",
-        };
-    }
-    catch (err) {
-        return {
-            reverted: false,
-            file: entity.file_path,
-            lines: "",
-            drift_status: "modified",
-            error: `Failed to restore modified entity: ${err instanceof Error ? err.message : String(err)}`,
-        };
-    }
-}

package/dist/tracking/file-hash-state.js

@@ -1,114 +0,0 @@
-/**
- * File Hash State Manager — tracks per-file content SHAs for state-aware skipping.
- *
- * Manages `.unerr/state/file_hashes.json` with the skip decision tree:
- *   - Content SHA unchanged + HEAD SHA unchanged → SKIP
- *   - Content SHA unchanged + HEAD SHA changed   → SKIP scan, UPDATE head_sha
- *   - Content SHA changed                        → PROCESS
- *
- * Uses atomic write (write to .tmp, rename) for crash safety.
- */
-import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, } from "node:fs";
-import { join } from "node:path";
-const STATE_FILE = "file_hashes.json";
-export class FileHashManager {
-    stateDir;
-    statePath;
-    state;
-    constructor(unerrDir) {
-        this.stateDir = join(unerrDir, "state");
-        this.statePath = join(this.stateDir, STATE_FILE);
-        this.state = this.load();
-    }
-    /**
-     * Determine if a file should be processed or skipped.
-     */
-    shouldProcess(filePath, contentSha, headSha) {
-        const entry = this.state.files[filePath];
-        if (!entry)
-            return "process";
-        if (entry.contentSha !== contentSha) {
-            // Content changed → must process
-            return "process";
-        }
-        if (entry.headSha !== headSha) {
-            // Content same but HEAD moved (e.g., commit or rebase) → skip but update headSha
-            entry.headSha = headSha;
-            entry.processedAt = new Date().toISOString();
-            // Defer save — caller should call save() after batch
-        }
-        return "skip";
-    }
-    /**
-     * Mark a file as processed with the given content and HEAD SHAs.
-     */
-    markProcessed(filePath, contentSha, headSha) {
-        this.state.files[filePath] = {
-            contentSha,
-            headSha,
-            processedAt: new Date().toISOString(),
-        };
-    }
-    /**
-     * Remove tracking for a specific file.
-     */
-    remove(filePath) {
-        delete this.state.files[filePath];
-    }
-    /**
-     * Clear all file hash state.
-     */
-    clearAll() {
-        this.state.files = {};
-        this.save();
-    }
-    /**
-     * Persist state to disk atomically (write .tmp → rename).
-     */
-    save() {
-        if (!existsSync(this.stateDir)) {
-            mkdirSync(this.stateDir, { recursive: true });
-        }
-        const tmpPath = `${this.statePath}.tmp`;
-        writeFileSync(tmpPath, JSON.stringify(this.state, null, 2), "utf-8");
-        renameSync(tmpPath, this.statePath);
-    }
-    /**
-     * Get the number of tracked files.
-     */
-    get trackedCount() {
-        return Object.keys(this.state.files).length;
-    }
-    /**
-     * Get the full state (for debugging / `unerr debug`).
-     */
-    getState() {
-        return this.state;
-    }
-    /**
-     * Restore state from a snapshot (e.g., branch switch restore).
-     * Replaces current in-memory state without persisting to disk.
-     */
-    restoreState(snapshot) {
-        this.state = { files: { ...snapshot.files } };
-    }
-    load() {
-        if (!existsSync(this.statePath)) {
-            return { files: {} };
-        }
-        try {
-            const raw = readFileSync(this.statePath, "utf-8");
-            return JSON.parse(raw);
-        }
-        catch {
-            return { files: {} };
-        }
-    }
-}
-/**
- * Compute SHA-256 hex digest of file content.
- */
-export function contentSha256(content) {
-    return createHash("sha256").update(content).digest("hex");
-}

package/dist/tracking/git-attribution.js

@@ -1,132 +0,0 @@
-/**
- * Git-Native Attribution — Phase 5.5 §1.5
- *
- * Attaches ledger metadata to Git commits using:
- *   1. Git Trailers (in commit messages) — lightweight, `git log --format="%(trailers)"` parseable
- *   2. Git Notes (under refs/notes/unerr) — rich JSON metadata, aligned with git-ai v3 standard
- *
- * Both mechanisms survive rebases, merges, squashes, and cherry-picks.
- * This makes ledger data git-mergeable by construction — no sidecar JSONL files.
- *
- * Integration point: Called from `unerr push` before git push (P13 bridge).
- */
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { writeNote } from "../utils/git.js";
-// ── Git Trailers ───────────────────────────────────────────────────────────
-/**
- * Build a commit message with Git Trailers appended.
- * Trailers are standardized key-value pairs at the end of a commit message,
- * separated from the body by a blank line. Parseable via `git log --format="%(trailers)"`.
- *
- * Aligned with git-ai v3 standard: session-based attribution with model + tool metadata.
- */
-export function buildCommitMessageWithTrailers(baseMessage, attribution) {
-    const trailers = [];
-    trailers.push(`Unerr-Session: ${attribution.sessionId}`);
-    if (attribution.ledgerEntryIds.length > 0) {
-        // Only include first entry ID to keep message short; full list in Git Notes
-        trailers.push(`Unerr-Ledger-Id: ${attribution.ledgerEntryIds[0]}`);
-    }
-    if (attribution.changeType) {
-        trailers.push(`Unerr-Change-Type: ${attribution.changeType}`);
-    }
-    if (attribution.featureArea) {
-        trailers.push(`Unerr-Feature: ${attribution.featureArea}`);
-    }
-    if (attribution.planSummary) {
-        // Truncate plan to 72 chars for trailer (single-line convention)
-        const truncated = attribution.planSummary.length > 72
-            ? `${attribution.planSummary.slice(0, 69)}...`
-            : attribution.planSummary;
-        trailers.push(`Unerr-Plan: ${truncated}`);
-    }
-    if (attribution.agentModel) {
-        trailers.push(`Unerr-Agent-Model: ${attribution.agentModel}`);
-    }
-    if (attribution.agentTool) {
-        trailers.push(`Unerr-Agent-Tool: ${attribution.agentTool}`);
-    }
-    // Git trailer format: blank line + trailers (one per line)
-    return `${baseMessage}\n\n${trailers.join("\n")}\n`;
-}
-// ── Git Notes ──────────────────────────────────────────────────────────────
-/**
- * Build the Git Note payload (JSON) for a commit.
- * Written to refs/notes/unerr — a custom namespace that won't conflict
- * with the default refs/notes/commits.
- *
- * Contains rich metadata: full prompt, plan, entities affected, etc.
- * The git-ai v3 standard uses a similar approach under refs/notes/ai.
- */
-export function buildGitNotePayload(attribution) {
-    return {
-        version: "1.0",
-        session_id: attribution.sessionId,
-        ledger_entry_ids: attribution.ledgerEntryIds,
-        prompt: attribution.prompt,
-        plan_summary: attribution.planSummary,
-        change_type: attribution.changeType,
-        feature_area: attribution.featureArea,
-        entities_affected: [], // Resolved from SCIP index
-        files_changed: attribution.filesChanged,
-        agent_model: attribution.agentModel,
-        agent_tool: attribution.agentTool,
-        created_at: new Date().toISOString(),
-    };
-}
-/**
- * Write a Git Note under refs/notes/unerr for a specific commit.
- * Uses simple-git via the centralized git utility.
- *
- * Target latency: <50ms (see §1.8.1).
- */
-export async function writeGitNote(dir, _gitdir, commitSha, payload) {
-    const noteContent = JSON.stringify(payload, null, 2);
-    await writeNote(dir, "unerr", commitSha, noteContent);
-}
-/**
- * Read the attribution context from the local workspace manifest.
- * The manifest (.unerr/manifest.json) is maintained by P10's Local Proxy
- * and contains session-scoped attribution data.
- *
- * Returns null if no manifest exists (non-AI push).
- */
-export function readAttributionFromManifest(cwd) {
-    const manifestPath = join(cwd, ".unerr", "manifest.json");
-    if (!existsSync(manifestPath))
-        return null;
-    try {
-        const raw = readFileSync(manifestPath, "utf-8");
-        const manifest = JSON.parse(raw);
-        if (!manifest.sessionId || !manifest.attributions?.length)
-            return null;
-        // Merge all unflushed attributions into a single context
-        const allEntryIds = [];
-        const allFiles = [];
-        const prompts = [];
-        for (const attr of manifest.attributions) {
-            if (attr.ledgerEntryIds)
-                allEntryIds.push(...attr.ledgerEntryIds);
-            if (attr.filesChanged)
-                allFiles.push(...attr.filesChanged);
-            if (attr.prompt)
-                prompts.push(attr.prompt);
-        }
-        const latest = manifest.attributions[manifest.attributions.length - 1];
-        return {
-            sessionId: manifest.sessionId,
-            ledgerEntryIds: [...new Set(allEntryIds)],
-            prompt: prompts.join(" → "),
-            planSummary: latest.planSummary,
-            changeType: latest.changeType,
-            featureArea: latest.featureArea,
-            agentModel: latest.agentModel,
-            agentTool: latest.agentTool,
-            filesChanged: [...new Set(allFiles)],
-        };
-    }
-    catch {
-        return null;
-    }
-}