@creativeintelligence/abbie 0.1.4 → 0.1.5

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

@@ -1,139 +0,0 @@
-import { Flags } from "@oclif/core";
-import {
-  type AgentPlatform,
-  discoverAllHooks,
-  getConfigPaths,
-  HOOK_PLATFORMS,
-  type HookRegistry,
-} from "../../../lib/hooks/index.js";
-import { BaseCommand } from "../../base-command.js";
-
-interface ListOutput {
-  registry: HookRegistry;
-  configPaths: Record<AgentPlatform, string>;
-}
-
-export default class HooksListCommand extends BaseCommand {
-  static override summary = "List configured hooks across all agent platforms";
-  static override description = `Discovers and displays hooks from:
-- Claude Code (~/.claude/settings.json)
-- Codex (~/.codex/config.toml)
-- Copilot (.github/hooks/hooks.json per-repo)`;
-
-  static override examples = [
-    "$ abbie hooks list",
-    "$ abbie hooks list --platform claude",
-    "$ abbie hooks list --json --quiet",
-  ];
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    platform: Flags.string({
-      char: "p",
-      description: `Filter by platform (${HOOK_PLATFORMS.join(", ")})`,
-      options: [...HOOK_PLATFORMS],
-    }),
-  };
-
-  async execute(): Promise<ListOutput> {
-    const { flags } = await this.parse(HooksListCommand);
-    this.parsedFlags = flags;
-
-    const registry = await discoverAllHooks();
-    const configPaths = getConfigPaths();
-
-    // Filter by platform if specified
-    if (flags.platform) {
-      const platform = flags.platform as AgentPlatform;
-      // Build filtered platforms object dynamically
-      const filteredPlatforms = Object.fromEntries(
-        HOOK_PLATFORMS.map((p) => [p, p === platform ? registry.platforms[p] : []]),
-      ) as Record<AgentPlatform, (typeof registry.platforms)[AgentPlatform]>;
-
-      const filtered: HookRegistry = {
-        platforms: filteredPlatforms,
-        totalCount: registry.platforms[platform].length,
-        discoveredAt: registry.discoveredAt,
-        errors: registry.errors.filter((e) => e.platform === platform),
-      };
-
-      if (!this.jsonEnabled?.()) {
-        this.renderTextOutput(filtered, configPaths, platform);
-      }
-
-      return { registry: filtered, configPaths };
-    }
-
-    // NDJSON: flatten all hooks, one per line
-    if (this.ndjsonEnabled()) {
-      const items: Array<{
-        platform: string;
-        event: string;
-        name: string;
-        path: string;
-        timeout?: number;
-      }> = [];
-      for (const platform of HOOK_PLATFORMS) {
-        for (const hook of registry.platforms[platform]) {
-          items.push({
-            platform,
-            event: hook.event,
-            name: hook.name,
-            path: hook.path,
-            timeout: hook.timeout,
-          });
-        }
-      }
-      this.outputNdjson(items);
-      return { registry, configPaths };
-    }
-
-    // Full output
-    if (!this.jsonEnabled?.()) {
-      this.renderTextOutput(registry, configPaths);
-    }
-
-    return { registry, configPaths };
-  }
-
-  private renderTextOutput(
-    registry: HookRegistry,
-    configPaths: Record<AgentPlatform, string>,
-    filterPlatform?: AgentPlatform,
-  ): void {
-    const platforms: AgentPlatform[] = filterPlatform ? [filterPlatform] : HOOK_PLATFORMS;
-
-    for (const platform of platforms) {
-      const hooks = registry.platforms[platform];
-      const configPath = configPaths[platform];
-
-      this.log(`\n=== ${platform} ===`);
-      this.log(`config: ${configPath}`);
-
-      if (hooks.length === 0) {
-        this.log("  (no hooks configured)");
-        continue;
-      }
-
-      for (const hook of hooks) {
-        this.log(`  ${hook.event}: ${hook.name}`);
-        this.log(`    path: ${hook.path}`);
-        if (hook.timeout) {
-          this.log(`    timeout: ${hook.timeout}s`);
-        }
-      }
-    }
-
-    // Summary
-    this.log("");
-    this.logInfo(`total: ${registry.totalCount} hooks`);
-
-    // Errors
-    if (registry.errors.length > 0) {
-      this.log("\nerrors:");
-      for (const err of registry.errors) {
-        this.log(`  ${err.platform}: ${err.message}`);
-      }
-    }
-  }
-}

package/src/cli/commands/hooks/lock.ts

@@ -1,47 +0,0 @@
-import { createLockfile } from "../../../lib/hooks/index.js";
-import { BaseCommand } from "../../base-command.js";
-
-interface LockOutput {
-  path: string;
-  pid: number;
-}
-
-export default class HooksLockCommand extends BaseCommand {
-  static override summary = "Create a hook context lockfile";
-  static override description = `Creates a lockfile to signal that hooks should be skipped.
-
-Use before spawning agents that might trigger their own hooks:
-  LOCK=$(abbie hook lock)
-  trap "abbie hook unlock $LOCK" EXIT
-  copilot ...
-
-Lockfiles auto-expire after 2 minutes (cleaned by guard command).`;
-
-  static override examples = [
-    "# Create lockfile",
-    "LOCK=$(abbie hook lock)",
-    "",
-    "# With cleanup trap",
-    "LOCK=$(abbie hook lock)",
-    'trap "abbie hook unlock $LOCK" EXIT',
-    'copilot -p "summarize"',
-  ];
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-  };
-
-  async execute(): Promise<LockOutput> {
-    const path = createLockfile();
-
-    if (!this.jsonEnabled?.()) {
-      // Just output the path for shell capture
-      this.log(path);
-    }
-
-    return {
-      path,
-      pid: process.pid,
-    };
-  }
-}

package/src/cli/commands/hooks/status.ts

@@ -1,56 +0,0 @@
-import { getAllLockfiles, type LockfileInfo } from "../../../lib/hooks/index.js";
-import { BaseCommand } from "../../base-command.js";
-
-interface StatusOutput {
-  lockfiles: LockfileInfo[];
-  active: number;
-  stale: number;
-  envVar: boolean;
-}
-
-export default class HooksStatusCommand extends BaseCommand {
-  static override summary = "Show hook context status and lockfiles";
-  static override description = `Lists all lockfiles (active and stale) for debugging hook issues.
-
-Active lockfiles are <2 minutes old and will cause 'abbie hook guard' to return 0.
-Stale lockfiles are >2 minutes old and will be cleaned up by 'abbie hook guard'.`;
-
-  static override examples = ["$ abbie hook status", "$ abbie hook status --json --quiet"];
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-  };
-
-  async execute(): Promise<StatusOutput> {
-    const lockfiles = getAllLockfiles();
-    const active = lockfiles.filter((l) => !l.stale);
-    const stale = lockfiles.filter((l) => l.stale);
-    const envVar = process.env.AGENTS_HOOK_CONTEXT === "true";
-
-    if (!this.jsonEnabled?.()) {
-      this.log(`AGENTS_HOOK_CONTEXT env: ${envVar ? "true" : "not set"}`);
-      this.log(`active lockfiles: ${active.length}`);
-      this.log(`stale lockfiles: ${stale.length}`);
-
-      if (lockfiles.length > 0) {
-        this.log("");
-        for (const l of lockfiles) {
-          const status = l.stale ? "(stale)" : "(active)";
-          this.log(`  ${l.path} - ${l.age}s old ${status}`);
-        }
-      }
-
-      if (active.length > 0 || envVar) {
-        this.log("");
-        this.logInfo("hooks will be skipped (guard returns 0)");
-      }
-    }
-
-    return {
-      lockfiles,
-      active: active.length,
-      stale: stale.length,
-      envVar,
-    };
-  }
-}

package/src/cli/commands/hooks/test.ts

@@ -1,190 +0,0 @@
-import { Args, Flags } from "@oclif/core";
-import {
-  discoverAllHooks,
-  generateMockPayload,
-  type Hook,
-  type HookTestResult,
-  runHook,
-} from "../../../lib/hooks/index.js";
-import { BaseCommand } from "../../base-command.js";
-
-interface TestOutput {
-  results: HookTestResult[];
-  summary: {
-    total: number;
-    passed: number;
-    failed: number;
-  };
-}
-
-export default class HooksTestCommand extends BaseCommand {
-  static override summary = "Test hooks by executing them with mock payloads";
-  static override description = `Runs hooks with mock payloads to verify they work correctly.
-
-Each platform receives appropriately formatted test data:
-- Claude Code: JSON via stdin (Stop event format)
-- Codex: JSON as CLI argument (turn-complete format)
-- OpenCode: JSON via stdin to JS plugin
-
-Test mode sets HOOK_TEST_MODE=true in the environment.`;
-
-  static override examples = [
-    "$ abbie hooks test                              # Test all hooks",
-    "$ abbie hooks test --platform claude            # Test only Claude hooks",
-    "$ abbie hooks test notify-stop.sh               # Test specific hook by name",
-    "$ abbie hooks test --json --quiet               # JSON output for agents",
-  ];
-
-  static override args = {
-    hook: Args.string({
-      description: "Hook name or ID to test (optional, tests all if omitted)",
-      required: false,
-    }),
-  };
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    platform: Flags.string({
-      char: "p",
-      description: "Filter by platform (claude, codex, copilot)",
-      options: ["claude", "codex", "copilot"],
-    }),
-    "show-payload": Flags.boolean({
-      description: "Show the mock payload that will be sent",
-      default: false,
-    }),
-    "dry-run": Flags.boolean({
-      description: "Show what would be tested without executing",
-      default: false,
-    }),
-  };
-
-  async execute(): Promise<TestOutput> {
-    const { args, flags } = await this.parse(HooksTestCommand);
-    this.parsedFlags = flags;
-
-    const registry = await discoverAllHooks();
-
-    // Collect all hooks
-    let hooksToTest: Hook[] = [];
-
-    if (flags.platform) {
-      hooksToTest = registry.platforms[flags.platform as keyof typeof registry.platforms];
-    } else {
-      hooksToTest = [
-        ...registry.platforms.claude,
-        ...registry.platforms.codex,
-        ...registry.platforms.copilot,
-      ];
-    }
-
-    // Filter by name if specified
-    if (args.hook) {
-      const searchTerm = args.hook.toLowerCase();
-      hooksToTest = hooksToTest.filter(
-        (h) =>
-          h.name.toLowerCase().includes(searchTerm) ||
-          h.id.toLowerCase().includes(searchTerm) ||
-          h.path.toLowerCase().includes(searchTerm),
-      );
-
-      if (hooksToTest.length === 0) {
-        this.logInfo(`no hooks matching "${args.hook}" found`);
-        return {
-          results: [],
-          summary: { total: 0, passed: 0, failed: 0 },
-        };
-      }
-    }
-
-    if (hooksToTest.length === 0) {
-      this.logInfo("no hooks found to test");
-      return {
-        results: [],
-        summary: { total: 0, passed: 0, failed: 0 },
-      };
-    }
-
-    // Show what will be tested
-    if (!this.jsonEnabled?.()) {
-      this.log(`\ntesting ${hooksToTest.length} hook(s)...\n`);
-    }
-
-    // Show payload if requested
-    if (flags["show-payload"] && !this.jsonEnabled?.()) {
-      for (const hook of hooksToTest) {
-        const payload = generateMockPayload(hook);
-        this.log(`=== ${hook.platform}:${hook.name} payload ===`);
-        this.log(JSON.stringify(payload, null, 2));
-        this.log("");
-      }
-    }
-
-    // Dry run - just show what would be tested
-    if (flags["dry-run"]) {
-      if (!this.jsonEnabled?.()) {
-        for (const hook of hooksToTest) {
-          this.log(`[dry-run] ${hook.platform}:${hook.name}`);
-          this.log(`  path: ${hook.path}`);
-          this.log(`  event: ${hook.event}`);
-        }
-      }
-      return {
-        results: hooksToTest.map((hook) => ({
-          hook,
-          success: true,
-          durationMs: 0,
-        })),
-        summary: {
-          total: hooksToTest.length,
-          passed: hooksToTest.length,
-          failed: 0,
-        },
-      };
-    }
-
-    // Execute tests
-    const results: HookTestResult[] = [];
-
-    for (const hook of hooksToTest) {
-      if (!this.jsonEnabled?.()) {
-        this.log(`testing ${hook.platform}:${hook.name}...`);
-      }
-
-      const result = await runHook(hook);
-      results.push(result);
-
-      if (!this.jsonEnabled?.()) {
-        if (result.success) {
-          this.log(`  ✓ passed (${result.durationMs}ms)`);
-        } else {
-          this.log(`  ✗ failed (${result.durationMs}ms)`);
-          if (result.error) {
-            this.log(`    error: ${result.error}`);
-          }
-          if (result.stderr) {
-            this.log(`    stderr: ${result.stderr.slice(0, 200)}`);
-          }
-        }
-      }
-    }
-
-    // Summary
-    const passed = results.filter((r) => r.success).length;
-    const failed = results.filter((r) => !r.success).length;
-
-    if (!this.jsonEnabled?.()) {
-      this.log("");
-      this.logInfo(`results: ${passed} passed, ${failed} failed`);
-    }
-
-    return {
-      results,
-      summary: {
-        total: results.length,
-        passed,
-        failed,
-      },
-    };
-  }
-}

package/src/cli/commands/hooks/unlock.ts

@@ -1,56 +0,0 @@
-import { Args } from "@oclif/core";
-import { removeLockfile } from "../../../lib/hooks/index.js";
-import { BaseCommand } from "../../base-command.js";
-
-interface UnlockOutput {
-  path: string;
-  removed: boolean;
-}
-
-export default class HooksUnlockCommand extends BaseCommand {
-  static override summary = "Remove a hook context lockfile";
-  static override description = `Removes a lockfile created by 'abbie hook lock'.
-
-Usually called via trap for cleanup:
-  LOCK=$(abbie hook lock)
-  trap "abbie hook unlock $LOCK" EXIT`;
-
-  static override examples = [
-    "# Remove specific lockfile",
-    "abbie hook unlock /tmp/.abbie-hook-context-12345-abc",
-    "",
-    "# In trap",
-    'trap "abbie hook unlock $LOCK" EXIT',
-  ];
-
-  static override args = {
-    path: Args.string({
-      description: "Path to lockfile (from abbie hook lock)",
-      required: true,
-    }),
-  };
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-  };
-
-  async execute(): Promise<UnlockOutput> {
-    const { args } = await this.parse(HooksUnlockCommand);
-    const { path } = args;
-
-    const removed = removeLockfile(path);
-
-    if (!this.jsonEnabled?.()) {
-      if (removed) {
-        this.log(`removed: ${path}`);
-      } else {
-        this.log(`not found: ${path}`);
-      }
-    }
-
-    return {
-      path,
-      removed,
-    };
-  }
-}

package/src/cli/commands/list.e2e.test.ts

@@ -1,58 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-/**
- * E2E tests for abbie list command.
- * Tests the actual CLI binary using Bun.spawn().
- */
-
-describe("abbie list (E2E)", () => {
-  async function runCLI(
-    args: string[],
-  ): Promise<{ stdout: string; stderr: string; exitCode: number | null }> {
-    const proc = Bun.spawn(["bun", "bin/run.js", "list", ...args], {
-      cwd: `${import.meta.dir}/../../..`,
-      stdout: "pipe",
-      stderr: "pipe",
-    });
-
-    const stdout = await new Response(proc.stdout).text();
-    const stderr = await new Response(proc.stderr).text();
-    await proc.exited;
-
-    return { stdout, stderr, exitCode: proc.exitCode };
-  }
-
-  it("lists all sessions successfully", async () => {
-    const { stdout, exitCode } = await runCLI([]);
-    expect(exitCode).toBe(0);
-    // Should list sessions (may be empty if no sessions exist)
-    expect(stdout.length).toBeGreaterThan(0);
-  });
-
-  it("filters by project", async () => {
-    const { stdout, exitCode } = await runCLI(["--project", "arbor"]);
-    expect(exitCode).toBe(0);
-    if (stdout.includes("arbor:")) {
-      expect(stdout).toContain("arbor:");
-    }
-  });
-
-  it("outputs JSON format", async () => {
-    const { stdout, exitCode } = await runCLI(["--json"]);
-    expect(exitCode).toBe(0);
-    const data = JSON.parse(stdout);
-    expect(typeof data).toBe("object");
-  });
-
-  it("suppresses info with --quiet", async () => {
-    const { stdout, exitCode } = await runCLI(["--quiet"]);
-    expect(exitCode).toBe(0);
-    expect(stdout).not.toContain("Total:");
-  });
-
-  it("handles non-existent project gracefully", async () => {
-    const { stderr, exitCode } = await runCLI(["--project", "nonexistent-project-12345"]);
-    expect(exitCode).toBe(0); // Not an error, just no results
-    expect(stderr).toContain("No sessions found");
-  });
-});

package/src/cli/commands/list.ts

@@ -1,96 +0,0 @@
-import { existsSync, readdirSync, statSync } from "node:fs";
-import { join } from "node:path";
-import { Flags } from "@oclif/core";
-import { BaseCommand } from "../base-command.js";
-
-type SessionList = Record<string, string[]>;
-
-export default class ListCommand extends BaseCommand {
-  static override summary = "List planning sessions";
-  static override description =
-    "Lists all planning sessions organized by project in ~/.abbie/plans/";
-
-  static override examples = [
-    "$ abbie list",
-    "$ abbie list --project arbor",
-    "$ abbie list --json",
-  ];
-
-  static override flags = {
-    ...BaseCommand.baseFlags,
-    project: Flags.string({
-      char: "p",
-      description: "Filter by project name",
-    }),
-  };
-
-  async execute(): Promise<SessionList> {
-    const { flags } = await this.parse(ListCommand);
-    this.parsedFlags = flags;
-
-    const plansDir = this.getPlansDir();
-
-    if (!existsSync(plansDir)) {
-      this.logWarn(`Plans directory not found: ${plansDir}`);
-      return {};
-    }
-
-    const projects = readdirSync(plansDir).filter((name) => {
-      const path = join(plansDir, name);
-      return statSync(path).isDirectory();
-    });
-
-    const filtered = flags.project ? projects.filter((p) => p === flags.project) : projects;
-
-    if (filtered.length === 0 && flags.project) {
-      this.logWarn(`No sessions found for project: ${flags.project}`);
-      return {};
-    }
-
-    const result = this.gatherSessions(plansDir, filtered);
-
-    // NDJSON: flatten to {project, session} per line
-    if (this.ndjsonEnabled()) {
-      const items: Array<{ project: string; session: string }> = [];
-      for (const [project, sessions] of Object.entries(result)) {
-        for (const session of sessions) {
-          items.push({ project, session });
-        }
-      }
-      this.outputNdjson(items);
-      return result;
-    }
-
-    // Output human-readable format if not JSON mode
-    if (!this.jsonEnabled?.()) {
-      for (const [project, sessions] of Object.entries(result)) {
-        this.log(`${project}:`);
-        for (const session of sessions) {
-          this.log(`  ${session}`);
-        }
-      }
-
-      const totalSessions = Object.values(result).flat().length;
-      this.logInfo(`\nTotal: ${totalSessions} sessions across ${filtered.length} projects`);
-    }
-
-    // Always return data for programmatic use
-    return result;
-  }
-
-  private gatherSessions(plansDir: string, projects: string[]): SessionList {
-    const result: SessionList = {};
-
-    for (const project of projects) {
-      const projectDir = join(plansDir, project);
-      const sessions = readdirSync(projectDir)
-        .filter((name) => statSync(join(projectDir, name)).isDirectory())
-        .sort()
-        .reverse(); // Most recent first
-
-      result[project] = sessions;
-    }
-
-    return result;
-  }
-}