@creativeintelligence/abbie 0.1.3 → 0.1.5

package/src/lib/process/snapshot.test.ts

@@ -1,188 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import {
-  buildProcessTree,
-  detectAgentType,
-  findDeepestDescendant,
-  findDescendants,
-  isAgentProcess,
-  isNvimProcess,
-  type ProcessInfo,
-  walkParentChain,
-} from "./snapshot.js";
-
-// Mock process snapshot for testing
-function createMockSnapshot(): Map<number, ProcessInfo> {
-  const snapshot = new Map<number, ProcessInfo>();
-
-  // Simulate: init(1) → tmux(100) → zsh(200) → nvim(300) → node(400)
-  //                                         └→ zsh(250) → codex(350)
-  snapshot.set(1, { pid: 1, ppid: 0, tty: "??", cmd: "init", args: "/sbin/init" });
-  snapshot.set(100, { pid: 100, ppid: 1, tty: "??", cmd: "tmux", args: "tmux new -s work" });
-  snapshot.set(200, { pid: 200, ppid: 100, tty: "ttys001", cmd: "zsh", args: "-zsh" });
-  snapshot.set(300, { pid: 300, ppid: 200, tty: "ttys001", cmd: "nvim", args: "nvim src/app.ts" });
-  snapshot.set(400, { pid: 400, ppid: 300, tty: "ttys001", cmd: "node", args: "node server.js" });
-  snapshot.set(250, { pid: 250, ppid: 100, tty: "ttys002", cmd: "zsh", args: "-zsh" });
-  snapshot.set(350, { pid: 350, ppid: 250, tty: "ttys002", cmd: "codex", args: "codex exec -" });
-
-  return snapshot;
-}
-
-describe("process snapshot", () => {
-  describe("buildProcessTree", () => {
-    it("builds parent→children map", () => {
-      const snapshot = createMockSnapshot();
-      const tree = buildProcessTree(snapshot);
-
-      expect(tree.get(1)).toContain(100);
-      expect(tree.get(100)).toContain(200);
-      expect(tree.get(100)).toContain(250);
-      expect(tree.get(200)).toContain(300);
-      expect(tree.get(300)).toContain(400);
-    });
-  });
-
-  describe("walkParentChain", () => {
-    it("walks up to init parent", () => {
-      const snapshot = createMockSnapshot();
-      const chain = walkParentChain(400, snapshot);
-
-      // Stops at 100 because its ppid is 1 (init)
-      expect(chain).toEqual([400, 300, 200, 100]);
-    });
-
-    it("respects maxDepth", () => {
-      const snapshot = createMockSnapshot();
-      const chain = walkParentChain(400, snapshot, 2);
-
-      expect(chain).toEqual([400, 300]);
-    });
-
-    it("handles unknown PID", () => {
-      const snapshot = createMockSnapshot();
-      const chain = walkParentChain(9999, snapshot);
-
-      expect(chain).toEqual([]);
-    });
-  });
-
-  describe("findDescendants", () => {
-    it("finds all descendants", () => {
-      const snapshot = createMockSnapshot();
-      const tree = buildProcessTree(snapshot);
-      const descendants = findDescendants(100, tree, snapshot);
-
-      expect(descendants).toContain(200);
-      expect(descendants).toContain(300);
-      expect(descendants).toContain(400);
-      expect(descendants).toContain(250);
-      expect(descendants).toContain(350);
-      expect(descendants).not.toContain(100); // not self
-    });
-
-    it("filters descendants", () => {
-      const snapshot = createMockSnapshot();
-      const tree = buildProcessTree(snapshot);
-      const nvimProcesses = findDescendants(100, tree, snapshot, isNvimProcess);
-
-      expect(nvimProcesses).toEqual([300]);
-    });
-  });
-
-  describe("findDeepestDescendant", () => {
-    it("finds deepest matching descendant", () => {
-      const snapshot = createMockSnapshot();
-      const tree = buildProcessTree(snapshot);
-
-      // node(400) is deeper than nvim(300) but we're looking for nvim
-      const deepestNvim = findDeepestDescendant(100, tree, snapshot, isNvimProcess);
-      expect(deepestNvim).toBe(300);
-    });
-
-    it("returns null when no match", () => {
-      const snapshot = createMockSnapshot();
-      const tree = buildProcessTree(snapshot);
-
-      const result = findDeepestDescendant(100, tree, snapshot, (p) => p.cmd === "emacs");
-      expect(result).toBeNull();
-    });
-
-    it("prefers deeper nested nvim", () => {
-      const snapshot = createMockSnapshot();
-      // Add a nested nvim inside the first nvim
-      snapshot.set(310, {
-        pid: 310,
-        ppid: 300,
-        tty: "ttys001",
-        cmd: "nvim",
-        args: "nvim nested.ts",
-      });
-
-      const tree = buildProcessTree(snapshot);
-      const deepestNvim = findDeepestDescendant(100, tree, snapshot, isNvimProcess);
-
-      expect(deepestNvim).toBe(310); // nested is deeper
-    });
-  });
-
-  describe("isNvimProcess", () => {
-    it("detects nvim", () => {
-      expect(isNvimProcess({ pid: 1, ppid: 0, tty: "??", cmd: "nvim", args: "nvim" })).toBe(true);
-      expect(isNvimProcess({ pid: 1, ppid: 0, tty: "??", cmd: "vim", args: "vim" })).toBe(true);
-      expect(isNvimProcess({ pid: 1, ppid: 0, tty: "??", cmd: "vi", args: "vi" })).toBe(true);
-    });
-
-    it("rejects non-nvim", () => {
-      expect(isNvimProcess({ pid: 1, ppid: 0, tty: "??", cmd: "zsh", args: "zsh" })).toBe(false);
-      expect(isNvimProcess({ pid: 1, ppid: 0, tty: "??", cmd: "node", args: "node" })).toBe(false);
-    });
-  });
-
-  describe("isAgentProcess", () => {
-    it("detects agents", () => {
-      expect(isAgentProcess({ pid: 1, ppid: 0, tty: "??", cmd: "claude", args: "claude" })).toBe(
-        true,
-      );
-      expect(isAgentProcess({ pid: 1, ppid: 0, tty: "??", cmd: "codex", args: "codex" })).toBe(
-        true,
-      );
-      expect(isAgentProcess({ pid: 1, ppid: 0, tty: "??", cmd: "copilot", args: "copilot" })).toBe(
-        true,
-      );
-      expect(isAgentProcess({ pid: 1, ppid: 0, tty: "??", cmd: "gemini", args: "gemini" })).toBe(
-        true,
-      );
-    });
-  });
-
-  describe("detectAgentType", () => {
-    it("detects direct agent processes", () => {
-      expect(detectAgentType({ pid: 1, ppid: 0, tty: "??", cmd: "claude", args: "claude" })).toBe(
-        "claude",
-      );
-      expect(
-        detectAgentType({ pid: 1, ppid: 0, tty: "??", cmd: "codex", args: "codex exec" }),
-      ).toBe("codex");
-    });
-
-    it("detects agents via wrappers", () => {
-      expect(
-        detectAgentType({
-          pid: 1,
-          ppid: 0,
-          tty: "??",
-          cmd: "node",
-          args: "node /usr/local/bin/claude",
-        }),
-      ).toBe("claude");
-      expect(
-        detectAgentType({ pid: 1, ppid: 0, tty: "??", cmd: "bun", args: "bun run codex exec -" }),
-      ).toBe("codex");
-    });
-
-    it("returns null for non-agents", () => {
-      expect(
-        detectAgentType({ pid: 1, ppid: 0, tty: "??", cmd: "node", args: "node server.js" }),
-      ).toBe(null);
-    });
-  });
-});

package/src/lib/process/snapshot.ts

@@ -1,257 +0,0 @@
-/**
- * Process snapshot utilities for parent chain walking and descendant search.
- * Used by windows module for nvim discovery and agent-audit correlation.
- */
-
-import { spawn } from "node:child_process";
-
-export interface ProcessInfo {
-  pid: number;
-  ppid: number;
-  tty: string;
-  cmd: string; // executable name
-  args: string; // full command line
-}
-
-/**
- * Execute a command and return stdout.
- */
-async function exec(command: string, args: string[]): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const proc = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
-    let stdout = "";
-    let stderr = "";
-
-    proc.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-    proc.stderr.on("data", (data) => {
-      stderr += data.toString();
-    });
-
-    proc.on("close", (code) => {
-      if (code === 0) {
-        resolve(stdout);
-      } else {
-        reject(new Error(`${command} failed: ${stderr || `exit code ${code}`}`));
-      }
-    });
-
-    proc.on("error", reject);
-  });
-}
-
-/**
- * Parse a single line of ps output.
- * Format: pid ppid tty comm args
- */
-function parsePsLine(line: string): ProcessInfo | null {
-  const trimmed = line.trim();
-  if (!trimmed) return null;
-
-  // Split on whitespace, but args can contain spaces
-  // Format: PID PPID TTY COMM ARGS...
-  const match = trimmed.match(/^\s*(\d+)\s+(\d+)\s+(\S+)\s+(\S+)\s+(.*)$/);
-  if (!match) {
-    // Try simpler format for lines where args might be empty
-    const simpleMatch = trimmed.match(/^\s*(\d+)\s+(\d+)\s+(\S+)\s+(\S+)\s*$/);
-    if (simpleMatch) {
-      return {
-        pid: parseInt(simpleMatch[1], 10),
-        ppid: parseInt(simpleMatch[2], 10),
-        tty: simpleMatch[3],
-        cmd: simpleMatch[4],
-        args: simpleMatch[4],
-      };
-    }
-    return null;
-  }
-
-  return {
-    pid: parseInt(match[1], 10),
-    ppid: parseInt(match[2], 10),
-    tty: match[3],
-    cmd: match[4],
-    args: match[5] || match[4],
-  };
-}
-
-/**
- * Get a snapshot of all running processes.
- * Uses `ps -axww -o pid=,ppid=,tty=,comm=,args=`
- */
-export async function getProcessSnapshot(): Promise<Map<number, ProcessInfo>> {
-  const snapshot = new Map<number, ProcessInfo>();
-
-  try {
-    // Use ps with custom format: pid, ppid, tty, comm (executable), args (full command)
-    const output = await exec("ps", ["-axww", "-o", "pid=,ppid=,tty=,comm=,args="]);
-
-    for (const line of output.split("\n")) {
-      const info = parsePsLine(line);
-      if (info) {
-        snapshot.set(info.pid, info);
-      }
-    }
-  } catch {
-    // Return empty snapshot on error
-  }
-
-  return snapshot;
-}
-
-/**
- * Build a parent→children map from process snapshot.
- */
-export function buildProcessTree(snapshot: Map<number, ProcessInfo>): Map<number, number[]> {
-  const tree = new Map<number, number[]>();
-
-  for (const [pid, info] of snapshot) {
-    const children = tree.get(info.ppid) || [];
-    children.push(pid);
-    tree.set(info.ppid, children);
-  }
-
-  return tree;
-}
-
-/**
- * Walk up the parent chain from a PID.
- * Returns array [pid, ppid, grandparent, ...] up to maxDepth.
- */
-export function walkParentChain(
-  pid: number,
-  snapshot: Map<number, ProcessInfo>,
-  maxDepth = 10,
-): number[] {
-  const chain: number[] = [];
-  let currentPid = pid;
-  let depth = 0;
-
-  while (depth < maxDepth) {
-    const info = snapshot.get(currentPid);
-    if (!info) break;
-
-    chain.push(currentPid);
-
-    // Stop at init (pid 1) or if parent is self
-    if (info.ppid === 0 || info.ppid === 1 || info.ppid === currentPid) {
-      break;
-    }
-
-    currentPid = info.ppid;
-    depth++;
-  }
-
-  return chain;
-}
-
-/**
- * Find all descendants of a PID matching an optional filter.
- */
-export function findDescendants(
-  pid: number,
-  tree: Map<number, number[]>,
-  snapshot: Map<number, ProcessInfo>,
-  filter?: (p: ProcessInfo) => boolean,
-): number[] {
-  const results: number[] = [];
-  const stack = [pid];
-  const visited = new Set<number>();
-
-  while (stack.length > 0) {
-    const current = stack.pop()!;
-    if (visited.has(current)) continue;
-    visited.add(current);
-
-    const info = snapshot.get(current);
-    if (info && current !== pid) {
-      if (!filter || filter(info)) {
-        results.push(current);
-      }
-    }
-
-    const children = tree.get(current) || [];
-    stack.push(...children);
-  }
-
-  return results;
-}
-
-/**
- * Find the deepest descendant matching a filter.
- * Useful for finding the most nested nvim instance.
- */
-export function findDeepestDescendant(
-  pid: number,
-  tree: Map<number, number[]>,
-  snapshot: Map<number, ProcessInfo>,
-  filter: (p: ProcessInfo) => boolean,
-): number | null {
-  let deepest: number | null = null;
-  let maxDepth = -1;
-
-  function dfs(current: number, depth: number): void {
-    const info = snapshot.get(current);
-    if (info && current !== pid && filter(info)) {
-      if (depth > maxDepth) {
-        maxDepth = depth;
-        deepest = current;
-      }
-    }
-
-    const children = tree.get(current) || [];
-    for (const child of children) {
-      dfs(child, depth + 1);
-    }
-  }
-
-  dfs(pid, 0);
-  return deepest;
-}
-
-/**
- * Check if a process is an nvim instance.
- */
-export function isNvimProcess(info: ProcessInfo): boolean {
-  const cmd = info.cmd.toLowerCase();
-  return cmd === "nvim" || cmd === "vim" || cmd === "vi";
-}
-
-/**
- * Check if a process is a coding agent.
- */
-export function isAgentProcess(info: ProcessInfo): boolean {
-  const cmd = info.cmd.toLowerCase();
-  return cmd === "claude" || cmd === "codex" || cmd === "copilot" || cmd === "gemini";
-}
-
-/**
- * Detect agent type from process info.
- * Handles wrapper processes (node, bun) running agent scripts.
- */
-export function detectAgentType(
-  info: ProcessInfo,
-): "claude" | "codex" | "copilot" | "gemini" | null {
-  const cmd = info.cmd.toLowerCase();
-
-  // Direct match
-  if (cmd === "claude") return "claude";
-  if (cmd === "codex") return "codex";
-  if (cmd === "copilot") return "copilot";
-  if (cmd === "gemini") return "gemini";
-
-  // Check args for wrapper processes
-  const wrappers = ["node", "bun", "npx", "pnpm", "npm"];
-  if (wrappers.includes(cmd)) {
-    const argsLower = info.args.toLowerCase();
-    // Order matters: some wrappers include model names (e.g. "claude-opus-4.6")
-    // even when the actual agent CLI is Copilot/Codex. Prefer the CLI name.
-    if (argsLower.includes("copilot")) return "copilot";
-    if (argsLower.includes("codex")) return "codex";
-    if (argsLower.includes("gemini")) return "gemini";
-    if (argsLower.includes("claude")) return "claude";
-  }
-
-  return null;
-}

package/src/lib/provider-auth.ts

@@ -1,258 +0,0 @@
-/**
- * Provider OAuth Authentication
- *
- * Runs AI provider OAuth flows (Anthropic, OpenAI, Google, GitHub Copilot)
- * using Pi's OAuth libraries, resolved dynamically from Pi's global install.
- *
- * Writes credentials to ~/.pi/agent/auth.json (Pi's auth storage format).
- * This means Pi starts with providers already configured — no /login needed.
- */
-
-import { existsSync, readFileSync, writeFileSync, mkdirSync, chmodSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { execSync } from "node:child_process";
-import { createInterface } from "node:readline";
-import { exec } from "node:child_process";
-
-const AUTH_JSON = join(homedir(), ".pi", "agent", "auth.json");
-
-// ============================================================================
-// Auth.json helpers
-// ============================================================================
-
-export interface ProviderCredential {
-  type: "oauth";
-  refresh: string;
-  access: string;
-  expires: number;
-  [key: string]: unknown;
-}
-
-type AuthData = Record<string, ProviderCredential>;
-
-export function readAuthJson(): AuthData {
-  try {
-    if (!existsSync(AUTH_JSON)) return {};
-    return JSON.parse(readFileSync(AUTH_JSON, "utf8")) as AuthData;
-  } catch {
-    return {};
-  }
-}
-
-function writeAuthJson(data: AuthData): void {
-  const dir = join(homedir(), ".pi", "agent");
-  mkdirSync(dir, { recursive: true, mode: 0o700 });
-  writeFileSync(AUTH_JSON, JSON.stringify(data, null, 2), "utf8");
-  chmodSync(AUTH_JSON, 0o600);
-}
-
-export function getConnectedProviders(): string[] {
-  const data = readAuthJson();
-  return Object.entries(data)
-    .filter(([, v]) => v?.type === "oauth" && v.access)
-    .map(([k]) => k);
-}
-
-export function hasAnyProvider(): boolean {
-  return getConnectedProviders().length > 0;
-}
-
-// ============================================================================
-// Provider info
-// ============================================================================
-
-export interface ProviderInfo {
-  id: string;
-  name: string;
-  description: string;
-}
-
-export const PROVIDERS: ProviderInfo[] = [
-  { id: "anthropic", name: "Anthropic", description: "Claude Pro/Max subscription" },
-  { id: "openai-codex", name: "OpenAI", description: "ChatGPT Plus/Pro subscription" },
-  { id: "google-gemini-cli", name: "Google Gemini", description: "Google Cloud Code Assist" },
-  { id: "github-copilot", name: "GitHub Copilot", description: "Copilot Individual/Business" },
-  { id: "google-antigravity", name: "Google Antigravity", description: "Gemini 3, Claude, GPT via Google Cloud" },
-];
-
-// ============================================================================
-// Dynamic import of Pi's OAuth module
-// ============================================================================
-
-interface OAuthModule {
-  getOAuthProvider: (id: string) => any;
-  getOAuthProviders: () => any[];
-}
-
-async function importPiOAuth(): Promise<OAuthModule | null> {
-  // Strategy: find @mariozechner/pi-ai from Pi's global install
-  const candidates: string[] = [];
-
-  // 1. Try resolving from pi binary location
-  try {
-    const piPath = execSync("which pi", { encoding: "utf8", timeout: 3000 }).trim();
-    if (piPath) {
-      const { realpathSync } = await import("node:fs");
-      const realPath = realpathSync(piPath);
-      // pi binary -> bin/pi.mjs -> package root -> node_modules/@mariozechner/pi-ai
-      const pkgRoot = join(realPath, "..", "..");
-      candidates.push(join(pkgRoot, "node_modules", "@mariozechner", "pi-ai", "dist", "index.js"));
-    }
-  } catch { /* not found */ }
-
-  // 2. Try common global paths
-  const nodeVersion = process.version.replace("v", "");
-  candidates.push(
-    join(homedir(), ".nvm", "versions", "node", `v${nodeVersion}`, "lib", "node_modules", "@mariozechner", "pi-coding-agent", "node_modules", "@mariozechner", "pi-ai", "dist", "index.js"),
-    join("/usr", "local", "lib", "node_modules", "@mariozechner", "pi-coding-agent", "node_modules", "@mariozechner", "pi-ai", "dist", "index.js"),
-  );
-
-  for (const candidate of candidates) {
-    if (existsSync(candidate)) {
-      try {
-        return await import(candidate) as OAuthModule;
-      } catch { /* import failed */ }
-    }
-  }
-
-  return null;
-}
-
-// ============================================================================
-// CLI OAuth flow helpers
-// ============================================================================
-
-function prompt(question: string): Promise<string> {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve) => {
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve(answer.trim());
-    });
-  });
-}
-
-function openBrowser(url: string): void {
-  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-  exec(`${cmd} "${url}"`);
-}
-
-// ============================================================================
-// Public API
-// ============================================================================
-
-/**
- * Run the provider selection + OAuth flow.
- * Returns the provider ID that was connected, or null if cancelled.
- */
-export async function connectProvider(
-  log: (msg: string) => void,
-): Promise<string | null> {
-  const piOAuth = await importPiOAuth();
-
-  if (!piOAuth) {
-    log("  ⚠ could not find Pi's OAuth module");
-    log("    connect providers in Pi instead: /login");
-    return null;
-  }
-
-  const connected = getConnectedProviders();
-
-  // Show provider list
-  log("");
-  log("  connect an AI provider");
-  log("  ─────────────────────");
-  log("");
-
-  const providers = piOAuth.getOAuthProviders();
-  for (let i = 0; i < providers.length; i++) {
-    const p = providers[i];
-    const isConnected = connected.includes(p.id);
-    const status = isConnected ? " ✓ connected" : "";
-    log(`  ${i + 1}. ${p.name}${status}`);
-  }
-  log(`  ${providers.length + 1}. skip for now`);
-  log("");
-
-  const choice = await prompt("  select (1-" + (providers.length + 1) + "): ");
-  const idx = parseInt(choice, 10) - 1;
-
-  if (isNaN(idx) || idx < 0 || idx >= providers.length) {
-    return null; // skip
-  }
-
-  const provider = providers[idx];
-  log("");
-  log(`  connecting ${provider.name}...`);
-  log("");
-
-  try {
-    const credentials = await provider.login({
-      onAuth: (info: { url: string; instructions?: string }) => {
-        log(`  open this URL to authenticate:`);
-        log(`  ${info.url}`);
-        if (info.instructions) {
-          log(`  ${info.instructions}`);
-        }
-        log("");
-        openBrowser(info.url);
-      },
-      onPrompt: async (promptInfo: { message: string; placeholder?: string; allowEmpty?: boolean }) => {
-        const answer = await prompt(`  ${promptInfo.message} `);
-        if (!answer && !promptInfo.allowEmpty) {
-          throw new Error("Input required");
-        }
-        return answer;
-      },
-      onProgress: (message: string) => {
-        log(`  ${message}`);
-      },
-      onManualCodeInput: async () => {
-        return await prompt("  paste the code or URL: ");
-      },
-    });
-
-    // Write to auth.json
-    const data = readAuthJson();
-    data[provider.id] = { type: "oauth", ...credentials };
-    writeAuthJson(data);
-
-    log(`  ✓ ${provider.name} connected`);
-    return provider.id;
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    if (msg.includes("cancelled")) {
-      log("  cancelled");
-    } else {
-      log(`  ✗ connection failed: ${msg}`);
-    }
-    return null;
-  }
-}
-
-/**
- * Check providers and optionally prompt for connection.
- * Used in the setup wizard.
- */
-export async function ensureProviderConnected(
-  log: (msg: string) => void,
-): Promise<boolean> {
-  const connected = getConnectedProviders();
-
-  if (connected.length > 0) {
-    const names = connected.map((id) => {
-      const info = PROVIDERS.find((p) => p.id === id);
-      return info?.name ?? id;
-    });
-    log(`  [4/4] providers: ${names.join(", ")} ✓`);
-    return true;
-  }
-
-  log("  [4/4] connect an AI provider");
-  log("         (uses your existing subscription — no API keys needed)");
-  log("");
-
-  const result = await connectProvider(log);
-  return result !== null;
-}