@creativeintelligence/abbie 0.1.0

package/dist/cli/commands/session/replay.js

@@ -0,0 +1,524 @@
+import { execSync } from "node:child_process";
+import { api, getHttpClient } from "@abbie/sdk/convex";
+import { Args, Flags } from "@oclif/core";
+import { getActiveSessionManager } from "../../../lib/active-sessions.js";
+import { AgentSessionMiner } from "../../../lib/agent-sessions.js";
+import { EventStore } from "../../../lib/events.js";
+import { SessionStateManager } from "../../../lib/session-state.js";
+import { AGENTS } from "../../../lib/types.js";
+import { BaseCommand } from "../../base-command.js";
+export default class SessionReplay extends BaseCommand {
+    static description = "Replay session history with correlated context from multiple sources";
+    static summary = "Replay session history";
+    static hidden = false;
+    static examples = [
+        "<%= config.bin %> session replay hostagent-20251222-123456-abc1",
+        "<%= config.bin %> session replay hostagent-20251222-123456-abc1 --verbose",
+        "<%= config.bin %> session replay --last                  # replay most recent",
+        "<%= config.bin %> session replay --project arbor --last  # most recent for project",
+        "<%= config.bin %> session replay abc123 --sources reports,git",
+        "<%= config.bin %> session replay abc123 --since 1h       # events from last hour",
+        "<%= config.bin %> session replay abc123 --json",
+    ];
+    static args = {
+        session_id: Args.string({
+            description: "Session ID to replay (or use --last)",
+            required: false,
+        }),
+    };
+    static flags = {
+        ...BaseCommand.baseFlags,
+        last: Flags.boolean({
+            char: "l",
+            description: "Replay most recent session",
+            default: false,
+        }),
+        project: Flags.string({
+            char: "p",
+            description: "Filter by project (with --last)",
+        }),
+        agent: Flags.string({
+            char: "a",
+            description: "Filter by agent (with --last)",
+            options: [...AGENTS],
+        }),
+        sources: Flags.string({
+            char: "s",
+            description: "Comma-separated sources to include (session_state,events,reports,git,active,mined)",
+            default: "session_state,events,reports,git",
+        }),
+        since: Flags.string({
+            description: "Time filter for events (e.g., 1h, 30m, 2d)",
+        }),
+        verbose: Flags.boolean({
+            char: "v",
+            description: "Show full event details",
+            default: false,
+        }),
+        limit: Flags.integer({
+            char: "n",
+            description: "Maximum events to show",
+            default: 50,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(SessionReplay);
+        this.parsedFlags = flags;
+        // Determine session ID
+        let sessionId = args.session_id || "";
+        if (!sessionId) {
+            if (flags.last) {
+                const found = await this.findMostRecentSession(flags.project, flags.agent);
+                if (!found) {
+                    return this.error("No sessions found", { exit: 1 });
+                }
+                sessionId = found;
+            }
+            else {
+                return this.error("Session ID required (or use --last)", { exit: 2 });
+            }
+        }
+        // Parse enabled sources
+        const enabledSources = new Set(flags.sources.split(",").map((s) => s.trim()));
+        // Collect data from all sources
+        const sessionState = enabledSources.has("session_state")
+            ? this.getSessionState(sessionId)
+            : null;
+        const events = enabledSources.has("events") ? this.getEvents(sessionId) : [];
+        const reportEvents = enabledSources.has("reports")
+            ? await this.getReportEvents(sessionId, flags.since)
+            : [];
+        const gitCommits = enabledSources.has("git") ? this.getGitCommits(sessionId, sessionState) : [];
+        const activeSession = enabledSources.has("active")
+            ? await this.getActiveSession(sessionId)
+            : null;
+        const minedSession = enabledSources.has("mined") ? this.getMinedSession(sessionId) : null;
+        // Build unified timeline
+        const timeline = this.buildTimeline(sessionState, events, reportEvents, gitCommits, activeSession, minedSession);
+        // Sort by timestamp
+        timeline.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+        // Apply limit
+        const limitedTimeline = timeline.slice(0, flags.limit);
+        // Build correlations
+        const correlations = this.buildCorrelations(sessionState, minedSession, gitCommits);
+        // Build session summary
+        const sessionSummary = this.buildSessionSummary(sessionId, sessionState, activeSession, minedSession);
+        const result = {
+            session: sessionSummary,
+            timeline: limitedTimeline,
+            sources: {
+                session_state: sessionState !== null,
+                events: events.length,
+                reports: reportEvents.length,
+                git: gitCommits.length,
+                active: activeSession !== null,
+                mined: minedSession !== null,
+            },
+            correlations,
+        };
+        if (!this.jsonEnabled?.()) {
+            this.renderTextOutput(result, flags.verbose);
+        }
+        return result;
+    }
+    async findMostRecentSession(project, agent) {
+        const stateManager = new SessionStateManager();
+        const sessions = stateManager.list({
+            project,
+            agent,
+            limit: 1,
+        });
+        if (sessions.length > 0) {
+            return sessions[0].session_id;
+        }
+        // Fall back to active sessions
+        const activeManager = getActiveSessionManager();
+        const active = await activeManager.listAsync({ project });
+        if (active.length > 0) {
+            return active[0].session_id;
+        }
+        return null;
+    }
+    getSessionState(sessionId) {
+        const manager = new SessionStateManager();
+        return manager.get(sessionId);
+    }
+    getEvents(sessionId) {
+        const store = new EventStore();
+        return store.readSession(sessionId);
+    }
+    parseSinceToMs(since) {
+        if (!since)
+            return undefined;
+        const match = since.match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d|w)$/);
+        if (!match)
+            return undefined;
+        const value = Number.parseFloat(match[1]);
+        const unit = match[2];
+        const multipliers = {
+            ms: 1,
+            s: 1_000,
+            m: 60_000,
+            h: 3_600_000,
+            d: 86_400_000,
+            w: 604_800_000,
+        };
+        const multiplier = multipliers[unit];
+        if (!multiplier)
+            return undefined;
+        return Date.now() - value * multiplier;
+    }
+    async getReportEvents(sessionId, since) {
+        try {
+            const client = getHttpClient();
+            const sinceMs = this.parseSinceToMs(since);
+            const reports = await client.query(api.reports.sieve, {
+                sessionId,
+                since: sinceMs,
+                limit: 50,
+            });
+            return Array.isArray(reports) ? reports : [];
+        }
+        catch {
+            return [];
+        }
+    }
+    getGitCommits(_sessionId, sessionState) {
+        if (!sessionState?.cwd)
+            return [];
+        try {
+            // Get commits since session started
+            const since = sessionState.started_at;
+            const until = sessionState.ended_at || new Date().toISOString();
+            const output = execSync(`git log --pretty=format:"%H|%s|%aI" --since="${since}" --until="${until}"`, {
+                encoding: "utf-8",
+                cwd: sessionState.cwd,
+                stdio: ["pipe", "pipe", "pipe"],
+                timeout: 5000,
+            }).trim();
+            if (!output)
+                return [];
+            return output.split("\n").map((line) => {
+                const [hash, message, timestamp] = line.split("|");
+                return { hash, message, timestamp };
+            });
+        }
+        catch {
+            return [];
+        }
+    }
+    async getActiveSession(sessionId) {
+        const manager = getActiveSessionManager();
+        return (await manager.getAsync(sessionId)) ?? null;
+    }
+    getMinedSession(sessionId) {
+        try {
+            const miner = new AgentSessionMiner();
+            const sessions = miner.mineAll({ since: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000) });
+            return (sessions.find((s) => s.id === sessionId || s.id.includes(sessionId.slice(0, 8))) || null);
+        }
+        catch {
+            return null;
+        }
+    }
+    buildTimeline(sessionState, events, reportEvents, gitCommits, activeSession, minedSession) {
+        const timeline = [];
+        // Session state events
+        if (sessionState) {
+            timeline.push({
+                timestamp: sessionState.started_at,
+                source: "session_state",
+                type: "session:start",
+                summary: `Session started (${sessionState.agent}, ${sessionState.project || "unknown project"})`,
+                data: { status: sessionState.status, cwd: sessionState.cwd },
+            });
+            if (sessionState.ended_at) {
+                timeline.push({
+                    timestamp: sessionState.ended_at,
+                    source: "session_state",
+                    type: "session:end",
+                    summary: `Session ended (${sessionState.status})`,
+                    data: { status: sessionState.status },
+                });
+            }
+        }
+        // EventStore events
+        for (const event of events) {
+            timeline.push({
+                timestamp: event.timestamp,
+                source: "events",
+                type: event.type,
+                summary: this.summarizeEvent(event),
+                data: "data" in event ? event.data : undefined,
+            });
+        }
+        // Report events
+        for (const event of reportEvents) {
+            const timestamp = String(event.timestamp || event.recorded_at || new Date().toISOString());
+            timeline.push({
+                timestamp,
+                source: "reports",
+                type: String(event.action || "unknown"),
+                summary: String(event.task || event.summary || "report event"),
+                data: event,
+            });
+        }
+        // Git commits
+        for (const commit of gitCommits) {
+            timeline.push({
+                timestamp: commit.timestamp,
+                source: "git",
+                type: "commit",
+                summary: `[${commit.hash.slice(0, 7)}] ${commit.message}`,
+                data: { hash: commit.hash, message: commit.message },
+            });
+        }
+        // Active session info
+        if (activeSession) {
+            timeline.push({
+                timestamp: activeSession.started_at,
+                source: "active",
+                type: "agent:spawn",
+                summary: `Agent spawned: ${activeSession.agent} (PID ${activeSession.pid})`,
+                data: { pid: activeSession.pid, goal: activeSession.goal },
+            });
+        }
+        // Mined session info
+        if (minedSession) {
+            if (minedSession.summary) {
+                timeline.push({
+                    timestamp: minedSession.last_activity,
+                    source: "mined",
+                    type: "session:summary",
+                    summary: minedSession.summary,
+                    data: {
+                        files_modified: minedSession.files_modified,
+                        commits: minedSession.commits,
+                    },
+                });
+            }
+        }
+        return timeline;
+    }
+    summarizeEvent(event) {
+        if ("data" in event && event.data) {
+            const data = event.data;
+            if (data.summary)
+                return String(data.summary);
+            if (data.description)
+                return String(data.description);
+            if (data.reason)
+                return String(data.reason);
+            if (data.task_id)
+                return `Task: ${data.task_id}`;
+            if (data.resource)
+                return `Resource: ${data.resource}`;
+        }
+        return event.type;
+    }
+    buildCorrelations(sessionState, minedSession, gitCommits) {
+        const correlations = {};
+        // Issue from session state metadata
+        if (sessionState?.metadata?.issue) {
+            correlations.issue = String(sessionState.metadata.issue);
+        }
+        // Branch from metadata
+        if (sessionState?.metadata?.git_branch) {
+            correlations.branch = String(sessionState.metadata.git_branch);
+        }
+        // Commits
+        if (gitCommits.length > 0) {
+            correlations.commits = gitCommits.map((c) => c.hash.slice(0, 7));
+        }
+        // Files from mined session
+        if (minedSession?.files_modified && minedSession.files_modified.length > 0) {
+            correlations.files = minedSession.files_modified;
+        }
+        return correlations;
+    }
+    buildSessionSummary(sessionId, sessionState, activeSession, minedSession) {
+        // Prefer session state, then active, then mined
+        if (sessionState) {
+            const duration_ms = sessionState.ended_at && sessionState.started_at
+                ? new Date(sessionState.ended_at).getTime() - new Date(sessionState.started_at).getTime()
+                : undefined;
+            return {
+                id: sessionState.session_id,
+                agent: sessionState.agent,
+                project: sessionState.project,
+                status: sessionState.status,
+                started_at: sessionState.started_at,
+                ended_at: sessionState.ended_at,
+                duration_ms,
+            };
+        }
+        if (activeSession) {
+            return {
+                id: activeSession.session_id,
+                agent: activeSession.agent,
+                project: activeSession.project,
+                status: activeSession.status,
+                started_at: activeSession.started_at,
+                ended_at: null,
+            };
+        }
+        if (minedSession) {
+            return {
+                id: minedSession.id,
+                agent: minedSession.agent,
+                project: minedSession.project || null,
+                status: "completed",
+                started_at: minedSession.last_activity,
+                ended_at: minedSession.last_activity,
+            };
+        }
+        return {
+            id: sessionId,
+            agent: "unknown",
+            project: null,
+            status: "unknown",
+            started_at: new Date().toISOString(),
+            ended_at: null,
+        };
+    }
+    renderTextOutput(result, verbose) {
+        // Session header
+        if (result.session) {
+            const s = result.session;
+            const statusIcon = this.getStatusIcon(s.status);
+            const duration = s.duration_ms ? this.formatDuration(s.duration_ms) : "";
+            this.log(`\n${statusIcon} Session: ${s.id}`);
+            this.log(`   Agent:   ${this.getAgentIcon(s.agent)} ${s.agent}`);
+            this.log(`   Project: ${s.project || "(none)"}`);
+            this.log(`   Status:  ${s.status}${duration ? ` (${duration})` : ""}`);
+            this.log(`   Started: ${this.formatTime(s.started_at)}`);
+            if (s.ended_at) {
+                this.log(`   Ended:   ${this.formatTime(s.ended_at)}`);
+            }
+        }
+        // Correlations
+        const { correlations } = result;
+        if (Object.keys(correlations).length > 0) {
+            this.log("\n📎 Correlations:");
+            if (correlations.issue)
+                this.log(`   Issue:   ${correlations.issue}`);
+            if (correlations.branch)
+                this.log(`   Branch:  ${correlations.branch}`);
+            if (correlations.commits?.length)
+                this.log(`   Commits: ${correlations.commits.join(", ")}`);
+            if (correlations.files?.length) {
+                const shown = correlations.files.slice(0, 5);
+                const more = correlations.files.length > 5 ? ` +${correlations.files.length - 5}` : "";
+                this.log(`   Files:   ${shown.join(", ")}${more}`);
+            }
+        }
+        // Timeline
+        if (result.timeline.length > 0) {
+            this.log("\n📜 Timeline:\n");
+            for (const event of result.timeline) {
+                const time = this.formatTimeShort(event.timestamp);
+                const sourceIcon = this.getSourceIcon(event.source);
+                if (verbose && event.data) {
+                    this.log(`${time} ${sourceIcon} ${event.type}`);
+                    this.log(`         ${event.summary}`);
+                    this.log(`         ${JSON.stringify(event.data)}`);
+                }
+                else {
+                    this.log(`${time} ${sourceIcon} ${event.summary}`);
+                }
+            }
+        }
+        else {
+            this.log("\n   (no events found)");
+        }
+        // Sources summary
+        this.log("\n📊 Sources:");
+        const { sources } = result;
+        const parts = [];
+        if (sources.session_state)
+            parts.push("session_state");
+        if (sources.events > 0)
+            parts.push(`events(${sources.events})`);
+        if (sources.reports > 0)
+            parts.push(`reports(${sources.reports})`);
+        if (sources.git > 0)
+            parts.push(`git(${sources.git})`);
+        if (sources.active)
+            parts.push("active");
+        if (sources.mined)
+            parts.push("mined");
+        this.log(`   ${parts.join(" | ")}`);
+        this.log("");
+    }
+    getStatusIcon(status) {
+        switch (status) {
+            case "active":
+            case "running":
+                return "🟢";
+            case "completed":
+                return "✅";
+            case "failed":
+                return "❌";
+            case "stopped":
+                return "⏹️";
+            default:
+                return "⚪";
+        }
+    }
+    getAgentIcon(agent) {
+        switch (agent) {
+            case "claude":
+                return "🐙";
+            case "codex":
+                return "🦉";
+            case "copilot":
+                return "🐕";
+            case "gemini":
+                return "🦊";
+            default:
+                return "🤖";
+        }
+    }
+    getSourceIcon(source) {
+        switch (source) {
+            case "session_state":
+                return "📋";
+            case "events":
+                return "📍";
+            case "reports":
+                return "📣";
+            case "git":
+                return "📝";
+            case "active":
+                return "⚡";
+            case "mined":
+                return "⛏️";
+            default:
+                return "•";
+        }
+    }
+    formatTime(timestamp) {
+        const date = new Date(timestamp);
+        return date.toLocaleString();
+    }
+    formatTimeShort(timestamp) {
+        const date = new Date(timestamp);
+        return date.toLocaleTimeString("en-US", {
+            hour: "2-digit",
+            minute: "2-digit",
+            second: "2-digit",
+        });
+    }
+    formatDuration(ms) {
+        const seconds = Math.floor(ms / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        if (hours > 0) {
+            return `${hours}h ${minutes % 60}m`;
+        }
+        if (minutes > 0) {
+            return `${minutes}m ${seconds % 60}s`;
+        }
+        return `${seconds}s`;
+    }
+}

package/dist/cli/commands/session/run.d.ts

@@ -0,0 +1,29 @@
+import { BaseCommand } from "../../base-command.js";
+/**
+ * Internal command for running an agent session as a supervisor.
+ *
+ * This command is NOT intended to be called directly by users.
+ * It's spawned by `abbie session start` to act as the runner/supervisor
+ * for an agent child process.
+ *
+ * The runner:
+ * - Owns the agent child process
+ * - Captures stdout/stderr to log files
+ * - Updates session status on exit
+ * - Writes result.json atomically
+ */
+export default class SessionRun extends BaseCommand {
+    static description: string;
+    static hidden: boolean;
+    static args: {
+        sessionId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        format: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "json-errors": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        ndjson: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    protected execute(): Promise<unknown>;
+}
+//# sourceMappingURL=run.d.ts.map

package/dist/cli/commands/session/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/session/run.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,OAAO,OAAO,UAAW,SAAQ,WAAW;IACjD,OAAgB,WAAW,SAAmD;IAC9E,OAAgB,MAAM,UAAQ;IAE9B,OAAgB,IAAI;;MAKlB;IAEF,OAAgB,KAAK;;;;;MAEnB;cAEc,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;CAW5C"}

package/dist/cli/commands/session/run.js

@@ -0,0 +1,38 @@
+import { Args } from "@oclif/core";
+import { runnerMain } from "../../../lib/runner.js";
+import { BaseCommand } from "../../base-command.js";
+/**
+ * Internal command for running an agent session as a supervisor.
+ *
+ * This command is NOT intended to be called directly by users.
+ * It's spawned by `abbie session start` to act as the runner/supervisor
+ * for an agent child process.
+ *
+ * The runner:
+ * - Owns the agent child process
+ * - Captures stdout/stderr to log files
+ * - Updates session status on exit
+ * - Writes result.json atomically
+ */
+export default class SessionRun extends BaseCommand {
+    static description = "Run an agent session as supervisor (internal)";
+    static hidden = true; // Internal command, not shown in help
+    static args = {
+        sessionId: Args.string({
+            description: "Session ID to run",
+            required: true,
+        }),
+    };
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    async execute() {
+        // The runner reads all config from environment variables
+        // This is set by ActiveSessionManager.start() before spawning
+        const exitCode = await runnerMain();
+        // Set process.exitCode rather than calling process.exit() directly
+        // This allows all streams to flush before the process exits
+        process.exitCode = exitCode;
+        return { status: "exited", exitCode };
+    }
+}

package/dist/cli/commands/session/show.d.ts

@@ -0,0 +1,23 @@
+import { BaseCommand } from "../../base-command.js";
+export default class SessionShow extends BaseCommand {
+    static description: string;
+    static hidden: boolean;
+    static examples: string[];
+    static args: {
+        session_id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        events: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        format: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "json-errors": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        ndjson: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    protected execute(): Promise<unknown>;
+    private formatStatus;
+    private formatTime;
+    private formatEvent;
+    private getEventIcon;
+}
+//# sourceMappingURL=show.d.ts.map

package/dist/cli/commands/session/show.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"show.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/session/show.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,WAAW;IAClD,OAAgB,WAAW,SAAyC;IACpE,OAAgB,MAAM,UAAS;IAE/B,OAAgB,QAAQ,WAItB;IAEF,OAAgB,IAAI;;MAKlB;IAEF,OAAgB,KAAK;;;;;;;MAYnB;cAEc,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;IAgE3C,OAAO,CAAC,YAAY;IAepB,OAAO,CAAC,UAAU;IAsBlB,OAAO,CAAC,WAAW;IAqBnB,OAAO,CAAC,YAAY;CAkBrB"}