@creativeintelligence/abbie 0.1.0

package/src/cli/commands/session/mark-done.ts

@@ -0,0 +1,132 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { getHttpClient, api } from "@abbie/sdk/convex";
+import { Args } from "@oclif/core";
+import { getActiveSessionManager } from "../../../lib/active-sessions.js";
+import { createEvent, EventStore } from "../../../lib/events.js";
+import { SessionArtifactStore } from "../../../lib/session-artifacts.js";
+import { BaseCommand } from "../../base-command.js";
+
+export default class SessionMarkDone extends BaseCommand {
+  static override description = "Mark a terminal-spawned session as done (called by tmux wrapper)";
+  static override hidden = true;
+
+  static override args = {
+    sessionId: Args.string({ description: "Session ID", required: true }),
+    exitCode: Args.integer({ description: "Exit code from agent process", required: true }),
+  };
+
+  static override flags = {
+    ...BaseCommand.baseFlags,
+  };
+
+  protected async execute(): Promise<unknown> {
+    const { args } = await this.parse(SessionMarkDone);
+    const manager = getActiveSessionManager();
+    const session = manager.get(args.sessionId);
+
+    if (!session) {
+      this.error(`Session not found: ${args.sessionId}`);
+    }
+
+    const status = args.exitCode === 0 ? "completed" : "failed";
+
+    // Try to extract error reason from stderr log (captured via tee in terminal mode)
+    let errorReason: string | undefined;
+    if (status === "failed" && session.output_path) {
+      const stderrPath = session.output_path.replace(/\.json$/, "-stderr.log");
+      if (existsSync(stderrPath)) {
+        try {
+          const stderr = readFileSync(stderrPath, "utf-8").trim();
+          // Extract the last meaningful error line (skip empty lines and noise)
+          const lines = stderr.split("\n").filter((l) => l.trim().length > 0);
+          const errorLine = lines
+            .reverse()
+            .find(
+              (l) =>
+                l.includes("error") ||
+                l.includes("Error") ||
+                l.includes("failed") ||
+                l.includes("limit") ||
+                l.includes("429"),
+            );
+          errorReason =
+            errorLine?.trim().slice(0, 500) || lines.slice(-3).join(" | ").slice(0, 500);
+        } catch {
+          // Best-effort
+        }
+      }
+    }
+
+    const updatedSession = {
+      ...session,
+      status: status as "completed" | "failed",
+      exit_code: args.exitCode,
+      ...(errorReason ? { error_reason: errorReason } : {}),
+    };
+
+    const sessionPath = join(homedir(), ".abbie", "active-sessions", `${args.sessionId}.json`);
+    writeFileSync(sessionPath, JSON.stringify(updatedSession, null, 2));
+
+    try {
+      const artifacts = new SessionArtifactStore();
+      artifacts.markComplete(args.sessionId, {
+        status: status as "completed" | "failed",
+        exitCode: args.exitCode,
+        outputPath: session.output_path,
+      });
+    } catch {
+      // Best-effort: active session files remain source of truth.
+    }
+
+    // Log event
+    const eventStore = new EventStore();
+    if (status === "completed") {
+      eventStore.append(
+        createEvent.complete(args.sessionId, session.agent, {
+          summary: "Terminal session completed",
+          artifacts: [],
+          duration_ms: Date.now() - new Date(session.started_at).getTime(),
+        }),
+      );
+    } else {
+      eventStore.append({
+        type: "session:failed",
+        session_id: args.sessionId,
+        agent: session.agent,
+        data: {
+          reason: errorReason || `Exit code ${args.exitCode}`,
+          exit_code: args.exitCode,
+        },
+      });
+    }
+
+    // Update the store so session list shows correct status
+    try {
+      const client = getHttpClient();
+      await client.mutation(api.sessions.update, {
+        sessionId: args.sessionId,
+        status,
+        endedAt: Date.now(),
+      });
+    } catch {
+      // Store update is best-effort — local JSON is the source of truth
+    }
+
+    // Clean up the tmux pane so zombie windows don't linger
+    if (session.pane_id) {
+      spawnSync("tmux", ["kill-pane", "-t", session.pane_id], {
+        stdio: ["ignore", "ignore", "ignore"],
+      });
+    }
+
+    const isJson = this.parsedFlags?.json || this.parsedFlags?.format === "json";
+    if (!isJson) {
+      this.log(`Session ${args.sessionId} marked as ${status} (exit code: ${args.exitCode})`);
+    }
+
+    return { session_id: args.sessionId, status, exit_code: args.exitCode };
+  }
+}

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

@@ -0,0 +1,189 @@
+import { Flags } from "@oclif/core";
+import type { AgentType } from "../../../lib/active-sessions.js";
+import { type AgentSession, AgentSessionMiner } from "../../../lib/agent-sessions.js";
+import { AGENTS } from "../../../lib/types.js";
+import { BaseCommand } from "../../base-command.js";
+
+export default class SessionMine extends BaseCommand {
+  static override description = "Mine sessions from all agents (Claude, Codex, Copilot)";
+  static override hidden = false;
+
+  static override examples = [
+    "<%= config.bin %> session mine",
+    "<%= config.bin %> session mine --project hostagent",
+    "<%= config.bin %> session mine --agent claude",
+    "<%= config.bin %> session mine --since 24h",
+    "<%= config.bin %> session mine --issue ZO-123",
+    "<%= config.bin %> session mine --json",
+  ];
+
+  static override flags = {
+    ...BaseCommand.baseFlags,
+    project: Flags.string({
+      char: "p",
+      description: "Filter by project",
+    }),
+    agent: Flags.string({
+      char: "a",
+      description: "Filter by agent type",
+      options: [...AGENTS],
+    }),
+    since: Flags.string({
+      char: "s",
+      description: "Filter by time (e.g., 24h, 7d, 2024-01-01)",
+      default: "24h",
+    }),
+    issue: Flags.string({
+      char: "i",
+      description: "Filter by issue reference",
+    }),
+    limit: Flags.integer({
+      char: "l",
+      description: "Limit number of results",
+      default: 20,
+    }),
+  };
+
+  protected async execute(): Promise<unknown> {
+    const { flags } = await this.parse(SessionMine);
+    this.parsedFlags = flags;
+
+    const miner = new AgentSessionMiner();
+    const since = this.parseSince(flags.since);
+
+    let sessions: AgentSession[];
+
+    if (flags.issue) {
+      sessions = miner.getSessionsByIssue(flags.issue);
+    } else {
+      sessions = miner.mineAll({
+        since,
+        project: flags.project,
+      });
+    }
+
+    // Filter by agent if specified
+    if (flags.agent) {
+      sessions = sessions.filter((s) => s.agent === flags.agent);
+    }
+
+    // Limit results
+    sessions = sessions.slice(0, flags.limit);
+
+    if (flags.json || flags.format === "json") {
+      return sessions;
+    }
+
+    if (sessions.length === 0) {
+      this.logInfo("No sessions found");
+      this.logInfo("\nTip: Try expanding the time range with --since 7d");
+      return [];
+    }
+
+    this.logInfo(`Found ${sessions.length} session(s):\n`);
+
+    for (const session of sessions) {
+      const agentIcon = this.getAgentIcon(session.agent);
+      const age = this.getAge(session.last_activity);
+
+      this.log(`${agentIcon} ${session.id}`);
+      this.log(`   Agent: ${session.agent}`);
+      if (session.project) {
+        this.log(`   Project: ${session.project}`);
+      }
+      if (session.issue) {
+        this.log(`   Issue: ${session.issue}`);
+      }
+      if (session.summary) {
+        this.log(
+          `   Summary: ${session.summary.slice(0, 80)}${session.summary.length > 80 ? "..." : ""}`,
+        );
+      }
+      if (session.files_modified && session.files_modified.length > 0) {
+        this.log(
+          `   Files: ${session.files_modified.slice(0, 3).join(", ")}${session.files_modified.length > 3 ? ` +${session.files_modified.length - 3}` : ""}`,
+        );
+      }
+      if (session.commits && session.commits.length > 0) {
+        this.log(
+          `   Commits: ${session.commits.slice(0, 3).join(", ")}${session.commits.length > 3 ? ` +${session.commits.length - 3}` : ""}`,
+        );
+      }
+      this.log(`   Last activity: ${age}`);
+      this.log("");
+    }
+
+    return sessions;
+  }
+
+  private parseSince(since: string): Date | undefined {
+    if (!since) return undefined;
+
+    // Parse relative time
+    const match = since.match(/^(\d+)([hdwm])$/);
+    if (match) {
+      const value = parseInt(match[1], 10);
+      const unit = match[2];
+      const date = new Date();
+
+      switch (unit) {
+        case "h":
+          date.setHours(date.getHours() - value);
+          break;
+        case "d":
+          date.setDate(date.getDate() - value);
+          break;
+        case "w":
+          date.setDate(date.getDate() - value * 7);
+          break;
+        case "m":
+          date.setMonth(date.getMonth() - value);
+          break;
+      }
+
+      return date;
+    }
+
+    // Parse absolute date
+    const parsed = new Date(since);
+    if (!Number.isNaN(parsed.getTime())) {
+      return parsed;
+    }
+
+    return undefined;
+  }
+
+  private getAgentIcon(agent: AgentType): string {
+    switch (agent) {
+      case "claude":
+        return "🐙";
+      case "codex":
+        return "🦉";
+      case "copilot":
+        return "🐕";
+      case "gemini":
+        return "🦊";
+      default:
+        return "🤖";
+    }
+  }
+
+  private getAge(timestamp: string): string {
+    const ms = Date.now() - new Date(timestamp).getTime();
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+
+    if (days > 0) {
+      return `${days}d ${hours % 24}h ago`;
+    }
+    if (hours > 0) {
+      return `${hours}h ${minutes % 60}m ago`;
+    }
+    if (minutes > 0) {
+      return `${minutes}m ago`;
+    }
+    return `${seconds}s ago`;
+  }
+}