nolo-cli 0.1.23 → 0.1.29

package/tui/session.ts

@@ -1,379 +1,50 @@
-import { DEFAULT_NOLO_SERVER_URL } from "../defaultServer";
-import type { AgentRuntimeRequestedMode } from "../agentRuntimeLocal";
-
-export const DEFAULT_TUI_AGENT_KEY = "agent-pub-01NOLOAPPBLD000000019KCKT0";
-export const DEFAULT_TUI_SERVER_URL = DEFAULT_NOLO_SERVER_URL;
-
-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",
-  },
-];
-
-const KNOWN_AGENT_ALIASES: Record<string, { name: string; key: string }> =
-  Object.fromEntries(KNOWN_AGENTS.map((agent) => [agent.name, agent]));
-
-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 type TuiState = {
-  agentKey: string;
-  agentName: string;
-  dialogId?: string;
-  dialogLabel: string;
-  profileName: string;
-  serverUrl: string;
-  cliVersion?: string;
-  attachedDocs: string[];
-  runtimeMode: AgentRuntimeRequestedMode;
-};
-
-export type TuiAction =
-  | {
-      type: "chat";
-      message: string;
-      agentKey: string;
-      runtimeMode: AgentRuntimeRequestedMode;
-      continueDialogId?: string;
-    }
-  | {
-      type: "compact";
-      dialogId: string;
-    }
-  | {
-      type: "self-update";
-    }
-  | {
-      type: "exit";
-    };
-
-export type TuiInputResult = {
-  nextState: TuiState;
-  output: string;
-  action?: TuiAction;
-};
-
-type EnvLike = Record<string, string | undefined>;
-
-export function createInitialTuiState(env: EnvLike = process.env): TuiState {
-  const agentKey = env.NOLO_AGENT?.trim() || DEFAULT_TUI_AGENT_KEY;
-  const agentName = env.NOLO_AGENT_NAME?.trim() || "nolo";
-
+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 {
-    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",
+    knownAgents: KNOWN_AGENTS,
+    renderHelp: renderTuiHelp,
+    renderContextPanel,
+    renderKnownAgents,
   };
 }
 
-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");
-}
-
-function resolveSwitchTarget(rawTarget: string) {
-  const target = rawTarget.trim();
-  if (/^\d+$/.test(target)) {
-    const agent = KNOWN_AGENTS[Number(target) - 1];
-    return agent ? { name: agent.name, key: agent.key } : null;
-  }
-  const alias = KNOWN_AGENT_ALIASES[target.toLowerCase()];
-  if (alias) return alias;
-  if (target.startsWith("agent-") || target.startsWith("agent-pub-")) {
-    return { name: target, key: target };
-  }
-  return null;
-}
+export {
+  createInitialTuiState,
+  renderContextPanel,
+  renderKnownAgents,
+  renderPrompt,
+  renderStatusLine,
+  renderTuiHelp,
+  renderWelcome,
+  resolveDialogLabel,
+};
 
 export function handleTuiInput(input: string, state: TuiState): TuiInputResult {
-  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: renderTuiHelp() };
-    case "/context":
-    case "/ctx":
-      return { nextState: state, output: 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${renderTuiHelp()}`,
-        };
-      }
-      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: renderKnownAgents(),
-      };
-    case "/switch": {
-      if (!argText) {
-        return {
-          nextState: state,
-          output: "Usage: /switch <agent-key|alias>",
-        };
-      }
-      const resolvedTarget = resolveSwitchTarget(argText);
-      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${renderTuiHelp()}`,
-      };
-  }
+  return handleTuiInputWithDeps(input, state, createInterpreterDeps());
 }

package/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]));
+

package/tui/tuiCommandInterpreter.test.ts

@@ -0,0 +1,169 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  handleTuiInput,
+  resolveSwitchTarget,
+  type TuiCommandInterpreterDeps,
+  type TuiInterpreterState,
+} from "./tuiCommandInterpreter";
+
+function createState(
+  overrides: Partial<TuiInterpreterState> = {}
+): TuiInterpreterState {
+  return {
+    agentKey: "agent-pub-01NOLOAPPBLD000000019KCKT0",
+    agentName: "nolo",
+    dialogLabel: "new",
+    profileName: "local",
+    serverUrl: "https://nolo.chat",
+    attachedDocs: [],
+    runtimeMode: "auto",
+    ...overrides,
+  };
+}
+
+function createDeps(): TuiCommandInterpreterDeps {
+  return {
+    knownAgents: [
+      { name: "nolo", key: "agent-pub-01NOLOAPPBLD000000019KCKT0" },
+      { name: "app-builder", key: "agent-pub-01APPBUILDER00000001YAII3I" },
+    ],
+    renderHelp: () => "HELP",
+    renderContextPanel: () => "CONTEXT",
+    renderKnownAgents: () => "AGENTS",
+  };
+}
+
+describe("tuiCommandInterpreter", () => {
+  test("treats normal text as a chat action", () => {
+    const result = handleTuiInput("修一下通知面板", createState(), createDeps());
+
+    expect(result.action).toEqual({
+      type: "chat",
+      message: "修一下通知面板",
+      agentKey: "agent-pub-01NOLOAPPBLD000000019KCKT0",
+      runtimeMode: "auto",
+    });
+    expect(result.output).toBe("");
+  });
+
+  test("includes continueDialogId for chat when dialog exists", () => {
+    const result = handleTuiInput(
+      "继续聊",
+      createState({ dialogId: "01KQHZ56KKMA7G2F755QXFA3QX" }),
+      createDeps()
+    );
+
+    expect(result.action).toEqual({
+      type: "chat",
+      message: "继续聊",
+      agentKey: "agent-pub-01NOLOAPPBLD000000019KCKT0",
+      runtimeMode: "auto",
+      continueDialogId: "01KQHZ56KKMA7G2F755QXFA3QX",
+    });
+  });
+
+  test("switches runtime modes and rejects invalid values", () => {
+    const deps = createDeps();
+    const state = createState();
+
+    const local = handleTuiInput("/runtime local", state, deps);
+    expect(local.nextState.runtimeMode).toBe("local");
+    expect(local.output).toBe("Runtime: local");
+
+    const server = handleTuiInput("/runtime server", local.nextState, deps);
+    expect(server.nextState.runtimeMode).toBe("server");
+    expect(server.output).toBe("Runtime: server");
+
+    const invalid = handleTuiInput("/runtime nope", server.nextState, deps);
+    expect(invalid.nextState.runtimeMode).toBe("server");
+    expect(invalid.output).toBe("Usage: /runtime <auto|local|server>");
+  });
+
+  test("/new clears dialog state and attached docs", () => {
+    const result = handleTuiInput(
+      "/new",
+      createState({
+        dialogId: "01OLD",
+        dialogLabel: "01OLD",
+        attachedDocs: ["notes"],
+      }),
+      createDeps()
+    );
+
+    expect(result.nextState.dialogId).toBeUndefined();
+    expect(result.nextState.dialogLabel).toBe("new");
+    expect(result.nextState.attachedDocs).toEqual([]);
+  });
+
+  test("/compact handles action, missing dialog, extra text, and trailing whitespace", () => {
+    const deps = createDeps();
+    const withDialog = createState({ dialogId: "01OLD", dialogLabel: "01OLD" });
+
+    expect(handleTuiInput("/compact", withDialog, deps).action).toEqual({
+      type: "compact",
+      dialogId: "01OLD",
+    });
+
+    const none = handleTuiInput("/compact", createState(), deps);
+    expect(none.action).toBeUndefined();
+    expect(none.output).toContain("nothing to compact");
+
+    const extra = handleTuiInput("/compact anything", withDialog, deps);
+    expect(extra.action).toBeUndefined();
+    expect(extra.output).toBe("Unknown command: /compact anything\n\nHELP");
+
+    expect(handleTuiInput("  /compact  ", withDialog, deps).action).toEqual({
+      type: "compact",
+      dialogId: "01OLD",
+    });
+  });
+
+  test("/switch resolves alias, numeric index, and full agent key", () => {
+    const deps = createDeps();
+    const state = createState();
+
+    const alias = handleTuiInput("/switch app-builder", state, deps);
+    expect(alias.nextState.agentName).toBe("app-builder");
+    expect(alias.nextState.agentKey).toBe("agent-pub-01APPBUILDER00000001YAII3I");
+
+    const numeric = handleTuiInput("/switch 2", state, deps);
+    expect(numeric.nextState.agentName).toBe("app-builder");
+
+    const fullKey = handleTuiInput("/switch agent-pub-01CUSTOM", state, deps);
+    expect(fullKey.nextState.agentName).toBe("agent-pub-01CUSTOM");
+    expect(fullKey.nextState.agentKey).toBe("agent-pub-01CUSTOM");
+  });
+
+  test("resolveSwitchTarget returns null for unknown targets", () => {
+    expect(resolveSwitchTarget("missing", createDeps())).toBeNull();
+  });
+
+  test("/doc attach adds one doc and deduplicates repeats", () => {
+    const deps = createDeps();
+    const first = handleTuiInput("/doc attach product-plan", createState(), deps);
+    expect(first.nextState.attachedDocs).toEqual(["product-plan"]);
+    expect(first.output).toBe("Attached doc: product-plan");
+
+    const again = handleTuiInput("/doc attach product-plan", first.nextState, deps);
+    expect(again.nextState.attachedDocs).toEqual(["product-plan"]);
+  });
+
+  test("unknown commands include injected help output", () => {
+    const result = handleTuiInput("/wat", createState(), createDeps());
+    expect(result.output).toBe("Unknown command: /wat\n\nHELP");
+  });
+
+  test("/exit and /update emit actions without mutating state", () => {
+    const state = createState({ attachedDocs: ["notes"] });
+    const deps = createDeps();
+
+    const exit = handleTuiInput("/exit", state, deps);
+    expect(exit.nextState).toEqual(state);
+    expect(exit.action).toEqual({ type: "exit" });
+
+    const update = handleTuiInput("/update", state, deps);
+    expect(update.nextState).toEqual(state);
+    expect(update.action).toEqual({ type: "self-update" });
+  });
+});