@creativeintelligence/abbie 0.1.4 → 0.1.5

package/src/cli/commands/session/state/get.ts

@@ -1,65 +0,0 @@
-import { Flags } from "@oclif/core";
-import { SessionStateManager } from "../../../../lib/session-state.js";
-import { BaseCommand } from "../../../base-command.js";
-
-export default class SessionStateGet extends BaseCommand {
-  static override description = "Get a session state record (or a specific metadata key)";
-  static override hidden = false;
-
-  static override examples = [
-    "<%= config.bin %> session state get --session test-123 --json",
-    "<%= config.bin %> session state get --session test-123 --key trace_id --json",
-  ];
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    session: Flags.string({
-      description: "Session ID",
-      required: true,
-    }),
-    key: Flags.string({
-      description: "Metadata key to fetch (returns the full record if omitted)",
-    }),
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { flags } = await this.parse(SessionStateGet);
-    this.parsedFlags = flags;
-
-    const manager = new SessionStateManager();
-    const record = manager.get(flags.session);
-
-    if (flags.key) {
-      const value = record?.metadata?.[flags.key] ?? null;
-
-      if (flags.json || flags.format === "json") {
-        return value;
-      }
-
-      if (value === null) {
-        this.logInfo("null");
-        return null;
-      }
-
-      if (typeof value === "string") {
-        this.log(value);
-        return value;
-      }
-
-      this.log(JSON.stringify(value, null, 2));
-      return value;
-    }
-
-    if (flags.json || flags.format === "json") {
-      return record;
-    }
-
-    if (!record) {
-      this.logInfo(`Session not found: ${flags.session}`);
-      return null;
-    }
-
-    this.log(JSON.stringify(record, null, 2));
-    return record;
-  }
-}

package/src/cli/commands/session/state/init.ts

@@ -1,50 +0,0 @@
-import { Flags } from "@oclif/core";
-import { type SessionAgentType, SessionStateManager } from "../../../../lib/session-state.js";
-import { AGENTS } from "../../../../lib/types.js";
-import { BaseCommand } from "../../../base-command.js";
-
-export default class SessionStateInit extends BaseCommand {
-  static override description = "Initialize a session state record in SQLite";
-  static override hidden = false;
-
-  static override examples = [
-    "<%= config.bin %> session state init --session test-123 --project arbor --agent claude --json",
-  ];
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    session: Flags.string({
-      description: "Session ID",
-      required: true,
-    }),
-    project: Flags.string({
-      description: "Project name",
-      required: true,
-    }),
-    agent: Flags.string({
-      description: "Agent type",
-      required: true,
-      options: [...AGENTS],
-    }),
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { flags } = await this.parse(SessionStateInit);
-    this.parsedFlags = flags;
-
-    const manager = new SessionStateManager();
-    const record = manager.init({
-      sessionId: flags.session,
-      project: flags.project,
-      agent: flags.agent as SessionAgentType,
-      cwd: process.cwd(),
-    });
-
-    if (flags.json || flags.format === "json") {
-      return record;
-    }
-
-    this.logInfo(`Initialized session state: ${record.session_id}`);
-    return record;
-  }
-}

package/src/cli/commands/session/state/list.ts

@@ -1,68 +0,0 @@
-import { Flags } from "@oclif/core";
-import {
-  type SessionAgentType,
-  SessionStateManager,
-  type SessionStateStatus,
-} from "../../../../lib/session-state.js";
-import { AGENTS } from "../../../../lib/types.js";
-import { BaseCommand } from "../../../base-command.js";
-
-export default class SessionStateList extends BaseCommand {
-  static override description = "List session state records";
-  static override hidden = false;
-
-  static override examples = [
-    "<%= config.bin %> session state list --json",
-    "<%= config.bin %> session state list --status active --project arbor --json",
-  ];
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    status: Flags.string({
-      description: "Filter by status",
-      options: ["active", "completed", "failed", "stopped"],
-      default: "active",
-    }),
-    project: Flags.string({
-      description: "Filter by project name",
-    }),
-    agent: Flags.string({
-      description: "Filter by agent type",
-      options: [...AGENTS],
-    }),
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { flags } = await this.parse(SessionStateList);
-    this.parsedFlags = flags;
-
-    const manager = new SessionStateManager();
-    const sessions = manager.list({
-      status: flags.status as SessionStateStatus,
-      project: flags.project,
-      agent: flags.agent as SessionAgentType | undefined,
-    });
-
-    if (flags.json || flags.format === "json") {
-      return sessions;
-    }
-
-    if (this.ndjsonEnabled()) {
-      this.outputNdjson(sessions);
-      return sessions;
-    }
-
-    if (sessions.length === 0) {
-      this.logInfo("No sessions found");
-      return [];
-    }
-
-    for (const s of sessions) {
-      this.log(
-        `${s.session_id}\t${s.status}\t${s.agent}\t${s.project ?? ""}\t${s.pid ?? ""}\t${s.started_at}`,
-      );
-    }
-
-    return sessions;
-  }
-}

package/src/cli/commands/session/state/update.ts

@@ -1,108 +0,0 @@
-import { Flags } from "@oclif/core";
-import { SessionStateManager } from "../../../../lib/session-state.js";
-import { BaseCommand } from "../../../base-command.js";
-
-function parseJsonOrString(value: string): unknown {
-  const trimmed = value.trim();
-  if (trimmed.length === 0) return "";
-  try {
-    return JSON.parse(trimmed) as unknown;
-  } catch {
-    return value;
-  }
-}
-
-function parseKeyValue(input: string): { key: string; value: unknown } {
-  const idx = input.indexOf("=");
-  if (idx <= 0) {
-    throw new Error(`Invalid --set value: ${input} (expected key=value)`);
-  }
-  const key = input.slice(0, idx).trim();
-  const raw = input.slice(idx + 1);
-  if (key.length === 0) {
-    throw new Error(`Invalid --set value: ${input} (empty key)`);
-  }
-  return { key, value: parseJsonOrString(raw) };
-}
-
-export default class SessionStateUpdate extends BaseCommand {
-  static override description = "Update session metadata in SQLite";
-  static override hidden = false;
-
-  static override examples = [
-    "<%= config.bin %> session state update --session test-123 --set trace_id=tr_abc --json",
-    "<%= config.bin %> session state update --session test-123 --set count=1 --set ok=true --json",
-    "echo '{\"foo\":123}' | <%= config.bin %> session state update --session test-123 --merge --json",
-  ];
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    session: Flags.string({
-      description: "Session ID",
-      required: true,
-    }),
-    set: Flags.string({
-      description: "Set a metadata key (key=value). Can be specified multiple times.",
-      multiple: true,
-    }),
-    merge: Flags.boolean({
-      description: "Merge JSON object from stdin into metadata",
-      default: false,
-    }),
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { flags } = await this.parse(SessionStateUpdate);
-    this.parsedFlags = flags;
-
-    const manager = new SessionStateManager();
-
-    const setEntries = flags.set ?? [];
-    const set: Record<string, unknown> = {};
-    for (const entry of setEntries) {
-      const { key, value } = parseKeyValue(entry);
-      set[key] = value;
-    }
-
-    let mergeObj: Record<string, unknown> | undefined;
-    if (flags.merge) {
-      const stdin = await this.readStdin();
-      if (!stdin) {
-        this.error("No stdin provided for --merge (expected a JSON object)");
-      }
-      let parsed: unknown;
-      try {
-        parsed = JSON.parse(stdin);
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        this.error(`Failed to parse JSON stdin: ${message}`);
-      }
-      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-        this.error("Invalid JSON for --merge (expected an object)");
-      }
-      mergeObj = parsed as Record<string, unknown>;
-    }
-
-    const hasSet = Object.keys(set).length > 0;
-    if (!hasSet && !mergeObj) {
-      this.error("Provide at least one --set or use --merge with JSON stdin");
-    }
-
-    const record = manager.update({
-      sessionId: flags.session,
-      set: hasSet ? set : undefined,
-      merge: mergeObj,
-    });
-
-    if (!record) {
-      this.error(`Session not found: ${flags.session}`);
-    }
-
-    if (flags.json || flags.format === "json") {
-      return record;
-    }
-
-    this.logInfo(`Updated session metadata: ${record.session_id}`);
-    return record;
-  }
-}

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

@@ -1,134 +0,0 @@
-import { getHttpClient, api } from "@creativeintelligence/sdk/convex";
-import { Args, Flags } from "@oclif/core";
-import { getActiveSessionManager } from "../../../lib/active-sessions.js";
-import { BaseCommand } from "../../base-command.js";
-
-export default class SessionStop extends BaseCommand {
-  static override description = "Stop a running agent session";
-  static override hidden = false;
-
-  static override examples = [
-    "<%= config.bin %> session stop hostagent-20241225-120000-abc1",
-    "<%= config.bin %> session stop hostagent-20241225-120000-abc1 --force",
-    "<%= config.bin %> session stop --all --project hostagent",
-  ];
-
-  static override args = {
-    session_id: Args.string({
-      description: "Session ID to stop",
-      required: false,
-    }),
-  };
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    force: Flags.boolean({
-      char: "f",
-      description: "Force kill (SIGKILL instead of SIGTERM)",
-      default: false,
-    }),
-    all: Flags.boolean({
-      description: "Stop all running sessions",
-      default: false,
-    }),
-    project: Flags.string({
-      char: "p",
-      description: "Filter by project (used with --all)",
-    }),
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { args, flags } = await this.parse(SessionStop);
-    this.parsedFlags = flags;
-
-    const manager = getActiveSessionManager();
-    const client = getHttpClient();
-    const signal: NodeJS.Signals = flags.force ? "SIGKILL" : "SIGTERM";
-
-    if (flags.all) {
-      // Stop all running sessions (async store with local fallback)
-      const sessions = await manager.listAsync({ status: "running", project: flags.project });
-
-      if (sessions.length === 0) {
-        this.logInfo("No running sessions found");
-        return { stopped: 0 };
-      }
-
-      const results: { session_id: string; stopped: boolean }[] = [];
-
-      for (const session of sessions) {
-        const stopped = manager.stop(session.session_id, signal);
-        results.push({ session_id: session.session_id, stopped });
-
-        if (stopped) {
-          try {
-            await client.mutation(api.sessions.update, {
-              sessionId: session.session_id,
-              status: "stopped",
-              endedAt: Date.now(),
-            });
-          } catch (error) {
-            this.logWarn(
-              `Store update failed for ${session.session_id}: ${(error as Error).message}`,
-            );
-          }
-        }
-
-        if (!flags.quiet && !this.jsonEnabled?.()) {
-          this.log(`${stopped ? "✓" : "✗"} ${session.session_id}`);
-        }
-      }
-
-      const stoppedCount = results.filter((r) => r.stopped).length;
-
-      if (flags.json || flags.format === "json") {
-        return { stopped: stoppedCount, results };
-      }
-
-      this.log(`\nStopped ${stoppedCount} of ${sessions.length} sessions`);
-      return { stopped: stoppedCount, results };
-    }
-
-    // Stop single session
-    if (!args.session_id) {
-      this.error("Session ID is required (or use --all)");
-    }
-
-    const session = await manager.getAsync(args.session_id);
-
-    if (!session) {
-      this.error(`Session not found: ${args.session_id}`);
-    }
-
-    if (session.status !== "running") {
-      this.error(`Session is not running (status: ${session.status})`);
-    }
-
-    const stopped = manager.stop(args.session_id, signal);
-
-    if (!stopped) {
-      this.error(`Failed to stop session ${args.session_id}`);
-    }
-
-    try {
-      await client.mutation(api.sessions.update, {
-        sessionId: args.session_id,
-        status: "stopped",
-        endedAt: Date.now(),
-      });
-    } catch (error) {
-      this.logWarn(`Store update failed (local session stopped): ${(error as Error).message}`);
-    }
-
-    if (flags.json || flags.format === "json") {
-      return {
-        session_id: args.session_id,
-        stopped: true,
-        signal,
-      };
-    }
-
-    this.log(`Session stopped: ${args.session_id}`);
-    return { session_id: args.session_id, stopped: true };
-  }
-}

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

@@ -1,186 +0,0 @@
-import { spawn, spawnSync } from "node:child_process";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
-import { Args, Flags } from "@oclif/core";
-import { getActiveSessionManager } from "../../../lib/active-sessions.js";
-import { ensureManagedSession } from "../../../lib/managed-session.js";
-import { getNvimInstanceForWindow } from "../../../lib/nvim/discovery.js";
-import { isServerReachable, remoteSend } from "../../../lib/nvim/remote.js";
-import { buildProcessTree, getProcessSnapshot } from "../../../lib/process/snapshot.js";
-import { getSessionLogPaths } from "../../../lib/session-result.js";
-import { getPaneId, listWindows } from "../../../lib/tmux/bridge.js";
-import { BaseCommand } from "../../base-command.js";
-
-export default class SessionView extends BaseCommand {
-  static override description = "Attach a viewer to a session's runner stdout log";
-  static override hidden = false;
-
-  static override examples = [
-    "<%= config.bin %> session view hostagent-20241225-120000-abc1",
-    "<%= config.bin %> session view hostagent-20241225-120000-abc1 --tmux-session abbie",
-  ];
-
-  static override args = {
-    session_id: Args.string({
-      description: "Session ID to view",
-      required: true,
-    }),
-  };
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    "tmux-session": Flags.string({
-      description: 'Tmux session name (default: managed "abbie" session)',
-    }),
-  };
-
-  protected async execute(): Promise<unknown> {
-    const { args, flags } = await this.parse(SessionView);
-    this.parsedFlags = flags;
-
-    const manager = getActiveSessionManager();
-    const session = await manager.getAsync(args.session_id);
-    if (!session) {
-      this.error(`Session not found: ${args.session_id}`);
-    }
-
-    const stdoutPath = session.stdout_path || getSessionLogPaths(args.session_id).stdoutPath;
-    this.ensureFile(stdoutPath);
-
-    const tmuxSession = flags["tmux-session"] || (await ensureManagedSession());
-    const projectWindowExists = await this.hasProjectWindow(tmuxSession, session.project);
-
-    const attachedInNvim = await this.openInNvimIfAvailable(
-      projectWindowExists,
-      session.project,
-      tmuxSession,
-      stdoutPath,
-    );
-
-    if (attachedInNvim) {
-      const payload = {
-        session_id: args.session_id,
-        project: session.project,
-        method: "nvim-tab",
-        stdout_path: stdoutPath,
-        tmux_session: tmuxSession,
-      };
-      if (flags.json || flags.format === "json") {
-        return payload;
-      }
-      this.log(`Attached via nvim tab: tail -F ${stdoutPath}`);
-      return payload;
-    }
-
-    await this.openInTmuxPane(
-      projectWindowExists,
-      session.project,
-      session.cwd,
-      tmuxSession,
-      stdoutPath,
-      args.session_id,
-    );
-
-    const payload = {
-      session_id: args.session_id,
-      project: session.project,
-      method: "tmux-pane",
-      stdout_path: stdoutPath,
-      tmux_session: tmuxSession,
-    };
-    if (flags.json || flags.format === "json") {
-      return payload;
-    }
-    this.log(`Attached via tmux pane: tail -F ${stdoutPath}`);
-    return payload;
-  }
-
-  private ensureFile(path: string): void {
-    if (existsSync(path)) return;
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, "", { flag: "a" });
-  }
-
-  private shellEscape(value: string): string {
-    return `'${value.replace(/'/g, `'\\''`)}'`;
-  }
-
-  private async runTmux(args: string[]): Promise<void> {
-    await new Promise<void>((resolve, reject) => {
-      const proc = spawn("tmux", args, { stdio: ["ignore", "ignore", "ignore"] });
-      proc.on("close", (code) => {
-        if (code === 0) resolve();
-        else reject(new Error(`tmux ${args.join(" ")} failed with code ${code}`));
-      });
-      proc.on("error", reject);
-    });
-  }
-
-  private async hasProjectWindow(tmuxSession: string, project: string): Promise<boolean> {
-    const windows = await listWindows(tmuxSession);
-    return windows.some((window) => window.name === project);
-  }
-
-  private async openInNvimIfAvailable(
-    projectWindowExists: boolean,
-    project: string,
-    tmuxSession: string,
-    stdoutPath: string,
-  ): Promise<boolean> {
-    if (!projectWindowExists) return false;
-
-    const paneId = await getPaneId(project, 0, tmuxSession);
-    if (!paneId) return false;
-
-    const panePidRaw = spawnSync("tmux", ["display-message", "-p", "-t", paneId, "#{pane_pid}"], {
-      encoding: "utf8",
-    }).stdout.trim();
-    const panePid = parseInt(panePidRaw, 10);
-    if (!(panePid > 0)) return false;
-
-    const snapshot = await getProcessSnapshot();
-    const tree = buildProcessTree(snapshot);
-    const nvimInstance = await getNvimInstanceForWindow(panePid, snapshot, tree);
-    if (!nvimInstance?.serverAddr) return false;
-
-    const reachable = await isServerReachable(nvimInstance.serverAddr);
-    if (!reachable) return false;
-
-    const tailCommand = `tail -F ${this.shellEscape(stdoutPath)}`;
-    return remoteSend(nvimInstance.serverAddr, `:tabnew | terminal ${tailCommand}\n`);
-  }
-
-  private async openInTmuxPane(
-    projectWindowExists: boolean,
-    project: string,
-    cwd: string,
-    tmuxSession: string,
-    stdoutPath: string,
-    sessionId: string,
-  ): Promise<void> {
-    const tailCommand = `tail -F ${this.shellEscape(stdoutPath)}`;
-
-    if (projectWindowExists) {
-      await this.runTmux([
-        "split-window",
-        "-t",
-        `${tmuxSession}:${project}`,
-        "-c",
-        cwd,
-        tailCommand,
-      ]);
-      return;
-    }
-
-    await this.runTmux([
-      "new-window",
-      "-t",
-      `${tmuxSession}:`,
-      "-n",
-      `${project}-view-${sessionId.slice(-4)}`,
-      "-c",
-      cwd,
-      tailCommand,
-    ]);
-  }
-}