nolo-cli 0.1.32 → 0.1.33

package/client/agentRunLocalExecution.test.ts

@@ -1,123 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import type { LocalAgentToolEvent } from "../agent-runtime/localLoop";
-import {
-  classifyTaskRunReviewStatus,
-  formatToolTraceEvent,
-  nextLocalToolRoundLimit,
-  parseLocalToolRoundLimitError,
-  resolveLocalToolRoundRetryLimit,
-  shouldCollectLocalToolEvidence,
-  shouldTraceLocalTools,
-  summarizeLocalToolEvidence,
-} from "./agentRunLocalExecution";
-
-function makeToolEvent(
-  overrides: Partial<LocalAgentToolEvent> & Pick<LocalAgentToolEvent, "type">
-): LocalAgentToolEvent {
-  return {
-    type: overrides.type,
-    round: overrides.round ?? 0,
-    toolCallId: overrides.toolCallId ?? "call-1",
-    toolName: overrides.toolName ?? "readWorkspaceFile",
-    message: overrides.message,
-    metadata: overrides.metadata,
-  };
-}
-
-describe("agentRunLocalExecution", () => {
-  test("traces local tools from explicit option or env flag", () => {
-    expect(shouldTraceLocalTools({ traceTools: true, env: {} })).toBe(true);
-    expect(shouldTraceLocalTools({ traceTools: false, env: { NOLO_TRACE_TOOLS: "1" } })).toBe(
-      true
-    );
-    expect(shouldTraceLocalTools({ env: {} })).toBe(false);
-  });
-
-  test("collects local tool evidence only when task-run row key exists", () => {
-    expect(shouldCollectLocalToolEvidence({ taskRunContext: { rowDbKey: "row-1" } })).toBe(true);
-    expect(shouldCollectLocalToolEvidence({ taskRunContext: {} })).toBe(false);
-    expect(shouldCollectLocalToolEvidence({})).toBe(false);
-  });
-
-  test("summarizes tool evidence with unique tools and event counts", () => {
-    const events: LocalAgentToolEvent[] = [
-      makeToolEvent({ type: "tool-call", toolName: "readWorkspaceFile", toolCallId: "call-1" }),
-      makeToolEvent({ type: "tool-result", toolName: "readWorkspaceFile", toolCallId: "call-1" }),
-      makeToolEvent({ type: "tool-call", round: 1, toolName: "execShell", toolCallId: "call-2" }),
-      makeToolEvent({ type: "tool-error", round: 1, toolName: "execShell", toolCallId: "call-2" }),
-      makeToolEvent({ type: "tool-call", round: 1, toolName: "readWorkspaceFile", toolCallId: "call-3" }),
-    ];
-
-    expect(summarizeLocalToolEvidence(events)).toEqual({
-      toolsUsed: ["readWorkspaceFile", "execShell"],
-      summary: {
-        callCount: 3,
-        resultCount: 1,
-        errorCount: 1,
-        rounds: 2,
-      },
-    });
-    expect(summarizeLocalToolEvidence([])).toBeUndefined();
-  });
-
-  test("parses local tool round limit errors only from matching messages", () => {
-    expect(parseLocalToolRoundLimitError(new Error("Local agent exceeded max tool rounds: 256"))).toBe(
-      256
-    );
-    expect(parseLocalToolRoundLimitError("Local agent exceeded max tool rounds: 4")).toBe(4);
-    expect(parseLocalToolRoundLimitError(new Error("other failure"))).toBeNull();
-  });
-
-  test("resolves retry limit from env positive integers and falls back to default", () => {
-    expect(resolveLocalToolRoundRetryLimit({ env: { NOLO_LOCAL_MAX_TOOL_ROUNDS_LIMIT: "64" } })).toBe(
-      64
-    );
-    expect(resolveLocalToolRoundRetryLimit({ env: { NOLO_LOCAL_MAX_TOOL_ROUNDS_LIMIT: "0" } })).toBe(
-      512
-    );
-    expect(resolveLocalToolRoundRetryLimit({ env: { NOLO_LOCAL_MAX_TOOL_ROUNDS_LIMIT: "abc" } })).toBe(
-      512
-    );
-    expect(resolveLocalToolRoundRetryLimit({ env: {} })).toBe(512);
-  });
-
-  test("increments next local tool round limit by doubling positive values", () => {
-    expect(nextLocalToolRoundLimit(0)).toBe(1);
-    expect(nextLocalToolRoundLimit(-1)).toBe(1);
-    expect(nextLocalToolRoundLimit(8)).toBe(16);
-  });
-
-  test("formats tool trace events for calls, results, and errors", () => {
-    expect(
-      formatToolTraceEvent(
-        makeToolEvent({ type: "tool-call", round: 0, toolName: "readWorkspaceFile", toolCallId: "call-1" })
-      )
-    ).toBe("[nolo:tool] round 1 -> readWorkspaceFile (call-1)\n");
-    expect(
-      formatToolTraceEvent(
-        makeToolEvent({ type: "tool-result", round: 1, toolName: "readWorkspaceFile", toolCallId: "call-1" })
-      )
-    ).toBe("[nolo:tool] round 2 <- readWorkspaceFile (call-1)\n");
-    expect(
-      formatToolTraceEvent(
-        makeToolEvent({
-          type: "tool-error",
-          round: 1,
-          toolName: "execShell",
-          toolCallId: "call-2",
-          message: "timed out",
-        })
-      )
-    ).toBe("[nolo:tool] round 2 !! execShell: timed out\n");
-  });
-
-  test("classifies review status only from explicit or strong signals", () => {
-    expect(classifyTaskRunReviewStatus("Review decision: passed")).toBe("passed");
-    expect(classifyTaskRunReviewStatus("Changes requested for missing test coverage")).toBe(
-      "needs_changes"
-    );
-    expect(classifyTaskRunReviewStatus("无法审查，存在阻塞")).toBe("blocked");
-    expect(classifyTaskRunReviewStatus("I looked at the diff and have notes")).toBeUndefined();
-  });
-});

package/client/agentRunLocalExecution.ts

@@ -1,124 +0,0 @@
-import type { LocalAgentToolEvent } from "../agent-runtime/localLoop";
-import type { EnvLike } from "../cliEnvHelpers";
-
-type TaskRunReviewStatus = "passed" | "needs_changes" | "blocked";
-
-export type TaskRunToolEvidence = {
-  toolsUsed: string[];
-  summary: {
-    callCount: number;
-    resultCount: number;
-    errorCount: number;
-    rounds: number;
-  };
-};
-
-type TraceLocalToolOptions = {
-  traceTools?: boolean;
-  env: EnvLike;
-};
-
-type CollectLocalToolEvidenceOptions = {
-  taskRunContext?: {
-    rowDbKey?: string;
-  };
-};
-
-type ResolveLocalToolRoundRetryLimitOptions = {
-  env: EnvLike;
-};
-
-const DEFAULT_LOCAL_AGENT_TOOL_ROUND_RETRY_LIMIT = 512;
-
-function parsePositiveInteger(value: string | undefined) {
-  if (!value) return null;
-  const parsed = Number(value);
-  if (!Number.isInteger(parsed) || parsed <= 0) return null;
-  return parsed;
-}
-
-export function shouldTraceLocalTools(options: TraceLocalToolOptions) {
-  return Boolean(options.traceTools || options.env.NOLO_TRACE_TOOLS === "1");
-}
-
-export function shouldCollectLocalToolEvidence(options: CollectLocalToolEvidenceOptions) {
-  return Boolean(options.taskRunContext?.rowDbKey);
-}
-
-export function summarizeLocalToolEvidence(
-  events: LocalAgentToolEvent[]
-): TaskRunToolEvidence | undefined {
-  if (events.length === 0) return undefined;
-  const toolsUsed = [
-    ...new Set(
-      events
-        .filter((event) => event.type === "tool-call")
-        .map((event) => event.toolName)
-        .filter(Boolean)
-    ),
-  ];
-  const rounds = new Set(events.map((event) => event.round)).size;
-  return {
-    toolsUsed,
-    summary: {
-      callCount: events.filter((event) => event.type === "tool-call").length,
-      resultCount: events.filter((event) => event.type === "tool-result").length,
-      errorCount: events.filter((event) => event.type === "tool-error").length,
-      rounds,
-    },
-  };
-}
-
-export function parseLocalToolRoundLimitError(error: unknown) {
-  const message = error instanceof Error ? error.message : String(error);
-  const match = message.match(/Local agent exceeded max tool rounds:\s*(\d+)/);
-  if (!match) return null;
-  return Number(match[1]);
-}
-
-export function resolveLocalToolRoundRetryLimit(
-  options: ResolveLocalToolRoundRetryLimitOptions
-) {
-  return (
-    parsePositiveInteger(options.env.NOLO_LOCAL_MAX_TOOL_ROUNDS_LIMIT) ??
-    DEFAULT_LOCAL_AGENT_TOOL_ROUND_RETRY_LIMIT
-  );
-}
-
-export function nextLocalToolRoundLimit(current: number) {
-  return current <= 0 ? 1 : current * 2;
-}
-
-export function formatToolTraceEvent(event: LocalAgentToolEvent) {
-  const round = event.round + 1;
-  if (event.type === "tool-call") {
-    return `[nolo:tool] round ${round} -> ${event.toolName} (${event.toolCallId})\n`;
-  }
-  if (event.type === "tool-error") {
-    return `[nolo:tool] round ${round} !! ${event.toolName}: ${event.message ?? "failed"}\n`;
-  }
-  return `[nolo:tool] round ${round} <- ${event.toolName} (${event.toolCallId})\n`;
-}
-
-export function classifyTaskRunReviewStatus(summary?: string): TaskRunReviewStatus | undefined {
-  const normalized = summary?.toLowerCase().trim();
-  if (!normalized) return undefined;
-
-  const explicit = normalized.match(/review\s+decision\s*:\s*(passed|needs_changes|blocked)/);
-  if (explicit?.[1]) return explicit[1] as TaskRunReviewStatus;
-
-  if (/\b(blocked|cannot review|unable to review)\b|无法审查|阻塞/.test(normalized)) {
-    return "blocked";
-  }
-  if (
-    /\b(needs changes|request changes|changes requested|not approved)\b|需要修改|需修改|发现问题/.test(
-      normalized
-    )
-  ) {
-    return "needs_changes";
-  }
-  if (/\b(approved|lgtm|no issues|passed)\b|通过|无问题/.test(normalized)) {
-    return "passed";
-  }
-  return undefined;
-}

package/client/agentRunLocalExecutor.ts

@@ -1,179 +0,0 @@
-import { runLocalAgentTurn, resolveHostRuntimeConfigFromEnv } from "../agentRuntimeLocal";
-import { LOCAL_AGENT_CONFIG_MISSING_CODE } from "../agent-runtime/localLoop";
-import type { LocalAgentToolEvent } from "../agent-runtime/localLoop";
-import { buildUserInputContent } from "./agentRunInput";
-import { createCliLocalRuntimeAdapter } from "./localRuntimeAdapter";
-import { prependTaskRunPrompt } from "./taskRunPrompt";
-import { recordTaskRunOutcome } from "./agentRunTaskRunRecorder";
-import {
-  formatToolTraceEvent,
-  nextLocalToolRoundLimit,
-  parseLocalToolRoundLimitError,
-  resolveLocalToolRoundRetryLimit,
-  shouldCollectLocalToolEvidence,
-  shouldTraceLocalTools,
-  summarizeLocalToolEvidence,
-} from "./agentRunLocalExecution";
-import type { RunAgentTurnOptions } from "./agentRun";
-
-export type LocalAgentTurnResult = {
-  exitCode: number;
-  dialogId?: string;
-  localError?: unknown;
-  toolEvidence?: ReturnType<typeof summarizeLocalToolEvidence>;
-};
-
-function buildDefaultLocalRuntimeAdapter(options: RunAgentTurnOptions) {
-  return createCliLocalRuntimeAdapter({
-    env: options.env,
-    hostRuntimeConfig: resolveHostRuntimeConfigFromEnv({
-      env: options.env,
-      surface: "cli-local",
-      workspaceBinding: "explicit-cwd",
-    }),
-    fetchImpl: options.fetchImpl,
-    cwd: options.localRuntimeCwd,
-    output: options.output,
-  });
-}
-
-export function resolveLocalRuntimeAdapter(options: RunAgentTurnOptions) {
-  return (
-    options.localRuntimeAdapter ||
-    options.localRuntimeAdapterFactory?.(options.env, { cwd: options.localRuntimeCwd }) ||
-    buildDefaultLocalRuntimeAdapter(options)
-  );
-}
-
-export function isMissingLocalAgentConfigError(error: unknown, agentRef: string) {
-  return Boolean(
-    error &&
-      typeof error === "object" &&
-      "code" in error &&
-      (error as { code?: string; agentRef?: string }).code === LOCAL_AGENT_CONFIG_MISSING_CODE &&
-      (error as { code?: string; agentRef?: string }).agentRef === agentRef
-  );
-}
-
-export async function runInjectedLocalAgentTurn(options: RunAgentTurnOptions) {
-  return runLocalAgentTurnWithAutoRoundExpansion(options, { reportFailure: true });
-}
-
-export async function refreshMissingLocalAgentConfig(options: RunAgentTurnOptions) {
-  const adapter = resolveLocalRuntimeAdapter(options);
-  if (!adapter) return false;
-  const agentConfig = await adapter.loadAgentConfig(options.agentKey);
-  return Boolean(agentConfig);
-}
-
-export async function runLocalAgentTurnWithAutoRoundExpansion(
-  options: RunAgentTurnOptions,
-  settings: { reportFailure: boolean }
-) {
-  const maxRetryLimit = resolveLocalToolRoundRetryLimit(options);
-  let currentMaxToolRounds = options.maxToolRounds;
-  let lastResult: Awaited<ReturnType<typeof runLocalAgentTurnForCli>> | null = null;
-
-  while (true) {
-    const attemptOptions = {
-      ...options,
-      ...(typeof currentMaxToolRounds === "number" ? { maxToolRounds: currentMaxToolRounds } : {}),
-    };
-    const result = await runLocalAgentTurnForCli(attemptOptions, { reportFailure: false });
-    lastResult = result;
-    if (result.exitCode === 0) return result;
-
-    const exhaustedRounds = parseLocalToolRoundLimitError(result.localError);
-    if (exhaustedRounds === null) break;
-
-    const nextMaxToolRounds = nextLocalToolRoundLimit(exhaustedRounds);
-    if (nextMaxToolRounds > maxRetryLimit) break;
-
-    options.output.write(
-      `[nolo] Local agent used all ${exhaustedRounds} tool rounds; retrying with ${nextMaxToolRounds}.\n`
-    );
-    currentMaxToolRounds = nextMaxToolRounds;
-  }
-
-  if (settings.reportFailure && lastResult?.localError) {
-    options.output.write(
-      `[nolo] Local agent run failed: ${
-        lastResult.localError instanceof Error ? lastResult.localError.message : String(lastResult.localError)
-      }\n`
-    );
-    await recordTaskRunOutcome({
-      options,
-      status: "failed",
-      errorCode: "LOCAL_AGENT_FAILED",
-      resultSummary:
-        lastResult.localError instanceof Error ? lastResult.localError.message : String(lastResult.localError),
-      toolEvidence: lastResult.toolEvidence,
-    });
-  }
-  return lastResult ?? { exitCode: 1 };
-}
-
-export async function runLocalAgentTurnForCli(
-  options: RunAgentTurnOptions,
-  settings: { reportFailure: boolean }
-): Promise<LocalAgentTurnResult> {
-  const adapter = resolveLocalRuntimeAdapter(options);
-  if (!adapter) {
-    options.output.write("[nolo] Local runtime was requested but no local runtime adapter is available.\n");
-    return { exitCode: 1 };
-  }
-
-  options.output.write(`\n${options.agentName} -> working locally...\n`);
-  const toolEvents: LocalAgentToolEvent[] = [];
-  try {
-    const traceLocalTools = shouldTraceLocalTools(options);
-    const collectToolEvidence = shouldCollectLocalToolEvidence(options);
-    const result = await runLocalAgentTurn({
-      adapter,
-      agentRef: options.agentKey,
-      input: buildUserInputContent(
-        prependTaskRunPrompt(options.message, options.taskRunContext),
-        options.imageUrls
-      ),
-      continueDialogId: options.continueDialogId,
-      spaceId: options.spaceId,
-      category: options.category,
-      inheritedFromDialogKey: options.inheritedFromDialogKey,
-      parentDialogId: options.parentDialogId,
-      background: options.background,
-      noStream: options.noStream,
-      maxToolRounds: options.maxToolRounds,
-      ...(traceLocalTools || collectToolEvidence
-        ? {
-            onToolEvent: (event) => {
-              if (collectToolEvidence) toolEvents.push(event);
-              if (traceLocalTools) options.output.write(formatToolTraceEvent(event));
-            },
-          }
-        : {}),
-    });
-    const content = result.content.trim();
-    if (content) {
-      options.output.write(`\n${options.agentName} > ${content}\n`);
-    } else {
-      options.output.write(`\n${options.agentName} > (no text response)\n`);
-    }
-    await recordTaskRunOutcome({
-      options,
-      status: options.background ? "running" : "completed",
-      dialogId: result.dialogId,
-      ...(!options.background && content ? { resultSummary: content } : {}),
-      toolEvidence: summarizeLocalToolEvidence(toolEvents),
-    });
-    return { exitCode: 0, dialogId: result.dialogId };
-  } catch (error) {
-    if (settings.reportFailure) {
-      options.output.write(
-        `[nolo] Local agent run failed: ${
-          error instanceof Error ? error.message : String(error)
-        }\n`
-      );
-    }
-    return { exitCode: 1, localError: error, toolEvidence: summarizeLocalToolEvidence(toolEvents) };
-  }
-}

package/client/agentRunRuntimeSelection.test.ts

@@ -1,159 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import {
-  findServerPlatformTools,
-  isKnownServerPlatformAgent,
-  normalizeAgentRef,
-  resolveRequestedRuntimeMode,
-  resolveServerPlatformToolNames,
-  shouldAttemptAutoLocal,
-  shouldShowUsage,
-  shouldSkipAutoLocalForServerPlatformTools,
-  shouldUseScriptBridge,
-  type OutputLike,
-} from "./agentRunRuntimeSelection";
-
-class CaptureOutput implements OutputLike {
-  chunks: string[] = [];
-
-  write(chunk: string) {
-    this.chunks.push(chunk);
-  }
-
-  text() {
-    return this.chunks.join("");
-  }
-}
-
-describe("agentRunRuntimeSelection", () => {
-  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", "execShell"])).toEqual([]);
-  });
-
-  test("merges server platform tool declarations from toolNames and runtime policy", () => {
-    expect(
-      resolveServerPlatformToolNames({
-        toolNames: ["queryTableRows", "readWorkspaceFile"],
-        runtimeToolPolicy: { agentTools: ["taskRun", "execShell", "updateTableRow"] },
-      })
-    ).toEqual(["queryTableRows", "taskRun", "updateTableRow"]);
-  });
-
-  test("normalizes agent refs before alias matching", () => {
-    expect(normalizeAgentRef("  Nolo   Fullstack  ")).toBe("nolo fullstack");
-    expect(isKnownServerPlatformAgent({ agentKey: "  Nolo   Fullstack  " })).toBe(true);
-  });
-
-  test("detects known server platform agents by canonical key", () => {
-    expect(isKnownServerPlatformAgent({ agentKey: "agent-b2e06f801f-01NOLOFULLSTK00000001J740Q" })).toBe(true);
-    expect(isKnownServerPlatformAgent({ agentKey: "agent-user-1-01FRONTENDAG0000000115N4E1" })).toBe(true);
-    expect(isKnownServerPlatformAgent({ agentKey: "agent-user-1-custom" })).toBe(false);
-  });
-
-  test("shows usage only when debug or usage env is enabled", () => {
-    expect(shouldShowUsage({})).toBe(false);
-    expect(shouldShowUsage({ NOLO_DEBUG: "1" })).toBe(true);
-    expect(shouldShowUsage({ NOLO_SHOW_USAGE: "1" })).toBe(true);
-  });
-
-  test("resolves requested runtime mode from explicit option before env", () => {
-    expect(resolveRequestedRuntimeMode({ runtimeMode: "local", env: { NOLO_RUNTIME_MODE: "server" } })).toBe(
-      "local"
-    );
-    expect(resolveRequestedRuntimeMode({ env: { NOLO_RUNTIME_MODE: "server" } })).toBe("server");
-    expect(resolveRequestedRuntimeMode({ env: { NOLO_RUNTIME_MODE: "weird" } })).toBe("auto");
-  });
-
-  test("attempts auto-local when an adapter/factory exists or local env is configured", () => {
-    expect(shouldAttemptAutoLocal({ env: {}, localRuntimeAdapter: { loadAgentConfig: async () => undefined } })).toBe(
-      true
-    );
-    expect(shouldAttemptAutoLocal({ env: {}, localRuntimeAdapterFactory: {} })).toBe(true);
-    expect(shouldAttemptAutoLocal({ env: { OPENAI_API_KEY: "key-1" } })).toBe(true);
-    expect(shouldAttemptAutoLocal({ env: { NOLO_LOCAL_AGENT_KEY: "agent-1" } })).toBe(true);
-    expect(shouldAttemptAutoLocal({ env: {} })).toBe(false);
-  });
-
-  test("skips auto-local immediately for known server platform agents", async () => {
-    const output = new CaptureOutput();
-
-    await expect(
-      shouldSkipAutoLocalForServerPlatformTools({
-        agentKey: "agent-b2e06f801f-01NOLOFULLSTK00000001J740Q",
-        env: {},
-        output,
-      })
-    ).resolves.toBe(true);
-
-    expect(output.text()).toContain("known platform agent");
-  });
-
-  test("skips auto-local when loaded agent config declares server platform tools", async () => {
-    const output = new CaptureOutput();
-
-    await expect(
-      shouldSkipAutoLocalForServerPlatformTools({
-        agentKey: "agent-user-1-tools",
-        env: {},
-        output,
-        localRuntimeAdapter: {
-          loadAgentConfig: async () => ({
-            toolNames: ["queryTableRows", "readWorkspaceFile"],
-            runtimeToolPolicy: { agentTools: ["addTableRow", "execShell"] },
-          }),
-        },
-      })
-    ).resolves.toBe(true);
-
-    expect(output.text()).toContain("queryTableRows, addTableRow");
-  });
-
-  test("does not skip auto-local when no adapter exists, loading fails, or no server tools are declared", async () => {
-    const output = new CaptureOutput();
-
-    await expect(
-      shouldSkipAutoLocalForServerPlatformTools({
-        agentKey: "agent-user-1-none",
-        env: {},
-        output,
-      })
-    ).resolves.toBe(false);
-
-    await expect(
-      shouldSkipAutoLocalForServerPlatformTools({
-        agentKey: "agent-user-1-error",
-        env: {},
-        output,
-        localRuntimeAdapter: {
-          loadAgentConfig: async () => {
-            throw new Error("load failed");
-          },
-        },
-      })
-    ).resolves.toBe(false);
-
-    await expect(
-      shouldSkipAutoLocalForServerPlatformTools({
-        agentKey: "agent-user-1-local",
-        env: {},
-        output,
-        resolveLocalRuntimeAdapter: () => ({
-          loadAgentConfig: async () => ({
-            toolNames: ["readWorkspaceFile"],
-            runtimeToolPolicy: { agentTools: ["execShell"] },
-          }),
-        }),
-      })
-    ).resolves.toBe(false);
-  });
-});