@renseiai/agentfactory-cli 0.8.0

package/dist/src/governor.js

@@ -0,0 +1,305 @@
+#!/usr/bin/env node
+/**
+ * AgentFactory Governor CLI
+ *
+ * Thin wrapper around the governor runner.
+ *
+ * Usage:
+ *   af-governor [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)
+ *   --no-auto-research          Disable auto-research from Icebox
+ *   --no-auto-backlog-creation  Disable auto-backlog-creation from Icebox
+ *   --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
+ *
+ * Environment:
+ *   LINEAR_API_KEY              Required API key for Linear authentication
+ *   GOVERNOR_PROJECTS           Comma-separated project names (fallback for --project)
+ */
+import path from 'path';
+import { config } from 'dotenv';
+// Load environment variables from .env.local
+config({ path: path.resolve(process.cwd(), '.env.local') });
+import { parseGovernorArgs, runGovernor, } from './lib/governor-runner.js';
+import { createRealDependencies } from './lib/governor-dependencies.js';
+import { printStartupBanner, printScanSummary, printCircuitBreakerWarning, } from './lib/governor-logger.js';
+import { getVersion, checkForUpdate, printUpdateNotification } from './lib/version.js';
+import { maybeAutoUpdate } from './lib/auto-updater.js';
+import { createLinearAgentClient } from '@renseiai/agentfactory-linear';
+import { createLogger, initTouchpointStorage } from '@renseiai/agentfactory';
+import { RedisOverrideStorage, listStoredWorkspaces, getAccessToken, createRedisTokenBucket, createRedisCircuitBreaker, } from '@renseiai/agentfactory-server';
+// ---------------------------------------------------------------------------
+// Logger
+// ---------------------------------------------------------------------------
+const log = createLogger({ workerShortId: 'governor' });
+// ---------------------------------------------------------------------------
+// Stub dependencies
+// ---------------------------------------------------------------------------
+/**
+ * Create placeholder dependencies for the Governor.
+ *
+ * In a production deployment, these would be backed by the Linear SDK
+ * and Redis (via packages/server). For now we provide stubs that log
+ * calls and return safe defaults. The WorkSchedulingFrontend (SUP-709
+ * Wave 3) will provide the real implementations.
+ */
+function createStubDependencies() {
+    return {
+        listIssues: async (_project) => {
+            log.warn('listIssues stub called — no issues returned', { project: _project });
+            return [];
+        },
+        hasActiveSession: async (_issueId) => false,
+        isWithinCooldown: async (_issueId) => false,
+        isParentIssue: async (_issueId) => false,
+        isHeld: async (_issueId) => false,
+        getOverridePriority: async (_issueId) => null,
+        getWorkflowStrategy: async (_issueId) => undefined,
+        isResearchCompleted: async (_issueId) => false,
+        isBacklogCreationCompleted: async (_issueId) => false,
+        getCompletedSessionCount: async (_issueId) => 0,
+        dispatchWork: async (_issue, _action) => {
+            log.warn('dispatchWork stub called', { issueId: _issue.id, action: _action });
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Default prompt generator (used when no external generator is provided)
+// ---------------------------------------------------------------------------
+function defaultGeneratePrompt(identifier, workType) {
+    const prompts = {
+        research: `Research and analyze ${identifier}.`,
+        'backlog-creation': `Create backlog issues for ${identifier}.`,
+        development: `Start work on ${identifier}.`,
+        qa: `QA ${identifier}.`,
+        acceptance: `Process acceptance for ${identifier}.`,
+        refinement: `Refine ${identifier} based on feedback.`,
+        coordination: `Coordinate sub-issue execution for ${identifier}.`,
+    };
+    return prompts[workType] || `Process ${workType} for ${identifier}.`;
+}
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+async function main() {
+    const args = parseGovernorArgs();
+    // Fall back to GOVERNOR_PROJECTS env var (comma-separated) when no --project flags
+    if (args.projects.length === 0 && process.env.GOVERNOR_PROJECTS) {
+        args.projects = process.env.GOVERNOR_PROJECTS.split(',').map(s => s.trim()).filter(Boolean);
+    }
+    if (args.projects.length === 0) {
+        console.error('Error: at least one --project is required (or set GOVERNOR_PROJECTS env var)');
+        process.exit(1);
+    }
+    const version = getVersion();
+    // -----------------------------------------------------------------------
+    // Choose real or stub dependencies based on environment
+    // -----------------------------------------------------------------------
+    let dependencies;
+    let linearClient;
+    const linearApiKey = process.env.LINEAR_API_KEY;
+    const redisUrl = process.env.REDIS_URL;
+    // Track latest quota from API responses
+    let latestQuota;
+    let redisConnected = false;
+    let oauthResolved = false;
+    if (linearApiKey) {
+        let organizationId;
+        // Shared rate limiter and circuit breaker strategies (Redis-backed when available)
+        let rateLimiterStrategy;
+        let circuitBreakerStrategy;
+        // OAuth client cache — re-created when the underlying token changes
+        let cachedOAuthToken;
+        let cachedOAuthClient;
+        // Initialize touchpoint storage (for isHeld / getOverridePriority) when Redis is available
+        if (redisUrl) {
+            redisConnected = true;
+            initTouchpointStorage(new RedisOverrideStorage());
+            // Resolve workspace and create shared strategies
+            try {
+                const workspaces = await listStoredWorkspaces();
+                if (workspaces.length > 0) {
+                    organizationId = workspaces[0]; // Use first workspace (single-tenant)
+                    // Create shared Redis rate limiter and circuit breaker for this workspace
+                    rateLimiterStrategy = createRedisTokenBucket(organizationId);
+                    circuitBreakerStrategy = createRedisCircuitBreaker(organizationId);
+                    // Eagerly resolve token at startup to populate banner status
+                    const accessToken = await getAccessToken(organizationId);
+                    if (accessToken) {
+                        cachedOAuthToken = accessToken;
+                        cachedOAuthClient = createLinearAgentClient({
+                            apiKey: accessToken,
+                            rateLimiterStrategy,
+                            circuitBreakerStrategy,
+                        });
+                        oauthResolved = true;
+                    }
+                }
+            }
+            catch (err) {
+                log.warn('Failed to resolve OAuth token', {
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        /**
+         * Lazy OAuth client resolver.
+         *
+         * Called on each dispatchWork() to ensure the OAuth token is fresh.
+         * Re-reads the token from Redis (which handles refresh internally),
+         * and only creates a new LinearAgentClient when the token has changed.
+         * Rate limiter and circuit breaker strategies are reused across clients.
+         */
+        const resolveOAuthClient = organizationId
+            ? async () => {
+                try {
+                    const accessToken = await getAccessToken(organizationId);
+                    if (!accessToken)
+                        return cachedOAuthClient;
+                    // Token unchanged — reuse existing client
+                    if (accessToken === cachedOAuthToken && cachedOAuthClient) {
+                        return cachedOAuthClient;
+                    }
+                    // Token was refreshed — create new client with same strategies
+                    log.info('OAuth token refreshed, creating new client');
+                    cachedOAuthToken = accessToken;
+                    cachedOAuthClient = createLinearAgentClient({
+                        apiKey: accessToken,
+                        rateLimiterStrategy,
+                        circuitBreakerStrategy,
+                    });
+                    oauthResolved = true;
+                    return cachedOAuthClient;
+                }
+                catch (err) {
+                    log.warn('Failed to resolve OAuth client', {
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                    return cachedOAuthClient;
+                }
+            }
+            : undefined;
+        linearClient = createLinearAgentClient({
+            apiKey: linearApiKey,
+            rateLimiterStrategy,
+            circuitBreakerStrategy,
+            onApiResponse: (quota) => {
+                latestQuota = quota;
+            },
+        });
+        dependencies = createRealDependencies({
+            linearClient,
+            resolveOAuthClient,
+            organizationId,
+            generatePrompt: defaultGeneratePrompt,
+        });
+    }
+    else {
+        log.warn('LINEAR_API_KEY not set — using stub dependencies (no real work will be dispatched)');
+        dependencies = createStubDependencies();
+    }
+    // -----------------------------------------------------------------------
+    // Print startup banner
+    // -----------------------------------------------------------------------
+    printStartupBanner({
+        version,
+        projects: args.projects,
+        scanIntervalMs: args.scanIntervalMs,
+        maxConcurrentDispatches: args.maxConcurrentDispatches,
+        mode: args.mode,
+        once: args.once,
+        features: {
+            autoResearch: args.enableAutoResearch,
+            autoBacklogCreation: args.enableAutoBacklogCreation,
+            autoDevelopment: args.enableAutoDevelopment,
+            autoQA: args.enableAutoQA,
+            autoAcceptance: args.enableAutoAcceptance,
+        },
+        redisConnected,
+        oauthResolved,
+    });
+    // -----------------------------------------------------------------------
+    // Update check (non-blocking — runs in background)
+    // -----------------------------------------------------------------------
+    const updateCheck = await checkForUpdate();
+    printUpdateNotification(updateCheck);
+    // -----------------------------------------------------------------------
+    // Configure and run
+    // -----------------------------------------------------------------------
+    const runnerConfig = {
+        projects: args.projects,
+        scanIntervalMs: args.scanIntervalMs,
+        maxConcurrentDispatches: args.maxConcurrentDispatches,
+        enableAutoResearch: args.enableAutoResearch,
+        enableAutoBacklogCreation: args.enableAutoBacklogCreation,
+        enableAutoDevelopment: args.enableAutoDevelopment,
+        enableAutoQA: args.enableAutoQA,
+        enableAutoAcceptance: args.enableAutoAcceptance,
+        once: args.once,
+        mode: args.mode,
+        dependencies,
+        callbacks: {
+            onScanComplete: async (results) => {
+                const apiCalls = linearClient?.apiCallCount;
+                printScanSummary(results, 0, latestQuota, apiCalls);
+                // Check circuit breaker status if available
+                // (CircuitBreaker instances expose a .state getter)
+                if (linearClient) {
+                    const breaker = linearClient.circuitBreaker;
+                    if (breaker?.state && breaker.state !== 'closed') {
+                        printCircuitBreakerWarning(breaker.state);
+                    }
+                }
+                // Reset for next scan
+                linearClient?.resetApiCallCount();
+                latestQuota = undefined;
+                // Auto-update at end of scan when no active dispatches
+                await maybeAutoUpdate(updateCheck, {
+                    cliFlag: args.autoUpdate,
+                });
+            },
+            onError: (error) => {
+                log.error('Governor error', { error: error.message });
+            },
+        },
+    };
+    try {
+        const { governor, scanResults } = await runGovernor(runnerConfig);
+        if (args.once && scanResults) {
+            // Print summary and exit
+            const apiCalls = linearClient?.apiCallCount;
+            printScanSummary(scanResults, 0, latestQuota, apiCalls);
+            let totalDispatched = 0;
+            let totalErrors = 0;
+            for (const result of scanResults) {
+                totalDispatched += result.actionsDispatched;
+                totalErrors += result.errors.length;
+            }
+            log.info(`Scan complete: ${totalDispatched} dispatched, ${totalErrors} errors`);
+            return;
+        }
+        // Continuous mode — handle graceful shutdown
+        log.info('Governor running. Press Ctrl+C to stop.');
+        const shutdown = () => {
+            log.info('Shutting down governor...');
+            governor.stop();
+            process.exit(0);
+        };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+    }
+    catch (error) {
+        log.error('Governor failed', { error: error instanceof Error ? error.message : String(error) });
+        process.exit(1);
+    }
+}
+main().catch((error) => {
+    log.error('Fatal error', { error: error instanceof Error ? error.message : String(error) });
+    process.exit(1);
+});

package/dist/src/index.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * AgentFactory CLI
+ *
+ * Entry point for the agentfactory command.
+ * Dispatches to sub-commands based on first argument.
+ */
+declare const command: string;
+declare function printHelp(): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AACA;;;;;GAKG;AAEH,QAAA,MAAM,OAAO,QAAkB,CAAA;AAE/B,iBAAS,SAAS,IAAI,IAAI,CAwBzB"}

package/dist/src/index.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * AgentFactory CLI
+ *
+ * Entry point for the agentfactory command.
+ * Dispatches to sub-commands based on first argument.
+ */
+const command = process.argv[2];
+function printHelp() {
+    console.log(`
+AgentFactory CLI — Multi-agent fleet management for coding agents
+
+Usage:
+  agentfactory <command> [options]
+
+Commands:
+  orchestrator    Spawn concurrent agents on backlog issues
+  governor        Automated workflow scan loop with configurable triggers
+  worker          Start a remote worker that polls for queued work
+  worker-fleet    Spawn and manage multiple worker processes
+  agent           Manage running agent sessions (stop, chat, status, reconnect)
+  cleanup         Clean up orphaned git worktrees
+  queue-admin     Manage Redis work queue and sessions
+  analyze-logs    Analyze agent session logs for errors
+  linear          Linear issue tracker operations
+  sync-routes     Generate missing route and page files from manifest
+  help            Show this help message
+
+Run 'agentfactory <command> --help' for command-specific options.
+
+Learn more: https://github.com/renseiai/agentfactory
+`);
+}
+switch (command) {
+    case 'orchestrator':
+        import('./orchestrator');
+        break;
+    case 'governor':
+        import('./governor');
+        break;
+    case 'worker':
+        import('./worker');
+        break;
+    case 'worker-fleet':
+        import('./worker-fleet');
+        break;
+    case 'agent':
+        import('./agent');
+        break;
+    case 'cleanup':
+        import('./cleanup');
+        break;
+    case 'queue-admin':
+        import('./queue-admin');
+        break;
+    case 'analyze-logs':
+        import('./analyze-logs');
+        break;
+    case 'linear':
+        import('./linear');
+        break;
+    case 'sync-routes':
+        import('./sync-routes');
+        break;
+    case 'help':
+    case '--help':
+    case '-h':
+    case undefined:
+        printHelp();
+        break;
+    default:
+        console.error(`Unknown command: ${command}`);
+        printHelp();
+        process.exit(1);
+}

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

@@ -0,0 +1,28 @@
+/**
+ * Agent Runner -- Programmatic API for the af-agent CLI.
+ *
+ * Provides stop, chat, status, and reconnect commands for managing running
+ * agent sessions. Works by updating Redis state directly — workers poll for
+ * status changes and pending prompts every 5 seconds.
+ */
+export type AgentCommand = 'stop' | 'chat' | 'status' | 'reconnect' | 'list';
+export interface AgentRunnerConfig {
+    /** Command to execute */
+    command: AgentCommand;
+    /** Issue identifier (e.g., SUP-674) or partial session ID — not required for 'list' */
+    issueId?: string;
+    /** Message text for 'chat' command */
+    message?: string;
+    /** Show all sessions including completed/failed (for 'list' command) */
+    all?: boolean;
+}
+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";
+};
+export declare function runAgent(config: AgentRunnerConfig): Promise<void>;
+//# sourceMappingURL=agent-runner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"agent-runner.d.ts","sourceRoot":"","sources":["../../../src/lib/agent-runner.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAiBH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,WAAW,GAAG,MAAM,CAAA;AAE5E,MAAM,WAAW,iBAAiB;IAChC,yBAAyB;IACzB,OAAO,EAAE,YAAY,CAAA;IACrB,uFAAuF;IACvF,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,sCAAsC;IACtC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,wEAAwE;IACxE,GAAG,CAAC,EAAE,OAAO,CAAA;CACd;AAMD,eAAO,MAAM,CAAC;;;;;;;CAOJ,CAAA;AAuRV,wBAAsB,QAAQ,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAuBvE"}