@datalabrotterdam/nova-ai-cli 1.1.0 → 1.2.0-alpha.2

package/dist/chunk-SKAW2KXC.js

@@ -0,0 +1,10 @@
+// src/version.ts
+import { readPackageVersion } from "@datalabrotterdam/nova-ai-agent/core/version.js";
+var CLI_PACKAGE_NAME = "@datalabrotterdam/nova-ai-cli";
+function cliVersion() {
+  return readPackageVersion(CLI_PACKAGE_NAME, import.meta.url);
+}
+
+export {
+  cliVersion
+};

package/dist/headless-OFJFVJ3O.js

@@ -0,0 +1,543 @@
+import {
+  TuiAcpClient,
+  choosePermissionOption,
+  createStore,
+  readWorkspaceMcpConfiguration
+} from "./chunk-NHGIUEIR.js";
+
+// src/headless/index.ts
+import { resolve } from "path";
+import { NOVA_NOTIFICATIONS } from "@datalabrotterdam/nova-ai-agent/acp/extensions.js";
+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
+var HeadlessAcpClient = class {
+  constructor(cwd, permissionMode, emit) {
+    this.permissionMode = permissionMode;
+    this.emit = emit;
+    const store = createStore({
+      messages: [],
+      plan: [],
+      pendingPermission: null,
+      pendingQuestion: null,
+      inputHistory: [],
+      busy: false,
+      mode: "chat",
+      permissionMode: "ask",
+      interactionMode: "agent",
+      sessionId: "headless",
+      cwd,
+      statusLine: null,
+      queuedCount: 0,
+      contextUsage: null,
+      updateAvailable: null
+    });
+    this.base = new TuiAcpClient(store, cwd);
+    this.baseContext = this.base.context();
+  }
+  permissionMode;
+  emit;
+  capabilities = {
+    fs: { readTextFile: true, writeTextFile: true },
+    terminal: true
+  };
+  base;
+  baseContext;
+  toolNames = /* @__PURE__ */ new Map();
+  context() {
+    return {
+      request: (method, params, options) => this.handleRequest(method, params, options),
+      notify: (method, params) => this.handleNotification(method, params)
+    };
+  }
+  async close() {
+    await this.base.releaseAllTerminals();
+  }
+  async handleRequest(method, params, options) {
+    options?.cancellationSignal?.throwIfAborted();
+    if (method === "session/request_permission") {
+      return this.requestPermission(params);
+    }
+    if (method === "elicitation/create") {
+      return { action: "decline" };
+    }
+    return this.baseContext.request(method, params, options);
+  }
+  async handleNotification(method, params) {
+    await this.emit({ type: "notification", method, params });
+    if (method === "session/update") await this.reportAgentDecision(params);
+    await this.baseContext.notify(method, params);
+  }
+  /**
+   * The agent's policy already applied rules and the mode (set from
+   * --permission-mode); what still reaches us needs a person, and there is
+   * none: only bypass-all approves it.
+   */
+  async requestPermission(params) {
+    const toolName = this.toolName(params.toolCall);
+    const allow = this.permissionMode === "bypass-all";
+    const optionId = choosePermissionOption(params.options, allow, "once") ?? (allow ? "allow_once" : "reject_once");
+    await this.emit({
+      type: "permission",
+      toolCallId: params.toolCall.toolCallId,
+      toolName,
+      decision: allow ? "allow" : "reject",
+      source: this.permissionMode
+    });
+    return { outcome: { outcome: "selected", optionId } };
+  }
+  /** Reports decisions the agent's policy made without asking. */
+  async reportAgentDecision(params) {
+    const update = params?.update;
+    if (!update) return;
+    const toolCallId = typeof update.toolCallId === "string" ? update.toolCallId : null;
+    if (!toolCallId) return;
+    if (update.sessionUpdate === "tool_call") {
+      this.toolNames.set(toolCallId, this.toolName(update));
+      return;
+    }
+    const permission = update._meta?.["nova-ai-cli/permission"];
+    if (update.sessionUpdate !== "tool_call_update" || !permission) return;
+    await this.emit({
+      type: "permission",
+      toolCallId,
+      toolName: this.toolNames.get(toolCallId) ?? "tool",
+      decision: permission.decision === "allow" ? "allow" : "reject",
+      source: permission.reason === "mode" ? this.permissionMode : "rule"
+    });
+  }
+  toolName(call) {
+    const fromMeta = call._meta?.["nova-ai-cli/tool"];
+    return typeof fromMeta === "string" ? fromMeta : call.title ?? "tool";
+  }
+};
+
+// src/headless/index.ts
+var AGENT_PERMISSION_MODE = {
+  "read-only": "default",
+  "accept-edits": "acceptEdits",
+  "bypass-all": "bypassPermissions"
+};
+async function runHeadless(args, dependencies = {}) {
+  const stdout = dependencies.stdout ?? process.stdout;
+  const stderr = dependencies.stderr ?? process.stderr;
+  let options;
+  try {
+    options = parseHeadlessArgs(args, process.cwd());
+  } catch (error) {
+    const message = errorMessage(error);
+    if (args.includes("--json") || args.some((arg) => /^--output-format(=|$)/.test(arg) && !arg.endsWith("=text"))) {
+      return writeFailure(true, stdout, stderr, message);
+    }
+    stderr.write(`${message}
+
+${HEADLESS_HELP}
+`);
+    return 1;
+  }
+  if (options.help) {
+    stdout.write(`${HEADLESS_HELP}
+`);
+    return 0;
+  }
+  let prompt = options.prompt;
+  if (!prompt) {
+    const canReadStdin = dependencies.readStdin || !process.stdin.isTTY;
+    if (canReadStdin) {
+      prompt = (await (dependencies.readStdin ?? readStdin)()).trim();
+    }
+  }
+  if (!prompt) {
+    return writeFailure(
+      options.outputFormat !== "text",
+      stdout,
+      stderr,
+      "Headless mode requires a prompt argument or piped stdin."
+    );
+  }
+  if (options.continueLast) {
+    const latest = listStoredSessions(options.cwd)[0];
+    if (!latest) {
+      return writeFailure(
+        options.outputFormat !== "text",
+        stdout,
+        stderr,
+        `No earlier session in ${options.cwd} to continue.`
+      );
+    }
+    options.resume = latest.sessionId;
+  }
+  if (options.resume) {
+    const stored = loadStoredSession(options.resume);
+    if (!stored) {
+      return writeFailure(
+        options.outputFormat !== "text",
+        stdout,
+        stderr,
+        `Session ${options.resume} not found.`
+      );
+    }
+    options.cwd = stored.cwd;
+  }
+  const output = createOutput(options.outputFormat, stdout, stderr);
+  const client = (dependencies.clientFactory ?? ((cwd, permissionMode, emit) => new HeadlessAcpClient(cwd, permissionMode, emit)))(options.cwd, options.permissionMode, output.event);
+  const connection = startInProcessAgent(
+    () => clientFromContext(client.context()),
+    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
+    });
+  }
+  let sessionId = null;
+  let interrupted = false;
+  const onInterrupt = () => {
+    interrupted = true;
+    if (sessionId) void agent.cancel({ sessionId }).catch(() => {
+    });
+  };
+  if (dependencies.registerSignals !== false)
+    process.once("SIGINT", onInterrupt);
+  try {
+    await agent.initialize({
+      protocolVersion: acp.PROTOCOL_VERSION,
+      clientCapabilities: client.capabilities,
+      clientInfo: { name: "nova-ai-cli-headless", version: "1" }
+    });
+    if (options.resume) {
+      await agent.resumeSession({
+        sessionId: options.resume,
+        cwd: options.cwd,
+        mcpServers: mcpConfiguration.servers
+      });
+      sessionId = options.resume;
+    } else {
+      const created = await agent.newSession({
+        cwd: options.cwd,
+        mcpServers: mcpConfiguration.servers
+      });
+      sessionId = created.sessionId;
+    }
+    await agent.setSessionConfigOption({
+      sessionId,
+      configId: "permission_mode",
+      value: AGENT_PERMISSION_MODE[options.permissionMode]
+    });
+    output.write({
+      type: "session.started",
+      sessionId,
+      cwd: options.cwd,
+      model: options.model,
+      resumed: Boolean(options.resume),
+      permissionMode: options.permissionMode
+    });
+    output.write({ type: "message", role: "user", text: prompt });
+    const response = await agent.prompt({
+      sessionId,
+      prompt: [{ type: "text", text: prompt }],
+      ...options.model ? { _meta: { "nova-ai-cli/model": options.model } } : {}
+    });
+    const exitCode = interrupted ? 130 : response.stopReason === "max_turn_requests" ? 3 : response.stopReason === "cancelled" ? 2 : 0;
+    output.finishText();
+    output.write({
+      type: "result",
+      sessionId,
+      stopReason: response.stopReason,
+      exitCode
+    });
+    return exitCode;
+  } catch (error) {
+    output.finishText();
+    output.error(errorMessage(error));
+    return 1;
+  } finally {
+    if (dependencies.registerSignals !== false)
+      process.removeListener("SIGINT", onInterrupt);
+    if (sessionId) await agent.closeSession({ sessionId }).catch(() => ({}));
+    await connection.close().catch(() => {
+    });
+    await client.close().catch(() => {
+    });
+  }
+}
+function parseHeadlessArgs(args, defaultCwd) {
+  const options = {
+    prompt: null,
+    cwd: resolve(defaultCwd),
+    model: null,
+    resume: null,
+    continueLast: false,
+    outputFormat: "text",
+    mcp: true,
+    trustWorkspace: false,
+    permissionMode: "read-only",
+    help: false
+  };
+  const positional = [];
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--") {
+      positional.push(...args.slice(index + 1));
+      break;
+    }
+    if (arg === "--json") options.outputFormat = "stream-json";
+    else if (arg === "--continue" || arg === "-c") options.continueLast = true;
+    else if (arg === "--output-format")
+      options.outputFormat = parseOutputFormat(takeValue(args, ++index, arg));
+    else if (arg.startsWith("--output-format="))
+      options.outputFormat = parseOutputFormat(arg.slice("--output-format=".length));
+    else if (arg === "--print" || arg === "-p") {
+      const next = args[index + 1];
+      if (next !== void 0 && !next.startsWith("-")) {
+        options.prompt = next;
+        index++;
+      }
+    } else if (arg === "--no-mcp") options.mcp = false;
+    else if (arg === "--trust-workspace") options.trustWorkspace = true;
+    else if (arg === "--help" || arg === "-h") options.help = true;
+    else if (arg === "--prompt")
+      options.prompt = takeValue(args, ++index, arg);
+    else if (arg.startsWith("--prompt="))
+      options.prompt = arg.slice("--prompt=".length);
+    else if (arg === "--cwd")
+      options.cwd = resolve(takeValue(args, ++index, arg));
+    else if (arg.startsWith("--cwd="))
+      options.cwd = resolve(arg.slice("--cwd=".length));
+    else if (arg === "--model") options.model = takeValue(args, ++index, arg);
+    else if (arg.startsWith("--model="))
+      options.model = arg.slice("--model=".length);
+    else if (arg === "--resume") options.resume = takeValue(args, ++index, arg);
+    else if (arg.startsWith("--resume="))
+      options.resume = arg.slice("--resume=".length);
+    else if (arg === "--permission-mode")
+      options.permissionMode = parsePermissionMode(
+        takeValue(args, ++index, arg)
+      );
+    else if (arg.startsWith("--permission-mode="))
+      options.permissionMode = parsePermissionMode(
+        arg.slice("--permission-mode=".length)
+      );
+    else if (arg.startsWith("-")) throw new Error(`Unknown option: ${arg}`);
+    else positional.push(arg);
+  }
+  if (options.prompt && positional.length) {
+    throw new Error(
+      "Provide the prompt either with --prompt or positionally, not both."
+    );
+  }
+  if (!options.prompt && positional.length)
+    options.prompt = positional.join(" ");
+  if (options.continueLast && options.resume) {
+    throw new Error("Use either --continue or --resume, not both.");
+  }
+  if (options.prompt !== null && !options.prompt.trim()) {
+    throw new Error("Prompt cannot be empty.");
+  }
+  return options;
+}
+function createOutput(format, stdout, stderr) {
+  let wroteText = false;
+  const summary = {
+    text: "",
+    tools: [],
+    permissions: []
+  };
+  const write = (record) => {
+    if (format === "stream-json") {
+      stdout.write(`${JSON.stringify({ schemaVersion: 1, ...record })}
+`);
+      return;
+    }
+    if (format !== "json") return;
+    if (record.type === "result") {
+      stdout.write(
+        `${JSON.stringify({ schemaVersion: 1, ...record, text: summary.text, tools: summary.tools, permissions: summary.permissions })}
+`
+      );
+    } else if (record.type === "error") {
+      stdout.write(`${JSON.stringify({ schemaVersion: 1, ...record })}
+`);
+    } else if (record.type === "message.delta" && record.role === "assistant") {
+      summary.text += String(record.text ?? "");
+    } else if (record.type === "tool.finished") {
+      summary.tools.push({ toolCallId: record.toolCallId, status: record.status });
+    } else if (record.type === "permission") {
+      summary.permissions.push(record);
+    }
+  };
+  return {
+    write,
+    event: async (event) => {
+      if (event.type === "permission") {
+        write(event);
+        return;
+      }
+      const record = notificationRecord(event.method, event.params);
+      if (record) write(record);
+      if (format === "text" && record?.type === "message.delta" && record.role === "assistant") {
+        stdout.write(String(record.text ?? ""));
+        wroteText = true;
+      }
+    },
+    finishText: () => {
+      if (format === "text" && wroteText) {
+        stdout.write("\n");
+        wroteText = false;
+      }
+    },
+    error: (message) => {
+      if (format === "text") stderr.write(`${message}
+`);
+      else write({ type: "error", message });
+    }
+  };
+}
+function notificationRecord(method, params) {
+  if (method === NOVA_NOTIFICATIONS.backgroundUpdate) {
+    return { type: "background.update", ...toRecord(params) ?? {} };
+  }
+  if (method === NOVA_NOTIFICATIONS.queueChanged) {
+    return { type: "queue.changed", ...toRecord(params) ?? {} };
+  }
+  if (method !== "session/update") {
+    return { type: "acp.notification", method, params };
+  }
+  const root = toRecord(params);
+  const update = toRecord(root?.update);
+  const sessionId = root?.sessionId;
+  switch (update?.sessionUpdate) {
+    case "agent_message_chunk":
+      return {
+        type: "message.delta",
+        sessionId,
+        role: "assistant",
+        text: textContent(update.content)
+      };
+    case "user_message_chunk":
+      return {
+        type: "message.delta",
+        sessionId,
+        role: "user",
+        text: textContent(update.content)
+      };
+    case "agent_thought_chunk":
+      return {
+        type: "thought",
+        sessionId,
+        text: textContent(update.content)
+      };
+    case "tool_call": {
+      const toolName = toRecord(update._meta)?.["nova-ai-cli/tool"];
+      return {
+        type: "tool.started",
+        sessionId,
+        toolCallId: update.toolCallId,
+        name: typeof toolName === "string" ? toolName : update.title,
+        title: update.title,
+        kind: update.kind,
+        input: update.rawInput
+      };
+    }
+    case "tool_call_update":
+      return {
+        type: update.status === "completed" || update.status === "failed" ? "tool.finished" : "tool.updated",
+        sessionId,
+        toolCallId: update.toolCallId,
+        status: update.status,
+        output: toRecord(update.rawOutput)?.output,
+        content: update.content
+      };
+    case "current_mode_update":
+      return {
+        type: "mode.changed",
+        sessionId,
+        mode: update.currentModeId
+      };
+    default:
+      return null;
+  }
+}
+function textContent(value) {
+  const content = toRecord(value);
+  return content?.type === "text" && typeof content.text === "string" ? content.text : "";
+}
+function toRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function parseOutputFormat(value) {
+  if (value === "text" || value === "json" || value === "stream-json") return value;
+  throw new Error(`Unknown output format: ${value}. Expected text, json, or stream-json.`);
+}
+function parsePermissionMode(value) {
+  if (value === "read-only" || value === "accept-edits" || value === "bypass-all") {
+    return value;
+  }
+  throw new Error(
+    `Unknown permission mode: ${value}. Expected read-only, accept-edits, or bypass-all.`
+  );
+}
+function takeValue(args, index, option) {
+  const value = args[index];
+  if (!value || value.startsWith("--")) {
+    throw new Error(`${option} requires a value.`);
+  }
+  return value;
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
+  return Buffer.concat(chunks).toString("utf8");
+}
+function writeFailure(json, stdout, stderr, message) {
+  if (json)
+    stdout.write(
+      `${JSON.stringify({ schemaVersion: 1, type: "error", message })}
+`
+    );
+  else stderr.write(`${message}
+`);
+  return 1;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var HEADLESS_HELP = `Usage: nova-ai -p [options] [prompt]
+
+Run one Nova agent request without the interactive terminal UI. The prompt
+can also be piped on stdin.
+
+Options:
+  -p, --print [prompt]             Run headless (the prompt may follow)
+      --output-format <format>     text (default), json (one object at the end)
+                                   or stream-json (JSON Lines while it runs)
+      --json                       Same as --output-format stream-json
+      --cwd <path>                 Workspace directory (default: current directory)
+      --model <id>                 Override the configured model
+      --resume <session-id>        Continue a persisted session
+  -c, --continue                   Continue the most recent session of the workspace
+      --no-mcp                     Ignore workspace MCP configuration
+      --trust-workspace            Trust this workspace (remembered): start the MCP
+                                   servers and apply the allow rules it declares
+      --permission-mode <mode>     read-only (default), accept-edits, or bypass-all
+  -h, --help                       Show this help
+
+Exit codes: 0 success, 1 configuration/runtime error, 2 cancelled,
+3 tool-turn safety limit, 130 interrupted.`;
+var headless_default = runHeadless;
+export {
+  HEADLESS_HELP,
+  headless_default as default,
+  parseHeadlessArgs,
+  runHeadless
+};