@creativeintelligence/abbie 0.1.0

package/dist/cli/commands/gc.js

@@ -0,0 +1,211 @@
+import { existsSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { Flags } from "@oclif/core";
+import { BaseCommand } from "../base-command.js";
+export default class GcCommand extends BaseCommand {
+    static summary = "Clean up local staging data";
+    static description = `Delete stale local staging data older than N days (default 7).
+
+Cleans:
+- ~/.abbie/active-sessions/*.json (completed/failed/stopped sessions)
+- ~/.abbie/session-artifacts/*.json
+- ~/.abbie/prompts/* (prompt files)
+- ~/.abbie/events/*/events.jsonl (compact to retention window)
+- ~/.abbie/sessions/* (heartbeat files)`;
+    static examples = [
+        "$ abbie gc",
+        "$ abbie gc --dry-run",
+        "$ abbie gc --days 3",
+        "$ abbie gc --json --quiet",
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        "dry-run": Flags.boolean({
+            description: "Preview what would be deleted without actually deleting",
+            default: false,
+        }),
+        days: Flags.integer({
+            char: "d",
+            description: "Delete files older than N days",
+            default: 7,
+        }),
+    };
+    async execute() {
+        const { flags } = await this.parse(GcCommand);
+        this.parsedFlags = flags;
+        const dryRun = flags["dry-run"];
+        const maxAgeMs = flags.days * 24 * 60 * 60 * 1000;
+        const cutoff = Date.now() - maxAgeMs;
+        const abbieDir = join(homedir(), ".abbie");
+        const details = [];
+        let deleted = 0;
+        let freedBytes = 0;
+        // 1. active-sessions/*.json — only terminal-status sessions
+        const activeSessionsDir = join(abbieDir, "active-sessions");
+        if (existsSync(activeSessionsDir)) {
+            for (const file of readdirSync(activeSessionsDir)) {
+                if (!file.endsWith(".json"))
+                    continue;
+                const filePath = join(activeSessionsDir, file);
+                const stat = statSync(filePath);
+                if (stat.mtimeMs >= cutoff)
+                    continue;
+                // Only delete sessions in terminal status
+                try {
+                    const content = JSON.parse(readFileSync(filePath, "utf-8"));
+                    const status = content.status;
+                    if (status === "running" || status === "spawned")
+                        continue;
+                }
+                catch {
+                    continue;
+                }
+                details.push({
+                    path: filePath,
+                    type: "active-session",
+                    ageMs: Date.now() - stat.mtimeMs,
+                    sizeBytes: stat.size,
+                    deleted: !dryRun,
+                });
+                if (!dryRun) {
+                    unlinkSync(filePath);
+                }
+                deleted++;
+                freedBytes += stat.size;
+            }
+        }
+        // 2. session-artifacts/*.json
+        const artifactsDir = join(abbieDir, "session-artifacts");
+        if (existsSync(artifactsDir)) {
+            for (const file of readdirSync(artifactsDir)) {
+                if (!file.endsWith(".json"))
+                    continue;
+                const filePath = join(artifactsDir, file);
+                const stat = statSync(filePath);
+                if (stat.mtimeMs >= cutoff)
+                    continue;
+                details.push({
+                    path: filePath,
+                    type: "session-artifact",
+                    ageMs: Date.now() - stat.mtimeMs,
+                    sizeBytes: stat.size,
+                    deleted: !dryRun,
+                });
+                if (!dryRun) {
+                    unlinkSync(filePath);
+                }
+                deleted++;
+                freedBytes += stat.size;
+            }
+        }
+        // 3. prompts/* (prompt files for sessions)
+        const promptsDir = join(abbieDir, "prompts");
+        if (existsSync(promptsDir)) {
+            for (const file of readdirSync(promptsDir)) {
+                const filePath = join(promptsDir, file);
+                const stat = statSync(filePath);
+                if (!stat.isFile() || stat.mtimeMs >= cutoff)
+                    continue;
+                details.push({
+                    path: filePath,
+                    type: "prompt",
+                    ageMs: Date.now() - stat.mtimeMs,
+                    sizeBytes: stat.size,
+                    deleted: !dryRun,
+                });
+                if (!dryRun) {
+                    unlinkSync(filePath);
+                }
+                deleted++;
+                freedBytes += stat.size;
+            }
+        }
+        // 4. events/*/events.jsonl — compact to retention window
+        const eventsDir = join(abbieDir, "events");
+        if (existsSync(eventsDir)) {
+            for (const project of readdirSync(eventsDir)) {
+                const projectDir = join(eventsDir, project);
+                if (!statSync(projectDir).isDirectory())
+                    continue;
+                const eventsFile = join(projectDir, "events.jsonl");
+                if (!existsSync(eventsFile))
+                    continue;
+                const stat = statSync(eventsFile);
+                const content = readFileSync(eventsFile, "utf-8");
+                const lines = content.split("\n").filter(Boolean);
+                const cutoffISO = new Date(cutoff).toISOString();
+                const kept = lines.filter((line) => {
+                    try {
+                        const event = JSON.parse(line);
+                        return event.timestamp >= cutoffISO;
+                    }
+                    catch {
+                        return false;
+                    }
+                });
+                const removed = lines.length - kept.length;
+                if (removed === 0)
+                    continue;
+                const originalSize = stat.size;
+                const newContent = kept.length > 0 ? `${kept.join("\n")}\n` : "";
+                const newSize = Buffer.byteLength(newContent);
+                const savedBytes = originalSize - newSize;
+                details.push({
+                    path: eventsFile,
+                    type: "events-compact",
+                    ageMs: 0, // compaction, not age-based
+                    sizeBytes: savedBytes,
+                    deleted: !dryRun,
+                });
+                if (!dryRun) {
+                    writeFileSync(eventsFile, newContent);
+                }
+                deleted += removed;
+                freedBytes += savedBytes;
+            }
+        }
+        // 5. sessions/* (heartbeat files)
+        const sessionsDir = join(abbieDir, "sessions");
+        if (existsSync(sessionsDir)) {
+            for (const file of readdirSync(sessionsDir)) {
+                const filePath = join(sessionsDir, file);
+                const stat = statSync(filePath);
+                if (!stat.isFile() || stat.mtimeMs >= cutoff)
+                    continue;
+                details.push({
+                    path: filePath,
+                    type: "heartbeat",
+                    ageMs: Date.now() - stat.mtimeMs,
+                    sizeBytes: stat.size,
+                    deleted: !dryRun,
+                });
+                if (!dryRun) {
+                    unlinkSync(filePath);
+                }
+                deleted++;
+                freedBytes += stat.size;
+            }
+        }
+        const result = {
+            dryRun,
+            deleted,
+            freedBytes,
+            details,
+        };
+        if (!this.jsonEnabled?.()) {
+            const action = dryRun ? "Would delete" : "Deleted";
+            const freedKB = (freedBytes / 1024).toFixed(1);
+            if (deleted === 0) {
+                this.log(`No stale files found (threshold: ${flags.days} days)`);
+            }
+            else {
+                this.log(`${action} ${deleted} items (${freedKB} KB freed)`);
+                if (dryRun) {
+                    this.log("\nRun without --dry-run to actually delete.");
+                }
+            }
+        }
+        return result;
+    }
+}

package/dist/cli/commands/history/index.d.ts

@@ -0,0 +1,49 @@
+import { type Doc } from "@abbie/sdk/convex";
+import { BaseCommand } from "../../base-command.js";
+type HistoryEvent = Doc<"reports">;
+interface HistoryResult {
+    success: boolean;
+    events: HistoryEvent[];
+    count: number;
+    filters: {
+        last?: number;
+        since?: string;
+        sessionId?: string;
+        traceId?: string;
+        agent?: string;
+    };
+}
+export default class HistoryCommand extends BaseCommand {
+    static summary: string;
+    static description: string;
+    static examples: string[];
+    static flags: {
+        last: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        since: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "trace-id": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        session: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        agent: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        action: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "min-confidence": import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        pattern: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        count: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        format: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "json-errors": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        ndjson: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    execute(): Promise<HistoryResult>;
+    /**
+     * Client-side post-filter for cross-filter scenarios.
+     *
+     * The server query picks the best single index (e.g., by_agent, by_timestamp),
+     * but can't intersect multiple dimensions in one index scan. This pass applies
+     * all remaining filters unconditionally — redundant filters are no-ops.
+     * Pattern matching also uses regex here vs. substring on the server.
+     */
+    private postFilter;
+    private buildFilters;
+    private renderTextOutput;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/commands/history/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/history/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,KAAK,GAAG,EAAiB,MAAM,mBAAmB,CAAC;AAEjE,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,KAAK,YAAY,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC;AAEnC,UAAU,aAAa;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE;QACP,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC;CACH;AAwBD,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,WAAW;IACrD,OAAgB,OAAO,SAA+B;IACtD,OAAgB,WAAW,SAIwB;IAEnD,OAAgB,QAAQ,WAQtB;IAEF,OAAgB,KAAK;;;;;;;;;;;;;;MAsCnB;IAEI,OAAO,IAAI,OAAO,CAAC,aAAa,CAAC;IA4DvC;;;;;;;OAOG;IACH,OAAO,CAAC,UAAU;IA8ClB,OAAO,CAAC,YAAY;IAWpB,OAAO,CAAC,gBAAgB;CAgCzB"}

package/dist/cli/commands/history/index.js

@@ -0,0 +1,210 @@
+import { api, getHttpClient } from "@abbie/sdk/convex";
+import { Flags } from "@oclif/core";
+import { BaseCommand } from "../../base-command.js";
+/**
+ * Parse duration strings like "1h", "30m", "2d", "24h" into milliseconds.
+ */
+function parseDuration(input) {
+    const match = input.match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d|w)$/);
+    if (!match)
+        throw new Error(`Invalid duration: "${input}" (expected e.g. 1h, 30m, 2d)`);
+    const value = parseFloat(match[1]);
+    const unit = match[2];
+    const multipliers = {
+        ms: 1,
+        s: 1000,
+        m: 60_000,
+        h: 3_600_000,
+        d: 86_400_000,
+        w: 604_800_000,
+    };
+    return value * multipliers[unit];
+}
+export default class HistoryCommand extends BaseCommand {
+    static summary = "Query agent event history";
+    static description = `Query event history with a unified interface.
+
+Reads lifecycle events from Convex reports table.
+
+SYMMETRY: abbie report writes → abbie history reads`;
+    static examples = [
+        "$ abbie history                         # recent events (default: 10)",
+        "$ abbie history --last 20               # last 20 events",
+        "$ abbie history --since 1h              # events from last hour",
+        "$ abbie history --since 24h --agent claude",
+        "$ abbie history --trace-id tr_abc123    # events in a trace",
+        "$ abbie history --session sess_xyz      # events in a session",
+        "$ abbie history --json                  # machine output",
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        last: Flags.integer({
+            char: "n",
+            description: "Number of recent events to show",
+            default: 10,
+        }),
+        since: Flags.string({
+            char: "s",
+            description: "Time filter (e.g., 1h, 30m, 2d, 24h)",
+        }),
+        "trace-id": Flags.string({
+            char: "t",
+            description: "Filter by trace ID",
+        }),
+        session: Flags.string({
+            description: "Filter by session ID",
+        }),
+        agent: Flags.string({
+            char: "a",
+            description: "Filter by agent (claude, codex, copilot, etc.)",
+        }),
+        action: Flags.string({
+            description: "Filter by action (started, completed, blocked, escalated)",
+        }),
+        "min-confidence": Flags.integer({
+            description: "Minimum confidence score",
+            min: 1,
+            max: 10,
+        }),
+        pattern: Flags.string({
+            char: "p",
+            description: "Regex pattern to match task/summary",
+        }),
+        count: Flags.boolean({
+            description: "Only output count of matching events",
+            default: false,
+        }),
+    };
+    async execute() {
+        const { flags } = await this.parse(HistoryCommand);
+        this.parsedFlags = flags;
+        const hasSieveFilters = flags.agent || flags.action || flags["min-confidence"];
+        try {
+            const client = getHttpClient();
+            let sinceMs;
+            if (flags.since) {
+                sinceMs = Date.now() - parseDuration(flags.since);
+            }
+            let events;
+            if (flags["trace-id"]) {
+                events = await client.query(api.reports.getTrace, {
+                    traceId: flags["trace-id"],
+                    limit: flags.last,
+                });
+            }
+            else if (hasSieveFilters) {
+                events = await client.query(api.reports.sieve, {
+                    agent: flags.agent,
+                    action: flags.action,
+                    minConfidence: flags["min-confidence"],
+                    since: sinceMs,
+                    sessionId: flags.session,
+                    limit: flags.last,
+                });
+            }
+            else {
+                events = await client.query(api.reports.replay, {
+                    limit: flags.last,
+                    since: sinceMs,
+                    sessionId: flags.session,
+                });
+            }
+            events = this.postFilter(events, flags, sinceMs);
+            if (flags.last) {
+                events = events.slice(0, flags.last);
+            }
+            const result = {
+                success: true,
+                events,
+                count: events.length,
+                filters: this.buildFilters(flags),
+            };
+            if (!this.jsonEnabled?.()) {
+                this.renderTextOutput(result, flags);
+            }
+            return result;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return this.error(`history query failed: ${message}`, { exit: 1 });
+        }
+    }
+    /**
+     * Client-side post-filter for cross-filter scenarios.
+     *
+     * The server query picks the best single index (e.g., by_agent, by_timestamp),
+     * but can't intersect multiple dimensions in one index scan. This pass applies
+     * all remaining filters unconditionally — redundant filters are no-ops.
+     * Pattern matching also uses regex here vs. substring on the server.
+     */
+    postFilter(events, flags, sinceMs) {
+        let filtered = events;
+        if (sinceMs !== undefined) {
+            filtered = filtered.filter((e) => e.timestamp >= sinceMs);
+        }
+        if (flags["trace-id"]) {
+            filtered = filtered.filter((e) => e.traceId === flags["trace-id"]);
+        }
+        if (flags.session) {
+            filtered = filtered.filter((e) => e.sessionId === flags.session);
+        }
+        if (flags.agent) {
+            filtered = filtered.filter((e) => e.agent === flags.agent);
+        }
+        if (flags.action) {
+            filtered = filtered.filter((e) => e.action === flags.action);
+        }
+        if (flags["min-confidence"] !== undefined) {
+            filtered = filtered.filter((e) => (e.confidence ?? 0) >= flags["min-confidence"]);
+        }
+        if (flags.pattern) {
+            let regex;
+            try {
+                regex = new RegExp(flags.pattern, "i");
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                throw new Error(`Invalid regex pattern "${flags.pattern}": ${msg}`);
+            }
+            filtered = filtered.filter((e) => regex.test(`${e.task ?? ""} ${e.summary ?? ""}`));
+        }
+        return filtered;
+    }
+    buildFilters(flags) {
+        const typedFlags = flags;
+        return {
+            last: typeof typedFlags.last === "number" ? typedFlags.last : undefined,
+            since: typeof typedFlags.since === "string" ? typedFlags.since : undefined,
+            sessionId: typeof typedFlags.session === "string" ? typedFlags.session : undefined,
+            traceId: typeof typedFlags["trace-id"] === "string" ? typedFlags["trace-id"] : undefined,
+            agent: typeof typedFlags.agent === "string" ? typedFlags.agent : undefined,
+        };
+    }
+    renderTextOutput(result, flags) {
+        const typedFlags = flags;
+        if (typedFlags.count === true) {
+            this.log(`${result.count} events`);
+            return;
+        }
+        if (result.events.length === 0) {
+            this.logInfo("no events found");
+            return;
+        }
+        for (const event of result.events) {
+            const timestamp = event.timestamp
+                ? new Date(event.timestamp).toLocaleString("en-US", {
+                    month: "short",
+                    day: "numeric",
+                    hour: "2-digit",
+                    minute: "2-digit",
+                })
+                : "";
+            const agent = event.agent ?? "unknown";
+            const action = event.action ?? "";
+            const confidence = event.confidence !== undefined ? `(${event.confidence}/10)` : "";
+            const task = event.task ?? event.summary ?? "";
+            this.log(`${timestamp} ${agent}:${action} ${confidence} ${task}`.trim());
+        }
+        this.logInfo(`\n${result.count} events`);
+    }
+}

package/dist/cli/commands/hooks/guard.d.ts

@@ -0,0 +1,20 @@
+import { BaseCommand } from "../../base-command.js";
+interface GuardOutput {
+    inContext: boolean;
+    lockfiles: number;
+    cleaned: number;
+}
+export default class HooksGuardCommand extends BaseCommand {
+    static summary: string;
+    static description: string;
+    static examples: string[];
+    static flags: {
+        format: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "json-errors": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        ndjson: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    execute(): Promise<GuardOutput>;
+}
+export {};
+//# sourceMappingURL=guard.d.ts.map

package/dist/cli/commands/hooks/guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guard.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/hooks/guard.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,UAAU,WAAW;IACnB,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,CAAC,OAAO,OAAO,iBAAkB,SAAQ,WAAW;IACxD,OAAgB,OAAO,SAAgE;IACvF,OAAgB,WAAW,SAKmC;IAE9D,OAAgB,QAAQ,WAMtB;IAEF,OAAgB,KAAK;;;;;MAEnB;IAEI,OAAO,IAAI,OAAO,CAAC,WAAW,CAAC;CAoCtC"}

package/dist/cli/commands/hooks/guard.js

@@ -0,0 +1,53 @@
+import { cleanupStaleLockfiles, getActiveLockfiles, isInHookContext, } from "../../../lib/hooks/index.js";
+import { BaseCommand } from "../../base-command.js";
+export default class HooksGuardCommand extends BaseCommand {
+    static summary = "Check if currently in hook context (should skip execution)";
+    static description = `Returns exit code 0 if in hook context (skip), 1 if should proceed.
+
+Used at the start of hook scripts to prevent recursive triggers:
+  abbie hook guard && exit 0
+
+Also cleans up stale lockfiles (>2 minutes old) on each check.`;
+    static examples = [
+        "# In a hook script",
+        "abbie hook guard && exit 0",
+        "",
+        "# Check status",
+        "abbie hook guard --json --quiet",
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    async execute() {
+        // Clean up stale lockfiles first
+        const cleaned = cleanupStaleLockfiles();
+        const inContext = isInHookContext();
+        const lockfiles = getActiveLockfiles();
+        if (!this.jsonEnabled?.()) {
+            if (inContext) {
+                this.log(`in hook context (${lockfiles.length} active lockfile${lockfiles.length === 1 ? "" : "s"})`);
+                if (cleaned > 0) {
+                    this.logInfo(`cleaned ${cleaned} stale lockfile${cleaned === 1 ? "" : "s"}`);
+                }
+            }
+            else {
+                this.log("not in hook context");
+                if (cleaned > 0) {
+                    this.logInfo(`cleaned ${cleaned} stale lockfile${cleaned === 1 ? "" : "s"}`);
+                }
+            }
+        }
+        // Exit 0 if in context (caller should skip), 1 if should proceed
+        if (inContext) {
+            process.exitCode = 0;
+        }
+        else {
+            process.exitCode = 1;
+        }
+        return {
+            inContext,
+            lockfiles: lockfiles.length,
+            cleaned,
+        };
+    }
+}

package/dist/cli/commands/hooks/list.d.ts

@@ -0,0 +1,22 @@
+import { type AgentPlatform, 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 summary: string;
+    static description: string;
+    static examples: string[];
+    static flags: {
+        platform: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        format: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "json-errors": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        ndjson: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    execute(): Promise<ListOutput>;
+    private renderTextOutput;
+}
+export {};
+//# sourceMappingURL=list.d.ts.map

package/dist/cli/commands/hooks/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/hooks/list.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,aAAa,EAIlB,KAAK,YAAY,EAClB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,UAAU,UAAU;IAClB,QAAQ,EAAE,YAAY,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;CAC5C;AAED,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,WAAW;IACvD,OAAgB,OAAO,SAAsD;IAC7E,OAAgB,WAAW,SAGkB;IAE7C,OAAgB,QAAQ,WAItB;IAEF,OAAgB,KAAK;;;;;;MAOnB;IAEI,OAAO,IAAI,OAAO,CAAC,UAAU,CAAC;IA6DpC,OAAO,CAAC,gBAAgB;CAwCzB"}

package/dist/cli/commands/hooks/list.js

@@ -0,0 +1,97 @@
+import { Flags } from "@oclif/core";
+import { discoverAllHooks, getConfigPaths, HOOK_PLATFORMS, } from "../../../lib/hooks/index.js";
+import { BaseCommand } from "../../base-command.js";
+export default class HooksListCommand extends BaseCommand {
+    static summary = "List configured hooks across all agent platforms";
+    static description = `Discovers and displays hooks from:
+- Claude Code (~/.claude/settings.json)
+- Codex (~/.codex/config.toml)
+- Copilot (.github/hooks/hooks.json per-repo)`;
+    static examples = [
+        "$ abbie hooks list",
+        "$ abbie hooks list --platform claude",
+        "$ abbie hooks list --json --quiet",
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        platform: Flags.string({
+            char: "p",
+            description: `Filter by platform (${HOOK_PLATFORMS.join(", ")})`,
+            options: [...HOOK_PLATFORMS],
+        }),
+    };
+    async execute() {
+        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;
+            // Build filtered platforms object dynamically
+            const filteredPlatforms = Object.fromEntries(HOOK_PLATFORMS.map((p) => [p, p === platform ? registry.platforms[p] : []]));
+            const filtered = {
+                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 = [];
+            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 };
+    }
+    renderTextOutput(registry, configPaths, filterPlatform) {
+        const platforms = 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}`);
+            }
+        }
+    }
+}