nolo-cli 0.1.30 → 0.1.32

package/cli/tableQueryRequest.ts

@@ -0,0 +1,53 @@
+import { includeTableActivityColumns } from "../render/table/activityColumns";
+import { readOption } from "./tableQueryParsing";
+
+export type TableQueryFilters = Record<string, unknown>;
+
+export type TableQueryRequestInput = {
+  tenantId: string;
+  tableId: string;
+  filters?: TableQueryFilters;
+  columns?: string[];
+  includeActivity?: boolean;
+  includeBaseFields?: boolean;
+  hasSingleRowShortcut?: boolean;
+  limit?: string | number;
+  offset?: string | number;
+  sortBy?: string;
+  sortOrder?: string;
+};
+
+export function mergeQueryShortcutFilters(
+  args: string[],
+  filters: TableQueryFilters | undefined,
+): TableQueryFilters | undefined {
+  const row = readOption(args, "--row") || readOption(args, "--row-id");
+  const rowDbKey = readOption(args, "--row-dbkey");
+  const shortcutFilters: TableQueryFilters = {};
+  if (row) {
+    if (row.startsWith("row-")) shortcutFilters.dbKey = row;
+    else shortcutFilters.rowId = row;
+  }
+  if (rowDbKey) shortcutFilters.dbKey = rowDbKey;
+  if (Object.keys(shortcutFilters).length === 0) return filters;
+  return {
+    ...(filters ?? {}),
+    ...shortcutFilters,
+  };
+}
+
+export function buildTableQueryRequest(input: TableQueryRequestInput) {
+  return {
+    tenantId: input.tenantId,
+    tableId: input.tableId,
+    filters: input.filters ?? {},
+    columns: input.includeActivity
+      ? includeTableActivityColumns(input.columns)
+      : input.columns,
+    includeBaseFields: input.includeBaseFields ?? true,
+    limit: Number(input.limit || (input.hasSingleRowShortcut ? 1 : 20)),
+    offset: Number(input.offset || 0),
+    sortBy: input.sortBy || "updatedAt",
+    sortOrder: input.sortOrder === "asc" ? "asc" : "desc",
+  };
+}

package/cli/taskRunActions.ts

@@ -0,0 +1,122 @@
+import { csv, optional, optionalJson, required } from "./taskRunParsing";
+
+export function buildBody(command: string, args: string[]) {
+  const dbKey = required(args, "--row-dbkey");
+  if (command === "read-context" || command === "readTaskContext") {
+    return { action: "readTaskContext", dbKey };
+  }
+  if (command === "claim-work-item" || command === "claimWorkItem") {
+    return {
+      action: "claimWorkItem",
+      dbKey,
+      workItemId: required(args, "--work-item-id"),
+      agentKey: required(args, "--agent-key"),
+      role: optional(args, "--role"),
+    };
+  }
+  if (command === "record-agent-run" || command === "recordAgentRun") {
+    const toolTraceSummary = optionalJson(args, "--tool-trace-summary");
+    return {
+      action: "recordAgentRun",
+      dbKey,
+      ...(optional(args, "--run-id") ? { runId: optional(args, "--run-id") } : {}),
+      agentKey: required(args, "--agent-key"),
+      ...(optional(args, "--role") ? { role: optional(args, "--role") } : {}),
+      runStatus: required(args, "--run-status"),
+      ...(optional(args, "--work-item-id") ? { workItemId: optional(args, "--work-item-id") } : {}),
+      ...(optional(args, "--dialog-id") ? { dialogId: optional(args, "--dialog-id") } : {}),
+      ...(optional(args, "--result-summary") ? { resultSummary: optional(args, "--result-summary") } : {}),
+      ...(optional(args, "--error-code") ? { errorCode: optional(args, "--error-code") } : {}),
+      ...(optional(args, "--tools-used") ? { toolsUsed: csv(optional(args, "--tools-used")!) } : {}),
+      ...(toolTraceSummary ? { toolTraceSummary } : {}),
+    };
+  }
+  if (command === "set-blocker" || command === "setBlocker") {
+    return {
+      action: "setBlocker",
+      dbKey,
+      workItemId: optional(args, "--work-item-id"),
+      blocker: {
+        layer: required(args, "--layer"),
+        code: required(args, "--code"),
+        message: required(args, "--message"),
+      },
+    };
+  }
+  if (command === "clear-blocker" || command === "clearBlocker") {
+    return {
+      action: "clearBlocker",
+      dbKey,
+      blockerId: required(args, "--blocker-id"),
+      workItemId: optional(args, "--work-item-id"),
+    };
+  }
+  if (command === "submit-outcome" || command === "submitOutcome") {
+    return {
+      action: "submitOutcome",
+      dbKey,
+      workItemId: required(args, "--work-item-id"),
+      summary: required(args, "--summary"),
+      ...(optional(args, "--dialog-id") ? { dialogId: optional(args, "--dialog-id") } : {}),
+      ...(optional(args, "--artifact-ids") ? { artifactIds: csv(optional(args, "--artifact-ids")!) } : {}),
+    };
+  }
+  if (command === "request-review" || command === "requestReview") {
+    return {
+      action: "requestReview",
+      dbKey,
+      workItemId: optional(args, "--work-item-id"),
+      reviewerAgentKey: required(args, "--reviewer-agent-key"),
+      ...(optional(args, "--dialog-id") ? { dialogId: optional(args, "--dialog-id") } : {}),
+      ...(optional(args, "--message") ? { message: optional(args, "--message") } : {}),
+      ...(optional(args, "--artifact-ids") ? { artifactIds: csv(optional(args, "--artifact-ids")!) } : {}),
+    };
+  }
+  if (command === "record-review" || command === "recordReview") {
+    return {
+      action: "recordReview",
+      dbKey,
+      ...(optional(args, "--work-item-id") ? { workItemId: optional(args, "--work-item-id") } : {}),
+      reviewStatus: required(args, "--review-status"),
+      ...(optional(args, "--reviewer-agent-key")
+        ? { reviewerAgentKey: optional(args, "--reviewer-agent-key") }
+        : {}),
+      ...(optional(args, "--dialog-id") ? { dialogId: optional(args, "--dialog-id") } : {}),
+      ...(optional(args, "--findings") ? { findings: optional(args, "--findings") } : {}),
+      ...(optional(args, "--artifact-ids") ? { artifactIds: csv(optional(args, "--artifact-ids")!) } : {}),
+    };
+  }
+  if (
+    command === "close-work-item" ||
+    command === "complete-work-item" ||
+    command === "closeWorkItem" ||
+    command === "completeWorkItem"
+  ) {
+    return {
+      action: "closeWorkItem",
+      dbKey,
+      workItemId: required(args, "--work-item-id"),
+      summary: required(args, "--summary"),
+      ...(optional(args, "--reason") ? { reason: optional(args, "--reason") } : {}),
+      ...(optional(args, "--dialog-id") ? { dialogId: optional(args, "--dialog-id") } : {}),
+      ...(optional(args, "--artifact-ids") ? { artifactIds: csv(optional(args, "--artifact-ids")!) } : {}),
+    };
+  }
+  throw new Error(`Unknown task-run command: ${command}`);
+}
+
+export function usage() {
+  return [
+    "Usage:",
+    "  nolo task-run read-context --row-dbkey <row>",
+    "  nolo task-run claim-work-item --row-dbkey <row> --work-item-id <id> --agent-key <agent> [--role <role>]",
+    "  nolo task-run record-agent-run --row-dbkey <row> --agent-key <agent> --run-status <status> [--tools-used <csv>]",
+    "  nolo task-run set-blocker --row-dbkey <row> [--work-item-id <id>] --layer <layer> --code <code> --message <message>",
+    "  nolo task-run clear-blocker --row-dbkey <row> --blocker-id <id> [--work-item-id <id>]",
+    "  nolo task-run submit-outcome --row-dbkey <row> --work-item-id <id> --summary <summary> [--dialog-id <id>]",
+    "  nolo task-run request-review --row-dbkey <row> --reviewer-agent-key <agent> [--work-item-id <id>]",
+    "  nolo task-run record-review --row-dbkey <row> [--work-item-id <id>] --review-status <passed|needs_changes|blocked> [--findings <text>]",
+    "  nolo task-run close-work-item --row-dbkey <row> --work-item-id <id> --summary <summary>",
+    "",
+  ].join("\n");
+}

package/cli/taskRunCommand.ts

@@ -0,0 +1,70 @@
+import type { EnvLike } from "./taskRunParsing";
+import type { OutputLike } from "./cliIoTypes";
+import { buildBody, usage } from "./taskRunActions";
+import {
+  loadTaskRunEnv,
+  resolveAuthToken,
+  resolveServerUrl,
+} from "./taskRunParsing";
+
+type TaskRunCommandDeps = {
+  env?: EnvLike;
+  output?: OutputLike;
+  fetchImpl?: typeof fetch;
+};
+
+const DEFAULT_TASK_RUN_TIMEOUT_MS = 10 * 60 * 1000;
+
+function resolveTaskRunTimeoutMs(env: EnvLike) {
+  const raw = env.NOLO_TASK_RUN_TIMEOUT_MS;
+  if (!raw) return DEFAULT_TASK_RUN_TIMEOUT_MS;
+  const value = Number(raw);
+  return Number.isFinite(value) && value > 0 ? value : DEFAULT_TASK_RUN_TIMEOUT_MS;
+}
+
+export async function runTaskRunCommand(args: string[], deps: TaskRunCommandDeps = {}) {
+  const env = loadTaskRunEnv(deps.env ?? process.env, { includeDefaultEnvFiles: deps.env === undefined });
+  const output = deps.output ?? process.stdout;
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const command = args[0];
+  if (!command || command === "--help" || command === "-h") {
+    output.write(usage());
+    return 0;
+  }
+
+  let body: Record<string, unknown>;
+  try {
+    body = buildBody(command, args.slice(1));
+  } catch (error) {
+    output.write(`[nolo] task-run failed: ${error instanceof Error ? error.message : String(error)}\n`);
+    return 1;
+  }
+
+  const authToken = resolveAuthToken(args, env);
+  if (!authToken) {
+    output.write("[nolo] task-run failed: AUTH_TOKEN or NOLO_MACHINE_API_KEY is required.\n");
+    return 1;
+  }
+
+  const serverUrl = resolveServerUrl(args, env);
+  const timeoutMs = resolveTaskRunTimeoutMs(env);
+  let response: Response;
+  try {
+    response = await fetchImpl(`${serverUrl}/api/task-run`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${authToken}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+  } catch (error) {
+    output.write(`[nolo] task-run failed: ${error instanceof Error ? error.message : String(error)}\n`);
+    return 1;
+  }
+
+  const text = await response.text();
+  output.write(text.trim() ? `${text.trim()}\n` : "");
+  return response.ok ? 0 : 1;
+}

package/cli/taskRunParsing.ts

@@ -0,0 +1,86 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+import {
+  readCliOptionValue,
+  resolveAuthTokenFromArgs,
+  resolveServerUrlFromArgs,
+} from "./cliEnvHelpers";
+
+export type EnvLike = Record<string, string | undefined>;
+
+export function parseEnvFile(path: string): EnvLike {
+  if (!path || !existsSync(path)) return {};
+  const parsed: EnvLike = {};
+  for (const rawLine of readFileSync(path, "utf8").split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const index = line.indexOf("=");
+    if (index <= 0) continue;
+    const key = line.slice(0, index).trim();
+    let value = line.slice(index + 1).trim();
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+    if (key) parsed[key] = value;
+  }
+  return parsed;
+}
+
+export function loadTaskRunEnv(
+  env: EnvLike,
+  options: { includeDefaultEnvFiles?: boolean } = {},
+) {
+  const envFileCandidates = [
+    env.NOLO_TASK_RUN_ENV_FILE,
+    env.NOLO_MACHINE_ENV_FILE,
+    ...(options.includeDefaultEnvFiles
+      ? ["/etc/nolo/machine-runner.env", join(homedir(), ".nolo", "machine-runner.env")]
+      : []),
+  ].filter((path): path is string => Boolean(path));
+  const fileEnv = Object.assign({}, ...envFileCandidates.map(parseEnvFile));
+  return { ...fileEnv, ...env };
+}
+
+export function readOption(args: string[], flag: string) {
+  return readCliOptionValue(args, flag);
+}
+
+export function csv(raw: string) {
+  return raw.split(",").map((item) => item.trim()).filter(Boolean);
+}
+
+export function required(args: string[], flag: string) {
+  const value = readOption(args, flag).trim();
+  if (!value) throw new Error(`${flag} is required`);
+  return value;
+}
+
+export function optional(args: string[], flag: string) {
+  const value = readOption(args, flag).trim();
+  return value || undefined;
+}
+
+export function optionalJson(args: string[], flag: string) {
+  const value = optional(args, flag);
+  if (!value) return undefined;
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    throw new Error(
+      `${flag} must be valid JSON: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+}
+
+export function resolveServerUrl(args: string[], env: EnvLike) {
+  return resolveServerUrlFromArgs(args, env);
+}
+
+export function resolveAuthToken(args: string[], env: EnvLike) {
+  return resolveAuthTokenFromArgs(args, env);
+}

package/cli/taskRunPromptShared.ts

@@ -0,0 +1,55 @@
+export type TaskRunPromptContext = {
+  rowDbKey: string;
+  taskRunId?: string;
+  workItemId?: string;
+  artifactIds?: string[];
+};
+
+export type TaskRunPromptRuntime = "cli" | "server-tool";
+
+function buildTaskRunPromptRuntimeLines(runtime: TaskRunPromptRuntime): string[] {
+  if (runtime === "cli") {
+    return [
+      "- When you create, update, hand off, block, or review work, update the task context with `bun run task:run -- ...`.",
+      "- If this turn already includes a server TaskRun preflight snapshot, use that snapshot directly for read-only reporting or planning.",
+    ];
+  }
+
+  return [
+    "- Use the server-side `taskRun` tool when you create, update, hand off, block, or review work.",
+    "- If this turn already includes a server TaskRun preflight snapshot, use that snapshot directly for read-only reporting or planning. Otherwise start with `readTaskContext`.",
+    "- Use primitive actions such as `upsertWorkItem`, `claimWorkItem`, `openDialog`, `setBlocker`, `requestReview`, `recordReview`, `submitOutcome`, and `closeWorkItem`.",
+    "- Do not emulate `taskRun` by directly editing `meta.taskRun` with table tools. Table tools are only for human-readable columns such as status, progress, and result.",
+    "- Do not delegate `taskRun` state writes through `streamParallelAgents`. The coordinating agent must write task-run state itself, then delegate implementation or review work if needed.",
+    "- If the `taskRun` tool is not exposed at runtime, report that as an infrastructure blocker instead of inventing a compatible-looking meta shape.",
+    "- Keep actions generic and configurable. Do not invent hardcoded workflow verbs like `handoff_frontend` when an `openDialog` or work item update is enough.",
+  ];
+}
+
+export function buildTaskRunPromptBlock(
+  context: TaskRunPromptContext,
+  runtime: TaskRunPromptRuntime
+): string {
+  const artifactIds = context.artifactIds?.filter(Boolean) ?? [];
+  return [
+    "AI-native task-run context:",
+    "- This system is AI-native. The current task board is only the present observation and validation use case; different users, companies, and workflows may use different task owners later.",
+    "- Treat the task row meta as the durable execution context. Do not infer branch, runner, handoff, review, or blocker state from chat history alone.",
+    `- rowDbKey: ${context.rowDbKey}`,
+    ...(context.taskRunId ? [`- taskRunId: ${context.taskRunId}`] : []),
+    ...(context.workItemId ? [`- workItemId: ${context.workItemId}`] : []),
+    ...(artifactIds.length ? [`- artifactIds: ${artifactIds.join(",")}`] : []),
+    "- Handoff rule: start from the durable task context, then inspect existing refs such as workItems.dialogIds, workItems.outcome, review.dialogId, activityRefs, agentRuns.dialogId/resultSummary, and artifactRefs. Use dialog read/search for exact evidence.",
+    ...buildTaskRunPromptRuntimeLines(runtime),
+    "- Keep long reasoning and logs in the dialog; record only resumable references in task row meta.",
+  ].join("\n");
+}
+
+export function prependTaskRunPromptForRuntime(
+  message: string,
+  context: TaskRunPromptContext | undefined,
+  runtime: TaskRunPromptRuntime
+): string {
+  if (!context?.rowDbKey) return message;
+  return `${buildTaskRunPromptBlock(context, runtime)}\n\nUser task:\n${message}`;
+}

package/cli/tui/readlineWorkspace.ts

@@ -0,0 +1,141 @@
+import { createInterface } from "node:readline";
+import { stdin as defaultInput, stdout as defaultOutput } from "node:process";
+import { runAgentTurn, type RunAgentTurnResult } from "../client/agentRun";
+import { compactDialog, type CompactDialogResult } from "../client/compactDialog";
+import { runSelfUpdate } from "../updateCommands";
+import {
+  createInitialTuiState,
+  handleTuiInput,
+  renderPrompt,
+  renderStatusLine,
+  renderWelcome,
+  type TuiState,
+} from "./session";
+
+export type SelfUpdater = (
+  output: NodeJS.WritableStream
+) => Promise<number>;
+
+type WorkspaceOptions = {
+  scriptDir: string;
+  env?: NodeJS.ProcessEnv;
+  input?: NodeJS.ReadableStream;
+  output?: NodeJS.WritableStream;
+  agentRunner?: typeof runAgentTurn;
+  compactRunner?: (options: {
+    serverUrl: string;
+    authToken: string;
+    dialogId: string;
+  }) => Promise<CompactDialogResult>;
+  selfUpdater?: SelfUpdater;
+};
+
+async function runAgentChat(
+  scriptDir: string,
+  state: TuiState,
+  message: string,
+  env: NodeJS.ProcessEnv,
+  output: NodeJS.WritableStream,
+  agentRunner: typeof runAgentTurn = runAgentTurn
+) {
+  const result: RunAgentTurnResult = await agentRunner({
+    agentName: state.agentName,
+    agentKey: state.agentKey,
+    serverUrl: state.serverUrl,
+    message,
+    continueDialogId: state.dialogId,
+    runtimeMode: state.runtimeMode,
+    scriptDir,
+    env,
+    output,
+  });
+  return result;
+}
+
+export async function startTuiWorkspace(options: WorkspaceOptions) {
+  let state = createInitialTuiState(options.env ?? process.env);
+  const input = options.input ?? defaultInput;
+  const output = options.output ?? defaultOutput;
+  const selfUpdater: SelfUpdater =
+    options.selfUpdater ?? ((target) => runSelfUpdate({ output: target }));
+  const rl = createInterface({ input, output });
+
+  output.write(renderWelcome(state));
+  rl.setPrompt(renderPrompt(state));
+  rl.prompt();
+
+  try {
+    for await (const line of rl) {
+      const result = handleTuiInput(line, state);
+      state = result.nextState;
+
+      if (result.output) {
+        output.write(`${result.output}\n`);
+      }
+
+      if (result.action?.type === "exit") {
+        break;
+      }
+
+      if (result.action?.type === "compact") {
+        const runner = options.compactRunner ?? compactDialog;
+        const authToken =
+          options.env?.AUTH_TOKEN ?? options.env?.AUTH ?? options.env?.BENCHMARK_AUTH_TOKEN ?? "";
+        try {
+          const compactResult = await runner({
+            serverUrl: state.serverUrl,
+            authToken,
+            dialogId: result.action.dialogId,
+          });
+          state = {
+            ...state,
+            dialogId: compactResult.dialogId,
+            dialogLabel: compactResult.dialogId,
+          };
+        } catch (error: any) {
+          output.write(
+            `[nolo] Compact failed: ${error?.message ?? String(error)}\n`
+          );
+        }
+      }
+
+      if (result.action?.type === "self-update") {
+        try {
+          const exitCode = await selfUpdater(output);
+          if (exitCode === 0) {
+            output.write("Update finished. Restart nolo to use the new version.\n");
+          } else {
+            output.write("Update failed. Fix the npm error above, then run /update again or use nolo update.\n");
+          }
+        } catch (error) {
+          output.write(`${error instanceof Error ? error.message : String(error)}\n`);
+          output.write("Update failed. Fix the npm error above, then run /update again or use nolo update.\n");
+        }
+      }
+
+      if (result.action?.type === "chat") {
+        const runResult = await runAgentChat(
+          options.scriptDir,
+          state,
+          result.action.message,
+          options.env ?? process.env,
+          output,
+          options.agentRunner
+        );
+        if (runResult.dialogId) {
+          state = {
+            ...state,
+            dialogId: runResult.dialogId,
+            dialogLabel: runResult.dialogId,
+          };
+        }
+      }
+
+      output.write(`\n${renderStatusLine(state)}\n`);
+      rl.setPrompt(renderPrompt(state));
+      rl.prompt();
+    }
+  } finally {
+    rl.close();
+  }
+}

package/cli/tui/session.ts

@@ -0,0 +1,50 @@
+import {
+  type TuiInterpreterAction,
+  type TuiInterpreterResult,
+  type TuiCommandInterpreterDeps,
+  handleTuiInput as handleTuiInputWithDeps,
+} from "./tuiCommandInterpreter";
+import {
+  DEFAULT_TUI_SERVER_URL,
+  type EnvLike,
+  type TuiState,
+  createInitialTuiState,
+  renderContextPanel,
+  renderKnownAgents,
+  renderPrompt,
+  renderStatusLine,
+  renderTuiHelp,
+  renderWelcome,
+  resolveDialogLabel,
+} from "./tuiPresentation";
+import { DEFAULT_TUI_AGENT_KEY, KNOWN_AGENTS, KNOWN_AGENT_ALIASES } from "./tuiCatalog";
+
+export { DEFAULT_TUI_AGENT_KEY, DEFAULT_TUI_SERVER_URL, KNOWN_AGENTS, KNOWN_AGENT_ALIASES };
+export type { EnvLike, TuiState } from "./tuiPresentation";
+
+export type TuiAction = TuiInterpreterAction;
+export type TuiInputResult = TuiInterpreterResult;
+
+function createInterpreterDeps(): TuiCommandInterpreterDeps {
+  return {
+    knownAgents: KNOWN_AGENTS,
+    renderHelp: renderTuiHelp,
+    renderContextPanel,
+    renderKnownAgents,
+  };
+}
+
+export {
+  createInitialTuiState,
+  renderContextPanel,
+  renderKnownAgents,
+  renderPrompt,
+  renderStatusLine,
+  renderTuiHelp,
+  renderWelcome,
+  resolveDialogLabel,
+};
+
+export function handleTuiInput(input: string, state: TuiState): TuiInputResult {
+  return handleTuiInputWithDeps(input, state, createInterpreterDeps());
+}

package/cli/tui/tuiCatalog.ts

@@ -0,0 +1,22 @@
+export const DEFAULT_TUI_AGENT_KEY = "agent-pub-01NOLOAPPBLD000000019KCKT0";
+
+export const KNOWN_AGENTS: Array<{
+  name: string;
+  key: string;
+  description: string;
+}> = [
+  {
+    name: "nolo",
+    key: "agent-pub-01NOLOAPPBLD000000019KCKT0",
+    description: "one assistant that routes work across your agents and data",
+  },
+  {
+    name: "app-builder",
+    key: "agent-pub-01APPBUILDER00000001YAII3I",
+    description: "builds web apps, tools, charts, and product prototypes",
+  },
+];
+
+export const KNOWN_AGENT_ALIASES: Record<string, { name: string; key: string }> =
+  Object.fromEntries(KNOWN_AGENTS.map((agent) => [agent.name, agent]));
+