nolo-cli 0.1.30 → 0.1.32

package/cli/tui/tuiCommandInterpreter.ts

@@ -0,0 +1,253 @@
+import type { AgentRuntimeRequestedMode } from "../agentRuntimeLocal";
+
+export type TuiInterpreterState = {
+  agentKey: string;
+  agentName: string;
+  dialogId?: string;
+  dialogLabel: string;
+  profileName: string;
+  serverUrl: string;
+  cliVersion?: string;
+  attachedDocs: string[];
+  runtimeMode: AgentRuntimeRequestedMode;
+};
+
+export type TuiInterpreterAction =
+  | {
+      type: "chat";
+      message: string;
+      agentKey: string;
+      runtimeMode: AgentRuntimeRequestedMode;
+      continueDialogId?: string;
+    }
+  | {
+      type: "compact";
+      dialogId: string;
+    }
+  | {
+      type: "self-update";
+    }
+  | {
+      type: "exit";
+    };
+
+export type TuiInterpreterResult = {
+  nextState: TuiInterpreterState;
+  output: string;
+  action?: TuiInterpreterAction;
+};
+
+export type TuiKnownAgent = {
+  name: string;
+  key: string;
+};
+
+export type TuiCommandInterpreterDeps = {
+  knownAgents: TuiKnownAgent[];
+  renderHelp: () => string;
+  renderContextPanel: (state: TuiInterpreterState) => string;
+  renderKnownAgents: () => string;
+};
+
+export function resolveSwitchTarget(
+  rawTarget: string,
+  deps: Pick<TuiCommandInterpreterDeps, "knownAgents">
+) {
+  const target = rawTarget.trim();
+  if (/^\d+$/.test(target)) {
+    const agent = deps.knownAgents[Number(target) - 1];
+    return agent ? { name: agent.name, key: agent.key } : null;
+  }
+
+  const knownAgentAliases: Record<string, TuiKnownAgent> = Object.fromEntries(
+    deps.knownAgents.map((agent) => [agent.name.toLowerCase(), agent])
+  );
+  const alias = knownAgentAliases[target.toLowerCase()];
+  if (alias) return alias;
+
+  if (target.startsWith("agent-") || target.startsWith("agent-pub-")) {
+    return { name: target, key: target };
+  }
+
+  return null;
+}
+
+export function handleTuiInput(
+  input: string,
+  state: TuiInterpreterState,
+  deps: TuiCommandInterpreterDeps
+): TuiInterpreterResult {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return { nextState: state, output: "" };
+  }
+
+  if (!trimmed.startsWith("/")) {
+    return {
+      nextState: state,
+      output: "",
+      action: {
+        type: "chat",
+        message: trimmed,
+        agentKey: state.agentKey,
+        runtimeMode: state.runtimeMode,
+        ...(state.dialogId ? { continueDialogId: state.dialogId } : {}),
+      },
+    };
+  }
+
+  const [command = "", ...rest] = trimmed.split(/\s+/);
+  const argText = rest.join(" ").trim();
+
+  switch (command) {
+    case "/help":
+      return { nextState: state, output: deps.renderHelp() };
+    case "/context":
+    case "/ctx":
+      return { nextState: state, output: deps.renderContextPanel(state) };
+    case "/runtime": {
+      if (argText !== "auto" && argText !== "local" && argText !== "server") {
+        return {
+          nextState: state,
+          output: "Usage: /runtime <auto|local|server>",
+        };
+      }
+
+      return {
+        nextState: { ...state, runtimeMode: argText },
+        output: `Runtime: ${argText}`,
+      };
+    }
+    case "/exit":
+    case "/quit":
+      return { nextState: state, output: "Bye.", action: { type: "exit" } };
+    case "/new":
+      return {
+        nextState: {
+          ...state,
+          dialogId: undefined,
+          dialogLabel: "new",
+          attachedDocs: [],
+        },
+        output: "Started a fresh dialog.",
+      };
+    case "/compact":
+      if (argText) {
+        return {
+          nextState: state,
+          output: `Unknown command: ${trimmed}\n\n${deps.renderHelp()}`,
+        };
+      }
+      if (!state.dialogId) {
+        return {
+          nextState: state,
+          output: "Current dialog: new (nothing to compact yet)",
+        };
+      }
+      return {
+        nextState: state,
+        output: "Compacting current dialog...",
+        action: { type: "compact", dialogId: state.dialogId },
+      };
+    case "/agent":
+      return {
+        nextState: state,
+        output: `Current agent: ${state.agentName} (${state.agentKey})`,
+      };
+    case "/agents":
+      return {
+        nextState: state,
+        output: deps.renderKnownAgents(),
+      };
+    case "/switch": {
+      if (!argText) {
+        return {
+          nextState: state,
+          output: "Usage: /switch <agent-key|alias>",
+        };
+      }
+      const resolvedTarget = resolveSwitchTarget(argText, deps);
+      if (!resolvedTarget) {
+        return {
+          nextState: state,
+          output:
+            `I don't know agent shortcut "${argText}" yet.\n` +
+            "Use /switch nolo, /switch app-builder, or a full agent key like agent-pub-...",
+        };
+      }
+      return {
+        nextState: {
+          ...state,
+          agentName: resolvedTarget.name,
+          agentKey: resolvedTarget.key,
+        },
+        output: `Switched to ${resolvedTarget.name}.`,
+      };
+    }
+    case "/dialog":
+      return {
+        nextState: state,
+        output: state.dialogId
+          ? `Current dialog: ${state.dialogId}`
+          : "Current dialog: new",
+      };
+    case "/doc": {
+      if (rest[0] === "attach") {
+        const docName = rest.slice(1).join(" ").trim();
+        if (!docName) {
+          return { nextState: state, output: "Usage: /doc attach <doc>" };
+        }
+        const attachedDocs = state.attachedDocs.includes(docName)
+          ? state.attachedDocs
+          : [...state.attachedDocs, docName];
+        return {
+          nextState: { ...state, attachedDocs },
+          output: `Attached doc: ${docName}`,
+        };
+      }
+      return {
+        nextState: state,
+        output:
+          state.attachedDocs.length > 0
+            ? `Attached docs: ${state.attachedDocs.join(", ")}`
+            : "No docs attached. Use /doc attach <doc>.",
+      };
+    }
+    case "/customize":
+      return {
+        nextState: state,
+        output:
+          "Tell nolo what to change, for example: /customize make my default agent more concise.",
+      };
+    case "/login":
+      return {
+        nextState: state,
+        output:
+          "MVP login uses profile/env auth. Set AUTH_TOKEN, NOLO_SERVER, or NOLO_PROFILE before starting nolo.",
+      };
+    case "/profile":
+      return {
+        nextState: state,
+        output: `Profile: ${state.profileName}`,
+      };
+    case "/update":
+      return {
+        nextState: state,
+        output: "Starting self-update...",
+        action: { type: "self-update" },
+      };
+    case "/version":
+      return {
+        nextState: state,
+        output:
+          `nolo ${state.cliVersion || "unknown version"}\n` +
+          "Update this install with: nolo update\n" +
+          "If repo-local output differs, publish/install the latest npm package first.",
+      };
+    default:
+      return {
+        nextState: state,
+        output: `Unknown command: ${command}\n\n${deps.renderHelp()}`,
+      };
+  }
+}

package/cli/tui/tuiPresentation.ts

@@ -0,0 +1,146 @@
+import { DEFAULT_NOLO_SERVER_URL } from "../defaultServer";
+import type { AgentRuntimeRequestedMode } from "../agentRuntimeLocal";
+import type { EnvLike } from "../cliEnvHelpers";
+import { DEFAULT_TUI_AGENT_KEY, KNOWN_AGENTS } from "./tuiCatalog";
+
+export const DEFAULT_TUI_SERVER_URL = DEFAULT_NOLO_SERVER_URL;
+
+export type TuiState = {
+  agentKey: string;
+  agentName: string;
+  dialogId?: string;
+  dialogLabel: string;
+  profileName: string;
+  serverUrl: string;
+  cliVersion?: string;
+  attachedDocs: string[];
+  runtimeMode: AgentRuntimeRequestedMode;
+};
+
+export function shortenDialogId(dialogId: string) {
+  return dialogId.length > 12
+    ? `${dialogId.slice(0, 6)}...${dialogId.slice(-4)}`
+    : dialogId;
+}
+
+export function resolveDialogLabel(
+  state: Pick<TuiState, "dialogId" | "dialogLabel">
+) {
+  return state.dialogId ? shortenDialogId(state.dialogId) : state.dialogLabel;
+}
+
+export function createInitialTuiState(env: EnvLike): TuiState {
+  const agentKey = env.NOLO_AGENT?.trim() || DEFAULT_TUI_AGENT_KEY;
+  const agentName = env.NOLO_AGENT_NAME?.trim() || "nolo";
+
+  return {
+    agentKey,
+    agentName,
+    dialogId: env.NOLO_DIALOG_ID?.trim() || undefined,
+    dialogLabel: env.NOLO_DIALOG?.trim() || "new",
+    profileName: env.NOLO_PROFILE?.trim() || "local",
+    serverUrl: (env.NOLO_SERVER || env.BASE_URL || DEFAULT_TUI_SERVER_URL).replace(
+      /\/+$/,
+      ""
+    ),
+    cliVersion: env.NOLO_CLI_VERSION?.trim() || undefined,
+    attachedDocs: [],
+    runtimeMode:
+      env.NOLO_RUNTIME_MODE === "local" || env.NOLO_RUNTIME_MODE === "server"
+        ? env.NOLO_RUNTIME_MODE
+        : "auto",
+  };
+}
+
+export function renderStatusLine(state: TuiState) {
+  const docs =
+    state.attachedDocs.length > 0
+      ? String(state.attachedDocs.length)
+      : "0";
+
+  return [
+    `agent ${state.agentName}`,
+    `dialog ${resolveDialogLabel(state)}`,
+    `docs ${docs}`,
+    `runtime ${state.runtimeMode}`,
+    `profile ${state.profileName}`,
+  ].join(" | ");
+}
+
+export function renderWelcome(state: TuiState) {
+  const docs =
+    state.attachedDocs.length > 0
+      ? `${state.attachedDocs.length} attached`
+      : "none";
+  return [
+    "",
+    `Nolo workspace${state.cliVersion ? `  nolo ${state.cliVersion}` : ""}`,
+    `agent ${state.agentName} | dialog ${resolveDialogLabel(state)} | docs ${docs} | profile ${state.profileName}`,
+    `server ${state.serverUrl}`,
+    "",
+    "Tell nolo what you want. Use /help for commands. Use /version if this install feels stale.",
+    "",
+  ].join("\n");
+}
+
+export function renderPrompt(_state: TuiState) {
+  return "you > ";
+}
+
+export function renderTuiHelp() {
+  return [
+    "Commands:",
+    "  /help                 Show this help",
+    "  /new                  Start a fresh dialog",
+    "  /compact              Compact current dialog and fork a new one",
+    "  /context              Show workspace context and next actions",
+    "  /runtime <mode>       Use auto, local, or server runtime",
+    "  /agent                Show the current agent",
+    "  /agents               List built-in agent shortcuts",
+    "  /switch <agent>       Switch the current agent",
+    "  /dialog               Show the current dialog",
+    "  /doc                  List attached docs",
+    "  /doc attach <doc>     Attach a doc to this workspace",
+    "  /customize            Describe how you want to tune nolo",
+    "  /login                Show login/profile hint",
+    "  /profile              Show active profile",
+    "  /update               Update the global nolo install",
+    "  /version              Show version/update hint",
+    "  /exit                 Leave the workspace",
+    "",
+    "You can also type normally. nolo will send it to the current agent.",
+  ].join("\n");
+}
+
+export function renderContextPanel(state: TuiState) {
+  const docs = state.attachedDocs.length
+    ? state.attachedDocs.join(", ")
+    : "none";
+  return [
+    "Workspace context",
+    "-----------------",
+    `agent   ${state.agentName}`,
+    `dialog  ${resolveDialogLabel(state)}`,
+    `docs    ${docs}`,
+    `profile ${state.profileName}`,
+    `runtime ${state.runtimeMode}`,
+    `server  ${state.serverUrl}`,
+    "",
+    "Next:",
+    "  /agents              see specialist shortcuts",
+    "  /doc attach <doc>    add working context",
+    "  /new                 start a clean dialog",
+  ].join("\n");
+}
+
+export function renderKnownAgents() {
+  return [
+    "Agents:",
+    ...KNOWN_AGENTS.map(
+      (agent, index) =>
+        `  ${index + 1}  ${agent.name.padEnd(11)} ${agent.description}`
+    ),
+    "",
+    "Tip: stay on nolo for the one-assistant feel; switch only when you want a specialist directly.",
+  ].join("\n");
+}

package/cli/updateCommands.ts

@@ -0,0 +1,134 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+type PackageInfo = {
+  name: string;
+  version: string;
+};
+
+type DoctorInfo = {
+  packageName: string;
+  version: string;
+  entrypoint: string;
+  serverUrl: string;
+  profileName: string;
+};
+
+type RunSelfUpdateOptions = {
+  output?: NodeJS.WritableStream;
+  spawn?: typeof Bun.spawn;
+};
+
+type SpawnOutputChunk = string | ArrayBuffer | ArrayBufferView;
+
+const CLI_DIR = dirname(fileURLToPath(import.meta.url));
+const PACKAGE_JSON_PATH = join(CLI_DIR, "package.json");
+
+export function readPackageInfo(): PackageInfo {
+  const raw = readFileSync(PACKAGE_JSON_PATH, "utf8");
+  const parsed = JSON.parse(raw) as Partial<PackageInfo>;
+  return {
+    name: parsed.name || "nolo-cli",
+    version: parsed.version || "0.0.0",
+  };
+}
+
+export function buildCliVersionText(info: PackageInfo) {
+  return `${info.name} ${info.version}`;
+}
+
+export function buildSelfUpdateCommand() {
+  return ["npm", "install", "-g", "nolo-cli@latest", "--force"];
+}
+
+export function buildCliDoctorText(info: DoctorInfo) {
+  const updateCommand = buildSelfUpdateCommand().join(" ");
+  return [
+    "Nolo CLI doctor",
+    "---------------",
+    `version  ${info.packageName} ${info.version}`,
+    `entry    ${info.entrypoint}`,
+    `server   ${info.serverUrl}`,
+    `profile  ${info.profileName}`,
+    `update   nolo update`,
+    "",
+    "If direct `nolo` differs from repo-local `bun ./packages/cli/index.ts`,",
+    "the global npm install is older than this checkout.",
+    "",
+    `Manual update: ${updateCommand}`,
+  ].join("\n");
+}
+
+function isRunSelfUpdateOptions(
+  value: NodeJS.WritableStream | RunSelfUpdateOptions
+): value is RunSelfUpdateOptions {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    ("output" in value || "spawn" in value)
+  );
+}
+
+async function forwardSpawnOutput(
+  stream: AsyncIterable<SpawnOutputChunk> | undefined,
+  output: NodeJS.WritableStream
+) {
+  if (!stream) {
+    return;
+  }
+
+  for await (const chunk of stream) {
+    output.write(normalizeSpawnChunk(chunk));
+  }
+}
+
+function normalizeSpawnChunk(
+  chunk: SpawnOutputChunk
+): string | Uint8Array<ArrayBufferLike> {
+  if (typeof chunk === "string" || chunk instanceof Uint8Array) {
+    return chunk;
+  }
+
+  if (chunk instanceof ArrayBuffer) {
+    return new Uint8Array(chunk);
+  }
+
+  return new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+}
+
+export async function runSelfUpdate(
+  outputOrOptions?: NodeJS.WritableStream | RunSelfUpdateOptions
+) {
+  const options =
+    outputOrOptions === undefined
+      ? {}
+      : isRunSelfUpdateOptions(outputOrOptions)
+        ? outputOrOptions
+        : { output: outputOrOptions };
+  const output = options.output ?? process.stdout;
+  const spawn = options.spawn ?? Bun.spawn;
+  const command = buildSelfUpdateCommand();
+  output.write(`Updating nolo with: ${command.join(" ")}\n`);
+
+  const useCustomSink = options.output !== undefined;
+  const proc = spawn({
+    cmd: command,
+    stdin: "inherit",
+    stdout: useCustomSink ? "pipe" : "inherit",
+    stderr: useCustomSink ? "pipe" : "inherit",
+    env: process.env,
+  });
+
+  if (!useCustomSink) {
+    return await proc.exited;
+  }
+
+  const [exitCode] = await Promise.all([
+    proc.exited,
+    forwardSpawnOutput(proc.stdout, output),
+    forwardSpawnOutput(proc.stderr, output),
+  ]);
+
+  return exitCode;
+}

package/cli/workflowInternalCommandEntries.ts

@@ -0,0 +1,31 @@
+import { createEnvCommand } from "./cliCommandFactories";
+import type { CommandEntry } from "./cliCommandTypes";
+import { runTableMetaCommand } from "./tableMetaCommands";
+import {
+  runTableAddColumnCommand,
+  runTableAddRowCommand,
+  runTableAddRowsCommand,
+  runTableDataCommand,
+  runTableDeleteRowCommand,
+  runTableDeleteRowsCommand,
+  runTableUpdateRowCommand,
+  runTableUpdateRowsCommand,
+} from "./tableMutationCommands";
+import { runTableQueryCommand } from "./tableCommands";
+import { runTaskRunCommand } from "./taskRunCommand";
+
+export function getWorkflowInternalCommandEntries(): CommandEntry[] {
+  return [
+    createEnvCommand(["table", "query"], "Query table rows", runTableQueryCommand),
+    createEnvCommand(["table", "meta"], "Create or update table metadata", runTableMetaCommand),
+    createEnvCommand(["table", "add-column"], "Add one table column", runTableAddColumnCommand),
+    createEnvCommand(["table", "add-row"], "Add one table row", runTableAddRowCommand),
+    createEnvCommand(["table", "add-rows"], "Add table rows", runTableAddRowsCommand),
+    createEnvCommand(["table", "update-row"], "Update one table row", runTableUpdateRowCommand),
+    createEnvCommand(["table", "update-rows"], "Update table rows", runTableUpdateRowsCommand),
+    createEnvCommand(["table", "delete-row"], "Delete one table row", runTableDeleteRowCommand),
+    createEnvCommand(["table", "delete-rows"], "Delete table rows", runTableDeleteRowsCommand),
+    createEnvCommand(["table", "data"], "Low-level table row command", runTableDataCommand),
+    createEnvCommand(["task-run"], "Update durable task-run state through the runner bridge", runTaskRunCommand),
+  ];
+}

package/cliEnvHelpers.ts

@@ -32,6 +32,14 @@ export function readCliOptionValue(args: string[], flag: string): string {
   return "";
 }
 
+export function hasExplicitServerOverride(args: string[]) {
+  return Boolean(
+    readCliOptionValue(args, "--server-url") ||
+      readCliOptionValue(args, "--server") ||
+      readCliOptionValue(args, "--base-url")
+  );
+}
+
 export function resolveServerUrlFromEnv(env: EnvLike) {
   return trimTrailingSlashes(
     firstDefinedEnvValue(env, ["NOLO_SERVER_URL", "NOLO_SERVER", "BASE_URL"]) ||