332 lines
12 KiB
TypeScript
332 lines
12 KiB
TypeScript
import { Command } from 'commander';
|
|
import { init } from './commands/init.js';
|
|
import { status } from './commands/status.js';
|
|
import { memoryAdd, memorySearch, memoryList } from './commands/memory.js';
|
|
import { taskCreate, taskList, taskShow, taskClaim, taskDone } from './commands/task.js';
|
|
import { handoffCreate, handoffRead, handoffList } from './commands/handoff.js';
|
|
import { decisionCreate, decisionList } from './commands/decision.js';
|
|
import { delegate } from './commands/delegate.js';
|
|
import { serverStart } from './commands/server.js';
|
|
import { loadConfig } from '../core/config.js';
|
|
import { remoteClient, RemoteError } from './remoteClient.js';
|
|
|
|
function getServerUrl(program: Command, cwd: string): string | undefined {
|
|
const flag = (program.opts().server as string | undefined) || process.env.AGENTHUB_SERVER;
|
|
if (flag) return flag;
|
|
try {
|
|
const config = loadConfig(cwd);
|
|
return config.serverUrl;
|
|
} catch {
|
|
return undefined;
|
|
}
|
|
}
|
|
|
|
function remoteOnly(): never {
|
|
console.error('Remote mode is not supported for this command. Run it locally or omit --server.');
|
|
process.exit(1);
|
|
}
|
|
|
|
async function runRemote(serverUrl: string, fn: () => Promise<void>): Promise<void> {
|
|
try {
|
|
await fn();
|
|
} catch (err) {
|
|
if (err instanceof RemoteError) {
|
|
if (err.status === 0) {
|
|
console.error(`AgentHub server at ${serverUrl} is not reachable. Is 'agenthub server start --host 0.0.0.0' running?`);
|
|
} else {
|
|
console.error(`AgentHub server error (${err.status}): ${err.message}`);
|
|
}
|
|
process.exit(1);
|
|
}
|
|
throw err;
|
|
}
|
|
}
|
|
|
|
export function createProgram(cwd: string): Command {
|
|
const program = new Command('agenthub')
|
|
.description('Local coordination layer for AI coding agents')
|
|
.version('0.1.0')
|
|
.option('--server <url>', 'AgentHub server URL (env: AGENTHUB_SERVER)');
|
|
|
|
program
|
|
.command('init')
|
|
.description('Initialize AgentHub in the current directory')
|
|
.option('-n, --project-name <name>', 'Project name')
|
|
.option('-y, --yes', 'Use defaults without prompts')
|
|
.option('--server <url>', 'Connect to a remote AgentHub server (stored in config)')
|
|
.action((options) => {
|
|
init(cwd, { ...options, server: options.server || (program.opts().server as string | undefined) });
|
|
});
|
|
|
|
program
|
|
.command('status')
|
|
.description('Show project status')
|
|
.option('-u, --update', 'Regenerate status before showing')
|
|
.action(async (options) => {
|
|
const serverUrl = getServerUrl(program, cwd);
|
|
if (serverUrl) {
|
|
await runRemote(serverUrl, async () => {
|
|
const body = options.update ? await remoteClient.updateStatus(serverUrl) : await remoteClient.getStatus(serverUrl);
|
|
console.log(body);
|
|
});
|
|
} else {
|
|
status(cwd, options);
|
|
}
|
|
});
|
|
|
|
const memoryCmd = new Command('memory').description('Manage memory entries');
|
|
memoryCmd
|
|
.command('add')
|
|
.description('Add a memory entry')
|
|
.option('--title <title>', 'Title')
|
|
.option('--category <category>', 'Category')
|
|
.option('--content <content>', 'Content')
|
|
.action(async (options) => {
|
|
const serverUrl = getServerUrl(program, cwd);
|
|
if (serverUrl) {
|
|
await runRemote(serverUrl, async () => {
|
|
const memory = await remoteClient.addMemory(serverUrl, options);
|
|
console.log(`Memory saved as ${memory.id}.`);
|
|
});
|
|
} else {
|
|
await memoryAdd(cwd, options);
|
|
}
|
|
});
|
|
memoryCmd
|
|
.command('search <query>')
|
|
.description('Search memory and tasks')
|
|
.action(async (query) => {
|
|
const serverUrl = getServerUrl(program, cwd);
|
|
if (serverUrl) {
|
|
await runRemote(serverUrl, async () => {
|
|
const results = await remoteClient.searchMemory(serverUrl, query);
|
|
if (results.length === 0) { console.log('No results found.'); return; }
|
|
for (const r of results) console.log(`[${r.type}] ${r.id}: ${r.title}`);
|
|
});
|
|
} else {
|
|
memorySearch(cwd, query);
|
|
}
|
|
});
|
|
memoryCmd
|
|
.command('list')
|
|
.description('List memory entries')
|
|
.action(async () => {
|
|
const serverUrl = getServerUrl(program, cwd);
|
|
if (serverUrl) {
|
|
await runRemote(serverUrl, async () => {
|
|
const memories = await remoteClient.listMemory(serverUrl);
|
|
if (memories.length === 0) { console.log('No memory entries found.'); return; }
|
|
for (const m of memories) console.log(`${m.id}: ${m.title}`);
|
|
});
|
|
} else {
|
|
memoryList(cwd);
|
|
}
|
|
});
|
|
program.addCommand(memoryCmd);
|
|
|
|
const taskCmd = new Command('task').description('Manage tasks');
|
|
taskCmd
|
|
.command('create')
|
|
.description('Create a task')
|
|
.option('--title <title>', 'Title')
|
|
.option('--role <role>', 'Role')
|
|
.option('--priority <priority>', 'Priority')
|
|
.action(async (options) => {
|
|
const serverUrl = getServerUrl(program, cwd);
|
|
if (serverUrl) {
|
|
await runRemote(serverUrl, async () => {
|
|
const task = await remoteClient.createTask(serverUrl, options);
|
|
console.log(`Created ${task.id}: ${task.title}`);
|
|
});
|
|
} else {
|
|
await taskCreate(cwd, options);
|
|
}
|
|
});
|
|
taskCmd
|
|
.command('list')
|
|
.description('List tasks')
|
|
.option('--status <status>', 'Filter by status')
|
|
.option('--role <role>', 'Filter by role')
|
|
.action(async (options) => {
|
|
const serverUrl = getServerUrl(program, cwd);
|
|
if (serverUrl) {
|
|
await runRemote(serverUrl, async () => {
|
|
const tasks = await remoteClient.listTasks(serverUrl, options);
|
|
if (tasks.length === 0) { console.log('No tasks found.'); return; }
|
|
for (const t of tasks) console.log(`${t.id} [${t.status}] (${t.role ?? 'unassigned'}) ${t.title}`);
|
|
});
|
|
} else {
|
|
taskList(cwd, options);
|
|
}
|
|
});
|
|
taskCmd
|
|
.command('show <id>')
|
|
.description('Show a task')
|
|
.action(async (id) => {
|
|
const serverUrl = getServerUrl(program, cwd);
|
|
if (serverUrl) {
|
|
await runRemote(serverUrl, async () => {
|
|
const { task, body } = await remoteClient.getTask(serverUrl, id);
|
|
console.log(`# ${task.title}`);
|
|
console.log(`Status: ${task.status} | Role: ${task.role ?? '-'} | Priority: ${task.priority}`);
|
|
console.log('\n' + body);
|
|
});
|
|
} else {
|
|
taskShow(cwd, id);
|
|
}
|
|
});
|
|
taskCmd
|
|
.command('claim <id>')
|
|
.description('Claim a task')
|
|
.requiredOption('--agent <agent>', 'Agent name')
|
|
.action(async (id, options) => {
|
|
const serverUrl = getServerUrl(program, cwd);
|
|
if (serverUrl) {
|
|
await runRemote(serverUrl, async () => {
|
|
await remoteClient.claimTask(serverUrl, id, options.agent);
|
|
console.log(`${id} claimed by ${options.agent}.`);
|
|
});
|
|
} else {
|
|
taskClaim(cwd, id, options.agent);
|
|
}
|
|
});
|
|
taskCmd
|
|
.command('done <id>')
|
|
.description('Mark a task as done')
|
|
.action(async (id) => {
|
|
const serverUrl = getServerUrl(program, cwd);
|
|
if (serverUrl) {
|
|
await runRemote(serverUrl, async () => {
|
|
await remoteClient.doneTask(serverUrl, id);
|
|
console.log(`${id} marked as done.`);
|
|
});
|
|
} else {
|
|
taskDone(cwd, id);
|
|
}
|
|
});
|
|
program.addCommand(taskCmd);
|
|
|
|
const handoffCmd = new Command('handoff').description('Manage handoffs');
|
|
handoffCmd
|
|
.command('create')
|
|
.description('Create a handoff')
|
|
.option('--fromRole <role>', 'From role')
|
|
.option('--toRole <role>', 'To role')
|
|
.option('--taskId <id>', 'Related task id')
|
|
.option('--summary <summary>', 'Summary')
|
|
.option('--context <context>', 'Context')
|
|
.action(async (options) => {
|
|
const serverUrl = getServerUrl(program, cwd);
|
|
if (serverUrl) {
|
|
await runRemote(serverUrl, async () => {
|
|
const handoff = await remoteClient.createHandoff(serverUrl, options);
|
|
console.log(`Handoff created: ${handoff.id}`);
|
|
});
|
|
} else {
|
|
await handoffCreate(cwd, options);
|
|
}
|
|
});
|
|
handoffCmd
|
|
.command('read <id>')
|
|
.description('Read a handoff')
|
|
.action(async (id) => {
|
|
const serverUrl = getServerUrl(program, cwd);
|
|
if (serverUrl) {
|
|
await runRemote(serverUrl, async () => {
|
|
const { handoff, body } = await remoteClient.getHandoff(serverUrl, id);
|
|
console.log(`# ${handoff.summary}`);
|
|
console.log(`From: ${handoff.fromRole} → ${handoff.toRole}`);
|
|
if (handoff.taskId) console.log(`Task: ${handoff.taskId}`);
|
|
console.log('\n' + body);
|
|
});
|
|
} else {
|
|
handoffRead(cwd, id);
|
|
}
|
|
});
|
|
handoffCmd
|
|
.command('list')
|
|
.description('List handoffs')
|
|
.action(async () => {
|
|
const serverUrl = getServerUrl(program, cwd);
|
|
if (serverUrl) {
|
|
await runRemote(serverUrl, async () => {
|
|
const handoffs = await remoteClient.listHandoffs(serverUrl);
|
|
if (handoffs.length === 0) { console.log('No handoffs found.'); return; }
|
|
for (const h of handoffs) console.log(`${h.id}: ${h.title}`);
|
|
});
|
|
} else {
|
|
handoffList(cwd);
|
|
}
|
|
});
|
|
program.addCommand(handoffCmd);
|
|
|
|
const decisionCmd = new Command('decision').description('Manage decisions');
|
|
decisionCmd
|
|
.command('create')
|
|
.description('Create a decision record')
|
|
.option('--title <title>', 'Title')
|
|
.option('--context <context>', 'Context')
|
|
.option('--decision <decision>', 'Decision')
|
|
.action(async (options) => {
|
|
const serverUrl = getServerUrl(program, cwd);
|
|
if (serverUrl) {
|
|
await runRemote(serverUrl, async () => {
|
|
const decision = await remoteClient.createDecision(serverUrl, options);
|
|
console.log(`Decision recorded: ${decision.id}`);
|
|
});
|
|
} else {
|
|
await decisionCreate(cwd, options);
|
|
}
|
|
});
|
|
decisionCmd
|
|
.command('list')
|
|
.description('List decisions')
|
|
.action(async () => {
|
|
const serverUrl = getServerUrl(program, cwd);
|
|
if (serverUrl) {
|
|
await runRemote(serverUrl, async () => {
|
|
const decisions = await remoteClient.listDecisions(serverUrl);
|
|
if (decisions.length === 0) { console.log('No decisions found.'); return; }
|
|
for (const d of decisions) console.log(`${d.id}: ${d.title}`);
|
|
});
|
|
} else {
|
|
decisionList(cwd);
|
|
}
|
|
});
|
|
program.addCommand(decisionCmd);
|
|
|
|
program
|
|
.command('delegate')
|
|
.description('Suggest or auto-delegate open tasks')
|
|
.option('--auto', 'Create handoff automatically')
|
|
.action(async (options) => {
|
|
const serverUrl = getServerUrl(program, cwd);
|
|
if (serverUrl) {
|
|
await runRemote(serverUrl, async () => {
|
|
const result = await remoteClient.delegate(serverUrl, options.auto ?? false);
|
|
if (!result.suggestion) { console.log('No open tasks to delegate.'); return; }
|
|
const s = result.suggestion;
|
|
console.log('Suggested delegation:');
|
|
console.log(` Task: ${s.task.id} — ${s.task.title}`);
|
|
console.log(` Role: ${s.role}`);
|
|
console.log(` Preferred agent: ${s.preferredAgent}`);
|
|
if (result.handoff) console.log('Handoff created automatically.');
|
|
else console.log('Run with --auto to create the handoff.');
|
|
});
|
|
} else {
|
|
await delegate(cwd, options);
|
|
}
|
|
});
|
|
|
|
const serverCmd = new Command('server').description('Optional local API server');
|
|
serverCmd
|
|
.command('start')
|
|
.description('Start the optional AgentHub API server')
|
|
.option('-p, --port <port>', 'Port', '3377')
|
|
.option('-h, --host <host>', 'Host to bind to', '127.0.0.1')
|
|
.action((options) => serverStart(cwd, { port: parseInt(options.port, 10), host: options.host }));
|
|
program.addCommand(serverCmd);
|
|
|
|
return program;
|
|
}
|