@creativeintelligence/abbie 0.1.3 → 0.1.5

package/src/cli/commands/windows/list.ts

@@ -1,213 +0,0 @@
-import { api, getHttpClient, isConvexConfigured } from "@creativeintelligence/sdk/convex";
-import { Flags } from "@oclif/core";
-import { getDeviceId } from "../../../lib/device.js";
-import { isRunning } from "../../../lib/tmux/index.js";
-import * as windows from "../../../lib/windows/index.js";
-import { BaseCommand } from "../../base-command.js";
-
-interface ListResult {
-  tmuxRunning: boolean;
-  windows: windows.WindowState[];
-}
-
-function abbreviateHome(path: string): string {
-  const home = process.env.HOME;
-  if (!home) return path;
-  if (path === home) return "~";
-  if (path.startsWith(`${home}/`)) return `~/${path.slice(home.length + 1)}`;
-  return path;
-}
-
-function paneRef(window: windows.WindowInfo): string {
-  return `${window.session}:${window.window}.${window.pane}`;
-}
-
-function windowLabel(window: windows.WindowInfo): string {
-  return `${window.window}:${window.windowName}`;
-}
-
-function pad(value: string, width: number): string {
-  if (value.length >= width) return value;
-  return value + " ".repeat(width - value.length);
-}
-
-function formatRow(state: windows.WindowState): {
-  id: string;
-  session: string;
-  window: string;
-  cmd: string;
-  cwd: string;
-  nvim: string;
-  agent: string;
-} {
-  const id = state.window.paneId || paneRef(state.window);
-  return {
-    id,
-    session: state.window.session,
-    window: windowLabel(state.window),
-    cmd: state.window.title,
-    cwd: abbreviateHome(state.window.cwd),
-    nvim: state.nvim?.available ? "✓" : "-",
-    agent: state.agent?.type ?? "-",
-  };
-}
-
-export default class WindowsListCommand extends BaseCommand {
-  static override summary = "List workspace windows (tmux panes)";
-  static hidden = false;
-
-  static override examples = [
-    "$ abbie windows list",
-    "$ abbie windows list --session work",
-    "$ abbie windows list --active",
-    "$ abbie windows list --no-with-nvim",
-    "$ abbie windows list --no-with-agent",
-    "$ abbie windows list --sync",
-    "$ abbie windows list --json",
-  ];
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    session: Flags.string({
-      char: "s",
-      description: "Filter to specific tmux session",
-    }),
-    active: Flags.boolean({
-      description: "Only show active panes",
-      default: false,
-    }),
-    "with-nvim": Flags.boolean({
-      description: "Include nvim state",
-      default: true,
-      allowNo: true,
-    }),
-    "with-agent": Flags.boolean({
-      description: "Include agent detection",
-      default: true,
-      allowNo: true,
-    }),
-    sync: Flags.boolean({
-      description: "Sync windows to Convex for cross-device visibility",
-      default: false,
-    }),
-  };
-
-  async execute(): Promise<unknown> {
-    const { flags } = await this.parse(WindowsListCommand);
-    this.parsedFlags = flags;
-
-    const tmuxRunning = await isRunning();
-    if (!tmuxRunning) {
-      const result: ListResult = { tmuxRunning: false, windows: [] };
-      if (!this.jsonEnabled?.()) {
-        this.log("tmux is not running");
-      }
-      return result;
-    }
-
-    const states = await windows.inventory({
-      session: flags.session,
-      includeNvim: flags["with-nvim"],
-      includeAgent: flags["with-agent"],
-      includeBuffers: false,
-    });
-
-    const filtered = (flags.active ? states.filter((s) => s.window.active) : states).sort(
-      (a, b) => {
-        if (a.window.session !== b.window.session)
-          return a.window.session.localeCompare(b.window.session);
-        if (a.window.window !== b.window.window) return a.window.window - b.window.window;
-        return a.window.pane - b.window.pane;
-      },
-    );
-
-    const result: ListResult = { tmuxRunning: true, windows: filtered };
-
-    // Sync to Convex if requested
-    if (flags.sync) {
-      await this.syncToConvex(filtered);
-    }
-
-    if (!this.jsonEnabled?.()) {
-      this.printText(result);
-    }
-
-    return result;
-  }
-
-  private async syncToConvex(states: windows.WindowState[]): Promise<void> {
-    if (!isConvexConfigured()) {
-      if (!this.jsonEnabled?.()) {
-        this.warn("Convex not configured, skipping sync");
-      }
-      return;
-    }
-
-    const deviceId = getDeviceId();
-    const windowData = states.map((state) => ({
-      paneId:
-        state.window.paneId ||
-        `${state.window.session}:${state.window.window}.${state.window.pane}`,
-      tmuxSession: state.window.session,
-      windowIndex: state.window.window,
-      windowName: state.window.windowName,
-      paneIndex: state.window.pane,
-      cwd: state.window.cwd || "",
-      title: state.window.title || undefined,
-      isActive: state.window.active,
-      cols: state.window.size.cols,
-      rows: state.window.size.rows,
-      hasNvim: state.nvim?.available ?? false,
-      nvimPid: state.nvim?.pid ?? undefined,
-      nvimServerAddr: state.nvim?.serverAddr ?? undefined,
-      agentType: state.agent?.type ?? undefined,
-      agentPid: state.agent?.pid ?? undefined,
-    }));
-
-    try {
-      const client = getHttpClient();
-      const syncResult = await client.mutation(api.windows.sync, {
-        deviceId,
-        windows: windowData,
-      });
-
-      if (!this.jsonEnabled?.()) {
-        this.log(`Synced ${syncResult.synced} windows to Convex`);
-      }
-    } catch (error) {
-      if (!this.jsonEnabled?.()) {
-        this.warn(
-          `Failed to sync to Convex: ${error instanceof Error ? error.message : "Unknown error"}`,
-        );
-      }
-    }
-  }
-
-  private printText(result: ListResult): void {
-    if (result.windows.length === 0) {
-      this.log("No windows found");
-      return;
-    }
-
-    const rows = result.windows.map(formatRow);
-
-    const widths = {
-      id: Math.max(2, ...rows.map((r) => r.id.length), "ID".length),
-      session: Math.max(2, ...rows.map((r) => r.session.length), "SESSION".length),
-      window: Math.max(2, ...rows.map((r) => r.window.length), "WINDOW".length),
-      cmd: Math.max(2, ...rows.map((r) => r.cmd.length), "CMD".length),
-      cwd: Math.max(2, ...rows.map((r) => r.cwd.length), "CWD".length),
-    };
-
-    this.log("WINDOWS");
-    this.log(
-      `${pad("ID", widths.id)}  ${pad("SESSION", widths.session)}  ${pad("WINDOW", widths.window)}  ${pad("CMD", widths.cmd)}  ${pad("CWD", widths.cwd)}  NVIM  AGENT`,
-    );
-
-    for (const row of rows) {
-      this.log(
-        `${pad(row.id, widths.id)}  ${pad(row.session, widths.session)}  ${pad(row.window, widths.window)}  ${pad(row.cmd, widths.cmd)}  ${pad(row.cwd, widths.cwd)}  ${pad(row.nvim, 4)}  ${row.agent}`,
-      );
-    }
-  }
-}

package/src/cli/commands/windows/map.ts

@@ -1,223 +0,0 @@
-import { Flags } from "@oclif/core";
-import { type ActiveSession, getActiveSessionManager } from "../../../lib/active-sessions.js";
-import { isRunning } from "../../../lib/tmux/index.js";
-import * as windows from "../../../lib/windows/index.js";
-import { BaseCommand } from "../../base-command.js";
-
-interface MappingRow {
-  session: string;
-  agent: string;
-  status: ActiveSession["status"] | "unknown";
-  window: string | null;
-  paneId: string | null;
-  cmd: string | null;
-  cwd: string | null;
-  match: "session-id" | "pid" | "none";
-  pid: number | null;
-  issue?: string;
-}
-
-interface MapResult {
-  tmuxRunning: boolean;
-  mappings: MappingRow[];
-  unmappedWindows: Array<{
-    paneId: string;
-    ref: string;
-    cmd: string;
-    cwd: string;
-    active: boolean;
-  }>;
-  orphanAgents: Array<{
-    session: string;
-    agent: string;
-    status: ActiveSession["status"];
-    pid: number | null;
-    cwd: string;
-  }>;
-}
-
-function abbreviateHome(path: string): string {
-  const home = process.env.HOME;
-  if (!home) return path;
-  if (path === home) return "~";
-  if (path.startsWith(`${home}/`)) return `~/${path.slice(home.length + 1)}`;
-  return path;
-}
-
-function paneRef(window: windows.WindowInfo): string {
-  return `${window.session}:${window.window}.${window.pane}`;
-}
-
-function pad(value: string, width: number): string {
-  if (value.length >= width) return value;
-  return value + " ".repeat(width - value.length);
-}
-
-export default class WindowsMapCommand extends BaseCommand {
-  static override summary = "Map agent sessions to windows";
-  static hidden = false;
-
-  static override examples = [
-    "$ abbie windows map",
-    "$ abbie windows map --orphans",
-    "$ abbie windows map --unmapped",
-    "$ abbie windows map --json",
-  ];
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    orphans: Flags.boolean({
-      description: "Show orphan agents (no associated window)",
-      default: false,
-    }),
-    unmapped: Flags.boolean({
-      description: "Show windows without agents",
-      default: false,
-    }),
-  };
-
-  async execute(): Promise<unknown> {
-    const { flags } = await this.parse(WindowsMapCommand);
-    this.parsedFlags = flags;
-
-    const tmuxRunning = await isRunning();
-    if (!tmuxRunning) {
-      const result: MapResult = {
-        tmuxRunning: false,
-        mappings: [],
-        unmappedWindows: [],
-        orphanAgents: [],
-      };
-      if (!this.jsonEnabled?.()) {
-        this.log("tmux is not running");
-      }
-      return result;
-    }
-
-    const manager = getActiveSessionManager();
-    const activeSessions = await manager.listAsync({ status: "running" });
-
-    const states = await windows.inventory({
-      includeNvim: false,
-      includeAgent: true,
-      includeBuffers: false,
-    });
-
-    const bySessionId = new Map<string, windows.WindowState>();
-    const byPid = new Map<number, windows.WindowState>();
-
-    for (const state of states) {
-      if (state.agent?.sessionId) {
-        bySessionId.set(state.agent.sessionId, state);
-      }
-      if (state.agent?.pid) {
-        byPid.set(state.agent.pid, state);
-      }
-    }
-
-    const mappings: MappingRow[] = [];
-
-    for (const session of activeSessions) {
-      let matched: windows.WindowState | undefined;
-      let match: MappingRow["match"] = "none";
-
-      if (bySessionId.has(session.session_id)) {
-        matched = bySessionId.get(session.session_id);
-        match = "session-id";
-      } else if (typeof session.agent_pid === "number" && byPid.has(session.agent_pid)) {
-        matched = byPid.get(session.agent_pid);
-        match = "pid";
-      }
-
-      mappings.push({
-        session: session.session_id,
-        agent: session.agent,
-        status: session.status,
-        window: matched ? paneRef(matched.window) : null,
-        paneId: matched?.window.paneId || null,
-        cmd: matched?.window.title || null,
-        cwd: matched ? abbreviateHome(matched.window.cwd) : session.cwd,
-        match,
-        pid: session.agent_pid ?? null,
-        issue: session.issue,
-      });
-    }
-
-    const unmappedWindows = states
-      .filter((s) => !s.agent)
-      .map((s) => ({
-        paneId: s.window.paneId || paneRef(s.window),
-        ref: paneRef(s.window),
-        cmd: s.window.title,
-        cwd: abbreviateHome(s.window.cwd),
-        active: s.window.active,
-      }))
-      .sort((a, b) => a.ref.localeCompare(b.ref));
-
-    const orphanAgents = mappings
-      .filter((m) => m.window === null)
-      .map((m) => ({
-        session: m.session,
-        agent: m.agent,
-        status: m.status as ActiveSession["status"],
-        pid: m.pid,
-        cwd: m.cwd ?? "",
-      }));
-
-    const result: MapResult = { tmuxRunning: true, mappings, unmappedWindows, orphanAgents };
-
-    if (!this.jsonEnabled?.()) {
-      this.printText(result, flags);
-    }
-
-    return result;
-  }
-
-  private printText(result: MapResult, flags: { orphans: boolean; unmapped: boolean }): void {
-    const mapped = result.mappings.filter((m) => m.window !== null);
-
-    if (mapped.length === 0) {
-      this.log("No agent mappings found");
-    } else {
-      const sessionWidth = Math.max("SESSION".length, ...mapped.map((m) => m.session.length));
-      const agentWidth = Math.max("AGENT".length, ...mapped.map((m) => m.agent.length));
-      const windowWidth = Math.max("WINDOW".length, ...mapped.map((m) => (m.window ?? "").length));
-
-      this.log("AGENT MAPPINGS");
-      this.log(
-        `${pad("SESSION", sessionWidth)}  ${pad("AGENT", agentWidth)}  ${pad("WINDOW", windowWidth)}  STATUS`,
-      );
-
-      for (const m of mapped) {
-        this.log(
-          `${pad(m.session, sessionWidth)}  ${pad(m.agent, agentWidth)}  ${pad(m.window ?? "-", windowWidth)}  ${m.status}`,
-        );
-      }
-    }
-
-    if (flags.unmapped) {
-      this.log("");
-      this.log("UNMAPPED WINDOWS (--unmapped)");
-      if (result.unmappedWindows.length === 0) {
-        this.log("None");
-      } else {
-        for (const w of result.unmappedWindows) {
-          this.log(`${w.paneId}  ${w.ref}  ${w.cmd}  ${w.cwd}${w.active ? " [active]" : ""}`);
-        }
-      }
-    }
-
-    if (flags.orphans) {
-      this.log("");
-      this.log("ORPHAN AGENTS (--orphans)");
-      if (result.orphanAgents.length === 0) {
-        this.log("None");
-      } else {
-        for (const a of result.orphanAgents) {
-          const pidStr = a.pid ? `PID ${a.pid}` : "PID -";
-          this.log(`${pidStr} (${a.agent}) - no associated window (${a.session})`);
-        }
-      }
-    }
-  }
-}

package/src/cli/commands/windows/read.ts

@@ -1,279 +0,0 @@
-import { Args, Flags } from "@oclif/core";
-import { getBufferLines, getCurrentBufferInfo, getVisibleRange } from "../../../lib/nvim/remote.js";
-import { isRunning } from "../../../lib/tmux/index.js";
-import { redactLine } from "../../../lib/tmux/redaction.js";
-import * as windows from "../../../lib/windows/index.js";
-import { BaseCommand } from "../../base-command.js";
-
-type ReadScope = "visible" | "cursor" | "all";
-
-interface ReadResult {
-  tmuxRunning: boolean;
-  window: windows.WindowInfo | null;
-  ref: string | null;
-  scope: ReadScope;
-  startLine: number | null;
-  endLine: number | null;
-  buffer: {
-    bufnr: number;
-    name: string;
-    filetype: string;
-    modified: boolean;
-    cursor?: { line: number; col: number };
-  } | null;
-  lines: string[];
-  redacted: boolean;
-  wasRedacted: boolean;
-}
-
-function abbreviateHome(path: string): string {
-  const home = process.env.HOME;
-  if (!home) return path;
-  if (path === home) return "~";
-  if (path.startsWith(`${home}/`)) return `~/${path.slice(home.length + 1)}`;
-  return path;
-}
-
-function paneRef(window: windows.WindowInfo): string {
-  return `${window.session}:${window.window}.${window.pane}`;
-}
-
-function formatPathForDisplay(path: string, cwd: string): string {
-  if (!path) return path;
-  const normalizedCwd = cwd.endsWith("/") ? cwd : `${cwd}/`;
-  if (path.startsWith(normalizedCwd)) {
-    return path.slice(normalizedCwd.length);
-  }
-  return abbreviateHome(path);
-}
-
-export default class WindowsReadCommand extends BaseCommand {
-  static override summary = "Read nvim buffer content for a window";
-  static hidden = false;
-
-  static override examples = [
-    "$ abbie windows read",
-    "$ abbie windows read %3",
-    "$ abbie windows read --scope visible",
-    "$ abbie windows read --scope cursor",
-    "$ abbie windows read --scope all",
-    "$ abbie windows read --lines 50",
-    "$ abbie windows read --no-redact",
-    "$ abbie windows read --json",
-  ];
-
-  static override args = {
-    ref: Args.string({
-      description: "Pane ID (e.g. %3) or session:window.pane (e.g. work:0.0)",
-      required: false,
-    }),
-  };
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    scope: Flags.string({
-      description: "Read scope",
-      options: ["visible", "cursor", "all"],
-      default: "visible",
-    }),
-    lines: Flags.integer({
-      description: "Maximum lines to read",
-      default: 50,
-    }),
-    redact: Flags.boolean({
-      description: "Enable redaction",
-      default: true,
-      allowNo: true,
-    }),
-  };
-
-  async execute(): Promise<unknown> {
-    const { args, flags } = await this.parse(WindowsReadCommand);
-    this.parsedFlags = flags;
-
-    const scope = flags.scope as ReadScope;
-    const maxLines = Math.max(1, flags.lines);
-
-    const tmuxRunning = await isRunning();
-    if (!tmuxRunning) {
-      const result: ReadResult = {
-        tmuxRunning: false,
-        window: null,
-        ref: null,
-        scope,
-        startLine: null,
-        endLine: null,
-        buffer: null,
-        lines: [],
-        redacted: flags.redact,
-        wasRedacted: false,
-      };
-      if (!this.jsonEnabled?.()) {
-        this.log("tmux is not running");
-      }
-      return result;
-    }
-
-    const state = args.ref
-      ? await windows.getWindowState(args.ref, {
-          includeNvim: true,
-          includeAgent: false,
-          includeBuffers: false,
-        })
-      : await windows.getFocusedWindow({
-          includeNvim: true,
-          includeAgent: false,
-          includeBuffers: false,
-        });
-
-    if (!state) {
-      const result: ReadResult = {
-        tmuxRunning: true,
-        window: null,
-        ref: null,
-        scope,
-        startLine: null,
-        endLine: null,
-        buffer: null,
-        lines: [],
-        redacted: flags.redact,
-        wasRedacted: false,
-      };
-      if (!this.jsonEnabled?.()) {
-        this.log("Window not found");
-      }
-      return result;
-    }
-
-    const nvimState = state.nvim;
-    if (!nvimState?.available || !nvimState.serverAddr) {
-      const result: ReadResult = {
-        tmuxRunning: true,
-        window: state.window,
-        ref: paneRef(state.window),
-        scope,
-        startLine: null,
-        endLine: null,
-        buffer: null,
-        lines: [],
-        redacted: flags.redact,
-        wasRedacted: false,
-      };
-      if (!this.jsonEnabled?.()) {
-        this.log("nvim is not available for this window");
-      }
-      return result;
-    }
-
-    const serverAddr = nvimState.serverAddr;
-
-    const bufferInfo = await getCurrentBufferInfo(serverAddr);
-    if (!bufferInfo) {
-      const result: ReadResult = {
-        tmuxRunning: true,
-        window: state.window,
-        ref: paneRef(state.window),
-        scope,
-        startLine: null,
-        endLine: null,
-        buffer: null,
-        lines: [],
-        redacted: flags.redact,
-        wasRedacted: false,
-      };
-      if (!this.jsonEnabled?.()) {
-        this.log("Unable to query nvim current buffer");
-      }
-      return result;
-    }
-
-    let startLine = 1;
-    let endLine = 1;
-    let cursor = bufferInfo.cursor ?? { line: 1, col: 1 };
-
-    if (scope === "visible") {
-      const range = await getVisibleRange(serverAddr, bufferInfo.bufnr);
-      if (range) {
-        startLine = range.topLine;
-        endLine = Math.min(range.bottomLine, range.topLine + maxLines - 1);
-        cursor = range.cursor;
-      } else {
-        endLine = startLine + maxLines - 1;
-      }
-    } else if (scope === "cursor") {
-      const desiredHalf = Math.min(20, Math.floor((maxLines - 1) / 2));
-      startLine = Math.max(1, cursor.line - desiredHalf);
-      endLine = startLine + Math.min(maxLines, desiredHalf * 2 + 1) - 1;
-    } else {
-      startLine = 1;
-      endLine = startLine + maxLines - 1;
-    }
-
-    const rawLines = await getBufferLines(serverAddr, bufferInfo.bufnr, startLine, endLine);
-    if (!rawLines) {
-      const result: ReadResult = {
-        tmuxRunning: true,
-        window: state.window,
-        ref: paneRef(state.window),
-        scope,
-        startLine,
-        endLine,
-        buffer: bufferInfo,
-        lines: [],
-        redacted: flags.redact,
-        wasRedacted: false,
-      };
-      if (!this.jsonEnabled?.()) {
-        this.log("Unable to read buffer content");
-      }
-      return result;
-    }
-
-    let wasRedacted = false;
-    const renderedLines = rawLines.map((line) => {
-      if (!flags.redact) return line;
-      const redacted = redactLine(line);
-      if (redacted !== line) wasRedacted = true;
-      return redacted;
-    });
-
-    const result: ReadResult = {
-      tmuxRunning: true,
-      window: state.window,
-      ref: paneRef(state.window),
-      scope,
-      startLine,
-      endLine,
-      buffer: { ...bufferInfo, cursor },
-      lines: renderedLines,
-      redacted: flags.redact,
-      wasRedacted,
-    };
-
-    if (!this.jsonEnabled?.()) {
-      this.printText(result);
-    }
-
-    return result;
-  }
-
-  private printText(result: ReadResult): void {
-    if (!result.window || !result.buffer || result.startLine === null || result.endLine === null) {
-      this.log("No buffer content available");
-      return;
-    }
-
-    const displayPath = formatPathForDisplay(result.buffer.name, result.window.cwd);
-    this.log(`BUFFER ${displayPath} (${result.buffer.filetype || "unknown"})`);
-    this.log(`Window: ${result.window.paneId || "-"} (${result.ref})`);
-    this.log(`Scope:  ${result.scope} (lines ${result.startLine}-${result.endLine})`);
-    this.log("");
-
-    const width = String(result.endLine).length;
-
-    for (let i = 0; i < result.lines.length; i++) {
-      const lineNo = result.startLine + i;
-      this.log(`  ${String(lineNo).padStart(width)} │ ${result.lines[i]}`);
-    }
-  }
-}