nolo-cli 0.1.19 → 0.1.21

package/client/agentRun.test.ts

@@ -1,7 +1,12 @@
 import { describe, expect, test } from "bun:test";
 import { Writable } from "node:stream";
 
-import { runAgentTurn, shouldUseScriptBridge } from "./agentRun";
+import {
+  classifyTaskRunReviewStatus,
+  findServerPlatformTools,
+  runAgentTurn,
+  shouldUseScriptBridge,
+} from "./agentRun";
 
 class CaptureOutput extends Writable {
   chunks: string[] = [];
@@ -16,12 +21,31 @@ class CaptureOutput extends Writable {
   }
 }
 
-describe("cli agent run client", () => {
-  test("uses the repo script bridge only when no auth token is available", () => {
-    expect(shouldUseScriptBridge({ hasAuthToken: false, scriptPathExists: true })).toBe(true);
-    expect(shouldUseScriptBridge({ hasAuthToken: true, scriptPathExists: true })).toBe(false);
-    expect(shouldUseScriptBridge({ hasAuthToken: false, scriptPathExists: false })).toBe(false);
-  });
+describe("cli agent run client", () => {
+  test("classifies only clear reviewer outcomes", () => {
+    expect(classifyTaskRunReviewStatus("Review decision: passed")).toBe("passed");
+    expect(classifyTaskRunReviewStatus("Review decision: needs_changes")).toBe("needs_changes");
+    expect(classifyTaskRunReviewStatus("Review decision: blocked")).toBe("blocked");
+    expect(classifyTaskRunReviewStatus("LGTM, no issues found")).toBe("passed");
+    expect(classifyTaskRunReviewStatus("Changes requested for missing test coverage")).toBe(
+      "needs_changes"
+    );
+    expect(classifyTaskRunReviewStatus("I looked at the diff and have notes")).toBeUndefined();
+  });
+
+  test("uses the repo script bridge only when no auth token is available", () => {
+    expect(shouldUseScriptBridge({ hasAuthToken: false, scriptPathExists: true })).toBe(true);
+    expect(shouldUseScriptBridge({ hasAuthToken: true, scriptPathExists: true })).toBe(false);
+    expect(shouldUseScriptBridge({ hasAuthToken: false, scriptPathExists: false })).toBe(false);
+  });
+
+  test("identifies server platform tools that local runtime cannot provide", () => {
+    expect(findServerPlatformTools(["readWorkspaceFile", "queryTableRows", "updateTableRow"])).toEqual([
+      "queryTableRows",
+      "updateTableRow",
+    ]);
+    expect(findServerPlatformTools(["readWorkspaceFile", "gitStatus"])).toEqual([]);
+  });
 
   test("calls the Nolo HTTP API directly when AUTH_TOKEN is present", async () => {
     const output = new CaptureOutput();
@@ -76,6 +100,78 @@ describe("cli agent run client", () => {
     expect(output.text()).not.toContain("tokens=");
   });
 
+  test("prepends task-run context for HTTP agent runs", async () => {
+    const output = new CaptureOutput();
+    const requests: Array<{ body: any }> = [];
+
+    await runAgentTurn({
+      agentName: "frontend",
+      agentKey: "frontend-implementer",
+      serverUrl: "https://nolo.chat",
+      message: "Fix the filter UI",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      runtimeMode: "server",
+      taskRunContext: {
+        rowDbKey: "row-b2e06f801f-01TASK",
+        taskRunId: "taskrun-1",
+        workItemId: "frontend-filter",
+        artifactIds: ["artifact-1"],
+      },
+      scriptPathExists: () => false,
+      fetchImpl: async (_url, init) => {
+        requests.push({ body: JSON.parse(String(init?.body)) });
+        return Response.json({ content: "ok", dialogId: "dialog-1" });
+      },
+    });
+
+    expect(requests[0]?.body.userInput).toContain("AI-native task-run context:");
+    expect(requests[0]?.body.userInput).toContain("current task board is only the present observation and validation use case");
+    expect(requests[0]?.body.userInput).toContain("rowDbKey: row-b2e06f801f-01TASK");
+    expect(requests[0]?.body.userInput).toContain("workItemId: frontend-filter");
+    expect(requests[0]?.body.userInput).toContain("User task:\nFix the filter UI");
+  });
+
+  test("records task-run completion after an HTTP agent run returns a dialog", async () => {
+    const output = new CaptureOutput();
+    const writebacks: any[] = [];
+
+    const result = await runAgentTurn({
+      agentName: "frontend-implementer",
+      agentKey: "agent-frontend",
+      serverUrl: "https://nolo.chat",
+      message: "Fix the filter UI",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      runtimeMode: "server",
+      taskRunContext: {
+        rowDbKey: "row-b2e06f801f-01TASK",
+        workItemId: "frontend-filter",
+      },
+      taskRunRecorder: async (args) => {
+        writebacks.push(args);
+      },
+      scriptPathExists: () => false,
+      fetchImpl: async () => {
+        return Response.json({ content: "patched", dialogId: "dialog-1" });
+      },
+    });
+
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-1" });
+    expect(writebacks).toHaveLength(1);
+    expect(writebacks[0]).toMatchObject({
+      status: "completed",
+      dialogId: "dialog-1",
+      resultSummary: "patched",
+    });
+    expect(writebacks[0].options.taskRunContext).toEqual({
+      rowDbKey: "row-b2e06f801f-01TASK",
+      workItemId: "frontend-filter",
+    });
+  });
+
   test("sends image inputs as multimodal userInput over HTTP", async () => {
     const output = new CaptureOutput();
     const requests: Array<{ body: any }> = [];
@@ -103,6 +199,49 @@ describe("cli agent run client", () => {
     ]);
   });
 
+  test("sends script-compatible dialog metadata over HTTP", async () => {
+    const output = new CaptureOutput();
+    const requests: Array<{ body: any }> = [];
+
+    const result = await runAgentTurn({
+      agentName: "nolo",
+      agentKey: "agent-pub-test",
+      serverUrl: "https://nolo.chat",
+      message: "hello",
+      spaceId: "space-1",
+      category: "manual-checks",
+      inheritedFromDialogKey: "dialog-user-1-dialog-2",
+      parentDialogId: "dialog-2",
+      background: true,
+      noStream: true,
+      maxToolRounds: 12,
+      timeoutMs: 600000,
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      runtimeMode: "server",
+      scriptPathExists: () => false,
+      fetchImpl: async (_url, init) => {
+        requests.push({ body: JSON.parse(String(init?.body)) });
+        return Response.json({ dialogId: "dialog-1", status: "queued" });
+      },
+    });
+
+    expect(requests[0]?.body).toMatchObject({
+      agentKey: "agent-pub-test",
+      userInput: "hello",
+      spaceId: "space-1",
+      category: "manual-checks",
+      inheritedFromDialogKey: "dialog-user-1-dialog-2",
+      parentDialogId: "dialog-2",
+      background: true,
+      maxRounds: 12,
+      timeoutMs: 600000,
+      stream: false,
+    });
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-1" });
+  });
+
   test("runs forced local turns through the injected runtime adapter without HTTP", async () => {
     const output = new CaptureOutput();
     const result = await runAgentTurn({
@@ -148,6 +287,240 @@ describe("cli agent run client", () => {
     expect(output.text()).toContain("frontend > local:polish notifications");
   });
 
+  test("increases local max tool rounds when a forced local run exhausts them", async () => {
+    const output = new CaptureOutput();
+    let completeCalls = 0;
+    const result = await runAgentTurn({
+      agentName: "frontend",
+      agentKey: "frontend-local",
+      serverUrl: "https://nolo.chat",
+      message: "polish notifications",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123", NOLO_LOCAL_MAX_TOOL_ROUNDS_LIMIT: "1" },
+      output,
+      runtimeMode: "local",
+      maxToolRounds: 0,
+      localRuntimeAdapter: {
+        host: "cli",
+        capabilities: ["local-provider", "local-persistence"],
+        loadAgentConfig: async (agentRef) => ({
+          key: agentRef,
+          name: "Frontend",
+          prompt: "Fix UI",
+          model: "fake-local",
+        }),
+        loadDialogHistory: async () => [],
+        saveTurn: async () => ({ dialogId: "dialog-local" }),
+        resolveProvider: async () => ({
+          model: "fake-local",
+          complete: async () => {
+            completeCalls += 1;
+            return {
+              content: "",
+              model: "fake-local",
+              tool_calls: [{
+                id: `call-${completeCalls}`,
+                type: "function",
+                function: { name: "readWorkspaceFile", arguments: "{}" },
+              }],
+            };
+          },
+        }),
+        executeTool: async () => ({ content: "ok" }),
+      },
+      scriptPathExists: () => false,
+      fetchImpl: async () => {
+        throw new Error("HTTP should not be called for forced local runs");
+      },
+    });
+
+    expect(result).toMatchObject({ exitCode: 1 });
+    expect(output.text()).toContain("Local agent used all 0 tool rounds; retrying with 1.");
+    expect(output.text()).toContain("Local agent exceeded max tool rounds: 1");
+  });
+
+  test("completes a forced local run after automatically increasing tool rounds", async () => {
+    const output = new CaptureOutput();
+    let completeCalls = 0;
+    let toolCalls = 0;
+
+    const result = await runAgentTurn({
+      agentName: "frontend",
+      agentKey: "frontend-local",
+      serverUrl: "https://nolo.chat",
+      message: "make screenshots",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      runtimeMode: "local",
+      maxToolRounds: 1,
+      localRuntimeAdapter: {
+        host: "cli",
+        capabilities: ["local-provider", "local-persistence", "local-tools"],
+        loadAgentConfig: async (agentRef) => ({
+          key: agentRef,
+          name: "Frontend",
+          prompt: "Fix UI",
+          model: "fake-local",
+          toolNames: ["readWorkspaceFile"],
+        }),
+        loadDialogHistory: async () => [],
+        saveTurn: async () => ({ dialogId: "dialog-local-retry" }),
+        resolveProvider: async () => ({
+          model: "fake-local",
+          complete: async () => {
+            completeCalls += 1;
+            if (completeCalls <= 3) {
+              return {
+                content: "",
+                model: "fake-local",
+                tool_calls: [{
+                  id: `call-${completeCalls}`,
+                  type: "function",
+                  function: { name: "readWorkspaceFile", arguments: "{}" },
+                }],
+              };
+            }
+            return { content: "done after retry", model: "fake-local" };
+          },
+        }),
+        executeTool: async () => {
+          toolCalls += 1;
+          return { content: "ok" };
+        },
+      },
+      scriptPathExists: () => false,
+    });
+
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-local-retry" });
+    expect(toolCalls).toBe(2);
+    expect(output.text()).toContain("Local agent used all 1 tool rounds; retrying with 2.");
+    expect(output.text()).toContain("frontend > done after retry");
+  });
+
+  test("prints local tool trace when requested", async () => {
+    const output = new CaptureOutput();
+    let completeCalls = 0;
+
+    const result = await runAgentTurn({
+      agentName: "frontend",
+      agentKey: "frontend-local",
+      serverUrl: "https://nolo.chat",
+      message: "inspect repo",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      runtimeMode: "local",
+      traceTools: true,
+      localRuntimeAdapter: {
+        host: "cli",
+        capabilities: ["local-provider", "local-persistence", "local-tools"],
+        loadAgentConfig: async (agentRef) => ({
+          key: agentRef,
+          name: "Frontend",
+          prompt: "Fix UI",
+          model: "fake-local",
+          toolNames: ["gitStatus"],
+        }),
+        loadDialogHistory: async () => [],
+        saveTurn: async () => ({ dialogId: "dialog-local" }),
+        resolveProvider: async () => ({
+          model: "fake-local",
+          complete: async () => {
+            completeCalls += 1;
+            if (completeCalls === 1) {
+              return {
+                content: "",
+                model: "fake-local",
+                tool_calls: [{
+                  id: "call-status",
+                  type: "function",
+                  function: { name: "gitStatus", arguments: "{}" },
+                }],
+              };
+            }
+            return { content: "done", model: "fake-local" };
+          },
+        }),
+        executeTool: async () => ({ content: "clean" }),
+      },
+      scriptPathExists: () => false,
+    });
+
+    expect(result).toMatchObject({ exitCode: 0, dialogId: "dialog-local" });
+    expect(output.text()).toContain("[nolo:tool] round 1 -> gitStatus (call-status)");
+    expect(output.text()).toContain("[nolo:tool] round 1 <- gitStatus (call-status)");
+  });
+
+  test("passes local tool evidence to task-run writeback", async () => {
+    const output = new CaptureOutput();
+    const writebacks: any[] = [];
+    let completeCalls = 0;
+
+    const result = await runAgentTurn({
+      agentName: "frontend",
+      agentKey: "frontend-local",
+      serverUrl: "https://nolo.chat",
+      message: "inspect repo",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      runtimeMode: "local",
+      taskRunContext: {
+        rowDbKey: "row-b2e06f801f-01TASK",
+        workItemId: "self",
+      },
+      taskRunRecorder: async (args) => {
+        writebacks.push(args);
+      },
+      localRuntimeAdapter: {
+        host: "cli",
+        capabilities: ["local-provider", "local-persistence", "local-tools"],
+        loadAgentConfig: async (agentRef) => ({
+          key: agentRef,
+          name: "Frontend",
+          prompt: "Fix UI",
+          model: "fake-local",
+          toolNames: ["gitStatus"],
+        }),
+        loadDialogHistory: async () => [],
+        saveTurn: async () => ({ dialogId: "dialog-local" }),
+        resolveProvider: async () => ({
+          model: "fake-local",
+          complete: async () => {
+            completeCalls += 1;
+            if (completeCalls === 1) {
+              return {
+                content: "",
+                model: "fake-local",
+                tool_calls: [{
+                  id: "call-status",
+                  type: "function",
+                  function: { name: "gitStatus", arguments: "{}" },
+                }],
+              };
+            }
+            return { content: "done", model: "fake-local" };
+          },
+        }),
+        executeTool: async () => ({ content: "clean" }),
+      },
+      scriptPathExists: () => false,
+    });
+
+    expect(result).toMatchObject({ exitCode: 0, dialogId: "dialog-local" });
+    expect(writebacks).toHaveLength(1);
+    expect(writebacks[0].toolEvidence).toEqual({
+      toolsUsed: ["gitStatus"],
+      summary: {
+        callCount: 1,
+        resultCount: 1,
+        errorCount: 0,
+        rounds: 1,
+      },
+    });
+  });
+
   test("auto mode prefers a working local runtime before HTTP", async () => {
     const output = new CaptureOutput();
     const httpCalls: string[] = [];
@@ -192,6 +565,56 @@ describe("cli agent run client", () => {
     expect(output.text()).toContain("frontend -> working locally");
   });
 
+  test("auto mode skips local runtime for agents that declare server platform tools", async () => {
+    const output = new CaptureOutput();
+    const httpCalls: Array<{ url: string; body: any }> = [];
+
+    const result = await runAgentTurn({
+      agentName: "pm",
+      agentKey: "nolo-project-manager",
+      serverUrl: "https://nolo.chat",
+      message: "write task rows",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      runtimeMode: "auto",
+      localRuntimeAdapter: {
+        host: "cli",
+        capabilities: ["leveldb-agent-config", "local-provider", "local-tools"],
+        loadAgentConfig: async (agentRef) => ({
+          key: agentRef,
+          name: "PM",
+          prompt: "Manage task rows",
+          model: "fake-local",
+          toolNames: ["queryTableRows", "addTableRow", "updateTableRow"],
+        }),
+        loadDialogHistory: async () => [],
+        saveTurn: async () => {
+          throw new Error("local runtime should be skipped");
+        },
+        resolveProvider: async () => {
+          throw new Error("local provider should be skipped");
+        },
+        executeTool: async () => {
+          throw new Error("local tools should be skipped");
+        },
+      },
+      scriptPathExists: () => false,
+      fetchImpl: async (url, init) => {
+        httpCalls.push({ url: String(url), body: JSON.parse(String(init?.body)) });
+        return Response.json({ content: "server ok", dialogId: "dialog-server" });
+      },
+    });
+
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-server" });
+    expect(httpCalls).toHaveLength(1);
+    expect(httpCalls[0]?.body.agentKey).toBe("nolo-project-manager");
+    expect(output.text()).toContain("auto runtime: skipping local runtime");
+    expect(output.text()).toContain("queryTableRows, addTableRow, updateTableRow");
+    expect(output.text()).toContain("pm -> working");
+    expect(output.text()).toContain("pm > server ok");
+  });
+
   test("builds the default local adapter when env requests local mode", async () => {
     const output = new CaptureOutput();
     const builtModes: string[] = [];