@creativeintelligence/abbie 0.1.4 → 0.1.6

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

@@ -1,439 +0,0 @@
-import { Flags } from "@oclif/core";
-import { getBufferLines, getCurrentBufferInfo, getVisibleRange } from "../../../lib/nvim/remote.js";
-import { isRunning } from "../../../lib/tmux/index.js";
-import { redactContent } from "../../../lib/tmux/redaction.js";
-import * as windows from "../../../lib/windows/index.js";
-import { BaseCommand } from "../../base-command.js";
-
-interface WorkspaceContextWindow {
-  id: string;
-  ref: string;
-  session: string;
-  window: number;
-  windowName: string;
-  pane: number;
-  active: boolean;
-  cwd: string;
-  cmd: string;
-  nvim: {
-    available: boolean;
-    pid: number | null;
-    server: string | null;
-    discoveryMethod: "argv" | "lsof" | null;
-    buffer: {
-      path: string;
-      filetype: string;
-      modified: boolean;
-      cursor: string | null;
-    } | null;
-    excerpt: {
-      scope: "visible";
-      startLine: number;
-      endLine: number;
-      redacted: boolean;
-      lines: string[];
-    } | null;
-  } | null;
-  agent: {
-    type: windows.AgentInfo["type"];
-    pid: number;
-    sessionId?: string;
-    issue?: string;
-  } | null;
-}
-
-interface WorkspaceContextResult {
-  generatedAt: string;
-  tmuxRunning: boolean;
-  truncated: boolean;
-  windows: WorkspaceContextWindow[];
-}
-
-type NvimContext = NonNullable<WorkspaceContextWindow["nvim"]>;
-
-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);
-}
-
-function escapeXml(str: string): string {
-  return str
-    .replace(/&/g, "&amp;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;")
-    .replace(/"/g, "&quot;")
-    .replace(/'/g, "&apos;");
-}
-
-function truncateToBytes(str: string, maxBytes: number): string {
-  const buf = Buffer.from(str, "utf-8");
-  if (buf.length <= maxBytes) {
-    return str;
-  }
-
-  let low = 0;
-  let high = str.length;
-
-  while (low < high) {
-    const mid = Math.ceil((low + high) / 2);
-    const slice = str.slice(0, mid);
-    if (Buffer.byteLength(slice, "utf-8") <= maxBytes) {
-      low = mid;
-    } else {
-      high = mid - 1;
-    }
-  }
-
-  return str.slice(0, low);
-}
-
-function bytesForLine(line: string): number {
-  return Buffer.byteLength(`${line}\n`, "utf-8");
-}
-
-function buildWindowXmlLines(
-  w: WorkspaceContextWindow,
-  maxBytes: number,
-): { lines: string[]; truncated: boolean } | null {
-  const baseLines: string[] = [];
-
-  baseLines.push(
-    `  <window id="${escapeXml(w.id)}" session="${escapeXml(w.session)}" window="${w.window}" pane="${w.pane}" active="${w.active}">`,
-  );
-  baseLines.push(`    <cwd>${escapeXml(w.cwd)}</cwd>`);
-  baseLines.push(`    <cmd>${escapeXml(w.cmd)}</cmd>`);
-
-  if (w.nvim) {
-    const attrs = [
-      `available="${w.nvim.available}"`,
-      w.nvim.pid !== null ? `pid="${w.nvim.pid}"` : null,
-      w.nvim.server ? `server="${escapeXml(w.nvim.server)}"` : null,
-      w.nvim.discoveryMethod ? `discovery="${w.nvim.discoveryMethod}"` : null,
-    ].filter(Boolean) as string[];
-
-    baseLines.push(`    <nvim ${attrs.join(" ")}>`);
-    if (w.nvim.buffer) {
-      const bufAttrs = [
-        `path="${escapeXml(w.nvim.buffer.path)}"`,
-        `filetype="${escapeXml(w.nvim.buffer.filetype)}"`,
-        `modified="${w.nvim.buffer.modified}"`,
-        w.nvim.buffer.cursor ? `cursor="${escapeXml(w.nvim.buffer.cursor)}"` : null,
-      ].filter(Boolean) as string[];
-      baseLines.push(`      <buffer ${bufAttrs.join(" ")} />`);
-    }
-
-    baseLines.push("    </nvim>");
-  }
-
-  if (w.agent) {
-    const attrs = [
-      `type="${w.agent.type}"`,
-      `pid="${w.agent.pid}"`,
-      w.agent.sessionId ? `session="${escapeXml(w.agent.sessionId)}"` : null,
-      w.agent.issue ? `issue="${escapeXml(w.agent.issue)}"` : null,
-    ].filter(Boolean) as string[];
-    baseLines.push(`    <agent ${attrs.join(" ")} />`);
-  }
-
-  baseLines.push("  </window>");
-
-  const baseBytes = baseLines.reduce((sum, line) => sum + bytesForLine(line), 0);
-  if (baseBytes > maxBytes) return null;
-
-  const excerpt = w.nvim?.excerpt;
-  if (!excerpt || excerpt.lines.length === 0) {
-    return { lines: baseLines, truncated: false };
-  }
-
-  const insertAt = baseLines.indexOf("    </nvim>");
-  if (insertAt === -1) {
-    return { lines: baseLines, truncated: false };
-  }
-
-  const excerptOpen = `      <excerpt scope="${excerpt.scope}" start_line="${excerpt.startLine}" end_line="${excerpt.endLine}" redacted="${excerpt.redacted}">`;
-  const excerptClose = "      </excerpt>";
-
-  const skeleton = [...baseLines];
-  skeleton.splice(insertAt, 0, excerptOpen, excerptClose);
-
-  const skeletonBytes = skeleton.reduce((sum, line) => sum + bytesForLine(line), 0);
-  if (skeletonBytes > maxBytes) {
-    return { lines: baseLines, truncated: true };
-  }
-
-  const remainingForContent = maxBytes - skeletonBytes;
-  const contentLines: string[] = [];
-  let used = 0;
-  let truncated = false;
-
-  for (const rawLine of excerpt.lines) {
-    const escaped = escapeXml(rawLine);
-    const line = `        ${escaped}`;
-    const lineBytes = bytesForLine(line);
-
-    if (used + lineBytes <= remainingForContent) {
-      contentLines.push(line);
-      used += lineBytes;
-      continue;
-    }
-
-    const remaining = remainingForContent - used;
-    const indentBytes = bytesForLine("        ");
-    if (remaining > indentBytes + 8) {
-      const availableForContent = remaining - indentBytes;
-      const clipped = truncateToBytes(escaped, Math.max(0, availableForContent));
-      contentLines.push(`        ${clipped}`);
-    }
-
-    truncated = true;
-    break;
-  }
-
-  const finalLines = [...baseLines];
-  finalLines.splice(insertAt, 0, excerptOpen, ...contentLines, excerptClose);
-
-  return { lines: finalLines, truncated };
-}
-
-function toXml(
-  context: WorkspaceContextResult,
-  maxBytes: number,
-): { xml: string; truncated: boolean } {
-  const lines: string[] = [];
-  let bytes = 0;
-  let truncated = false;
-
-  const closeRoot = "</workspace_context>";
-  const closeRootBytes = bytesForLine(closeRoot);
-
-  const root = `<workspace_context generated_at="${escapeXml(context.generatedAt)}" tmux_running="${context.tmuxRunning}">`;
-  lines.push(root);
-  bytes += bytesForLine(root);
-
-  for (const w of context.windows) {
-    const remaining = maxBytes - bytes - closeRootBytes;
-    if (remaining <= 0) {
-      truncated = true;
-      break;
-    }
-
-    const built = buildWindowXmlLines(w, remaining);
-    if (!built) {
-      truncated = true;
-      break;
-    }
-
-    const windowBytes = built.lines.reduce((sum, line) => sum + bytesForLine(line), 0);
-    if (bytes + windowBytes + closeRootBytes > maxBytes) {
-      truncated = true;
-      break;
-    }
-
-    lines.push(...built.lines);
-    bytes += windowBytes;
-
-    if (built.truncated) {
-      truncated = true;
-    }
-  }
-
-  lines.push(closeRoot);
-
-  return { xml: lines.join("\n"), truncated };
-}
-
-export default class WindowsContextCommand extends BaseCommand {
-  static override summary = "Generate workspace context from windows inventory";
-  static hidden = false;
-
-  static override examples = [
-    "$ abbie windows context",
-    "$ abbie windows context --focus",
-    "$ abbie windows context --json",
-    "$ abbie windows context --no-with-buffers",
-    "$ abbie windows context --max-bytes 100000",
-    "$ abbie windows context --no-redact",
-  ];
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    focus: Flags.boolean({
-      description: "Only include the focused window",
-      default: false,
-    }),
-    "with-buffers": Flags.boolean({
-      description: "Include buffer excerpts (visible range)",
-      default: true,
-      allowNo: true,
-    }),
-    "max-bytes": Flags.integer({
-      description: "Maximum output size in bytes",
-      default: 200000,
-    }),
-    redact: Flags.boolean({
-      description: "Enable redaction",
-      default: true,
-      allowNo: true,
-    }),
-  };
-
-  async execute(): Promise<unknown> {
-    const { flags } = await this.parse(WindowsContextCommand);
-    this.parsedFlags = flags;
-
-    const generatedAt = new Date().toISOString();
-    const tmuxRunning = await isRunning();
-
-    if (!tmuxRunning) {
-      const context: WorkspaceContextResult = {
-        generatedAt,
-        tmuxRunning: false,
-        truncated: false,
-        windows: [],
-      };
-
-      if (this.jsonEnabled?.()) {
-        return context;
-      }
-
-      const xml = toXml(context, flags["max-bytes"]);
-      context.truncated = xml.truncated;
-      const output = flags.format === "json" ? JSON.stringify(context, null, 2) : xml.xml;
-      this.log(output);
-      return context;
-    }
-
-    let states = await windows.inventory({
-      includeNvim: true,
-      includeAgent: true,
-      includeBuffers: false,
-    });
-
-    // Filter to focused window if requested
-    if (flags.focus) {
-      const focused = await windows.getFocusedWindow({ includeNvim: true, includeAgent: true });
-      states = focused ? [focused] : [];
-    }
-
-    const sorted = 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 ctxWindows: WorkspaceContextWindow[] = [];
-
-    for (const state of sorted) {
-      const id = state.window.paneId || paneRef(state.window);
-      const ref = paneRef(state.window);
-
-      let buffer: NvimContext["buffer"] = null;
-      let excerpt: NvimContext["excerpt"] = null;
-
-      if (state.nvim?.available && state.nvim.serverAddr) {
-        const info = await getCurrentBufferInfo(state.nvim.serverAddr);
-        if (info) {
-          const cursor = info.cursor ? `${info.cursor.line}:${info.cursor.col}` : null;
-          buffer = {
-            path: formatPathForDisplay(info.name, state.window.cwd),
-            filetype: info.filetype,
-            modified: info.modified,
-            cursor,
-          };
-
-          if (flags["with-buffers"]) {
-            const visible = await getVisibleRange(state.nvim.serverAddr, info.bufnr);
-            if (visible) {
-              const raw = await getBufferLines(
-                state.nvim.serverAddr,
-                info.bufnr,
-                visible.topLine,
-                visible.bottomLine,
-              );
-              if (raw) {
-                const joined = raw.join("\n");
-                const redaction = flags.redact
-                  ? redactContent(joined, "balanced")
-                  : { content: joined, wasRedacted: false };
-                const lines = redaction.content.split("\n");
-                excerpt = {
-                  scope: "visible",
-                  startLine: visible.topLine,
-                  endLine: visible.bottomLine,
-                  redacted: flags.redact && redaction.wasRedacted,
-                  lines,
-                };
-              }
-            }
-          }
-        }
-      }
-
-      ctxWindows.push({
-        id,
-        ref,
-        session: state.window.session,
-        window: state.window.window,
-        windowName: state.window.windowName,
-        pane: state.window.pane,
-        active: state.window.active,
-        cwd: abbreviateHome(state.window.cwd),
-        cmd: state.window.title,
-        nvim: state.nvim
-          ? {
-              available: state.nvim.available,
-              pid: state.nvim.pid,
-              server: state.nvim.serverAddr,
-              discoveryMethod: state.nvim.discoveryMethod,
-              buffer,
-              excerpt,
-            }
-          : null,
-        agent: state.agent
-          ? {
-              type: state.agent.type,
-              pid: state.agent.pid,
-              sessionId: state.agent.sessionId,
-              issue: state.agent.issue,
-            }
-          : null,
-      });
-    }
-
-    const context: WorkspaceContextResult = {
-      generatedAt,
-      tmuxRunning: true,
-      truncated: false,
-      windows: ctxWindows,
-    };
-
-    if (this.jsonEnabled?.()) {
-      return context;
-    }
-
-    const xml = toXml(context, flags["max-bytes"]);
-    context.truncated = xml.truncated;
-
-    const output = flags.format === "json" ? JSON.stringify(context, null, 2) : xml.xml;
-    this.log(output);
-
-    return context;
-  }
-}

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

@@ -1,130 +0,0 @@
-import { Flags } from "@oclif/core";
-import { isRunning } from "../../../lib/tmux/index.js";
-import * as windows from "../../../lib/windows/index.js";
-import { BaseCommand } from "../../base-command.js";
-
-interface FocusResult {
-  tmuxRunning: boolean;
-  window: windows.WindowState | null;
-}
-
-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 windowLabel(window: windows.WindowInfo): string {
-  return `${window.window}:${window.windowName}`;
-}
-
-export default class WindowsFocusCommand extends BaseCommand {
-  static override summary = "Show focused window";
-  static hidden = false;
-
-  static override examples = [
-    "$ abbie windows focus",
-    "$ abbie windows focus --no-with-nvim",
-    "$ abbie windows focus --with-buffers",
-    "$ abbie windows focus --json",
-  ];
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    "with-nvim": Flags.boolean({
-      description: "Include nvim details",
-      default: true,
-      allowNo: true,
-    }),
-    "with-buffers": Flags.boolean({
-      description: "Include buffer list",
-      default: false,
-    }),
-  };
-
-  async execute(): Promise<unknown> {
-    const { flags } = await this.parse(WindowsFocusCommand);
-    this.parsedFlags = flags;
-
-    const tmuxRunning = await isRunning();
-    if (!tmuxRunning) {
-      const result: FocusResult = { tmuxRunning: false, window: null };
-      if (!this.jsonEnabled?.()) {
-        this.log("tmux is not running");
-      }
-      return result;
-    }
-
-    const includeNvim = flags["with-nvim"] || flags["with-buffers"];
-    const includeBuffers = flags["with-buffers"];
-
-    const state = await windows.getFocusedWindow({
-      includeNvim,
-      includeAgent: true,
-      includeBuffers,
-    });
-
-    const result: FocusResult = { tmuxRunning: true, window: state };
-
-    if (!this.jsonEnabled?.()) {
-      this.printText(result, flags);
-    }
-
-    return result;
-  }
-
-  private printText(
-    result: FocusResult,
-    flags: { "with-nvim": boolean; "with-buffers": boolean },
-  ): void {
-    if (!result.window) {
-      this.log("No focused window");
-      return;
-    }
-
-    const { window, nvim, agent, buffers } = result.window;
-
-    this.log("FOCUSED WINDOW");
-    this.log(`Session: ${window.session}`);
-    this.log(`Window:  ${windowLabel(window)}`);
-    this.log(
-      `Pane:    ${window.paneId || `${window.pane}`} (${window.active ? "active" : "inactive"})`,
-    );
-    this.log(`CWD:     ${abbreviateHome(window.cwd)}`);
-    this.log(`CMD:     ${window.title}`);
-
-    if (agent) {
-      this.log(
-        `Agent:   ${agent.type} (pid: ${agent.pid}${agent.sessionId ? `, session: ${agent.sessionId}` : ""})`,
-      );
-    }
-
-    if (flags["with-nvim"]) {
-      this.log("");
-      this.log("NVIM");
-      if (nvim?.available) {
-        this.log(`PID:     ${nvim.pid ?? "-"}`);
-        this.log(
-          `Server:  ${nvim.serverAddr ?? "-"}${nvim.discoveryMethod ? ` (${nvim.discoveryMethod})` : ""}`,
-        );
-      } else {
-        this.log("Not available");
-      }
-    }
-
-    if (flags["with-buffers"]) {
-      this.log("");
-      this.log("BUFFERS");
-      if (buffers.length === 0) {
-        this.log("No buffers");
-      } else {
-        for (const buf of buffers) {
-          const mod = buf.modified ? " [modified]" : "";
-          this.log(`- ${buf.name || buf.path} (${buf.filetype || "unknown"})${mod}`);
-        }
-      }
-    }
-  }
-}