nolo-cli 0.1.32 → 0.1.34

package/cli/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/cli/client/agentRunRuntimeSelection.ts

@@ -1,145 +0,0 @@
-import type { AgentRuntimeRequestedMode } from "../agentRuntimeLocal";
-import {
-  isKnownPlatformAgentKey,
-} from "../agentAliases";
-import type { EnvLike } from "../cliEnvHelpers";
-import type { OutputLike } from "../cliIoTypes";
-export type { OutputLike } from "../cliIoTypes";
-
-export type ScriptBridgeDecision = {
-  hasAuthToken: boolean;
-  scriptPathExists: boolean;
-};
-
-export type RuntimeSelectionAgentConfig = {
-  toolNames?: string[];
-  runtimeToolPolicy?: {
-    agentTools?: string[];
-  };
-};
-
-export type RuntimeSelectionAdapter = {
-  loadAgentConfig(agentKey: string): Promise<RuntimeSelectionAgentConfig | undefined>;
-};
-
-export type RuntimeSelectionOptions = {
-  agentKey: string;
-  env: EnvLike;
-  output: OutputLike;
-  runtimeMode?: AgentRuntimeRequestedMode;
-  localRuntimeAdapter?: RuntimeSelectionAdapter;
-  localRuntimeAdapterFactory?: unknown;
-  resolveLocalRuntimeAdapter?: () => RuntimeSelectionAdapter | undefined;
-};
-
-const SERVER_PLATFORM_TOOL_NAMES = new Set([
-  "addTableRow",
-  "addTableRows",
-  "deleteTableRow",
-  "deleteTableRows",
-  "queryTableRows",
-  "streamParallelAgents",
-  "taskRun",
-  "updateTableRow",
-  "updateTableRows",
-]);
-
-const KNOWN_SERVER_PLATFORM_AGENT_ALIASES = new Set([
-  "code-review",
-  "frontend",
-  "frontend-agent",
-  "frontend-implementer",
-  "full-stack",
-  "fullstack",
-  "nolo code review",
-  "nolo frontend",
-  "nolo fullstack",
-  "nolo reviewer",
-  "nolo-code-review",
-  "nolo-frontend",
-  "nolo-fullstack",
-  "nolo-reviewer",
-  "review",
-  "reviewer",
-]);
-
-export function shouldUseScriptBridge(decision: ScriptBridgeDecision) {
-  return !decision.hasAuthToken && decision.scriptPathExists;
-}
-
-export function findServerPlatformTools(toolNames?: string[]) {
-  if (!Array.isArray(toolNames)) return [];
-  return toolNames.filter((toolName) => SERVER_PLATFORM_TOOL_NAMES.has(toolName));
-}
-
-export function resolveServerPlatformToolNames(agentConfig: RuntimeSelectionAgentConfig | undefined) {
-  return findServerPlatformTools([
-    ...(Array.isArray(agentConfig?.toolNames) ? agentConfig.toolNames : []),
-    ...(Array.isArray(agentConfig?.runtimeToolPolicy?.agentTools)
-      ? agentConfig.runtimeToolPolicy.agentTools
-      : []),
-  ]);
-}
-
-export function normalizeAgentRef(ref?: string) {
-  return ref?.trim().toLowerCase().replace(/\s+/g, " ");
-}
-
-export function isKnownServerPlatformAgent(options: Pick<RuntimeSelectionOptions, "agentKey">) {
-  if (isKnownPlatformAgentKey(options.agentKey)) return true;
-  const normalizedKey = normalizeAgentRef(options.agentKey);
-  return Boolean(normalizedKey && KNOWN_SERVER_PLATFORM_AGENT_ALIASES.has(normalizedKey));
-}
-
-export function shouldShowUsage(env: EnvLike) {
-  return env.NOLO_DEBUG === "1" || env.NOLO_SHOW_USAGE === "1";
-}
-
-export function resolveRequestedRuntimeMode(
-  options: Pick<RuntimeSelectionOptions, "env" | "runtimeMode">
-) {
-  const envMode = options.env.NOLO_RUNTIME_MODE;
-  if (options.runtimeMode) return options.runtimeMode;
-  if (envMode === "local" || envMode === "server" || envMode === "auto") return envMode;
-  return "auto";
-}
-
-export function shouldAttemptAutoLocal(
-  options: Pick<RuntimeSelectionOptions, "env" | "localRuntimeAdapter" | "localRuntimeAdapterFactory">
-) {
-  if (options.localRuntimeAdapter || options.localRuntimeAdapterFactory) return true;
-  return Boolean(
-    options.env.NOLO_LOCAL_OPENAI_API_KEY ||
-      options.env.OPENAI_API_KEY ||
-      options.env.NOLO_LOCAL_OPENAI_BASE_URL ||
-      options.env.OPENAI_BASE_URL ||
-      options.env.NOLO_LOCAL_AGENT_KEY
-  );
-}
-
-export async function shouldSkipAutoLocalForServerPlatformTools(
-  options: RuntimeSelectionOptions
-) {
-  if (isKnownServerPlatformAgent(options)) {
-    options.output.write(
-      `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is a known platform agent. ` +
-        "Use --local explicitly to force local workspace tools.\n"
-    );
-    return true;
-  }
-  const adapter = options.localRuntimeAdapter || options.resolveLocalRuntimeAdapter?.();
-  if (!adapter) return false;
-  let agentConfig;
-  try {
-    agentConfig = await adapter.loadAgentConfig(options.agentKey);
-  } catch {
-    return false;
-  }
-  const serverTools = resolveServerPlatformToolNames(agentConfig);
-  if (serverTools.length === 0) return false;
-  options.output.write(
-    `[nolo] auto runtime: skipping local runtime because ${options.agentKey} declares server platform tools ` +
-      `(${serverTools.join(", ")}). Use --local explicitly to force local workspace tools.\n`
-  );
-  return true;
-}