@creativeintelligence/abbie 0.1.3 → 0.1.5

package/src/cli/commands/session/replay.ts

@@ -1,659 +0,0 @@
-import { execSync } from "node:child_process";
-import { api, getHttpClient } from "@creativeintelligence/sdk/convex";
-import { Args, Flags } from "@oclif/core";
-import { type ActiveSession, getActiveSessionManager } from "../../../lib/active-sessions.js";
-import { type AgentSession, AgentSessionMiner } from "../../../lib/agent-sessions.js";
-import { EventStore, type SessionEvent } from "../../../lib/events.js";
-import { SessionStateManager, type SessionStateRecord } from "../../../lib/session-state.js";
-import type { AgentType } from "../../../lib/types.js";
-import { AGENTS } from "../../../lib/types.js";
-import { BaseCommand } from "../../base-command.js";
-
-/**
- * Unified timeline event from any source.
- */
-interface TimelineEvent {
-  timestamp: string;
-  source: "session_state" | "events" | "reports" | "git" | "active" | "mined";
-  type: string;
-  summary: string;
-  data?: Record<string, unknown>;
-}
-
-/**
- * Replay result containing session info and unified timeline.
- */
-interface ReplayResult {
-  session: {
-    id: string;
-    agent: string;
-    project: string | null;
-    status: string;
-    started_at: string;
-    ended_at: string | null;
-    duration_ms?: number;
-  } | null;
-  timeline: TimelineEvent[];
-  sources: {
-    session_state: boolean;
-    events: number;
-    reports: number;
-    git: number;
-    active: boolean;
-    mined: boolean;
-  };
-  correlations: {
-    issue?: string;
-    branch?: string;
-    commits?: string[];
-    files?: string[];
-  };
-}
-
-export default class SessionReplay extends BaseCommand {
-  static override description =
-    "Replay session history with correlated context from multiple sources";
-  static override summary = "Replay session history";
-  static override hidden = false;
-
-  static override 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 override args = {
-    session_id: Args.string({
-      description: "Session ID to replay (or use --last)",
-      required: false,
-    }),
-  };
-
-  static override 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,
-    }),
-  };
-
-  protected async execute(): Promise<ReplayResult> {
-    const { args, flags } = await this.parse(SessionReplay);
-    this.parsedFlags = flags;
-
-    // Determine session ID
-    let sessionId: string = args.session_id || "";
-
-    if (!sessionId) {
-      if (flags.last) {
-        const found = await this.findMostRecentSession(
-          flags.project,
-          flags.agent as AgentType | undefined,
-        );
-        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: string) => 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: ReplayResult = {
-      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;
-  }
-
-  private async findMostRecentSession(project?: string, agent?: AgentType): Promise<string | null> {
-    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;
-  }
-
-  private getSessionState(sessionId: string): SessionStateRecord | null {
-    const manager = new SessionStateManager();
-    return manager.get(sessionId);
-  }
-
-  private getEvents(sessionId: string): SessionEvent[] {
-    const store = new EventStore();
-    return store.readSession(sessionId);
-  }
-
-  private parseSinceToMs(since?: string): number | undefined {
-    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: Record<string, number> = {
-      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;
-  }
-
-  private async getReportEvents(
-    sessionId: string,
-    since?: string,
-  ): Promise<Array<Record<string, unknown>>> {
-    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 as Array<Record<string, unknown>>) : [];
-    } catch {
-      return [];
-    }
-  }
-
-  private getGitCommits(
-    _sessionId: string,
-    sessionState: SessionStateRecord | null,
-  ): Array<{ hash: string; message: string; timestamp: string }> {
-    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 [];
-    }
-  }
-
-  private async getActiveSession(sessionId: string): Promise<ActiveSession | null> {
-    const manager = getActiveSessionManager();
-    return (await manager.getAsync(sessionId)) ?? null;
-  }
-
-  private getMinedSession(sessionId: string): AgentSession | null {
-    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;
-    }
-  }
-
-  private buildTimeline(
-    sessionState: SessionStateRecord | null,
-    events: SessionEvent[],
-    reportEvents: Array<Record<string, unknown>>,
-    gitCommits: Array<{ hash: string; message: string; timestamp: string }>,
-    activeSession: ActiveSession | null,
-    minedSession: AgentSession | null,
-  ): TimelineEvent[] {
-    const timeline: TimelineEvent[] = [];
-
-    // 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 as Record<string, unknown>) : 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;
-  }
-
-  private summarizeEvent(event: SessionEvent): string {
-    if ("data" in event && event.data) {
-      const data = event.data as Record<string, unknown>;
-      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;
-  }
-
-  private buildCorrelations(
-    sessionState: SessionStateRecord | null,
-    minedSession: AgentSession | null,
-    gitCommits: Array<{ hash: string; message: string; timestamp: string }>,
-  ): ReplayResult["correlations"] {
-    const correlations: ReplayResult["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;
-  }
-
-  private buildSessionSummary(
-    sessionId: string,
-    sessionState: SessionStateRecord | null,
-    activeSession: ActiveSession | null,
-    minedSession: AgentSession | null,
-  ): ReplayResult["session"] {
-    // 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,
-    };
-  }
-
-  private renderTextOutput(result: ReplayResult, verbose: boolean): void {
-    // 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 as AgentType)} ${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: string[] = [];
-    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("");
-  }
-
-  private getStatusIcon(status: string): string {
-    switch (status) {
-      case "active":
-      case "running":
-        return "🟢";
-      case "completed":
-        return "✅";
-      case "failed":
-        return "❌";
-      case "stopped":
-        return "⏹️";
-      default:
-        return "⚪";
-    }
-  }
-
-  private getAgentIcon(agent: AgentType): string {
-    switch (agent) {
-      case "claude":
-        return "🐙";
-      case "codex":
-        return "🦉";
-      case "copilot":
-        return "🐕";
-      case "gemini":
-        return "🦊";
-      default:
-        return "🤖";
-    }
-  }
-
-  private getSourceIcon(source: string): string {
-    switch (source) {
-      case "session_state":
-        return "📋";
-      case "events":
-        return "📍";
-      case "reports":
-        return "📣";
-      case "git":
-        return "📝";
-      case "active":
-        return "⚡";
-      case "mined":
-        return "⛏️";
-      default:
-        return "•";
-    }
-  }
-
-  private formatTime(timestamp: string): string {
-    const date = new Date(timestamp);
-    return date.toLocaleString();
-  }
-
-  private formatTimeShort(timestamp: string): string {
-    const date = new Date(timestamp);
-    return date.toLocaleTimeString("en-US", {
-      hour: "2-digit",
-      minute: "2-digit",
-      second: "2-digit",
-    });
-  }
-
-  private formatDuration(ms: number): string {
-    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/src/cli/commands/session/run.ts

@@ -1,44 +0,0 @@
-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 override description = "Run an agent session as supervisor (internal)";
-  static override hidden = true; // Internal command, not shown in help
-
-  static override args = {
-    sessionId: Args.string({
-      description: "Session ID to run",
-      required: true,
-    }),
-  };
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-  };
-
-  protected async execute(): Promise<unknown> {
-    // 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 };
-  }
-}