@datalabrotterdam/nova-ai-cli 1.2.0-alpha.5 → 1.2.0-alpha.7

package/CHANGELOG.md

@@ -1,3 +1,30 @@
+# [@datalabrotterdam/nova-ai-cli-v1.2.0-alpha.7](https://github.com/Datalab-Rotterdam/nova-ai-cli/compare/@datalabrotterdam/nova-ai-cli@1.2.0-alpha.6...@datalabrotterdam/nova-ai-cli@1.2.0-alpha.7) (2026-10-24)
+
+
+### Features
+
+* **agent:** Claude Code compatible hooks ([227fe8b](https://github.com/Datalab-Rotterdam/nova-ai-cli/commit/227fe8b273ec2e211e9d57674e76af5c42a473bd))
+* **agent:** install the shared Nova skills ([64139dd](https://github.com/Datalab-Rotterdam/nova-ai-cli/commit/64139dd612933343f04f165de1a9ab78832d6864))
+* **agent:** mark and protect bundled skills ([6ef52eb](https://github.com/Datalab-Rotterdam/nova-ai-cli/commit/6ef52eb6d048f8a3b4e75686244aabcfd0f62d6e))
+* **agent:** thinking effort for reasoning models ([8551fea](https://github.com/Datalab-Rotterdam/nova-ai-cli/commit/8551feacff3e1675f369030e20fb2b5071f0db7f))
+* **agent:** web_search tool ([12985eb](https://github.com/Datalab-Rotterdam/nova-ai-cli/commit/12985eb9ca06d6c814d4e0162465c651889d9370))
+* **cli:** /effort slider for thinking models ([8ca67f2](https://github.com/Datalab-Rotterdam/nova-ai-cli/commit/8ca67f2f5dcc8f6bff8c36409a2baba5d43c4a02))
+* **cli:** remember the thinking level ([883196c](https://github.com/Datalab-Rotterdam/nova-ai-cli/commit/883196c9fdb089f4f26ac82b557cc87dfc0b1c0b))
+* OAuth sign-in for MCP servers ([ba57c79](https://github.com/Datalab-Rotterdam/nova-ai-cli/commit/ba57c79642f902ab2bc20f59e4627fb2b774bb4a))
+* the user's agent files as session modes ([3386de8](https://github.com/Datalab-Rotterdam/nova-ai-cli/commit/3386de88d07b0351bd1e44960fcacfef26e3d45b))
+
+# [@datalabrotterdam/nova-ai-cli-v1.2.0-alpha.6](https://github.com/Datalab-Rotterdam/nova-ai-cli/compare/@datalabrotterdam/nova-ai-cli@1.2.0-alpha.5...@datalabrotterdam/nova-ai-cli@1.2.0-alpha.6) (2026-10-23)
+
+
+### Bug Fixes
+
+* **cli:** start the session before the first prompt ([0c26456](https://github.com/Datalab-Rotterdam/nova-ai-cli/commit/0c26456b8126e3b42a6de2e38212213ae5380e62))
+
+
+### Features
+
+* **agent:** set workspace trust over ACP ([cec4a89](https://github.com/Datalab-Rotterdam/nova-ai-cli/commit/cec4a8949a4232f46448219e4d5363289651215d))
+
 # [@datalabrotterdam/nova-ai-cli-v1.2.0-alpha.5](https://github.com/Datalab-Rotterdam/nova-ai-cli/compare/@datalabrotterdam/nova-ai-cli@1.2.0-alpha.4...@datalabrotterdam/nova-ai-cli@1.2.0-alpha.5) (2026-10-23)
 
 

package/README.md

@@ -79,6 +79,8 @@ row. To select text, hold Shift (Option in some macOS terminals) while dragging.
 
 - **Modes** (Shift+Tab): `agent` does the work; `plan` reads the code, asks
   questions and builds a task list but changes nothing; `ask` only answers.
+  Your own agents (`~/.nova-ai/agents/<name>.agent.md`, the format the VS Code
+  extension uses) are extra modes after these; `/mode` lists them.
 - **Permissions**: before an edit or command you choose once, for this
   session, always (saved as an exact rule) or deny. Ctrl+K switches between
   asking, accepting edits, and bypass (never remembered).
@@ -95,12 +97,12 @@ row. To select text, hold Shift (Option in some macOS terminals) while dragging.
 | Enter / Shift+Enter | Send / new line (Shift+Enter where the terminal supports the kitty keyboard protocol: VS Code, kitty, WezTerm, Ghostty, foot, Alacritty, recent iTerm2; Alt+Enter, Ctrl+J or a trailing `\` work everywhere) |
 | Esc | Cancel the running turn |
 | Ctrl+C twice | Exit; prints `nova-ai --resume <id>` |
-| Shift+Tab | Cycle agent / ask / plan |
+| Shift+Tab | Cycle agent / ask / plan and your own agents |
 | Ctrl+R / Ctrl+P / Ctrl+K | Sessions / models / permission mode |
 | Ctrl+O / Ctrl+T / Ctrl+B | Verbose tool output / tool inspector / background jobs |
 | Alt+V | Paste a clipboard image |
 
-Slash commands: `/help`, `/model`, `/mode`, `/permission`, `/session`,
+Slash commands: `/help`, `/model`, `/effort` (thinking models), `/mode`, `/permission`, `/session`,
 `/resume`, `/clear`, `/compact`, `/rewind [n]`, `/queue`, `/steer`, `/usage`,
 `/tools`, `/mcp`, `/skills`, `/shell` and `/agent` (background jobs), `/trust`
 and `/exit`. Details:
@@ -169,7 +171,10 @@ need ACP. Everything is documented in
   and nested shells need an exact rule.
 - **Web pages are fetched only with approval.** `fetch_url` asks every time
   unless a rule allows that URL (a URL can carry data out), and a redirect to
-  another site needs its own approval.
+  another site needs its own approval. `web_search` asks the same way, since
+  the query goes to the search providers (You.com, DuckDuckGo; your own
+  SearXNG server first when `~/.nova-ai/settings.json` has
+  `"webSearch": { "searxngUrl": "https://…" }`).
 - **File access stays in the workspace** (symlinks resolved); commands run in
   their own process group with a timeout, and the whole tree is stopped on
   cancel.
@@ -194,7 +199,22 @@ VS Code extension: settings, per-project trust, sessions and memory.
   skills folders are read too). `/skills` lists them; `/skills off <name>`
   switches one off in this project (`--global`: everywhere). Only names and
   short descriptions go into the prompt; Nova loads a skill when it fits.
+  Nova installs its own skills for Word, Excel, PowerPoint and PDF files
+  (`nova-docx`, `nova-xlsx`, `nova-pptx`, `nova-pdf`, from
+  [nova-ai-skills](https://github.com/Datalab-Rotterdam/nova-ai-skills)) in
+  `~/.nova-ai/skills` and keeps them up to date; they need Python 3.
+- **Hooks**: Claude Code's `hooks` format in the same settings files (a
+  repository's own only once you trust the workspace): `PreToolUse`,
+  `PostToolUse`, `UserPromptSubmit`, `SessionStart` and `Stop`, with Claude
+  Code's tool names as matchers, so hooks from `.claude/settings.json` work
+  when copied over.
 - **MCP servers**: `.mcp.json` or `mcpServers` in `.nova-ai/settings.json`.
+  HTTP servers that use OAuth show "needs sign-in" in `/mcp`; `/mcp login
+  <server>` opens the sign-in page in your browser (tokens are kept in
+  `~/.nova-ai/mcp-auth`, refreshed automatically), `/mcp logout <server>`
+  forgets them. A server that wants a client registered by hand takes
+  `"oauth": { "clientId", "clientSecret", "scope", "callbackPort" }` in
+  `.mcp.json`.
 
 The complete layout and rule syntax: [docs/NOVA_HOME.md](https://github.com/Datalab-Rotterdam/nova-ai-cli/blob/main/docs/NOVA_HOME.md).
 
@@ -207,6 +227,12 @@ to a text protocol for models that don't support it. When the context window
 fills up, older messages are summarized automatically (`/compact` does it by
 hand).
 
+Thinking models are marked ◆ in the model list. For those with levels the
+status line shows the current one (`· thinking medium`) and `/effort` opens a
+slider (←/→, Enter), or sets one directly (`/effort high`, `/effort off`). The
+choice is remembered like the model; a model without that level uses its own
+default.
+
 | Environment | |
 |---|---|
 | `NOVA_API_KEY`, `NOVA_MODEL` | Use this key / model instead of the stored ones |

package/dist/{chunk-NHGIUEIR.js → chunk-EOPM4RRE.js}

@@ -1,149 +1,6 @@
-// src/tui/settings/workspace-mcp.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { join as join2 } from "path";
-import { isWorkspaceTrusted } from "@datalabrotterdam/nova-ai-agent/core/nova-home.js";
-import { readSettings } from "@datalabrotterdam/nova-ai-agent/core/policy/settings.js";
-
-// src/tui/settings/workspace-settings.ts
-import { readFileSync } from "fs";
-import { join } from "path";
-function settingsPath(cwd) {
-  return join(cwd, ".nova-ai", "settings.json");
-}
-function readWorkspaceSettings(cwd) {
-  try {
-    const raw = readFileSync(settingsPath(cwd), "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return {};
-  }
-}
-
-// src/tui/settings/workspace-mcp.ts
-var UNTRUSTED_MCP_MESSAGE = "Not started: MCP servers declared by this workspace only run once you trust it (/trust in the TUI, --trust-workspace headless).";
-function readWorkspaceMcpConfiguration(cwd, options = {}) {
-  const configured = readWorkspaceSettings(cwd).mcpServers ?? [];
-  const project = readProjectMcpConfiguration(cwd);
-  const servers = new Map(configured.map((server) => [server.name, server]));
-  for (const server of project.servers) servers.set(server.name, server);
-  const declared = [...servers.values()];
-  if (declared.length && !(options.trusted ?? isWorkspaceTrusted(cwd))) {
-    return {
-      servers: [],
-      failures: [
-        ...project.failures,
-        ...declared.map((server) => ({ serverName: server.name, message: UNTRUSTED_MCP_MESSAGE }))
-      ],
-      untrusted: declared.map((server) => server.name)
-    };
-  }
-  return { servers: declared, failures: project.failures };
-}
-function workspaceNeedsTrust(cwd) {
-  if (isWorkspaceTrusted(cwd)) return false;
-  if (readWorkspaceMcpConfiguration(cwd, { trusted: true }).servers.length) return true;
-  return loadWorkspaceAllowRules(cwd).length > 0;
-}
-function loadWorkspaceAllowRules(cwd) {
-  return ["settings.json", "settings.local.json"].flatMap((name) => {
-    const allow = readSettings(join2(cwd, ".nova-ai", name))?.permissions?.allow;
-    return Array.isArray(allow) ? allow : [];
-  });
-}
-function readProjectMcpConfiguration(cwd) {
-  const path = join2(cwd, ".mcp.json");
-  let raw;
-  try {
-    raw = readFileSync2(path, "utf8");
-  } catch (error) {
-    if (error.code === "ENOENT") return { servers: [], failures: [] };
-    return { servers: [], failures: [{ serverName: ".mcp.json", message: errorMessage(error, "Could not read file") }] };
-  }
-  let document;
-  try {
-    document = JSON.parse(raw);
-  } catch (error) {
-    return { servers: [], failures: [{ serverName: ".mcp.json", message: errorMessage(error, "Invalid JSON") }] };
-  }
-  const root = asRecord(document);
-  const definitions = root ? asRecord(root.mcpServers) : null;
-  if (!definitions) {
-    return {
-      servers: [],
-      failures: [{ serverName: ".mcp.json", message: 'Expected an "mcpServers" object.' }]
-    };
-  }
-  const servers = [];
-  const failures = [];
-  for (const [name, value] of Object.entries(definitions)) {
-    const config = asRecord(value);
-    if (config?.disabled === true || config?.enabled === false) continue;
-    try {
-      servers.push(normalizeProjectServer(name, config));
-    } catch (error) {
-      failures.push({ serverName: `.mcp.json:${name}`, message: errorMessage(error, "Invalid server configuration") });
-    }
-  }
-  return { servers, failures };
-}
-function normalizeProjectServer(name, config) {
-  if (!config) throw new Error("Server definition must be an object.");
-  const type = typeof config.type === "string" ? config.type : config.url ? "http" : "stdio";
-  if (type === "http" || type === "sse") {
-    if (typeof config.url !== "string" || !config.url) throw new Error(`${type} server requires a URL.`);
-    try {
-      new URL(config.url);
-    } catch {
-      throw new Error(`${type} server requires a valid URL.`);
-    }
-    return {
-      name,
-      type,
-      url: config.url,
-      headers: normalizePairs(config.headers, "headers")
-    };
-  }
-  if (type !== "stdio") throw new Error(`Unsupported transport type: ${type}.`);
-  if (typeof config.command !== "string" || !config.command) throw new Error("stdio server requires a command.");
-  if (config.args !== void 0 && (!Array.isArray(config.args) || !config.args.every((arg) => typeof arg === "string"))) {
-    throw new Error("args must be an array of strings.");
-  }
-  return {
-    name,
-    command: config.command,
-    args: config.args ?? [],
-    env: normalizePairs(config.env, "env")
-  };
-}
-function normalizePairs(value, label) {
-  if (value === void 0) return [];
-  if (Array.isArray(value)) {
-    if (!value.every((entry) => {
-      const pair = asRecord(entry);
-      return typeof pair?.name === "string" && typeof pair.value === "string";
-    })) {
-      throw new Error(`${label} must contain name/value strings.`);
-    }
-    return value.map((entry) => {
-      const pair = entry;
-      return { name: pair.name, value: pair.value };
-    });
-  }
-  const record = asRecord(value);
-  if (!record || !Object.values(record).every((entry) => typeof entry === "string")) {
-    throw new Error(`${label} must be an object of string values.`);
-  }
-  return Object.entries(record).map(([name, entry]) => ({ name, value: entry }));
-}
-function asRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
-}
-function errorMessage(error, fallback) {
-  return error instanceof Error && error.message ? `${fallback}: ${error.message}` : fallback;
-}
-
 // src/tui/session/tui-acp-client.ts
 import { NOVA_NOTIFICATIONS } from "@datalabrotterdam/nova-ai-agent/acp/extensions.js";
+import { openBrowser } from "@datalabrotterdam/nova-ai-agent/acp/auth-server.js";
 import { readFile, writeFile, mkdir } from "fs/promises";
 import { dirname } from "path";
 import {
@@ -151,13 +8,11 @@ import {
   terminateProcessTree
 } from "@datalabrotterdam/nova-ai-agent/core/process-tree.js";
 import { resolveWorkspaceFile } from "@datalabrotterdam/nova-ai-agent/core/tools/workspace-paths.js";
-import {
-  isInteractionMode
-} from "@datalabrotterdam/nova-ai-agent/core/interaction-modes.js";
 import {
   fromElicitationRequest,
   toElicitationResponse
 } from "@datalabrotterdam/nova-ai-agent/acp/user-questions.js";
+import { INTERACTION_MODES } from "@datalabrotterdam/nova-ai-agent/core/interaction-modes.js";
 var DEFAULT_OUTPUT_LIMIT = 1e5;
 var nextMessageId = 0;
 function uid() {
@@ -175,6 +30,8 @@ var TuiAcpClient = class {
   cwd;
   onBackgroundLifecycle;
   onInteractionModeChange;
+  /** The modes the agent offers (built-in, then the user's agent files); set by the runner. */
+  modeIds = [...INTERACTION_MODES];
   capabilities = {
     fs: { readTextFile: true, writeTextFile: true },
     terminal: true,
@@ -235,6 +92,29 @@ var TuiAcpClient = class {
   appendUserMessage(text) {
     this.appendMessage({ id: uid(), role: "user", text });
   }
+  /** An MCP server's sign-in page: opened in the browser, and printed in case that fails. */
+  mcpAuthUrl(params) {
+    const { serverName, url } = params ?? {};
+    if (typeof serverName !== "string" || typeof url !== "string") return;
+    let page;
+    try {
+      page = new URL(url);
+    } catch {
+      return;
+    }
+    if (page.protocol !== "https:" && page.protocol !== "http:") {
+      this.appendError(`MCP server "${serverName}" sent a sign-in address that is not a web page; not opened.`);
+      return;
+    }
+    openBrowser(page.toString());
+    this.appendMessage({
+      id: uid(),
+      role: "assistant",
+      streaming: false,
+      text: `Sign in to MCP server "${serverName}" in your browser. If it did not open, visit:
+${page}`
+    });
+  }
   appendError(text) {
     this.appendMessage({ id: uid(), role: "error", text });
   }
@@ -439,7 +319,7 @@ ${err.message}`;
         }
         return;
       case "current_mode_update":
-        if (isInteractionMode(update.currentModeId)) {
+        if (this.modeIds.includes(update.currentModeId)) {
           this.onInteractionModeChange?.(update.currentModeId);
         }
         return;
@@ -559,6 +439,8 @@ ${err.message}`;
         return this.backgroundUpdate(params);
       case NOVA_NOTIFICATIONS.queueChanged:
         return this.queueChanged(params);
+      case NOVA_NOTIFICATIONS.mcpAuthUrl:
+        return this.mcpAuthUrl(params);
       default:
         return;
     }
@@ -746,8 +628,6 @@ function createStore(initial) {
 }
 
 export {
-  readWorkspaceMcpConfiguration,
-  workspaceNeedsTrust,
   TuiAcpClient,
   choosePermissionOption,
   createStore

package/dist/{headless-OFJFVJ3O.js → headless-QLCJRT3X.js}

@@ -1,9 +1,8 @@
 import {
   TuiAcpClient,
   choosePermissionOption,
-  createStore,
-  readWorkspaceMcpConfiguration
-} from "./chunk-NHGIUEIR.js";
+  createStore
+} from "./chunk-EOPM4RRE.js";
 
 // src/headless/index.ts
 import { resolve } from "path";
@@ -12,7 +11,6 @@ import * as acp from "@agentclientprotocol/sdk";
 import { NovaAgent } from "@datalabrotterdam/nova-ai-agent/acp/agent.js";
 import { clientFromContext } from "@datalabrotterdam/nova-ai-agent/client/context-client.js";
 import { startInProcessAgent } from "@datalabrotterdam/nova-ai-agent/client/in-process.js";
-import { setWorkspaceTrusted } from "@datalabrotterdam/nova-ai-agent/core/nova-home.js";
 import { listStoredSessions, loadStoredSession } from "@datalabrotterdam/nova-ai-agent/core/sessions.js";
 
 // src/headless/client.ts
@@ -191,15 +189,19 @@ ${HEADLESS_HELP}
     dependencies.agent ?? new NovaAgent()
   );
   const agent = connection.client;
-  if (options.trustWorkspace) setWorkspaceTrusted(options.cwd, true);
-  const mcpConfiguration = options.mcp ? readWorkspaceMcpConfiguration(options.cwd) : { servers: [], failures: [] };
-  for (const failure of mcpConfiguration.failures) {
-    output.write({
-      type: "mcp.configuration_error",
-      serverName: failure.serverName,
-      message: failure.message
-    });
-  }
+  const sessionMeta = { "nova-ai-cli/workspaceMcp": options.mcp };
+  const reportMcpFailures = (meta) => {
+    const failures = toRecord(toRecord(meta)?.["nova-ai-cli/mcp"])?.failures;
+    for (const failure of Array.isArray(failures) ? failures : []) {
+      const item = toRecord(failure);
+      if (typeof item?.serverName !== "string" || typeof item.message !== "string") continue;
+      output.write({
+        type: "mcp.configuration_error",
+        serverName: item.serverName,
+        message: item.message
+      });
+    }
+  };
   let sessionId = null;
   let interrupted = false;
   const onInterrupt = () => {
@@ -215,18 +217,23 @@ ${HEADLESS_HELP}
       clientCapabilities: client.capabilities,
       clientInfo: { name: "nova-ai-cli-headless", version: "1" }
     });
+    if (options.trustWorkspace) await agent.workspaceTrust({ cwd: options.cwd, trusted: true });
     if (options.resume) {
-      await agent.resumeSession({
+      const resumed = await agent.resumeSession({
         sessionId: options.resume,
         cwd: options.cwd,
-        mcpServers: mcpConfiguration.servers
+        mcpServers: [],
+        _meta: sessionMeta
       });
+      reportMcpFailures(resumed._meta);
       sessionId = options.resume;
     } else {
       const created = await agent.newSession({
         cwd: options.cwd,
-        mcpServers: mcpConfiguration.servers
+        mcpServers: [],
+        _meta: sessionMeta
       });
+      reportMcpFailures(created._meta);
       sessionId = created.sessionId;
     }
     await agent.setSessionConfigOption({

package/dist/index.js

@@ -17,8 +17,7 @@ var MODE_FLAGS = {
   "--headless": "print",
   "--setup": "login",
   "--version": "version",
-  "-v": "version",
-  "--web": "web"
+  "-v": "version"
 };
 function parseCli(argv) {
   const first = argv[0];
@@ -34,7 +33,7 @@ function parseCli(argv) {
   const mode = [...modes][0];
   const wantsHelp = options.includes("--help") || options.includes("-h");
   if (!mode) return wantsHelp ? { mode: "help", args: [] } : { mode: "tui", args: argv };
-  const drop = /* @__PURE__ */ new Set(["--acp", "--headless", "--setup", "--version", "-v", "--web"]);
+  const drop = /* @__PURE__ */ new Set(["--acp", "--headless", "--setup", "--version", "-v"]);
   return { mode, args: argv.filter((arg, index) => !(drop.has(arg) && (end < 0 || index < end))) };
 }
 function versionText() {
@@ -140,7 +139,7 @@ ${MAIN_HELP}
     }
     case "print": {
       const update = startUpdateCheck();
-      const { default: runHeadless } = await import("./headless-OFJFVJ3O.js");
+      const { default: runHeadless } = await import("./headless-QLCJRT3X.js");
       const code = await runHeadless(command.args);
       if (update) await noticeUpdate(update, 500);
       return code;
@@ -153,11 +152,6 @@ ${MAIN_HELP}
       const { runLogout } = await import("@datalabrotterdam/nova-ai-agent/commands/login.js");
       return runLogout();
     }
-    case "web": {
-      const { default: runWebUi } = await import("./webui-L4GGMXJ3.js");
-      await runWebUi();
-      return 0;
-    }
     case "tui": {
       let options;
       try {
@@ -175,7 +169,7 @@ ${MAIN_HELP}
         );
         return 2;
       }
-      const { default: runChat } = await import("./tui-4XTC6VJP.js");
+      const { default: runChat } = await import("./tui-HJQOYGHL.js");
       return runChat(options);
     }
   }