agent-dealer 0.2.0 → 1.0.0

package/dist/lifecycle.contract.test.js

@@ -0,0 +1,135 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { runActionCommand } from "./action.js";
+import { runAgentCommand } from "./agent.js";
+import { runIssueCommand } from "./issue.js";
+function openAction(id, actionType, choices) {
+    return {
+        id,
+        issueId: "00000000-0000-4000-a000-000000000010",
+        runId: null,
+        workflowInstanceId: null,
+        actionType,
+        reason: "Operator decision required",
+        question: "Choose the next action",
+        evidenceJson: null,
+        responseOptionsJson: JSON.stringify(choices),
+        continuationPreviewJson: null,
+        requestId: null,
+        status: "open",
+        resolutionJson: null,
+        resolvedBy: null,
+        requestedAt: "2026-09-12T00:00:00.000Z",
+        resolvedAt: null,
+    };
+}
+test("agent-operated CLI contract: discover profiles/issues, start, inspect choices, and resolve every action type", async () => {
+    const issueId = "00000000-0000-4000-a000-000000000010";
+    const actions = [
+        openAction("00000000-0000-4000-a000-000000000021", "product_scope_decision", [
+            { choice: "resume", label: "Acceptance criteria added — start" },
+        ]),
+        openAction("00000000-0000-4000-a000-000000000022", "policy_escalation", [
+            { choice: "resume", label: "Retry" },
+            { choice: "close", label: "Close" },
+        ]),
+        openAction("00000000-0000-4000-a000-000000000023", "attempts_exhausted", [
+            { choice: "retry", label: "Grant another round" },
+            { choice: "close", label: "Close" },
+        ]),
+        openAction("00000000-0000-4000-a000-000000000024", "final_review", [
+            { choice: "complete", label: "Accept — merge & mark done" },
+            { choice: "repair", label: "Request repair" },
+            { choice: "close", label: "Close" },
+        ]),
+    ];
+    const resolutions = ["resume", "resume", "retry", "complete"];
+    const expected = [
+        {
+            path: "/api/agents",
+            method: "GET",
+            response: {
+                agents: [
+                    {
+                        id: "00000000-0000-4000-a000-000000000001",
+                        runtime: "claude_code",
+                        defaultModel: "sonnet",
+                        workspaceRoot: "/repo",
+                        deckId: "00000000-0000-4000-a000-000000000100",
+                        deckName: "dev",
+                        healthy: true,
+                        issues: [],
+                    },
+                ],
+                issueCount: 0,
+            },
+        },
+        {
+            path: "/api/issues?status=ready%2Cneeds_human",
+            method: "GET",
+            response: [
+                {
+                    id: issueId,
+                    status: "ready",
+                    currentOwner: "system",
+                    currentIntent: null,
+                    hasOpenHumanAction: false,
+                },
+            ],
+        },
+        {
+            // NOT-118: start answers with the admission outcome — admitted (with the instance and
+            // round-1 work item) or queued at a position with a wait reason.
+            path: `/api/issues/${issueId}/start`,
+            method: "POST",
+            response: { state: "admitted", instance: { id: "wf-1" }, workItem: { id: "work-1", kind: "developer" } },
+        },
+        { path: "/api/human-actions", method: "GET", response: actions },
+        ...actions.map((action, index) => ({
+            path: `/api/human-actions/${action.id}/resolve`,
+            method: "POST",
+            body: { choice: resolutions[index], resolvedBy: "cli-agent" },
+            response: { issueStatus: index === actions.length - 1 ? "done" : "developing" },
+        })),
+    ];
+    const originalFetch = globalThis.fetch;
+    const originalLog = console.log;
+    const logs = [];
+    let callIndex = 0;
+    globalThis.fetch = (async (input, init) => {
+        const call = expected[callIndex++];
+        assert.ok(call, `unexpected request: ${String(input)}`);
+        assert.ok(String(input).endsWith(call.path), `expected ${call.path}, got ${String(input)}`);
+        assert.equal(init?.method ?? "GET", call.method);
+        const body = init?.body ? JSON.parse(String(init.body)) : undefined;
+        assert.deepEqual(body, call.body);
+        return new Response(JSON.stringify(call.response), {
+            status: 200,
+            headers: { "content-type": "application/json" },
+        });
+    });
+    console.log = (message) => logs.push(String(message));
+    try {
+        assert.equal(await runAgentCommand(["list"]), 0);
+        assert.equal(await runIssueCommand(["list", "--status", "ready,needs_human"]), 0);
+        assert.equal(await runIssueCommand(["start", issueId]), 0);
+        assert.equal(await runActionCommand(["list"]), 0);
+        for (let index = 0; index < actions.length; index += 1) {
+            assert.equal(await runActionCommand([
+                "resolve",
+                actions[index].id,
+                "--choice",
+                resolutions[index],
+                "--by",
+                "cli-agent",
+            ]), 0);
+        }
+        assert.equal(callIndex, expected.length);
+        const listedActions = JSON.parse(logs[3]);
+        assert.deepEqual(listedActions.map((action) => action.choices), actions.map((action) => JSON.parse(action.responseOptionsJson)));
+    }
+    finally {
+        globalThis.fetch = originalFetch;
+        console.log = originalLog;
+    }
+});

package/dist/queue.d.ts

@@ -0,0 +1,11 @@
+export type ParsedQueueArgs = {
+    subcommand: "add";
+    issueId: string;
+} | {
+    subcommand: "remove";
+    issueId: string;
+} | {
+    subcommand: "list";
+};
+export declare function parseQueueArgs(args: string[]): ParsedQueueArgs;
+export declare function runQueueCommand(args: string[]): Promise<number>;

package/dist/queue.js

@@ -0,0 +1,60 @@
+import { apiFetch } from "./http.js";
+export function parseQueueArgs(args) {
+    const [subcommand, ...rest] = args;
+    switch (subcommand) {
+        case "add": {
+            const issueId = rest[0];
+            if (!issueId)
+                throw new Error("queue add requires an issue id");
+            return { subcommand: "add", issueId };
+        }
+        case "remove": {
+            const issueId = rest[0];
+            if (!issueId)
+                throw new Error("queue remove requires an issue id");
+            return { subcommand: "remove", issueId };
+        }
+        case "list":
+            return { subcommand: "list" };
+        default:
+            throw new Error(`Unknown queue subcommand: ${subcommand ?? "(none)"}`);
+    }
+}
+export async function runQueueCommand(args) {
+    let parsed;
+    try {
+        parsed = parseQueueArgs(args);
+    }
+    catch (err) {
+        console.error(err.message);
+        return 1;
+    }
+    try {
+        switch (parsed.subcommand) {
+            case "add": {
+                const result = await apiFetch("/api/queue", {
+                    method: "POST",
+                    body: { issueId: parsed.issueId },
+                });
+                console.log(JSON.stringify(result, null, 2));
+                return 0;
+            }
+            case "remove": {
+                const result = await apiFetch(`/api/queue/${encodeURIComponent(parsed.issueId)}`, {
+                    method: "DELETE",
+                });
+                console.log(JSON.stringify(result, null, 2));
+                return 0;
+            }
+            case "list": {
+                const result = await apiFetch("/api/queue");
+                console.log(JSON.stringify(result, null, 2));
+                return 0;
+            }
+        }
+    }
+    catch (err) {
+        console.error(err.message);
+        return 1;
+    }
+}

package/dist/queue.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/queue.test.js

@@ -0,0 +1,46 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { parseQueueArgs, runQueueCommand } from "./queue.js";
+import { stubFetch } from "./test-fetch-stub.js";
+test("parseQueueArgs: add/remove require an issue id", () => {
+    assert.deepEqual(parseQueueArgs(["add", "issue-1"]), { subcommand: "add", issueId: "issue-1" });
+    assert.deepEqual(parseQueueArgs(["remove", "issue-1"]), {
+        subcommand: "remove",
+        issueId: "issue-1",
+    });
+    assert.throws(() => parseQueueArgs(["add"]));
+    assert.throws(() => parseQueueArgs(["remove"]));
+});
+test("parseQueueArgs: list has no args", () => {
+    assert.deepEqual(parseQueueArgs(["list"]), { subcommand: "list" });
+});
+test("queue list calls GET /api/queue", async () => {
+    const stub = stubFetch("/api/queue", "GET", []);
+    try {
+        assert.equal(await runQueueCommand(["list"]), 0);
+        stub.assertCalled();
+    }
+    finally {
+        stub.restore();
+    }
+});
+test("queue add calls POST /api/queue", async () => {
+    const stub = stubFetch("/api/queue", "POST", { issueId: "issue-1", state: "queued" });
+    try {
+        assert.equal(await runQueueCommand(["add", "issue-1"]), 0);
+        stub.assertCalled();
+    }
+    finally {
+        stub.restore();
+    }
+});
+test("queue remove calls DELETE /api/queue/:id", async () => {
+    const stub = stubFetch(/\/api\/queue\/issue-1$/, "DELETE", { issueId: "issue-1", state: "removed" });
+    try {
+        assert.equal(await runQueueCommand(["remove", "issue-1"]), 0);
+        stub.assertCalled();
+    }
+    finally {
+        stub.restore();
+    }
+});

package/dist/test-fetch-stub.d.ts

@@ -0,0 +1,6 @@
+/** Stubs global fetch for one call, asserts the request shape, and restores it —
+ * exercises a CLI command's HTTP contract without a live server. */
+export declare function stubFetch(expectedUrl: string | RegExp, expectedMethod: string, response: unknown, status?: number): {
+    restore: () => void;
+    assertCalled: () => unknown;
+};

package/dist/test-fetch-stub.js

@@ -0,0 +1,31 @@
+import assert from "node:assert/strict";
+/** Stubs global fetch for one call, asserts the request shape, and restores it —
+ * exercises a CLI command's HTTP contract without a live server. */
+export function stubFetch(expectedUrl, expectedMethod, response, status = 200) {
+    const original = globalThis.fetch;
+    let captured;
+    globalThis.fetch = (async (url, opts) => {
+        captured = { url: String(url), method: opts?.method ?? "GET", body: opts?.body ? JSON.parse(opts.body) : undefined };
+        return {
+            ok: status < 400,
+            status,
+            json: async () => response,
+        };
+    });
+    return {
+        restore: () => {
+            globalThis.fetch = original;
+        },
+        assertCalled: () => {
+            assert.ok(captured, "expected fetch to be called");
+            if (typeof expectedUrl === "string") {
+                assert.ok(captured.url.endsWith(expectedUrl), `expected url to end with ${expectedUrl}, got ${captured.url}`);
+            }
+            else {
+                assert.match(captured.url, expectedUrl);
+            }
+            assert.equal(captured.method, expectedMethod);
+            return captured.body;
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-dealer",
-  "version": "0.2.0",
+  "version": "1.0.0",
   "description": "Human control plane for agent execution — queue, plan approval, audit",
   "license": "MIT",
   "type": "module",
@@ -46,6 +46,7 @@
     "better-sqlite3": "^12.11.1",
     "dotenv": "^16.5.0",
     "fastify": "^5.3.3",
+    "smol-toml": "^1.8.0",
     "uuid": "^11.1.0"
   }
 }

package/templates/prod.env.example

@@ -14,7 +14,7 @@ AGENT_DEALER_API=http://127.0.0.1:2222
 # Linear (optional — manual tasks work without; edit after `agent-dealer setup`)
 LINEAR_API_KEY=
 LINEAR_TEAM_ID=
-LINEAR_STATE_FILTER="Todo,Backlog"
+LINEAR_STATE_FILTER="Backlog,Todo,In Progress,In Review"
 
 # Agent Deck UI proxy (optional)
 # AGENT_DECK_API_URL=http://127.0.0.1:1111