@phuetz/code-buddy 1.6.1 → 2.1.0

package/dist/observability/run-store.js

@@ -9,13 +9,16 @@
  * Written in append mode for performance — no full-file parsing per event.
  * Automatic pruning keeps the 30 most recent runs.
  */
+import { RunEventWriter } from './run-event-writer.js';
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
 import { randomBytes } from 'crypto';
-import Database from 'better-sqlite3';
+import { isOptionalSqliteUnavailableError, loadBetterSqlite3Sync, SQLITE_INSTALL_GUIDANCE, } from '../database/optional-sqlite.js';
 import { logger } from '../utils/logger.js';
 import { executeHermesLifecycleHook } from '../hooks/hermes-lifecycle-hooks.js';
+import { readJsonAtomicSync, writeJsonAtomicSync } from '../utils/atomic-write.js';
+import { auditLogger } from '../security/audit-logger.js';
 const MAX_RUNS = 30;
 const MAX_ARTIFACT_SEARCH_BYTES = 200_000;
 const ARTIFACT_INDEX_DB = 'artifact-index.sqlite';
@@ -33,6 +36,7 @@ export class RunStore {
     runsDir;
     /** File handles for active run event streams */
     handles = new Map();
+    eventWriters = new Map();
     /** Immediate in-process view of events, avoiding read-after-write stream races. */
     eventBuffers = new Map();
     /** In-memory event counts per run */
@@ -45,6 +49,8 @@ export class RunStore {
     artifactIndexDb = null;
     /** If SQLite/FTS is unavailable, keep run search on the file-scan fallback. */
     artifactIndexUnavailable = false;
+    /** Set by dispose(): the artifact index must never be lazily reopened afterwards. */
+    disposed = false;
     constructor(runsDir) {
         this.runsDir =
             runsDir || process.env.CODEBUDDY_RUNS_DIR || path.join(os.homedir(), '.codebuddy', 'runs');
@@ -74,6 +80,7 @@ export class RunStore {
         return this._currentRunId;
     }
     dispose() {
+        this.disposed = true;
         for (const ws of this.handles.values()) {
             try {
                 ws.destroy();
@@ -124,12 +131,9 @@ export class RunStore {
         const eventsPath = path.join(runDir, 'events.jsonl');
         fs.writeFileSync(eventsPath, '', { flag: 'a' }); // ensure file exists
         const ws = fs.createWriteStream(eventsPath, { flags: 'a', encoding: 'utf-8' });
-        ws.on('error', (err) => {
-            logger.debug('RunStore: event stream error', {
-                runId,
-                err: err instanceof Error ? err.message : String(err),
-            });
-        });
+        this.eventWriters.set(runId, new RunEventWriter(ws, error => {
+            logger.warn('RunStore: journal persistence failed', { runId, error: error.message });
+        }));
         this.handles.set(runId, ws);
         // Emit run_start event
         this.emit(runId, { type: 'run_start', data: { objective, metadata } });
@@ -145,6 +149,14 @@ export class RunStore {
         });
         this.saveSummary(runId, summary);
         this.pruneOldRuns();
+        // Initialize audit logger in production where RunStore starts
+        try {
+            const auditDir = process.env.CODEBUDDY_AUDIT_DIR || path.join(os.homedir(), '.codebuddy');
+            auditLogger.init({ logDir: auditDir, sessionId: metadata?.sessionId });
+        }
+        catch {
+            // Ignore
+        }
         this._currentRunId = runId;
         setActiveRunStore(this);
         logger.debug(`RunStore: started run ${runId}`, { objective });
@@ -185,6 +197,15 @@ export class RunStore {
     /**
      * Emit an event for a run. Thread-safe: writes are serialized by the writable stream.
      */
+    getPersistenceStatus(runId) {
+        return this.eventWriters.get(runId)?.status();
+    }
+    async flushRun(runId) {
+        const writer = this.eventWriters.get(runId);
+        if (!writer)
+            throw new Error(`No active journal writer for run ${runId}`);
+        return writer.flush();
+    }
     emit(runId, event) {
         const ws = this.handles.get(runId);
         if (!ws)
@@ -198,12 +219,7 @@ export class RunStore {
         if (buffer) {
             buffer.push(fullEvent);
         }
-        try {
-            ws.write(JSON.stringify(fullEvent) + '\n');
-        }
-        catch (err) {
-            logger.debug('RunStore: failed to write event', { runId, err });
-        }
+        this.eventWriters.get(runId)?.write(JSON.stringify(fullEvent) + '\n');
         // Update in-memory count
         const count = (this.eventCounts.get(runId) || 0) + 1;
         this.eventCounts.set(runId, count);
@@ -211,13 +227,36 @@ export class RunStore {
         if (summary) {
             summary.eventCount = count;
         }
+        if (event.type === 'tool_call') {
+            const current = this.getRun(runId)?.metrics.toolCallCount ?? 0;
+            this.updateMetrics(runId, { toolCallCount: current + 1 });
+        }
     }
     /**
      * End a run and flush the event stream.
      */
-    endRun(runId, status) {
+    endRun(runId, status, finalMetrics) {
+        if (finalMetrics) {
+            this.updateMetrics(runId, finalMetrics);
+        }
         this.emit(runId, { type: 'run_end', data: { status } });
-        const summary = this.summaries.get(runId);
+        let summary = this.summaries.get(runId);
+        if (!summary) {
+            try {
+                const summaryPath = path.join(this.runDir(runId), 'summary.json');
+                summary = readJsonAtomicSync(summaryPath, null, {
+                    mode: 0o600,
+                    isValid: (value) => Boolean(value && typeof value === 'object' && !Array.isArray(value) &&
+                        typeof value.runId === 'string'),
+                }) ?? undefined;
+                if (summary) {
+                    this.summaries.set(runId, summary);
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
         if (summary) {
             summary.status = status;
             summary.endedAt = Date.now();
@@ -226,10 +265,27 @@ export class RunStore {
         // Update metrics duration
         try {
             const metricsPath = path.join(this.runDir(runId), 'metrics.json');
-            if (fs.existsSync(metricsPath)) {
-                const metrics = JSON.parse(fs.readFileSync(metricsPath, 'utf-8'));
-                metrics.durationMs = (summary?.endedAt || Date.now()) - (summary?.startedAt || Date.now());
-                fs.writeFileSync(metricsPath, JSON.stringify(metrics, null, 2));
+            const metrics = fs.existsSync(metricsPath)
+                ? readJsonAtomicSync(metricsPath, null, {
+                    mode: 0o600,
+                    isValid: (value) => Boolean(value && typeof value === 'object' && !Array.isArray(value)),
+                })
+                : null;
+            const durationMs = Math.max(1, (summary?.endedAt || Date.now()) - (summary?.startedAt || Date.now()));
+            if (metrics) {
+                metrics.durationMs = durationMs;
+                writeJsonAtomicSync(metricsPath, metrics, { mode: 0o600 });
+            }
+            else {
+                writeJsonAtomicSync(metricsPath, {
+                    totalTokens: 0,
+                    promptTokens: 0,
+                    completionTokens: 0,
+                    totalCost: 0,
+                    durationMs,
+                    toolCallCount: 0,
+                    failoverCount: 0,
+                }, { mode: 0o600 });
             }
         }
         catch {
@@ -300,11 +356,12 @@ export class RunStore {
         try {
             const metricsPath = path.join(this.runDir(runId), 'metrics.json');
             let existing = {};
-            if (fs.existsSync(metricsPath)) {
-                existing = JSON.parse(fs.readFileSync(metricsPath, 'utf-8'));
-            }
+            existing = readJsonAtomicSync(metricsPath, {}, {
+                mode: 0o600,
+                isValid: (value) => Boolean(value && typeof value === 'object' && !Array.isArray(value)),
+            });
             const merged = { ...existing, ...metrics };
-            fs.writeFileSync(metricsPath, JSON.stringify(merged, null, 2));
+            writeJsonAtomicSync(metricsPath, merged, { mode: 0o600 });
         }
         catch {
             // Ignore
@@ -324,9 +381,10 @@ export class RunStore {
         let metrics = {};
         try {
             const metricsPath = path.join(runDir, 'metrics.json');
-            if (fs.existsSync(metricsPath)) {
-                metrics = JSON.parse(fs.readFileSync(metricsPath, 'utf-8'));
-            }
+            metrics = readJsonAtomicSync(metricsPath, {}, {
+                mode: 0o600,
+                isValid: (value) => Boolean(value && typeof value === 'object' && !Array.isArray(value)),
+            });
         }
         catch {
             // Ignore
@@ -341,7 +399,8 @@ export class RunStore {
         catch {
             // Ignore
         }
-        return { summary, metrics, artifacts };
+        const persistence = this.getPersistenceStatus(runId);
+        return { summary, metrics, artifacts, ...(persistence ? { persistence } : {}) };
     }
     /**
      * List runs, most recent first.
@@ -758,15 +817,22 @@ export class RunStore {
     runDir(runId) {
         return path.join(this.runsDir, runId);
     }
+    loadDatabaseConstructor() {
+        return loadBetterSqlite3Sync();
+    }
     getArtifactIndexDb() {
-        if (this.artifactIndexUnavailable) {
+        // Post-run hooks (learning retrospective, lifecycle hooks) may still call
+        // saveArtifact() after the owner disposed the store; reopening the SQLite
+        // index here would leak the handle the dispose just released.
+        if (this.artifactIndexUnavailable || this.disposed) {
             return null;
         }
         if (this.artifactIndexDb) {
             return this.artifactIndexDb;
         }
         try {
-            const db = new Database(path.join(this.runsDir, ARTIFACT_INDEX_DB));
+            const DatabaseConstructor = this.loadDatabaseConstructor();
+            const db = new DatabaseConstructor(path.join(this.runsDir, ARTIFACT_INDEX_DB));
             db.pragma('journal_mode = WAL');
             // Check if table exists and does NOT have tokenize='trigram'
             let needsRebuild = false;
@@ -826,8 +892,9 @@ export class RunStore {
         }
         catch (err) {
             this.artifactIndexUnavailable = true;
-            logger.debug('RunStore: artifact FTS index unavailable, falling back to file scan', {
-                err: err instanceof Error ? err.message : String(err),
+            const guidance = isOptionalSqliteUnavailableError(err) ? ` ${SQLITE_INSTALL_GUIDANCE}` : '';
+            logger.warn(`RunStore: artifact FTS index unavailable, falling back to file scan.${guidance}`, {
+                error: err instanceof Error ? err.message : String(err),
             });
             return null;
         }
@@ -931,7 +998,7 @@ export class RunStore {
     saveMetrics(runId, metrics) {
         try {
             const metricsPath = path.join(this.runDir(runId), 'metrics.json');
-            fs.writeFileSync(metricsPath, JSON.stringify(metrics, null, 2));
+            writeJsonAtomicSync(metricsPath, metrics, { mode: 0o600 });
         }
         catch {
             // Ignore
@@ -940,7 +1007,7 @@ export class RunStore {
     saveSummary(runId, summary) {
         try {
             const summaryPath = path.join(this.runDir(runId), 'summary.json');
-            fs.writeFileSync(summaryPath, JSON.stringify(summary, null, 2));
+            writeJsonAtomicSync(summaryPath, summary, { mode: 0o600 });
         }
         catch {
             // Ignore
@@ -954,8 +1021,12 @@ export class RunStore {
             for (const dir of dirs) {
                 try {
                     const summaryPath = path.join(this.runsDir, dir, 'summary.json');
-                    if (fs.existsSync(summaryPath)) {
-                        const summary = JSON.parse(fs.readFileSync(summaryPath, 'utf-8'));
+                    const summary = readJsonAtomicSync(summaryPath, null, {
+                        mode: 0o600,
+                        isValid: (value) => Boolean(value && typeof value === 'object' && !Array.isArray(value) &&
+                            typeof value.runId === 'string'),
+                    });
+                    if (summary) {
                         this.summaries.set(summary.runId, summary);
                         // Count events from file size heuristic (avoid full parse on load)
                         const eventsPath = path.join(this.runsDir, dir, 'events.jsonl');
@@ -988,6 +1059,7 @@ export class RunStore {
             if (ws) {
                 ws.destroy();
                 this.handles.delete(s.runId);
+                this.eventWriters.delete(s.runId);
             }
             // Remove directory after a short delay to let the stream fully close
             setTimeout(() => {

package/dist/observability/run-trajectory-load.d.ts

@@ -0,0 +1,16 @@
+/**
+ * I/O loader for the unified Trajectory view. Read-only, never-throws.
+ * Missing journals become `sources.missing` — the presenter says « non journalisé ».
+ */
+import { RunStore } from './run-store.js';
+import { type Trajectory, type TrajectorySources } from './run-trajectory.js';
+export interface LoadTrajectoryOptions {
+    since?: number;
+    generatedAt?: string;
+    homeDir?: string;
+    store?: RunStore;
+    timelineEnabled?: boolean;
+}
+export declare function loadTrajectorySources(runId: string, options?: LoadTrajectoryOptions): TrajectorySources;
+export declare function loadTrajectory(runId: string, options?: LoadTrajectoryOptions): Trajectory;
+export declare function parseTrajectorySince(raw: string | undefined): number | undefined;

package/dist/observability/run-trajectory-load.js

@@ -0,0 +1,266 @@
+/**
+ * I/O loader for the unified Trajectory view. Read-only, never-throws.
+ * Missing journals become `sources.missing` — the presenter says « non journalisé ».
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { RunStore } from './run-store.js';
+import { buildTrajectory, } from './run-trajectory.js';
+function safeReadJsonl(filePath, pick) {
+    try {
+        if (!fs.existsSync(filePath))
+            return [];
+        const lines = fs.readFileSync(filePath, 'utf8').split('\n');
+        const out = [];
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const parsed = JSON.parse(line);
+                const value = pick(parsed);
+                if (value !== null)
+                    out.push(value);
+            }
+            catch {
+                // skip malformed
+            }
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+function listAuditFiles(homeDir) {
+    const dir = path.join(homeDir, '.codebuddy');
+    try {
+        if (!fs.existsSync(dir))
+            return [];
+        return fs.readdirSync(dir)
+            .filter((name) => /^audit-\d{4}-\d{2}-\d{2}\.jsonl$/.test(name))
+            .map((name) => path.join(dir, name));
+    }
+    catch {
+        return [];
+    }
+}
+function loadAuditEntries(homeDir) {
+    const files = listAuditFiles(homeDir);
+    const envDir = process.env.CODEBUDDY_AUDIT_DIR;
+    if (envDir) {
+        try {
+            files.push(...fs.readdirSync(envDir)
+                .filter((name) => name.endsWith('.jsonl'))
+                .map((name) => path.join(envDir, name)));
+        }
+        catch {
+            // ignore
+        }
+    }
+    const entries = [];
+    let found = files.length > 0;
+    for (const file of files) {
+        const rows = safeReadJsonl(file, (value) => {
+            if (!value || typeof value !== 'object')
+                return null;
+            const row = value;
+            if (typeof row.timestamp !== 'string' || typeof row.action !== 'string')
+                return null;
+            return {
+                timestamp: row.timestamp,
+                action: row.action,
+                decision: typeof row.decision === 'string' ? row.decision : undefined,
+                target: typeof row.target === 'string' ? row.target : undefined,
+                details: typeof row.details === 'string' ? row.details : undefined,
+                source: typeof row.source === 'string' ? row.source : undefined,
+            };
+        });
+        if (rows.length > 0)
+            found = true;
+        entries.push(...rows);
+    }
+    return { entries, found };
+}
+function loadTimeline(homeDir, sessionId, enabled) {
+    if (!enabled)
+        return { entries: null, found: false };
+    if (!sessionId)
+        return { entries: null, found: false };
+    const filePath = path.join(homeDir, '.codebuddy', 'timelines', `${encodeURIComponent(sessionId)}.jsonl`);
+    const entries = safeReadJsonl(filePath, (value) => {
+        if (!value || typeof value !== 'object')
+            return null;
+        const row = value;
+        if (typeof row.turn !== 'number' || typeof row.ts !== 'string' || !Array.isArray(row.toolCalls) || !Array.isArray(row.filesTouched)) {
+            return null;
+        }
+        return {
+            turn: row.turn,
+            ts: row.ts,
+            toolCalls: row.toolCalls.flatMap((call) => {
+                if (!call || typeof call !== 'object')
+                    return [];
+                const item = call;
+                if (typeof item.name !== 'string' || typeof item.ok !== 'boolean')
+                    return [];
+                return [{ name: item.name, ok: item.ok }];
+            }),
+            filesTouched: row.filesTouched.filter((file) => typeof file === 'string'),
+        };
+    });
+    return { entries, found: entries.length > 0 };
+}
+function loadSessionTurns(homeDir, sessionId) {
+    if (!sessionId)
+        return { turns: null, found: false };
+    const filePath = path.join(homeDir, '.codebuddy', 'sessions', `${sessionId}.json`);
+    try {
+        if (!fs.existsSync(filePath))
+            return { turns: null, found: false };
+        const raw = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        const list = Array.isArray(raw.turns) ? raw.turns : Array.isArray(raw.metadata?.turns) ? raw.metadata.turns : [];
+        const turns = [];
+        for (const item of list) {
+            if (!item || typeof item !== 'object')
+                continue;
+            const row = item;
+            if (typeof row.timestamp !== 'string')
+                continue;
+            if (typeof row.inputTokens !== 'number' || typeof row.outputTokens !== 'number')
+                continue;
+            turns.push({
+                timestamp: row.timestamp,
+                inputTokens: row.inputTokens,
+                outputTokens: row.outputTokens,
+                costUsd: typeof row.costUsd === 'number' ? row.costUsd : 0,
+            });
+        }
+        return { turns, found: turns.length > 0 };
+    }
+    catch {
+        return { turns: null, found: false };
+    }
+}
+function loadCostRecords(homeDir) {
+    const filePath = path.join(homeDir, '.codebuddy', 'cost-history.json');
+    try {
+        if (!fs.existsSync(filePath))
+            return { records: [], found: false };
+        const raw = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        if (!Array.isArray(raw))
+            return { records: [], found: false };
+        const records = [];
+        for (const item of raw) {
+            if (!item || typeof item !== 'object')
+                continue;
+            const row = item;
+            const ts = typeof row.timestamp === 'string' ? Date.parse(row.timestamp)
+                : typeof row.timestamp === 'number' ? row.timestamp
+                    : NaN;
+            if (!Number.isFinite(ts))
+                continue;
+            records.push({
+                timestamp: ts,
+                inputTokens: typeof row.inputTokens === 'number' ? row.inputTokens : 0,
+                outputTokens: typeof row.outputTokens === 'number' ? row.outputTokens : 0,
+                cost: typeof row.cost === 'number' ? row.cost : 0,
+            });
+        }
+        return { records, found: true };
+    }
+    catch {
+        return { records: [], found: false };
+    }
+}
+function loadRuleRuns(homeDir) {
+    const override = process.env.CODEBUDDY_RULE_RUNS_FILE;
+    const filePath = override || path.join(homeDir, '.codebuddy', 'companion', 'rule-runs.jsonl');
+    const runs = safeReadJsonl(filePath, (value) => {
+        if (!value || typeof value !== 'object')
+            return null;
+        const row = value;
+        if (typeof row.ts !== 'number' || typeof row.rule !== 'string')
+            return null;
+        return {
+            ts: row.ts,
+            rule: row.rule,
+            action: typeof row.action === 'string' ? row.action : 'unknown',
+            ok: row.ok === true,
+        };
+    });
+    return { runs, found: fs.existsSync(filePath) };
+}
+export function loadTrajectorySources(runId, options = {}) {
+    const homeDir = options.homeDir ?? os.homedir();
+    const store = options.store ?? RunStore.getInstance();
+    const missing = [];
+    const record = store.getRun(runId);
+    const events = record ? store.getEvents(runId) : [];
+    if (!record)
+        missing.push('run introuvable dans RunStore');
+    const sessionId = record?.summary.metadata?.sessionId;
+    const audit = loadAuditEntries(homeDir);
+    if (!audit.found)
+        missing.push('audit JSONL (auditLogger.init n\'est appelé nulle part en production)');
+    const timelineEnabled = options.timelineEnabled ?? process.env.CODEBUDDY_TIMELINE === 'true';
+    const timeline = loadTimeline(homeDir, sessionId, timelineEnabled);
+    if (!timelineEnabled)
+        missing.push('timeline désactivée (CODEBUDDY_TIMELINE ≠ true)');
+    else if (!timeline.found)
+        missing.push('timeline session absente');
+    const sessionTurns = loadSessionTurns(homeDir, sessionId);
+    if (!sessionTurns.found)
+        missing.push('session.turns (usage par tour)');
+    const cost = loadCostRecords(homeDir);
+    if (!cost.found)
+        missing.push('cost-history.json');
+    const rules = loadRuleRuns(homeDir);
+    if (!rules.found)
+        missing.push('rule-runs.jsonl');
+    const summary = record
+        ? {
+            objective: record.summary.objective,
+            status: record.summary.status,
+            startedAt: record.summary.startedAt,
+            endedAt: record.summary.endedAt,
+            sessionId,
+        }
+        : null;
+    return {
+        runId,
+        since: options.since,
+        generatedAt: options.generatedAt,
+        summary,
+        metrics: record?.metrics,
+        events,
+        artifacts: record?.artifacts,
+        auditEntries: audit.found ? audit.entries : undefined,
+        timelineEntries: timelineEnabled ? timeline.entries : null,
+        sessionTurns: sessionTurns.found ? sessionTurns.turns : null,
+        costRecords: cost.found ? cost.records : undefined,
+        ruleRuns: rules.found ? rules.runs : null,
+        missing,
+    };
+}
+export function loadTrajectory(runId, options = {}) {
+    return buildTrajectory(loadTrajectorySources(runId, options));
+}
+export function parseTrajectorySince(raw) {
+    if (raw === undefined || raw.trim() === '')
+        return undefined;
+    const trimmed = raw.trim();
+    if (/^\d+$/.test(trimmed)) {
+        const value = Number(trimmed);
+        if (!Number.isSafeInteger(value) || value < 0) {
+            throw new Error('--since must be an ISO-8601 timestamp or epoch milliseconds');
+        }
+        return value;
+    }
+    const ms = Date.parse(trimmed);
+    if (!Number.isFinite(ms)) {
+        throw new Error('--since must be an ISO-8601 timestamp or epoch milliseconds');
+    }
+    return ms;
+}
+//# sourceMappingURL=run-trajectory-load.js.map