@agentmeshhq/agent 0.4.1 → 0.4.3

package/dist/cli/index.js

@@ -3,24 +3,31 @@ import { createRequire } from "node:module";
 import { Command } from "commander";
 import pc from "picocolors";
 import { attach } from "./attach.js";
+import { runAutopilot } from "./autopilot.js";
 import { build } from "./build.js";
+import { createClaim, listClaims, releaseClaim } from "./claims.js";
 import { configCmd } from "./config.js";
 import { contextCmd } from "./context.js";
 import { deploy } from "./deploy.js";
+import { completeHandoff, inbox, reassignHandoff, updateHandoffStatus } from "./handoff.js";
 import { init } from "./init.js";
+import { claimIssue, closeIssue, createIssue, handoffIssue, listIssues, showIssue, updateIssue, } from "./issue.js";
 import { list } from "./list.js";
-import { localDown, localLogs, localStatus, localUp } from "./local.js";
+import { localDoctor, localDown, localLogs, localSmoke, localStatus, localUp } from "./local.js";
 import { logs } from "./logs.js";
 import { migrate } from "./migrate.js";
 import { nudge } from "./nudge.js";
+import { ready } from "./ready.js";
 import { restart } from "./restart.js";
 import { slack } from "./slack.js";
 import { start } from "./start.js";
 import { status } from "./status.js";
 import { stop } from "./stop.js";
+import { sync } from "./sync.js";
 import { test } from "./test.js";
 import { token } from "./token.js";
-import { whoami } from "./whoami.js";
+import { resolvePO, whoami } from "./whoami.js";
+import { pauseWorkerAutomation, resumeWorkerAutomation } from "./worker.js";
 const require = createRequire(import.meta.url);
 const pkg = require("../../package.json");
 const program = new Command();
@@ -28,6 +35,40 @@ program
     .name("agentmesh")
     .description("AgentMesh Agent Wrapper - Turn any AI assistant into a dispatchable agent")
     .version(pkg.version);
+program
+    .command("autopilot")
+    .description("Legacy compatibility wrapper for worker autopilot mode")
+    .command("run")
+    .description("Run autonomous worker mode (canonical path: agentmesh start --worker)")
+    .requiredOption("-n, --name <name>", "Agent name")
+    .option("-c, --command <command>", "Command to run (default: opencode)")
+    .option("-w, --workdir <path>", "Working directory")
+    .option("-m, --model <model>", "Model identifier")
+    .option("--restore-context", "Restore context from previous session")
+    .option("--auto-setup", "Auto-clone repository for project assignments")
+    .option("-p, --project <code>", "Project code — auto-resolves workdir from project settings")
+    .option("--role <role>", "Role for auto-assignment (default: dev)")
+    .option("--no-auto-accept-handoffs", "Disable automatic handoff acceptance in worker mode (enabled by default)")
+    .action(async (options) => {
+    try {
+        console.log(pc.yellow("[deprecated] `agentmesh autopilot run` is a compatibility wrapper. Prefer `agentmesh start --worker`."));
+        await runAutopilot({
+            name: options.name,
+            command: options.command,
+            workdir: options.workdir,
+            model: options.model,
+            restoreContext: options.restoreContext,
+            autoSetup: options.autoSetup,
+            project: options.project,
+            role: options.role,
+            noAutoAcceptHandoffs: options.noAutoAcceptHandoffs,
+        });
+    }
+    catch (error) {
+        console.error(pc.red(error.message));
+        process.exit(1);
+    }
+});
 program
     .command("init")
     .description("Initialize AgentMesh configuration")
@@ -50,6 +91,7 @@ program
     .option("-f, --foreground", "Run in foreground (blocking)")
     .option("--restore-context", "Restore context from previous session (default: disabled)")
     .option("--worker", "Enable auto-nudge and restart for worker agents (default: disabled)")
+    .option("--no-auto-accept-handoffs", "Disable automatic handoff acceptance in worker mode (enabled by default for --worker)")
     .option("--auto-setup", "Auto-clone repository for project assignments")
     .option("-p, --project <code>", "Project code — auto-resolves workdir from project settings")
     .option("--role <role>", "Role for auto-assignment (default: dev)")
@@ -129,13 +171,175 @@ program
         process.exit(1);
     }
 });
+program
+    .command("inbox")
+    .description("List inbox items (defaults to pending handoffs)")
+    .option("-n, --name <name>", "Agent name")
+    .option("--type <type>", "Inbox type filter", "handoff")
+    .option("--all", "Include all statuses (default: pending only)")
+    .option("--json", "Output JSON")
+    .action(async (options) => {
+    try {
+        await inbox({
+            name: options.name,
+            type: options.type,
+            includeAll: options.all,
+            json: options.json,
+        });
+    }
+    catch (error) {
+        console.error(pc.red(error.message));
+        process.exit(1);
+    }
+});
+const handoffCommand = program.command("handoff").description("Manage handoff lifecycle");
+handoffCommand
+    .command("accept")
+    .description("Accept a handoff")
+    .argument("<handoffId>", "Handoff ID")
+    .option("-n, --name <name>", "Agent name")
+    .action(async (handoffId, options) => {
+    try {
+        await updateHandoffStatus(handoffId, "accepted", options.name);
+    }
+    catch (error) {
+        console.error(pc.red(error.message));
+        process.exit(1);
+    }
+});
+const claimsCommand = program.command("claims").description("Manage coordination claims");
+claimsCommand
+    .command("create")
+    .description("Create a claim for path patterns")
+    .requiredOption("--scope <scope>", "Claim scope")
+    .requiredOption("--path <pattern...>", "Path pattern(s), repeat or pass comma-separated values")
+    .option("--ttl-seconds <seconds>", "Claim TTL in seconds (30-86400)")
+    .option("-n, --name <name>", "Agent name")
+    .action(async (options) => {
+    try {
+        await createClaim({
+            name: options.name,
+            scope: options.scope,
+            paths: options.path,
+            ttlSeconds: options.ttlSeconds ? parseInt(options.ttlSeconds, 10) : undefined,
+        });
+    }
+    catch (error) {
+        console.error(pc.red(error.message));
+        process.exit(1);
+    }
+});
+claimsCommand
+    .command("list")
+    .description("List claims in the current workspace")
+    .option("-n, --name <name>", "Agent name")
+    .option("--status <status>", "Filter by status (active, released, expired, force_released)")
+    .option("--json", "Output JSON")
+    .action(async (options) => {
+    try {
+        await listClaims({
+            name: options.name,
+            status: options.status,
+            json: options.json,
+        });
+    }
+    catch (error) {
+        console.error(pc.red(error.message));
+        process.exit(1);
+    }
+});
+claimsCommand
+    .command("release")
+    .description("Release an active claim")
+    .argument("<claimId>", "Claim ID")
+    .option("-n, --name <name>", "Agent name")
+    .action(async (claimId, options) => {
+    try {
+        await releaseClaim(claimId, { name: options.name });
+    }
+    catch (error) {
+        console.error(pc.red(error.message));
+        process.exit(1);
+    }
+});
+handoffCommand
+    .command("reject")
+    .description("Reject a handoff")
+    .argument("<handoffId>", "Handoff ID")
+    .option("-n, --name <name>", "Agent name")
+    .action(async (handoffId, options) => {
+    try {
+        await updateHandoffStatus(handoffId, "rejected", options.name);
+    }
+    catch (error) {
+        console.error(pc.red(error.message));
+        process.exit(1);
+    }
+});
+handoffCommand
+    .command("complete")
+    .description("Complete an accepted handoff")
+    .argument("<handoffId>", "Handoff ID")
+    .option("-n, --name <name>", "Agent name")
+    .option("--notes <notes>", "Completion notes")
+    .action(async (handoffId, options) => {
+    try {
+        await completeHandoff(handoffId, { name: options.name, notes: options.notes });
+    }
+    catch (error) {
+        console.error(pc.red(error.message));
+        process.exit(1);
+    }
+});
+handoffCommand
+    .command("reassign")
+    .description("Reassign a handoff to another agent")
+    .argument("<handoffId>", "Handoff ID")
+    .requiredOption("--to-agent-id <agentId>", "Target agent ID")
+    .option("-n, --name <name>", "Agent name")
+    .option("--scope <scope>", "Optional scope override for reassigned handoff")
+    .option("--reason <reason>", "Optional reason override for reassigned handoff")
+    .action(async (handoffId, options) => {
+    try {
+        await reassignHandoff(handoffId, {
+            name: options.name,
+            toAgentId: options.toAgentId,
+            scope: options.scope,
+            reason: options.reason,
+        });
+    }
+    catch (error) {
+        console.error(pc.red(error.message));
+        process.exit(1);
+    }
+});
 program
     .command("whoami")
     .description("Show current agent identity and status")
     .argument("[name]", "Agent name (optional)")
-    .action(async (name) => {
+    .option("--po", "Resolve and print the canonical Product Owner agent ID for this team")
+    .action(async (name, options) => {
+    try {
+        if (options.po) {
+            await resolvePO(name);
+        }
+        else {
+            await whoami(name);
+        }
+    }
+    catch (error) {
+        console.error(pc.red(error.message));
+        process.exit(1);
+    }
+});
+const poCmd = program.command("po").description("Product Owner operations");
+poCmd
+    .command("resolve")
+    .description("Resolve the canonical Product Owner agent ID for the current team/workspace")
+    .option("-n, --name <name>", "Agent name (for token resolution)")
+    .action(async (options) => {
     try {
-        await whoami(name);
+        await resolvePO(options.name);
     }
     catch (error) {
         console.error(pc.red(error.message));
@@ -145,7 +349,7 @@ program
 program
     .command("token")
     .description("Manage agent tokens")
-    .argument("[action]", "Action: show (default), refresh, info")
+    .argument("[action]", "Action: show (default), refresh, info, health")
     .option("-n, --name <name>", "Agent name")
     .action(async (action, options) => {
     try {
@@ -159,9 +363,37 @@ program
 program
     .command("status")
     .description("Show AgentMesh status and health")
-    .action(async () => {
+    .option("--sla-minutes <minutes>", "Pending handoff SLA threshold in minutes", "5")
+    .action(async (options) => {
+    try {
+        await status({ pendingHandoffSlaMinutes: parseInt(options.slaMinutes, 10) });
+    }
+    catch (error) {
+        console.error(pc.red(error.message));
+        process.exit(1);
+    }
+});
+const workerCommand = program.command("worker").description("Worker intervention controls");
+workerCommand
+    .command("pause")
+    .description("Pause autonomous worker actions for an agent")
+    .argument("<name>", "Agent name")
+    .action(async (name) => {
+    try {
+        await pauseWorkerAutomation(name);
+    }
+    catch (error) {
+        console.error(pc.red(error.message));
+        process.exit(1);
+    }
+});
+workerCommand
+    .command("resume")
+    .description("Resume autonomous worker actions for an agent")
+    .argument("<name>", "Agent name")
+    .action(async (name) => {
     try {
-        await status();
+        await resumeWorkerAutomation(name);
     }
     catch (error) {
         console.error(pc.red(error.message));
@@ -251,9 +483,17 @@ localCmd
     .command("up")
     .description("Start local development stack")
     .option("--no-detach", "Run in foreground")
+    .option("--target <path>", "Compose file path or target name (default: docker/docker-compose.local.yml)")
+    .option("--slot <number>", "Slot number for deterministic non-overlapping port block (0-based)", parseInt)
+    .option("--project <name>", "Docker Compose project name for namespace isolation")
     .action(async (options) => {
     try {
-        await localUp({ detach: options.detach });
+        await localUp({
+            detach: options.detach,
+            target: options.target,
+            slot: options.slot,
+            project: options.project,
+        });
     }
     catch (error) {
         console.error(pc.red(error.message));
@@ -263,9 +503,16 @@ localCmd
 localCmd
     .command("down")
     .description("Stop local development stack")
-    .action(async () => {
+    .option("--target <path>", "Compose file path or target name")
+    .option("--slot <number>", "Slot number", parseInt)
+    .option("--project <name>", "Docker Compose project name")
+    .action(async (options) => {
     try {
-        await localDown();
+        await localDown({
+            target: options.target,
+            slot: options.slot,
+            project: options.project,
+        });
     }
     catch (error) {
         console.error(pc.red(error.message));
@@ -275,9 +522,16 @@ localCmd
 localCmd
     .command("status")
     .description("Show local stack status and ports")
-    .action(async () => {
+    .option("--target <path>", "Compose file path or target name")
+    .option("--slot <number>", "Slot number", parseInt)
+    .option("--project <name>", "Docker Compose project name")
+    .action(async (options) => {
     try {
-        await localStatus();
+        await localStatus({
+            target: options.target,
+            slot: options.slot,
+            project: options.project,
+        });
     }
     catch (error) {
         console.error(pc.red(error.message));
@@ -289,9 +543,50 @@ localCmd
     .description("View local stack logs")
     .option("-f, --follow", "Follow log output")
     .option("-s, --service <name>", "Specific service to show logs for")
+    .option("--target <path>", "Compose file path or target name")
+    .option("--slot <number>", "Slot number", parseInt)
+    .option("--project <name>", "Docker Compose project name")
+    .action(async (options) => {
+    try {
+        await localLogs({
+            follow: options.follow,
+            service: options.service,
+            target: options.target,
+            slot: options.slot,
+            project: options.project,
+        });
+    }
+    catch (error) {
+        console.error(pc.red(error.message));
+        process.exit(1);
+    }
+});
+localCmd
+    .command("doctor")
+    .description("Run preflight checks (port availability, compose file) without starting")
+    .option("--target <path>", "Compose file path or target name")
+    .option("--slot <number>", "Slot number", parseInt)
+    .option("--project <name>", "Docker Compose project name")
     .action(async (options) => {
     try {
-        await localLogs({ follow: options.follow, service: options.service });
+        await localDoctor({
+            target: options.target,
+            slot: options.slot,
+            project: options.project,
+        });
+    }
+    catch (error) {
+        console.error(pc.red(error.message));
+        process.exit(1);
+    }
+});
+localCmd
+    .command("smoke")
+    .description("Quick smoke test — verify local stack API is reachable")
+    .option("--slot <number>", "Slot number", parseInt)
+    .action(async (options) => {
+    try {
+        await localSmoke({ slot: options.slot });
     }
     catch (error) {
         console.error(pc.red(error.message));
@@ -370,5 +665,193 @@ program
         process.exit(1);
     }
 });
+// Issue tracking commands
+const issueCmd = program.command("issue").description("Manage issues (integrated issue tracking)");
+issueCmd
+    .command("create")
+    .description("Create a new issue")
+    .requiredOption("-t, --title <title>", "Issue title")
+    .option("-d, --description <desc>", "Issue description")
+    .option("--type <type>", "Issue type: bug, feature, task, epic", "task")
+    .option("--priority <priority>", "Priority: P0, P1, P2, P3, P4", "P2")
+    .option("--project <id>", "Project ID")
+    .option("--parent <id>", "Parent issue ID (for sub-tasks)")
+    .option("-l, --labels <labels>", "Comma-separated labels")
+    .action(async (options) => {
+    try {
+        await createIssue({
+            title: options.title,
+            description: options.description,
+            type: options.type,
+            priority: options.priority,
+            project: options.project,
+            parent: options.parent,
+            labels: options.labels?.split(",").map((l) => l.trim()),
+        });
+    }
+    catch (error) {
+        console.error(pc.red(error.message));
+        process.exit(1);
+    }
+});
+issueCmd
+    .command("list")
+    .alias("ls")
+    .description("List issues")
+    .option("-s, --status <status>", "Filter by status: open, in_progress, review, closed")
+    .option("--type <type>", "Filter by type: bug, feature, task, epic")
+    .option("--priority <priority>", "Filter by priority: P0, P1, P2, P3, P4")
+    .option("-a, --assignee <id>", "Filter by assignee (use 'me' for self)")
+    .option("--project <id>", "Filter by project")
+    .option("-n, --limit <n>", "Number of issues to show", "20")
+    .action(async (options) => {
+    try {
+        await listIssues({
+            status: options.status,
+            type: options.type,
+            priority: options.priority,
+            assignee: options.assignee,
+            project: options.project,
+            limit: parseInt(options.limit, 10),
+        });
+    }
+    catch (error) {
+        console.error(pc.red(error.message));
+        process.exit(1);
+    }
+});
+issueCmd
+    .command("show")
+    .description("Show issue details")
+    .argument("<id>", "Issue ID (e.g., agentmesh-abc)")
+    .action(async (id) => {
+    try {
+        await showIssue(id);
+    }
+    catch (error) {
+        console.error(pc.red(error.message));
+        process.exit(1);
+    }
+});
+issueCmd
+    .command("update")
+    .description("Update an issue")
+    .argument("<id>", "Issue ID")
+    .option("-t, --title <title>", "New title")
+    .option("-d, --description <desc>", "New description")
+    .option("--type <type>", "New type")
+    .option("--priority <priority>", "New priority")
+    .option("-s, --status <status>", "New status")
+    .option("--project <id>", "Assign to project")
+    .option("-a, --assignee <id>", "Assign to agent")
+    .option("-l, --labels <labels>", "Comma-separated labels")
+    .action(async (id, options) => {
+    try {
+        await updateIssue(id, {
+            title: options.title,
+            description: options.description,
+            type: options.type,
+            priority: options.priority,
+            status: options.status,
+            project: options.project,
+            assignee: options.assignee,
+            labels: options.labels?.split(",").map((l) => l.trim()),
+        });
+    }
+    catch (error) {
+        console.error(pc.red(error.message));
+        process.exit(1);
+    }
+});
+issueCmd
+    .command("close")
+    .description("Close an issue")
+    .argument("<id>", "Issue ID")
+    .action(async (id) => {
+    try {
+        await closeIssue(id);
+    }
+    catch (error) {
+        console.error(pc.red(error.message));
+        process.exit(1);
+    }
+});
+issueCmd
+    .command("claim")
+    .description("Claim an issue (assign to self and set in_progress)")
+    .argument("<id>", "Issue ID")
+    .action(async (id) => {
+    try {
+        await claimIssue(id);
+    }
+    catch (error) {
+        console.error(pc.red(error.message));
+        process.exit(1);
+    }
+});
+issueCmd
+    .command("handoff")
+    .description("Hand off an issue to another agent (creates handoff record)")
+    .argument("<id>", "Issue ID")
+    .requiredOption("--to <agent>", "Target agent ID")
+    .option("-r, --reason <reason>", "Reason for handoff")
+    .action(async (id, options) => {
+    try {
+        await handoffIssue(id, { to: options.to, reason: options.reason });
+    }
+    catch (error) {
+        console.error(pc.red(error.message));
+        process.exit(1);
+    }
+});
+// Inbox command
+program
+    .command("inbox")
+    .description("Show your assigned issues and pending handoffs")
+    .option("-n, --name <name>", "Agent name")
+    .option("--type <type>", "Filter by type (handoff|issue)")
+    .option("--all", "Include all statuses")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    try {
+        await inbox({
+            name: options.name,
+            type: options.type,
+            includeAll: options.all,
+            json: options.json,
+        });
+    }
+    catch (error) {
+        console.error(pc.red(error.message));
+        process.exit(1);
+    }
+});
+// Ready command
+program
+    .command("ready")
+    .description("Show available unassigned work")
+    .action(async () => {
+    try {
+        await ready();
+    }
+    catch (error) {
+        console.error(pc.red(error.message));
+        process.exit(1);
+    }
+});
+// Sync command
+program
+    .command("sync")
+    .description("Sync local issue cache with AgentMesh HQ")
+    .option("-f, --force", "Force sync even if there are errors")
+    .action(async (options) => {
+    try {
+        await sync({ force: options.force });
+    }
+    catch (error) {
+        console.error(pc.red(error.message));
+        process.exit(1);
+    }
+});
 program.parse();
 //# sourceMappingURL=index.js.map