nolo-cli 0.1.18 → 0.1.20

package/agentRunCommand.ts

@@ -1,9 +1,16 @@
 import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
 import { runAgentTurn, type RunAgentTurnResult } from "./client/agentRun";
-import type { AgentRuntimeRequestedMode } from "./agentRuntimeLocal";
+import type { AgentRuntimeHostAdapter, AgentRuntimeRequestedMode } from "./agentRuntimeLocal";
 import { existsSync, readFileSync } from "node:fs";
-import { extname, join, resolve } from "node:path";
+import { extname, resolve } from "node:path";
 import { resolveCliAgentKeyInput } from "./agentAliases";
+import {
+  ensureWorkspacePackageLinks,
+  formatPreparedTaskWorktree,
+  prepareTaskWorktree,
+  type PreparedTaskWorktree,
+} from "./client/taskWorktree";
+import type { TaskRunPromptContext } from "./client/taskRunPrompt";
 
 type EnvLike = Record<string, string | undefined>;
 
@@ -16,7 +23,24 @@ type AgentRunCommandDeps = {
   scriptDir: string;
   output?: OutputLike;
   runner?: typeof runAgentTurn;
-  prepareShellWorktree?: typeof prepareShellWorktree;
+  localRuntimeAdapterFactory?: (env: EnvLike, options?: { cwd?: string }) => AgentRuntimeHostAdapter;
+  prepareTaskWorktree?: typeof prepareTaskWorktree;
+  ensureWorkspacePackageLinks?: typeof ensureWorkspacePackageLinks;
+  inspectLocalRunWorkspace?: typeof inspectLocalRunWorkspace;
+};
+
+type LocalRunWorkspaceInspection = {
+  cwd: string;
+  clean: boolean;
+  status: string;
+  commit?: {
+    hash: string;
+    subject: string;
+  };
+};
+
+type ParseAgentRunArgsOptions = {
+  readTextFile?: (path: string) => string;
 };
 
 type ParsedAgentRunArgs = {
@@ -26,8 +50,26 @@ type ParsedAgentRunArgs = {
   allowShell: boolean;
   runtimeMode?: AgentRuntimeRequestedMode;
   continueDialogId?: string;
+  spaceId?: string;
+  category?: string;
+  inheritedFromDialogKey?: string;
+  parentDialogId?: string;
+  background: boolean;
+  noStream: boolean;
+  noDefaultTestRoot: boolean;
+  cwd?: string;
+  maxToolRounds?: number;
+  timeoutMs?: number;
+  traceTools: boolean;
+  useTaskWorktree: boolean;
+  taskRunContext?: TaskRunPromptContext;
 };
 
+const DEFAULT_TEST_ROOT_DIALOG_ID = "01KN6V3MVEQA4Q1PNKVM2W7YY8";
+const DEFAULT_TEST_ROOT_DIALOG_KEY = `dialog-b2e06f801f-${DEFAULT_TEST_ROOT_DIALOG_ID}`;
+const DEFAULT_AGENT_SPACE_ID = "01KKY77TT0DA9NY7TNW3R7255N";
+const DEFAULT_TEST_DIALOG_CATEGORY_ID = "test-dialogs";
+
 function readFlagValue(args: string[], flag: string) {
   const index = args.indexOf(flag);
   if (index < 0) return undefined;
@@ -52,6 +94,20 @@ function runtimeModeFromArgs(args: string[]): AgentRuntimeRequestedMode | undefi
   return undefined;
 }
 
+function parseNonNegativeInteger(value: string | undefined) {
+  if (!value) return undefined;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) return undefined;
+  return Math.floor(parsed);
+}
+
+function parsePositiveInteger(value: string | undefined) {
+  if (!value) return undefined;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) return undefined;
+  return Math.floor(parsed);
+}
+
 function positionalArgs(args: string[]) {
   const values: string[] = [];
   const valuelessFlags = new Set([
@@ -59,6 +115,12 @@ function positionalArgs(args: string[]) {
     "--server",
     "--auto",
     "--dangerously-allow-shell",
+    "--worktree-task",
+    "--trace-tools",
+    "--bg",
+    "--no-stream",
+    "--debug",
+    "--no-default-test-root",
   ]);
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
@@ -72,24 +134,98 @@ function positionalArgs(args: string[]) {
   return values;
 }
 
-export function parseAgentRunArgs(args: string[]): ParsedAgentRunArgs | null {
+export function parseAgentRunArgs(
+  args: string[],
+  options: ParseAgentRunArgsOptions = {}
+): ParsedAgentRunArgs | null {
   const agentKey = readFlagValue(args, "--agent") ?? positionalArgs(args)[0];
   const explicitMsg = readFlagValue(args, "--msg");
-  const message = explicitMsg ?? positionalArgs(args).slice(1).join(" ");
-  if (!agentKey || !message.trim()) return null;
+  const msgFile = readFlagValue(args, "--msg-file");
+  const fileMessage = msgFile
+    ? (options.readTextFile ?? ((path: string) => readFileSync(path, "utf8")))(msgFile)
+    : undefined;
+  const rawMessage = explicitMsg ?? fileMessage ?? positionalArgs(args).slice(1).join(" ");
+  if (!agentKey || !rawMessage.trim()) return null;
+  const message = rawMessage.trim();
   const runtimeMode = runtimeModeFromArgs(args);
   const continueDialogId = readFlagValue(args, "--continue") ?? readFlagValue(args, "--dialog");
+  const spaceId = readFlagValue(args, "--space");
+  const category = readFlagValue(args, "--category");
+  const inheritedFromDialog = readFlagValue(args, "--inherit-from-dialog");
+  const noDefaultTestRoot = args.includes("--no-default-test-root");
+  const cwd = readFlagValue(args, "--cwd");
+  const maxToolRounds = parseNonNegativeInteger(
+    readFlagValue(args, "--max-tool-rounds") ?? readFlagValue(args, "--rounds")
+  );
+  const timeoutMs = parsePositiveInteger(readFlagValue(args, "--timeout-ms"));
+  const inheritedRef = inheritedFromDialog
+    ? parseDialogReference(inheritedFromDialog)
+    : !continueDialogId && !noDefaultTestRoot
+      ? {
+          dialogKey: DEFAULT_TEST_ROOT_DIALOG_KEY,
+          dialogId: DEFAULT_TEST_ROOT_DIALOG_ID,
+        }
+      : undefined;
   const imageUrls = [
     ...readRepeatedFlagValues(args, "--image"),
     ...readRepeatedFlagValues(args, "--image-url"),
   ];
+  const useTaskWorktree = args.includes("--worktree-task");
+  const taskRowDbKey = readFlagValue(args, "--task-row-dbkey");
+  const artifactIds = readFlagValue(args, "--artifact-ids")
+    ?.split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
   return {
     agentKey: resolveCliAgentKeyInput(agentKey),
-    message: message.trim(),
+    message,
     imageUrls,
     allowShell: args.includes("--dangerously-allow-shell"),
-    ...(runtimeMode ? { runtimeMode } : {}),
+    traceTools: args.includes("--trace-tools"),
+    useTaskWorktree,
+    ...(taskRowDbKey
+      ? {
+          taskRunContext: {
+            rowDbKey: taskRowDbKey,
+            ...(readFlagValue(args, "--task-run-id") ? { taskRunId: readFlagValue(args, "--task-run-id") } : {}),
+            ...(readFlagValue(args, "--work-item-id") ? { workItemId: readFlagValue(args, "--work-item-id") } : {}),
+            ...(artifactIds?.length ? { artifactIds } : {}),
+          },
+        }
+      : {}),
+    ...(runtimeMode ? { runtimeMode } : useTaskWorktree ? { runtimeMode: "local" as const } : {}),
+    background: args.includes("--bg"),
+    noStream: args.includes("--no-stream"),
+    noDefaultTestRoot,
     ...(continueDialogId ? { continueDialogId } : {}),
+    ...(!continueDialogId ? { spaceId: spaceId ?? DEFAULT_AGENT_SPACE_ID } : {}),
+    ...(category ? { category } : !continueDialogId && !noDefaultTestRoot ? { category: DEFAULT_TEST_DIALOG_CATEGORY_ID } : {}),
+    ...(inheritedRef?.dialogKey ? { inheritedFromDialogKey: inheritedRef.dialogKey } : {}),
+    ...(inheritedRef?.dialogId ? { parentDialogId: inheritedRef.dialogId } : {}),
+    ...(cwd ? { cwd } : {}),
+    ...(typeof maxToolRounds === "number" ? { maxToolRounds } : {}),
+    ...(typeof timeoutMs === "number" ? { timeoutMs } : {}),
+  };
+}
+
+function parseDialogReference(rawInput: string) {
+  const normalized = rawInput.trim();
+  if (normalized.startsWith("dialog-")) {
+    const parts = normalized.split("-");
+    return {
+      dialogKey: normalized,
+      dialogId: parts.at(-1) ?? normalized,
+    };
+  }
+  const dialogMatch = normalized.match(/dialog-([a-zA-Z0-9]+)-([a-zA-Z0-9]+)/);
+  if (dialogMatch) {
+    return {
+      dialogKey: `dialog-${dialogMatch[1]}-${dialogMatch[2]}`,
+      dialogId: dialogMatch[2],
+    };
+  }
+  return {
+    dialogId: normalized,
   };
 }
 
@@ -115,24 +251,14 @@ export function normalizeCliImageInput(input: string) {
   return `data:${mimeTypeForPath(absolutePath)};base64,${base64}`;
 }
 
-function resolveServerUrl(env: EnvLike) {
-  return (env.NOLO_SERVER || env.BASE_URL || DEFAULT_NOLO_SERVER_URL).replace(/\/+$/, "");
-}
-
-function safePathSegment(input: string) {
-  return input.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "agent";
-}
-
-function createTaskId() {
-  return Date.now().toString(36).toUpperCase();
-}
-
-async function runGit(args: string[], cwd: string) {
-  const proc = Bun.spawn(["git", ...args], {
-    cwd,
+async function runGitForLocalSummary(args: {
+  cwd: string;
+  gitArgs: string[];
+}) {
+  const proc = Bun.spawn(["git", ...args.gitArgs], {
+    cwd: args.cwd,
     stdout: "pipe",
     stderr: "pipe",
-    stdin: "ignore",
   });
   const [stdout, stderr, exitCode] = await Promise.all([
     new Response(proc.stdout).text(),
@@ -140,32 +266,80 @@ async function runGit(args: string[], cwd: string) {
     proc.exited,
   ]);
   if (exitCode !== 0) {
-    throw new Error(stderr.trim() || stdout.trim() || `git ${args.join(" ")} failed`);
+    throw new Error((stderr || stdout || `git ${args.gitArgs.join(" ")} failed`).trim());
   }
   return stdout.trim();
 }
 
-export async function prepareShellWorktree(args: {
-  agentKey: string;
-  cwd?: string;
-  env?: EnvLike;
+async function inspectLocalRunWorkspace(cwd: string): Promise<LocalRunWorkspaceInspection> {
+  const status = await runGitForLocalSummary({
+    cwd,
+    gitArgs: ["status", "--short"],
+  });
+  const rawCommit = await runGitForLocalSummary({
+    cwd,
+    gitArgs: ["log", "-1", "--format=%h%x00%s"],
+  }).catch(() => "");
+  const [hash, subject] = rawCommit.split("\0");
+  return {
+    cwd,
+    clean: status.trim() === "",
+    status,
+    ...(hash ? { commit: { hash, subject: subject ?? "" } } : {}),
+  };
+}
+
+function shouldPrintLocalRunSummary(args: {
+  parsed: ParsedAgentRunArgs;
+  localRuntimeCwd?: string;
+}) {
+  return Boolean(args.localRuntimeCwd && args.parsed.runtimeMode === "local");
+}
+
+function formatLocalRunSummary(args: {
+  dialogId?: string;
+  inspection: LocalRunWorkspaceInspection;
+}) {
+  return [
+    "",
+    "[nolo] local run summary",
+    `workspace: ${args.inspection.cwd}`,
+    ...(args.dialogId ? [`dialog: ${args.dialogId}`] : []),
+    ...(args.inspection.commit
+      ? [`commit: ${args.inspection.commit.hash} ${args.inspection.commit.subject}`]
+      : []),
+    `dirty: ${args.inspection.clean ? "clean" : "dirty"}`,
+    ...(!args.inspection.clean && args.inspection.status.trim()
+      ? [`status:\n${args.inspection.status.trim()}`]
+      : []),
+    "",
+  ].join("\n");
+}
+
+function resolveServerUrl(env: EnvLike) {
+  return (env.NOLO_SERVER || env.BASE_URL || DEFAULT_NOLO_SERVER_URL).replace(/\/+$/, "");
+}
+
+function shouldPrepareTaskWorktree(parsed: ParsedAgentRunArgs) {
+  return !parsed.cwd && (parsed.useTaskWorktree || parsed.allowShell);
+}
+
+function buildTaskWorktreeEnv(args: {
+  env: EnvLike;
+  worktreePath?: string;
+  allowShell: boolean;
 }) {
-  if (args.env?.NOLO_LOCAL_WORKTREE) return args.env.NOLO_LOCAL_WORKTREE;
-  const cwd = args.cwd ?? process.cwd();
-  const root = await runGit(["rev-parse", "--show-toplevel"], cwd);
-  const parent = join(root, ".worktrees");
-  const safeAgent = safePathSegment(args.agentKey);
-  const taskId = createTaskId();
-  const worktreePath = join(parent, `nolo-agent-${safeAgent}-${taskId}`);
-  const branchName = `nolo-agent-${safeAgent}-${taskId}`;
-  await runGit(["worktree", "add", worktreePath, "-b", branchName, "HEAD"], root);
-  return worktreePath;
+  return {
+    ...args.env,
+    ...(args.allowShell ? { NOLO_LOCAL_SHELL_MODE: "worktree" } : {}),
+    ...(args.worktreePath ? { NOLO_LOCAL_WORKTREE: args.worktreePath } : {}),
+  };
 }
 
 function writeUsage(output: OutputLike) {
   output.write(
-    "Usage: nolo agent run <agent> <message> [--local|--server|--auto] [--continue <dialogId>]\n" +
-      "       nolo agent run --agent <agent> --msg <message> [--image <url-or-path>] [--dangerously-allow-shell] [--local|--server|--auto]\n"
+    "Usage: nolo agent run <agent> <message> [--local|--server|--auto] [--continue <dialogId>] [--cwd <path>] [--max-tool-rounds <n>]\n" +
+      "       nolo agent run --agent <agent> --msg <message> [--image <url-or-path>] [--space <spaceId>] [--category <name>] [--inherit-from-dialog <dialog>] [--task-row-dbkey <key>] [--bg] [--timeout-ms <n>] [--no-stream]\n"
   );
 }
 
@@ -179,19 +353,47 @@ export async function runAgentRunCommand(args: string[], deps: AgentRunCommandDe
   }
 
   const runner = deps.runner ?? runAgentTurn;
-  let localRuntimeCwd: string | undefined;
-  if (parsed.allowShell) {
-    localRuntimeCwd = await (deps.prepareShellWorktree ?? prepareShellWorktree)({
-      agentKey: parsed.agentKey,
-      env,
-    });
+  let localRuntimeCwd = parsed.cwd;
+  if (shouldPrepareTaskWorktree(parsed)) {
+    try {
+      const preparedWorktree = await (deps.prepareTaskWorktree ?? prepareTaskWorktree)({
+        agentKey: parsed.agentKey,
+        env,
+      });
+      localRuntimeCwd = preparedWorktree.path;
+      output.write(formatPreparedTaskWorktree(preparedWorktree));
+    } catch (error) {
+      output.write(
+        "[nolo] Could not prepare a local task worktree.\n" +
+          "Run from inside a git repository, or set NOLO_LOCAL_WORKTREE to an existing isolated checkout.\n" +
+          `Reason: ${error instanceof Error ? error.message : String(error)}\n`
+      );
+      return 1;
+    }
+  }
+  const shouldBindLocalWorkspace =
+    !!localRuntimeCwd &&
+    (parsed.runtimeMode === "local" || parsed.allowShell || parsed.useTaskWorktree);
+  if (shouldBindLocalWorkspace) {
+    try {
+      await (deps.ensureWorkspacePackageLinks ?? ensureWorkspacePackageLinks)(
+        localRuntimeCwd!
+      );
+    } catch (error) {
+      output.write(
+        "[nolo] Dependency preflight failed for local task worktree.\n" +
+          "The worktree may have node_modules entries that point outside the task checkout, or paths that cannot be repaired safely.\n" +
+          `Reason: ${error instanceof Error ? error.message : String(error)}\n`
+      );
+      return 1;
+    }
   }
-  const runEnv = parsed.allowShell
-    ? {
-        ...env,
-        NOLO_LOCAL_SHELL_MODE: "worktree",
-        ...(localRuntimeCwd ? { NOLO_LOCAL_WORKTREE: localRuntimeCwd } : {}),
-      }
+  const runEnv = shouldBindLocalWorkspace
+    ? buildTaskWorktreeEnv({
+        env,
+        worktreePath: localRuntimeCwd,
+        allowShell: parsed.allowShell,
+      })
     : env;
   const result: RunAgentTurnResult = await runner({
     agentName: parsed.agentKey,
@@ -202,13 +404,46 @@ export async function runAgentRunCommand(args: string[], deps: AgentRunCommandDe
     scriptDir: deps.scriptDir,
     env: runEnv,
     output,
+    ...(deps.localRuntimeAdapterFactory
+      ? { localRuntimeAdapterFactory: deps.localRuntimeAdapterFactory }
+      : {}),
     ...(localRuntimeCwd ? { localRuntimeCwd } : {}),
     ...(parsed.runtimeMode ? { runtimeMode: parsed.runtimeMode } : {}),
     ...(parsed.continueDialogId ? { continueDialogId: parsed.continueDialogId } : {}),
+    ...(parsed.spaceId ? { spaceId: parsed.spaceId } : {}),
+    ...(parsed.category ? { category: parsed.category } : {}),
+    ...(parsed.inheritedFromDialogKey ? { inheritedFromDialogKey: parsed.inheritedFromDialogKey } : {}),
+    ...(parsed.parentDialogId ? { parentDialogId: parsed.parentDialogId } : {}),
+    background: parsed.background,
+    noStream: parsed.noStream,
+    noDefaultTestRoot: parsed.noDefaultTestRoot,
+    ...(typeof parsed.maxToolRounds === "number" ? { maxToolRounds: parsed.maxToolRounds } : {}),
+    ...(typeof parsed.timeoutMs === "number" ? { timeoutMs: parsed.timeoutMs } : {}),
+    traceTools: parsed.traceTools,
+    ...(parsed.taskRunContext ? { taskRunContext: parsed.taskRunContext } : {}),
   });
 
   if (result.dialogId) {
-    output.write(`\n[nolo] dialog ${result.dialogId}\n`);
+    if (parsed.background) {
+      output.write(`\n[nolo] background dialog ${result.dialogId}\n`);
+      output.write(`[nolo] read: nolo dialog read ${result.dialogId}\n`);
+    } else {
+      output.write(`\n[nolo] dialog ${result.dialogId}\n`);
+    }
+  }
+  if (shouldPrintLocalRunSummary({ parsed, localRuntimeCwd })) {
+    try {
+      const inspect = deps.inspectLocalRunWorkspace ?? inspectLocalRunWorkspace;
+      const inspection = await inspect(localRuntimeCwd!);
+      output.write(formatLocalRunSummary({
+        dialogId: result.dialogId,
+        inspection,
+      }));
+    } catch (error) {
+      output.write(
+        `\n[nolo] local run summary unavailable: ${error instanceof Error ? error.message : String(error)}\n`
+      );
+    }
   }
   return result.exitCode;
 }