@creativeintelligence/abbie 0.1.0

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

@@ -0,0 +1,139 @@
+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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,190 @@
+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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,96 @@
+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;
+  }
+}