@renseiai/agentfactory-cli 0.8.0

package/dist/src/lib/governor-runner.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Governor Runner -- Programmatic API for the governor CLI.
+ *
+ * Exports `runGovernor()` so the governor can be invoked from code
+ * (e.g. Next.js route handlers, tests, or custom scripts) without going
+ * through process.argv / process.env / process.exit.
+ */
+import { WorkflowGovernor, EventDrivenGovernor, type GovernorDependencies, type GovernorEventBus, type EventDeduplicator } from '@renseiai/agentfactory';
+import type { ScanResult } from '@renseiai/agentfactory';
+export interface GovernorRunnerConfig {
+    /** Projects to scan */
+    projects: string[];
+    /** Scan interval in milliseconds (default: 60000) */
+    scanIntervalMs?: number;
+    /** Maximum concurrent dispatches per scan (default: 3) */
+    maxConcurrentDispatches?: number;
+    /** Enable auto-research from Icebox (default: false) */
+    enableAutoResearch?: boolean;
+    /** Enable auto-backlog-creation from Icebox (default: false) */
+    enableAutoBacklogCreation?: boolean;
+    /** Enable auto-development from Backlog (default: true) */
+    enableAutoDevelopment?: boolean;
+    /** Enable auto-QA from Finished (default: true) */
+    enableAutoQA?: boolean;
+    /** Enable auto-acceptance from Delivered (default: true) */
+    enableAutoAcceptance?: boolean;
+    /** Run a single scan pass and exit (for testing / cron) */
+    once?: boolean;
+    /** Dependency injection for the governor (required) */
+    dependencies: GovernorDependencies;
+    /** Callbacks for governor lifecycle events */
+    callbacks?: GovernorRunnerCallbacks;
+    /** Governor execution mode (default: 'poll-only') */
+    mode?: 'poll-only' | 'event-driven';
+    /** Event bus for event-driven mode (created automatically if not provided) */
+    eventBus?: GovernorEventBus;
+    /** Event deduplicator for event-driven mode (created automatically if not provided) */
+    deduplicator?: EventDeduplicator;
+}
+export interface GovernorRunnerCallbacks {
+    onScanComplete?: (results: ScanResult[]) => void | Promise<void>;
+    onError?: (error: Error) => void;
+}
+export interface GovernorRunnerResult {
+    governor: WorkflowGovernor | EventDrivenGovernor;
+    /** Only populated in --once mode (poll-only) */
+    scanResults?: ScanResult[];
+}
+/**
+ * Start the Workflow Governor with the given configuration.
+ *
+ * In `poll-only` mode (default):
+ *   - `once` mode: runs a single scan pass and returns the results.
+ *   - Otherwise: starts the scan loop and returns the governor instance
+ *     (caller is responsible for calling `governor.stop()` on shutdown).
+ *
+ * In `event-driven` mode:
+ *   - Creates an EventDrivenGovernor with an event bus and optional deduplicator.
+ *   - Starts the event loop and periodic poll sweep.
+ *   - `once` mode is not supported in event-driven mode (falls back to poll-only).
+ */
+export declare function runGovernor(config: GovernorRunnerConfig): Promise<GovernorRunnerResult>;
+export interface GovernorCLIArgs {
+    projects: string[];
+    scanIntervalMs: number;
+    maxConcurrentDispatches: number;
+    enableAutoResearch: boolean;
+    enableAutoBacklogCreation: boolean;
+    enableAutoDevelopment: boolean;
+    enableAutoQA: boolean;
+    enableAutoAcceptance: boolean;
+    once: boolean;
+    mode: 'poll-only' | 'event-driven';
+    autoUpdate?: boolean;
+}
+/**
+ * Parse CLI arguments for the governor command.
+ *
+ * Usage:
+ *   agentfactory governor --project <name> [--project <name>] [options]
+ *
+ * Options:
+ *   --project <name>            Project to scan (can be repeated)
+ *   --scan-interval <ms>        Scan interval in milliseconds (default: 60000)
+ *   --max-dispatches <n>        Maximum concurrent dispatches per scan (default: 3)
+ *   --auto-research              Enable auto-research from Icebox (default: off)
+ *   --auto-backlog-creation      Enable auto-backlog-creation from Icebox (default: off)
+ *   --no-auto-research           Disable auto-research (explicit override)
+ *   --no-auto-backlog-creation   Disable auto-backlog-creation (explicit override)
+ *   --no-auto-development       Disable auto-development from Backlog
+ *   --no-auto-qa                Disable auto-QA from Finished
+ *   --no-auto-acceptance        Disable auto-acceptance from Delivered
+ *   --once                      Run a single scan pass and exit
+ *   --auto-update               Enable automatic updates
+ *   --no-auto-update            Disable automatic updates
+ *   --help, -h                  Show help
+ */
+export declare function parseGovernorArgs(argv?: string[]): GovernorCLIArgs;
+/**
+ * Print help text for the governor command.
+ */
+export declare function printGovernorHelp(): void;
+//# sourceMappingURL=governor-runner.d.ts.map

package/dist/src/lib/governor-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"governor-runner.d.ts","sourceRoot":"","sources":["../../../src/lib/governor-runner.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EAGnB,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EAEvB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,KAAK,EAIV,UAAU,EACX,MAAM,wBAAwB,CAAA;AAM/B,MAAM,WAAW,oBAAoB;IACnC,uBAAuB;IACvB,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,qDAAqD;IACrD,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,0DAA0D;IAC1D,uBAAuB,CAAC,EAAE,MAAM,CAAA;IAChC,wDAAwD;IACxD,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAC5B,gEAAgE;IAChE,yBAAyB,CAAC,EAAE,OAAO,CAAA;IACnC,2DAA2D;IAC3D,qBAAqB,CAAC,EAAE,OAAO,CAAA;IAC/B,mDAAmD;IACnD,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,4DAA4D;IAC5D,oBAAoB,CAAC,EAAE,OAAO,CAAA;IAC9B,2DAA2D;IAC3D,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,uDAAuD;IACvD,YAAY,EAAE,oBAAoB,CAAA;IAClC,8CAA8C;IAC9C,SAAS,CAAC,EAAE,uBAAuB,CAAA;IACnC,qDAAqD;IACrD,IAAI,CAAC,EAAE,WAAW,GAAG,cAAc,CAAA;IACnC,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,gBAAgB,CAAA;IAC3B,uFAAuF;IACvF,YAAY,CAAC,EAAE,iBAAiB,CAAA;CACjC;AAED,MAAM,WAAW,uBAAuB;IACtC,cAAc,CAAC,EAAE,CAAC,OAAO,EAAE,UAAU,EAAE,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAChE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;CACjC;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,gBAAgB,GAAG,mBAAmB,CAAA;IAChD,gDAAgD;IAChD,WAAW,CAAC,EAAE,UAAU,EAAE,CAAA;CAC3B;AAMD;;;;;;;;;;;;GAYG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,oBAAoB,GAC3B,OAAO,CAAC,oBAAoB,CAAC,CAyD/B;AAMD,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,cAAc,EAAE,MAAM,CAAA;IACtB,uBAAuB,EAAE,MAAM,CAAA;IAC/B,kBAAkB,EAAE,OAAO,CAAA;IAC3B,yBAAyB,EAAE,OAAO,CAAA;IAClC,qBAAqB,EAAE,OAAO,CAAA;IAC9B,YAAY,EAAE,OAAO,CAAA;IACrB,oBAAoB,EAAE,OAAO,CAAA;IAC7B,IAAI,EAAE,OAAO,CAAA;IACb,IAAI,EAAE,WAAW,GAAG,cAAc,CAAA;IAClC,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,GAAE,MAAM,EAA0B,GAAG,eAAe,CAmEzF;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CA8CxC"}

package/dist/src/lib/governor-runner.js

@@ -0,0 +1,210 @@
+/**
+ * Governor Runner -- Programmatic API for the governor CLI.
+ *
+ * Exports `runGovernor()` so the governor can be invoked from code
+ * (e.g. Next.js route handlers, tests, or custom scripts) without going
+ * through process.argv / process.env / process.exit.
+ */
+import { WorkflowGovernor, EventDrivenGovernor, InMemoryEventBus, InMemoryEventDeduplicator, } from '@renseiai/agentfactory';
+// ---------------------------------------------------------------------------
+// Runner
+// ---------------------------------------------------------------------------
+/**
+ * Start the Workflow Governor with the given configuration.
+ *
+ * In `poll-only` mode (default):
+ *   - `once` mode: runs a single scan pass and returns the results.
+ *   - Otherwise: starts the scan loop and returns the governor instance
+ *     (caller is responsible for calling `governor.stop()` on shutdown).
+ *
+ * In `event-driven` mode:
+ *   - Creates an EventDrivenGovernor with an event bus and optional deduplicator.
+ *   - Starts the event loop and periodic poll sweep.
+ *   - `once` mode is not supported in event-driven mode (falls back to poll-only).
+ */
+export async function runGovernor(config) {
+    const governorConfig = {
+        projects: config.projects,
+        scanIntervalMs: config.scanIntervalMs,
+        maxConcurrentDispatches: config.maxConcurrentDispatches,
+        enableAutoResearch: config.enableAutoResearch,
+        enableAutoBacklogCreation: config.enableAutoBacklogCreation,
+        enableAutoDevelopment: config.enableAutoDevelopment,
+        enableAutoQA: config.enableAutoQA,
+        enableAutoAcceptance: config.enableAutoAcceptance,
+    };
+    const mode = config.mode ?? 'poll-only';
+    // -- Event-driven mode --
+    if (mode === 'event-driven' && !config.once) {
+        const eventBus = config.eventBus ?? new InMemoryEventBus();
+        const deduplicator = config.deduplicator ?? new InMemoryEventDeduplicator();
+        const governor = new EventDrivenGovernor({
+            ...governorConfig,
+            // Spread required GovernorConfig defaults so TypeScript is happy
+            projects: config.projects,
+            scanIntervalMs: config.scanIntervalMs ?? 60_000,
+            maxConcurrentDispatches: config.maxConcurrentDispatches ?? 3,
+            enableAutoResearch: config.enableAutoResearch ?? false,
+            enableAutoBacklogCreation: config.enableAutoBacklogCreation ?? false,
+            enableAutoDevelopment: config.enableAutoDevelopment ?? true,
+            enableAutoQA: config.enableAutoQA ?? true,
+            enableAutoAcceptance: config.enableAutoAcceptance ?? true,
+            humanResponseTimeoutMs: 4 * 60 * 60 * 1000,
+            eventBus,
+            deduplicator,
+        }, config.dependencies);
+        await governor.start();
+        return { governor };
+    }
+    // -- Poll-only mode (default) --
+    const governorCallbacks = {
+        onScanComplete: config.callbacks?.onScanComplete,
+    };
+    const governor = new WorkflowGovernor(governorConfig, config.dependencies, governorCallbacks);
+    // -- Single scan mode (--once) --
+    if (config.once) {
+        const results = await governor.scanOnce();
+        return { governor, scanResults: results };
+    }
+    // -- Continuous scan loop --
+    governor.start();
+    return { governor };
+}
+/**
+ * Parse CLI arguments for the governor command.
+ *
+ * Usage:
+ *   agentfactory governor --project <name> [--project <name>] [options]
+ *
+ * Options:
+ *   --project <name>            Project to scan (can be repeated)
+ *   --scan-interval <ms>        Scan interval in milliseconds (default: 60000)
+ *   --max-dispatches <n>        Maximum concurrent dispatches per scan (default: 3)
+ *   --auto-research              Enable auto-research from Icebox (default: off)
+ *   --auto-backlog-creation      Enable auto-backlog-creation from Icebox (default: off)
+ *   --no-auto-research           Disable auto-research (explicit override)
+ *   --no-auto-backlog-creation   Disable auto-backlog-creation (explicit override)
+ *   --no-auto-development       Disable auto-development from Backlog
+ *   --no-auto-qa                Disable auto-QA from Finished
+ *   --no-auto-acceptance        Disable auto-acceptance from Delivered
+ *   --once                      Run a single scan pass and exit
+ *   --auto-update               Enable automatic updates
+ *   --no-auto-update            Disable automatic updates
+ *   --help, -h                  Show help
+ */
+export function parseGovernorArgs(argv = process.argv.slice(2)) {
+    const result = {
+        projects: [],
+        scanIntervalMs: 60_000,
+        maxConcurrentDispatches: 3,
+        enableAutoResearch: false,
+        enableAutoBacklogCreation: false,
+        enableAutoDevelopment: true,
+        enableAutoQA: true,
+        enableAutoAcceptance: true,
+        once: false,
+        mode: 'poll-only',
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        switch (arg) {
+            case '--project':
+                result.projects.push(argv[++i]);
+                break;
+            case '--scan-interval':
+                result.scanIntervalMs = parseInt(argv[++i], 10);
+                break;
+            case '--max-dispatches':
+                result.maxConcurrentDispatches = parseInt(argv[++i], 10);
+                break;
+            case '--auto-research':
+                result.enableAutoResearch = true;
+                break;
+            case '--no-auto-research':
+                result.enableAutoResearch = false;
+                break;
+            case '--auto-backlog-creation':
+                result.enableAutoBacklogCreation = true;
+                break;
+            case '--no-auto-backlog-creation':
+                result.enableAutoBacklogCreation = false;
+                break;
+            case '--no-auto-development':
+                result.enableAutoDevelopment = false;
+                break;
+            case '--no-auto-qa':
+                result.enableAutoQA = false;
+                break;
+            case '--no-auto-acceptance':
+                result.enableAutoAcceptance = false;
+                break;
+            case '--auto-update':
+                result.autoUpdate = true;
+                break;
+            case '--no-auto-update':
+                result.autoUpdate = false;
+                break;
+            case '--once':
+                result.once = true;
+                break;
+            case '--mode':
+                result.mode = argv[++i];
+                break;
+            case '--help':
+            case '-h':
+                printGovernorHelp();
+                process.exit(0);
+        }
+    }
+    return result;
+}
+/**
+ * Print help text for the governor command.
+ */
+export function printGovernorHelp() {
+    console.log(`
+AgentFactory Governor — Automated workflow scan loop
+
+Usage:
+  agentfactory governor [options]
+
+Options:
+  --project <name>            Project to scan (can be repeated for multiple projects)
+  --scan-interval <ms>        Scan interval in milliseconds (default: 60000)
+  --max-dispatches <n>        Maximum concurrent dispatches per scan (default: 3)
+  --mode <mode>               Execution mode: poll-only (default) or event-driven
+  --auto-research             Enable auto-research from Icebox (default: off)
+  --auto-backlog-creation     Enable auto-backlog-creation from Icebox (default: off)
+  --no-auto-development       Disable auto-development from Backlog
+  --no-auto-qa                Disable auto-QA from Finished
+  --no-auto-acceptance        Disable auto-acceptance from Delivered
+  --once                      Run a single scan pass and exit
+  --help, -h                  Show this help message
+
+Modes:
+  poll-only      Periodic scan loop using WorkflowGovernor (default)
+  event-driven   Hybrid event-driven + poll sweep using EventDrivenGovernor.
+                 Reacts to events in real time with a periodic safety-net poll.
+
+Environment:
+  LINEAR_API_KEY              Required API key for Linear authentication
+  REDIS_URL                   Redis connection URL (required for real dependencies)
+  GOVERNOR_PROJECTS           Comma-separated project names (fallback for --project)
+
+Examples:
+  # Start the governor for a project
+  agentfactory governor --project MyProject
+
+  # Scan multiple projects with custom interval
+  agentfactory governor --project ProjectA --project ProjectB --scan-interval 30000
+
+  # Run a single scan and exit (useful for cron jobs)
+  agentfactory governor --project MyProject --once
+
+  # Disable auto-QA (only scan for development work)
+  agentfactory governor --project MyProject --no-auto-qa --no-auto-acceptance
+
+  # Use event-driven mode
+  agentfactory governor --project MyProject --mode event-driven
+`);
+}

package/dist/src/lib/linear-runner.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Linear CLI Runner — re-exports from @renseiai/agentfactory (core).
+ *
+ * The canonical implementation lives in packages/core/src/tools/linear-runner.ts
+ * so both the CLI and the in-process tool plugin share a single source of truth.
+ */
+export { runLinear, parseLinearArgs, type LinearRunnerConfig, type LinearRunnerResult, } from '@renseiai/agentfactory';
+//# sourceMappingURL=linear-runner.d.ts.map

package/dist/src/lib/linear-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linear-runner.d.ts","sourceRoot":"","sources":["../../../src/lib/linear-runner.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EACL,SAAS,EACT,eAAe,EACf,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,GACxB,MAAM,wBAAwB,CAAA"}

package/dist/src/lib/linear-runner.js

@@ -0,0 +1,7 @@
+/**
+ * Linear CLI Runner — re-exports from @renseiai/agentfactory (core).
+ *
+ * The canonical implementation lives in packages/core/src/tools/linear-runner.ts
+ * so both the CLI and the in-process tool plugin share a single source of truth.
+ */
+export { runLinear, parseLinearArgs, } from '@renseiai/agentfactory';

package/dist/src/lib/orchestrator-runner.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Orchestrator Runner -- Programmatic API for the orchestrator CLI.
+ *
+ * Exports `runOrchestrator()` so the orchestrator can be invoked from code
+ * (e.g. Next.js route handlers, tests, or custom scripts) without going
+ * through process.argv / process.env / process.exit.
+ */
+import { type AgentProcess, type OrchestratorIssue } from '@renseiai/agentfactory';
+export interface OrchestratorRunnerConfig {
+    /** Linear API key for authentication */
+    linearApiKey: string;
+    /** Filter issues by project name */
+    project?: string;
+    /** Maximum concurrent agents (default: 3) */
+    max?: number;
+    /** Process a single issue by ID */
+    single?: string;
+    /** Wait for agents to complete (default: true) */
+    wait?: boolean;
+    /** Show what would be done without executing (default: false) */
+    dryRun?: boolean;
+    /** Git repository root (default: auto-detect) */
+    gitRoot?: string;
+    /** Callbacks for agent lifecycle events */
+    callbacks?: OrchestratorCallbacks;
+    /** Custom workflow template directory path */
+    templateDir?: string;
+    /** Git repository URL for worktree cloning */
+    repository?: string;
+    /** Force a specific work type (used with --single) */
+    workType?: string;
+}
+export interface OrchestratorCallbacks {
+    onIssueSelected?: (issue: OrchestratorIssue) => void;
+    onAgentStart?: (agent: AgentProcess) => void;
+    onAgentComplete?: (agent: AgentProcess) => void;
+    onAgentError?: (agent: AgentProcess, error: Error) => void;
+    onAgentIncomplete?: (agent: AgentProcess) => void;
+}
+export interface OrchestratorRunnerResult {
+    agentsSpawned: number;
+    errors: Array<{
+        issueId: string;
+        error: Error;
+    }>;
+    completed: AgentProcess[];
+}
+export declare function getGitRoot(): string;
+export declare function formatDuration(ms: number): string;
+export declare function runOrchestrator(config: OrchestratorRunnerConfig): Promise<OrchestratorRunnerResult>;
+//# sourceMappingURL=orchestrator-runner.d.ts.map

package/dist/src/lib/orchestrator-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator-runner.d.ts","sourceRoot":"","sources":["../../../src/lib/orchestrator-runner.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACvB,MAAM,wBAAwB,CAAA;AAM/B,MAAM,WAAW,wBAAwB;IACvC,wCAAwC;IACxC,YAAY,EAAE,MAAM,CAAA;IACpB,oCAAoC;IACpC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,6CAA6C;IAC7C,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,mCAAmC;IACnC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,kDAAkD;IAClD,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,iEAAiE;IACjE,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,iDAAiD;IACjD,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,2CAA2C;IAC3C,SAAS,CAAC,EAAE,qBAAqB,CAAA;IACjC,8CAA8C;IAC9C,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,8CAA8C;IAC9C,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,sDAAsD;IACtD,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,qBAAqB;IACpC,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAA;IACpD,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAA;IAC5C,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAA;IAC/C,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;IAC1D,iBAAiB,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAA;CAClD;AAED,MAAM,WAAW,wBAAwB;IACvC,aAAa,EAAE,MAAM,CAAA;IACrB,MAAM,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAE,CAAC,CAAA;IAChD,SAAS,EAAE,YAAY,EAAE,CAAA;CAC1B;AAMD,wBAAgB,UAAU,IAAI,MAAM,CASnC;AAED,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAYjD;AA0CD,wBAAsB,eAAe,CACnC,MAAM,EAAE,wBAAwB,GAC/B,OAAO,CAAC,wBAAwB,CAAC,CA6FnC"}

package/dist/src/lib/orchestrator-runner.js

@@ -0,0 +1,151 @@
+/**
+ * Orchestrator Runner -- Programmatic API for the orchestrator CLI.
+ *
+ * Exports `runOrchestrator()` so the orchestrator can be invoked from code
+ * (e.g. Next.js route handlers, tests, or custom scripts) without going
+ * through process.argv / process.env / process.exit.
+ */
+import path from 'path';
+import { execSync } from 'child_process';
+import { createOrchestrator, } from '@renseiai/agentfactory';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+export function getGitRoot() {
+    try {
+        return execSync('git rev-parse --show-toplevel', {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+    }
+    catch {
+        return process.cwd();
+    }
+}
+export function formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    if (hours > 0) {
+        return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+    }
+    if (minutes > 0) {
+        return `${minutes}m ${seconds % 60}s`;
+    }
+    return `${seconds}s`;
+}
+// ---------------------------------------------------------------------------
+// Default callbacks (console.log-based, matching the original CLI output)
+// ---------------------------------------------------------------------------
+function defaultCallbacks() {
+    return {
+        onIssueSelected: (issue) => {
+            console.log(`Selected: ${issue.identifier} - ${issue.title}`);
+            console.log(`  URL: ${issue.url}`);
+            console.log(`  Labels: ${issue.labels.join(', ') || 'none'}`);
+        },
+        onAgentStart: (agent) => {
+            console.log(`Agent started: ${agent.identifier} (PID: ${agent.pid})`);
+            console.log(`  Worktree: ${agent.worktreePath}`);
+        },
+        onAgentComplete: (agent) => {
+            const duration = agent.completedAt
+                ? formatDuration(agent.completedAt.getTime() - agent.startedAt.getTime())
+                : 'unknown';
+            console.log(`Agent completed: ${agent.identifier} (${duration})`);
+        },
+        onAgentError: (_agent, error) => {
+            console.error(`Agent failed: ${_agent.identifier}`);
+            console.error(`  Error: ${error.message}`);
+        },
+        onAgentIncomplete: (agent) => {
+            const duration = agent.completedAt
+                ? formatDuration(agent.completedAt.getTime() - agent.startedAt.getTime())
+                : 'unknown';
+            console.warn(`Agent incomplete: ${agent.identifier} (${duration})`);
+            console.warn(`  Reason: ${agent.incompleteReason ?? 'unknown'}`);
+            console.warn(`  Worktree preserved: ${agent.worktreePath}`);
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Runner
+// ---------------------------------------------------------------------------
+export async function runOrchestrator(config) {
+    const maxConcurrent = config.max ?? 3;
+    const wait = config.wait ?? true;
+    const dryRun = config.dryRun ?? false;
+    const gitRoot = config.gitRoot ?? getGitRoot();
+    const cb = config.callbacks ?? defaultCallbacks();
+    const orchestratorConfig = {
+        project: config.project,
+        maxConcurrent,
+        worktreePath: path.resolve(gitRoot, '.worktrees'),
+        linearApiKey: config.linearApiKey,
+    };
+    if (config.templateDir) {
+        orchestratorConfig.templateDir = config.templateDir;
+    }
+    if (config.repository) {
+        orchestratorConfig.repository = config.repository;
+    }
+    const orchestrator = createOrchestrator(orchestratorConfig, {
+        onIssueSelected: cb.onIssueSelected,
+        onAgentStart: cb.onAgentStart,
+        onAgentComplete: cb.onAgentComplete,
+        onAgentError: cb.onAgentError,
+        onAgentIncomplete: cb.onAgentIncomplete,
+    });
+    const result = {
+        agentsSpawned: 0,
+        errors: [],
+        completed: [],
+    };
+    // --single mode ----------------------------------------------------------
+    if (config.single) {
+        if (dryRun) {
+            return result;
+        }
+        await orchestrator.spawnAgentForIssue(config.single, undefined, config.workType);
+        result.agentsSpawned = 1;
+        if (wait) {
+            // Wire up SIGINT so callers running from a terminal can stop agents
+            const sigintHandler = () => {
+                orchestrator.stopAll();
+            };
+            process.on('SIGINT', sigintHandler);
+            try {
+                const completed = await orchestrator.waitForAll();
+                result.completed = completed;
+            }
+            finally {
+                process.removeListener('SIGINT', sigintHandler);
+            }
+        }
+        return result;
+    }
+    // --dry-run mode ---------------------------------------------------------
+    if (dryRun) {
+        await orchestrator.getBacklogIssues();
+        // Nothing to spawn in dry-run; caller can inspect issues via callbacks
+        return result;
+    }
+    // Normal run -------------------------------------------------------------
+    const runResult = await orchestrator.run();
+    result.agentsSpawned = runResult.agents.length;
+    result.errors = runResult.errors;
+    if (wait && runResult.agents.length > 0) {
+        const sigintHandler = () => {
+            orchestrator.stopAll();
+        };
+        process.on('SIGINT', sigintHandler);
+        try {
+            const completed = await orchestrator.waitForAll();
+            result.completed = completed;
+        }
+        finally {
+            process.removeListener('SIGINT', sigintHandler);
+        }
+    }
+    return result;
+}

package/dist/src/lib/queue-admin-runner.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Queue Admin Runner -- Programmatic API for the queue admin CLI.
+ *
+ * Extracts ALL command handlers from the queue-admin bin script so they can be
+ * invoked programmatically (e.g. from a Next.js route handler or test) without
+ * process.exit / dotenv / argv coupling.
+ */
+export type QueueAdminCommand = 'list' | 'sessions' | 'workers' | 'clear-claims' | 'clear-queue' | 'clear-all' | 'reset' | 'remove';
+export interface QueueAdminRunnerConfig {
+    /** Command to execute */
+    command: QueueAdminCommand;
+    /** Session ID for 'remove' command (partial match) */
+    sessionId?: string;
+}
+export declare const C: {
+    readonly reset: "\u001B[0m";
+    readonly red: "\u001B[31m";
+    readonly green: "\u001B[32m";
+    readonly yellow: "\u001B[33m";
+    readonly cyan: "\u001B[36m";
+    readonly gray: "\u001B[90m";
+};
+/**
+ * Run a queue admin command programmatically.
+ *
+ * Throws if REDIS_URL is not set or if the 'remove' command is called without
+ * a sessionId.
+ */
+export declare function runQueueAdmin(config: QueueAdminRunnerConfig): Promise<void>;
+//# sourceMappingURL=queue-admin-runner.d.ts.map

package/dist/src/lib/queue-admin-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-admin-runner.d.ts","sourceRoot":"","sources":["../../../src/lib/queue-admin-runner.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAkBH,MAAM,MAAM,iBAAiB,GACzB,MAAM,GACN,UAAU,GACV,SAAS,GACT,cAAc,GACd,aAAa,GACb,WAAW,GACX,OAAO,GACP,QAAQ,CAAA;AAEZ,MAAM,WAAW,sBAAsB;IACrC,yBAAyB;IACzB,OAAO,EAAE,iBAAiB,CAAA;IAC1B,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAgBD,eAAO,MAAM,CAAC;;;;;;;CAOJ,CAAA;AAgZV;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CA8BjF"}