@ekkos/cli 0.2.18 → 0.3.3

package/dist/capture/transcript-repair.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Transcript Repair - Handles orphan tool_result recovery
+ *
+ * When ccDNA's validate mode detects orphan tool_results (tool_result without
+ * matching tool_use), this module repairs the transcript:
+ *
+ * 1. ROLLBACK (preferred): Restore from backup if valid
+ * 2. SURGICAL REPAIR (fallback): Remove orphan tool_result lines
+ *
+ * This closes the loop: ccDNA detects → ekkos-cli repairs → /clear + /continue
+ */
+type RepairAction = 'none' | 'rollback' | 'surgical_repair' | 'failed';
+export interface RepairResult {
+    action: RepairAction;
+    orphansFound: number;
+    removedLines?: number;
+    backupUsed?: string;
+    reason?: string;
+}
+/**
+ * Minimal validator: tool_result.tool_use_id must reference a tool_use.id that
+ * appears earlier in the transcript (in-order).
+ */
+export declare function countOrphansInJsonl(jsonlPath: string): {
+    orphans: number;
+    orphanIds: string[];
+};
+/**
+ * Main entry point: repair or rollback a transcript with orphan tool_results.
+ *
+ * Strategy:
+ * 1. Check if there are orphans (exit early if none)
+ * 2. Try rollback to newest valid backup
+ * 3. If no valid backup, surgically remove orphan lines
+ */
+export declare function repairOrRollbackTranscript(jsonlPath: string): RepairResult;
+/**
+ * Quick validation check - can be called before operations to verify health.
+ */
+export declare function isTranscriptHealthy(jsonlPath: string): boolean;
+/**
+ * Get detailed transcript health info.
+ */
+export declare function getTranscriptHealth(jsonlPath: string): {
+    exists: boolean;
+    healthy: boolean;
+    orphans: number;
+    orphanIds: string[];
+};
+export {};

package/dist/capture/transcript-repair.js

@@ -0,0 +1,308 @@
+"use strict";
+/**
+ * Transcript Repair - Handles orphan tool_result recovery
+ *
+ * When ccDNA's validate mode detects orphan tool_results (tool_result without
+ * matching tool_use), this module repairs the transcript:
+ *
+ * 1. ROLLBACK (preferred): Restore from backup if valid
+ * 2. SURGICAL REPAIR (fallback): Remove orphan tool_result lines
+ *
+ * This closes the loop: ccDNA detects → ekkos-cli repairs → /clear + /continue
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countOrphansInJsonl = countOrphansInJsonl;
+exports.repairOrRollbackTranscript = repairOrRollbackTranscript;
+exports.isTranscriptHealthy = isTranscriptHealthy;
+exports.getTranscriptHealth = getTranscriptHealth;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+// Debug logging to the same file as eviction
+function debugLog(category, msg, data) {
+    try {
+        const logDir = path.join(os.homedir(), '.ekkos', 'logs');
+        if (!fs.existsSync(logDir))
+            fs.mkdirSync(logDir, { recursive: true });
+        const logPath = path.join(logDir, 'eviction-debug.log');
+        const ts = new Date().toISOString();
+        const line = `[${ts}] [REPAIR:${category}] ${msg}${data ? '\n  ' + JSON.stringify(data, null, 2).replace(/\n/g, '\n  ') : ''}`;
+        fs.appendFileSync(logPath, line + '\n');
+    }
+    catch {
+        // Silent fail
+    }
+}
+/**
+ * Minimal validator: tool_result.tool_use_id must reference a tool_use.id that
+ * appears earlier in the transcript (in-order).
+ */
+function countOrphansInJsonl(jsonlPath) {
+    const content = fs.readFileSync(jsonlPath, 'utf-8');
+    const lines = content.split('\n').filter(l => l.trim().length > 0);
+    const seenToolUses = new Set();
+    const orphanIds = [];
+    for (const line of lines) {
+        let obj;
+        try {
+            obj = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const blocks = obj?.message?.content;
+        if (!Array.isArray(blocks))
+            continue;
+        for (const b of blocks) {
+            const block = b;
+            if (block?.type === 'tool_use' && typeof block?.id === 'string') {
+                seenToolUses.add(block.id);
+            }
+            else if (block?.type === 'tool_result' && typeof block?.tool_use_id === 'string') {
+                if (!seenToolUses.has(block.tool_use_id)) {
+                    orphanIds.push(block.tool_use_id);
+                }
+            }
+        }
+    }
+    return { orphans: orphanIds.length, orphanIds };
+}
+/**
+ * Find plausible backups for a jsonl file.
+ * Our jsonl-rewriter uses: ${filePath}.backup (single backup)
+ */
+function findBackups(jsonlPath) {
+    const dir = path.dirname(jsonlPath);
+    const base = path.basename(jsonlPath);
+    if (!fs.existsSync(dir))
+        return [];
+    const candidates = [];
+    // Primary backup: exact .backup suffix (from jsonl-rewriter.ts)
+    const primaryBackup = `${jsonlPath}.backup`;
+    if (fs.existsSync(primaryBackup)) {
+        candidates.push(primaryBackup);
+    }
+    // Also check for other backup patterns in case user has manual backups
+    const files = fs.readdirSync(dir);
+    const additionalBackups = files
+        .filter(f => f.startsWith(base) &&
+        f !== base &&
+        (f.includes('.bak') || f.includes('.backup') || f.includes('.old') || f.includes('.prev')))
+        .map(f => path.join(dir, f))
+        .filter(f => !candidates.includes(f)) // Don't duplicate
+        .sort((a, b) => {
+        // Sort by mtime, newest first
+        const am = fs.statSync(a).mtimeMs;
+        const bm = fs.statSync(b).mtimeMs;
+        return bm - am;
+    });
+    return [...candidates, ...additionalBackups];
+}
+/**
+ * Atomically replace target file with source file.
+ * Keeps the corrupted version for forensics.
+ */
+function atomicReplace(target, source) {
+    const dir = path.dirname(target);
+    const tmp = path.join(dir, `${path.basename(target)}.tmp-repair-${Date.now()}`);
+    fs.copyFileSync(source, tmp);
+    const corrupt = path.join(dir, `${path.basename(target)}.corrupt-${Date.now()}`);
+    fs.renameSync(target, corrupt);
+    fs.renameSync(tmp, target);
+    debugLog('ATOMIC_REPLACE', 'Replaced corrupt file', {
+        target,
+        source,
+        corruptBackup: corrupt,
+    });
+}
+/**
+ * Surgical repair: drop any line that contains a tool_result whose tool_use_id
+ * has not appeared earlier in the file. This unbricks at the cost of losing those results.
+ */
+function surgicalRepair(jsonlPath) {
+    const content = fs.readFileSync(jsonlPath, 'utf-8');
+    const lines = content.split('\n').filter(l => l.trim().length > 0);
+    const seenToolUses = new Set();
+    const kept = [];
+    let removed = 0;
+    for (const line of lines) {
+        let obj;
+        try {
+            obj = JSON.parse(line);
+        }
+        catch {
+            // Keep non-JSON lines (shouldn't happen, but safe)
+            kept.push(line);
+            continue;
+        }
+        const blocks = obj?.message?.content;
+        if (!Array.isArray(blocks)) {
+            kept.push(line);
+            continue;
+        }
+        // First pass: collect tool_use IDs from this line
+        const lineToolUseIds = [];
+        for (const b of blocks) {
+            const block = b;
+            if (block?.type === 'tool_use' && typeof block?.id === 'string') {
+                lineToolUseIds.push(block.id);
+            }
+        }
+        // Second pass: check for orphan tool_results
+        let hasOrphanResult = false;
+        for (const b of blocks) {
+            const block = b;
+            if (block?.type === 'tool_result' && typeof block?.tool_use_id === 'string') {
+                if (!seenToolUses.has(block.tool_use_id)) {
+                    hasOrphanResult = true;
+                    debugLog('SURGICAL_DROP', 'Dropping line with orphan tool_result', {
+                        tool_use_id: block.tool_use_id,
+                        linePreview: line.slice(0, 200),
+                    });
+                }
+            }
+        }
+        if (hasOrphanResult) {
+            removed++;
+            continue;
+        }
+        // If kept, update seen tool uses AFTER keeping (order matters)
+        for (const id of lineToolUseIds) {
+            seenToolUses.add(id);
+        }
+        kept.push(line);
+    }
+    // Write atomically
+    const dir = path.dirname(jsonlPath);
+    const tmp = path.join(dir, `${path.basename(jsonlPath)}.tmp-surgical-${Date.now()}`);
+    fs.writeFileSync(tmp, kept.join('\n') + '\n', 'utf-8');
+    const corrupt = path.join(dir, `${path.basename(jsonlPath)}.corrupt-${Date.now()}`);
+    fs.renameSync(jsonlPath, corrupt);
+    fs.renameSync(tmp, jsonlPath);
+    const { orphans: orphansAfter } = countOrphansInJsonl(jsonlPath);
+    debugLog('SURGICAL_COMPLETE', 'Surgical repair finished', {
+        removed,
+        orphansAfter,
+        corruptBackup: corrupt,
+    });
+    return { removed, orphansAfter };
+}
+/**
+ * Main entry point: repair or rollback a transcript with orphan tool_results.
+ *
+ * Strategy:
+ * 1. Check if there are orphans (exit early if none)
+ * 2. Try rollback to newest valid backup
+ * 3. If no valid backup, surgically remove orphan lines
+ */
+function repairOrRollbackTranscript(jsonlPath) {
+    debugLog('REPAIR_START', '═══════════════════════════════════════════════════════════', {
+        action: 'TRANSCRIPT_REPAIR_INITIATED',
+        jsonlPath,
+        timestamp: new Date().toISOString(),
+    });
+    if (!fs.existsSync(jsonlPath)) {
+        debugLog('REPAIR_ABORT', 'JSONL file not found', { jsonlPath });
+        return { action: 'failed', orphansFound: 0, reason: 'jsonl_not_found' };
+    }
+    const initial = countOrphansInJsonl(jsonlPath);
+    debugLog('REPAIR_SCAN', 'Initial orphan count', {
+        orphans: initial.orphans,
+        orphanIds: initial.orphanIds,
+    });
+    if (initial.orphans === 0) {
+        debugLog('REPAIR_CLEAN', 'No orphans found - transcript is healthy');
+        return { action: 'none', orphansFound: 0 };
+    }
+    // 1) Try rollback to newest valid backup
+    const backups = findBackups(jsonlPath);
+    debugLog('REPAIR_BACKUPS', `Found ${backups.length} backup candidates`, { backups });
+    for (const backup of backups) {
+        try {
+            const v = countOrphansInJsonl(backup);
+            debugLog('REPAIR_CHECK_BACKUP', 'Validating backup', {
+                backup,
+                orphans: v.orphans,
+            });
+            if (v.orphans === 0) {
+                atomicReplace(jsonlPath, backup);
+                debugLog('REPAIR_ROLLBACK_SUCCESS', 'Rolled back to valid backup', { backup });
+                return { action: 'rollback', orphansFound: initial.orphans, backupUsed: backup };
+            }
+        }
+        catch (err) {
+            debugLog('REPAIR_BACKUP_ERROR', 'Failed to check backup', {
+                backup,
+                error: err.message,
+            });
+        }
+    }
+    // 2) Surgical repair fallback
+    debugLog('REPAIR_SURGICAL', 'No valid backup found - attempting surgical repair');
+    const { removed, orphansAfter } = surgicalRepair(jsonlPath);
+    if (orphansAfter === 0) {
+        return { action: 'surgical_repair', orphansFound: initial.orphans, removedLines: removed };
+    }
+    debugLog('REPAIR_FAILED', 'Surgical repair incomplete - orphans remain', {
+        orphansAfter,
+        removed,
+    });
+    return {
+        action: 'failed',
+        orphansFound: initial.orphans,
+        removedLines: removed,
+        reason: 'orphans_remain_after_surgical',
+    };
+}
+/**
+ * Quick validation check - can be called before operations to verify health.
+ */
+function isTranscriptHealthy(jsonlPath) {
+    if (!fs.existsSync(jsonlPath))
+        return true; // Non-existent is not unhealthy
+    const { orphans } = countOrphansInJsonl(jsonlPath);
+    return orphans === 0;
+}
+/**
+ * Get detailed transcript health info.
+ */
+function getTranscriptHealth(jsonlPath) {
+    if (!fs.existsSync(jsonlPath)) {
+        return { exists: false, healthy: true, orphans: 0, orphanIds: [] };
+    }
+    const { orphans, orphanIds } = countOrphansInJsonl(jsonlPath);
+    return { exists: true, healthy: orphans === 0, orphans, orphanIds };
+}

package/dist/commands/doctor.js

@@ -21,10 +21,17 @@ const fs_1 = require("fs");
 const child_process_1 = require("child_process");
 const chalk_1 = __importDefault(require("chalk"));
 const hooks_1 = require("./hooks");
+// ekkOS-managed Claude installation path (same as run.ts)
+const EKKOS_CLAUDE_BIN = (0, path_1.join)((0, os_1.homedir)(), '.ekkos', 'claude-code', 'node_modules', '.bin', 'claude');
 /**
- * Check if a command exists in PATH
+ * Check if a command exists in PATH or managed location
+ * For 'claude', prioritizes ekkOS-managed installation
  */
 function commandExists(cmd) {
+    // For claude, check managed path first
+    if (cmd === 'claude' && (0, fs_1.existsSync)(EKKOS_CLAUDE_BIN)) {
+        return true;
+    }
     try {
         const which = (0, os_1.platform)() === 'win32' ? 'where' : 'which';
         (0, child_process_1.execSync)(`${which} ${cmd}`, { stdio: 'ignore' });
@@ -36,8 +43,23 @@ function commandExists(cmd) {
 }
 /**
  * Get command version safely
+ * For 'claude', prioritizes ekkOS-managed installation
  */
 function getVersion(cmd, versionFlag = '--version') {
+    // For claude, try managed path first
+    if (cmd === 'claude' && (0, fs_1.existsSync)(EKKOS_CLAUDE_BIN)) {
+        try {
+            const output = (0, child_process_1.execSync)(`"${EKKOS_CLAUDE_BIN}" ${versionFlag}`, {
+                encoding: 'utf-8',
+                timeout: 10000,
+                stdio: ['pipe', 'pipe', 'pipe']
+            }).trim();
+            return output.split('\n')[0];
+        }
+        catch {
+            // Fall through to PATH lookup
+        }
+    }
     try {
         const output = (0, child_process_1.execSync)(`${cmd} ${versionFlag}`, {
             encoding: 'utf-8',

package/dist/commands/run.d.ts

@@ -5,6 +5,8 @@ interface RunOptions {
     doctor?: boolean;
     noInject?: boolean;
     research?: boolean;
+    noDna?: boolean;
+    noProxy?: boolean;
     slashOpenDelayMs?: number;
     charDelayMs?: number;
     postEnterDelayMs?: number;