@supaku/agentfactory-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Supaku
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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,CAgBzB"}

package/dist/src/index.js

@@ -0,0 +1,44 @@
+#!/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
+  worker          Start a remote worker that polls for queued work
+  help            Show this help message
+
+Run 'agentfactory <command> --help' for command-specific options.
+
+Learn more: https://github.com/supaku/agentfactory
+`);
+}
+switch (command) {
+    case 'orchestrator':
+        import('./orchestrator');
+        break;
+    case 'worker':
+        import('./worker');
+        break;
+    case 'help':
+    case '--help':
+    case '-h':
+    case undefined:
+        printHelp();
+        break;
+    default:
+        console.error(`Unknown command: ${command}`);
+        printHelp();
+        process.exit(1);
+}

package/dist/src/orchestrator.d.ts

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+/**
+ * AgentFactory Orchestrator CLI
+ *
+ * Local script to spawn concurrent coding agents on backlog issues.
+ *
+ * Usage:
+ *   af-orchestrator [options]
+ *
+ * Options:
+ *   --project <name>    Filter issues by project name
+ *   --max <number>      Maximum concurrent agents (default: 3)
+ *   --single <id>       Process a single issue by ID
+ *   --no-wait           Don't wait for agents to complete
+ *   --dry-run           Show what would be done without executing
+ *
+ * Environment:
+ *   LINEAR_API_KEY      Required API key for Linear authentication
+ */
+export {};
+//# sourceMappingURL=orchestrator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["../../src/orchestrator.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;GAiBG"}

package/dist/src/orchestrator.js

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+/**
+ * AgentFactory Orchestrator CLI
+ *
+ * Local script to spawn concurrent coding agents on backlog issues.
+ *
+ * Usage:
+ *   af-orchestrator [options]
+ *
+ * Options:
+ *   --project <name>    Filter issues by project name
+ *   --max <number>      Maximum concurrent agents (default: 3)
+ *   --single <id>       Process a single issue by ID
+ *   --no-wait           Don't wait for agents to complete
+ *   --dry-run           Show what would be done without executing
+ *
+ * Environment:
+ *   LINEAR_API_KEY      Required API key for Linear authentication
+ */
+import path from 'path';
+import { execSync } from 'child_process';
+import { config } from 'dotenv';
+// Load environment variables from .env.local
+config({ path: path.resolve(process.cwd(), '.env.local') });
+import { createOrchestrator } from '@supaku/agentfactory';
+function getGitRoot() {
+    try {
+        return execSync('git rev-parse --show-toplevel', {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+    }
+    catch {
+        return process.cwd();
+    }
+}
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const result = {
+        project: undefined,
+        max: 3,
+        single: undefined,
+        wait: true,
+        dryRun: false,
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        switch (arg) {
+            case '--project':
+                result.project = args[++i];
+                break;
+            case '--max':
+                result.max = parseInt(args[++i], 10);
+                break;
+            case '--single':
+                result.single = args[++i];
+                break;
+            case '--no-wait':
+                result.wait = false;
+                break;
+            case '--dry-run':
+                result.dryRun = true;
+                break;
+            case '--help':
+            case '-h':
+                printHelp();
+                process.exit(0);
+        }
+    }
+    return result;
+}
+function printHelp() {
+    console.log(`
+AgentFactory Orchestrator — Multi-agent fleet management for coding agents
+
+Usage:
+  af-orchestrator [options]
+
+Options:
+  --project <name>    Filter issues by project name
+  --max <number>      Maximum concurrent agents (default: 3)
+  --single <id>       Process a single issue by ID
+  --no-wait           Don't wait for agents to complete
+  --dry-run           Show what would be done without executing
+  --help, -h          Show this help message
+
+Environment:
+  LINEAR_API_KEY      Required API key for Linear authentication
+
+Examples:
+  # Process up to 3 backlog issues from a project
+  af-orchestrator --project MyProject
+
+  # Process a specific issue
+  af-orchestrator --single PROJ-123
+
+  # Preview what issues would be processed
+  af-orchestrator --project MyProject --dry-run
+`);
+}
+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`;
+}
+async function main() {
+    const args = parseArgs();
+    if (!process.env.LINEAR_API_KEY) {
+        console.error('Error: LINEAR_API_KEY environment variable is required');
+        process.exit(1);
+    }
+    console.log('AgentFactory Orchestrator');
+    console.log('========================');
+    console.log(`Project: ${args.project ?? 'All'}`);
+    console.log(`Max concurrent: ${args.max}`);
+    console.log(`Dry run: ${args.dryRun}`);
+    console.log('');
+    const gitRoot = getGitRoot();
+    const orchestrator = createOrchestrator({
+        project: args.project,
+        maxConcurrent: args.max,
+        worktreePath: path.resolve(gitRoot, '.worktrees'),
+    }, {
+        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}`);
+        },
+    });
+    try {
+        if (args.single) {
+            console.log(`Processing single issue: ${args.single}`);
+            if (args.dryRun) {
+                console.log('[DRY RUN] Would spawn agent for:', args.single);
+                return;
+            }
+            await orchestrator.spawnAgentForIssue(args.single);
+            console.log(`Agent spawned for ${args.single}`);
+            if (args.wait) {
+                console.log('Waiting for agent to complete...');
+                await orchestrator.waitForAll();
+            }
+            return;
+        }
+        if (args.dryRun) {
+            const issues = await orchestrator.getBacklogIssues();
+            if (issues.length === 0) {
+                console.log('No backlog issues found');
+                return;
+            }
+            console.log(`[DRY RUN] Would process ${issues.length} issue(s):`);
+            for (const issue of issues) {
+                console.log(`  - ${issue.identifier}: ${issue.title}`);
+                console.log(`    Priority: ${issue.priority || 'none'}`);
+                console.log(`    Labels: ${issue.labels.join(', ') || 'none'}`);
+            }
+            return;
+        }
+        const result = await orchestrator.run();
+        console.log('');
+        console.log('Orchestrator started');
+        console.log(`  Agents spawned: ${result.agents.length}`);
+        console.log(`  Errors: ${result.errors.length}`);
+        if (result.errors.length > 0) {
+            console.log('');
+            console.log('Errors:');
+            for (const { issueId, error } of result.errors) {
+                console.log(`  ${issueId}: ${error.message}`);
+            }
+        }
+        if (args.wait && result.agents.length > 0) {
+            console.log('');
+            console.log('Waiting for all agents to complete...');
+            process.on('SIGINT', () => {
+                console.log('');
+                console.log('Received SIGINT, stopping agents...');
+                orchestrator.stopAll();
+                process.exit(1);
+            });
+            const completedAgents = await orchestrator.waitForAll();
+            console.log('');
+            console.log('All agents completed');
+            console.log('Results:');
+            for (const agent of completedAgents) {
+                const duration = agent.completedAt
+                    ? formatDuration(agent.completedAt.getTime() - agent.startedAt.getTime())
+                    : 'unknown';
+                const status = agent.status === 'completed' ? 'SUCCESS' : 'FAILED';
+                console.log(`  ${agent.identifier}: ${status} (${duration})`);
+            }
+        }
+    }
+    catch (error) {
+        console.error('Orchestrator failed:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/dist/src/worker.d.ts

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+/**
+ * AgentFactory Worker CLI
+ *
+ * Starts a remote worker that polls the Redis work queue
+ * and processes assigned agent sessions.
+ *
+ * Usage:
+ *   af-worker [options]
+ *
+ * Options:
+ *   --capacity <number>   Maximum concurrent agents (default: 2)
+ *   --api-url <url>       Agent API URL for activity proxying
+ *   --api-key <key>       API key for worker authentication
+ *
+ * Environment:
+ *   LINEAR_API_KEY        Required API key for Linear authentication
+ *   REDIS_URL             Required for work queue polling
+ *   WORKER_API_URL        Agent API URL (alternative to --api-url)
+ *   WORKER_API_KEY        API key (alternative to --api-key)
+ */
+export {};
+//# sourceMappingURL=worker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../src/worker.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;;GAmBG"}

package/dist/src/worker.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+/**
+ * AgentFactory Worker CLI
+ *
+ * Starts a remote worker that polls the Redis work queue
+ * and processes assigned agent sessions.
+ *
+ * Usage:
+ *   af-worker [options]
+ *
+ * Options:
+ *   --capacity <number>   Maximum concurrent agents (default: 2)
+ *   --api-url <url>       Agent API URL for activity proxying
+ *   --api-key <key>       API key for worker authentication
+ *
+ * Environment:
+ *   LINEAR_API_KEY        Required API key for Linear authentication
+ *   REDIS_URL             Required for work queue polling
+ *   WORKER_API_URL        Agent API URL (alternative to --api-url)
+ *   WORKER_API_KEY        API key (alternative to --api-key)
+ */
+import path from 'path';
+import { config } from 'dotenv';
+// Load environment variables
+config({ path: path.resolve(process.cwd(), '.env.local') });
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const result = {
+        capacity: 2,
+        apiUrl: process.env.WORKER_API_URL,
+        apiKey: process.env.WORKER_API_KEY,
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        switch (arg) {
+            case '--capacity':
+                result.capacity = parseInt(args[++i], 10);
+                break;
+            case '--api-url':
+                result.apiUrl = args[++i];
+                break;
+            case '--api-key':
+                result.apiKey = args[++i];
+                break;
+            case '--help':
+            case '-h':
+                printHelp();
+                process.exit(0);
+        }
+    }
+    return result;
+}
+function printHelp() {
+    console.log(`
+AgentFactory Worker — Remote agent worker for distributed processing
+
+Usage:
+  af-worker [options]
+
+Options:
+  --capacity <number>   Maximum concurrent agents (default: 2)
+  --api-url <url>       Agent API URL for activity proxying
+  --api-key <key>       API key for worker authentication
+  --help, -h            Show this help message
+
+Environment:
+  LINEAR_API_KEY        Required API key for Linear authentication
+  REDIS_URL             Required for work queue polling
+  WORKER_API_URL        Agent API URL (alternative to --api-url)
+  WORKER_API_KEY        API key (alternative to --api-key)
+`);
+}
+async function main() {
+    const args = parseArgs();
+    if (!process.env.LINEAR_API_KEY) {
+        console.error('Error: LINEAR_API_KEY environment variable is required');
+        process.exit(1);
+    }
+    if (!process.env.REDIS_URL) {
+        console.error('Error: REDIS_URL environment variable is required for worker mode');
+        process.exit(1);
+    }
+    console.log('AgentFactory Worker');
+    console.log('===================');
+    console.log(`Capacity: ${args.capacity}`);
+    console.log(`API URL: ${args.apiUrl ?? 'not configured'}`);
+    console.log('');
+    console.log('Worker started. Polling for work...');
+    console.log('Press Ctrl+C to stop.');
+    // Keep process alive
+    process.on('SIGINT', () => {
+        console.log('');
+        console.log('Worker shutting down...');
+        process.exit(0);
+    });
+    // TODO: Implement worker polling loop
+    // This is a placeholder — the full implementation involves:
+    // 1. Register with worker-storage
+    // 2. Poll work-queue at interval
+    // 3. Claim and process work items
+    // 4. Send heartbeats
+    // 5. Clean up on shutdown
+    console.log('Worker implementation: see @supaku/agentfactory-server for queue operations');
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@supaku/agentfactory-cli",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "CLI tools for AgentFactory — local orchestrator, remote worker, queue admin",
+  "author": "Supaku (https://supaku.com)",
+  "license": "MIT",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/supaku/agentfactory",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/supaku/agentfactory/tree/main/packages/cli",
+  "bugs": {
+    "url": "https://github.com/supaku/agentfactory/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "cli",
+    "orchestrator",
+    "worker",
+    "agent-management"
+  ],
+  "bin": {
+    "agentfactory": "./dist/src/index.js",
+    "af-orchestrator": "./dist/src/orchestrator.js",
+    "af-worker": "./dist/src/worker.js"
+  },
+  "main": "./dist/src/index.js",
+  "module": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "dotenv": "^17.2.3",
+    "@supaku/agentfactory": "0.1.0",
+    "@supaku/agentfactory-linear": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.5.4",
+    "typescript": "^5.7.3"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  }
+}