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

package/dist/acp/credentials.d.ts

@@ -1,11 +0,0 @@
-export type StoredCredentials = {
-    apiKey: string;
-    defaultModel?: string;
-};
-/**
- * Single place that owns "how we get the Nova API key", so swapping this for
- * an OAuth-based Agent Auth flow later only touches this file.
- */
-export declare function readCredentials(): StoredCredentials | null;
-export declare function writeCredentials(credentials: StoredCredentials): void;
-export declare function credentialsPath(): string;

package/dist/acp/credentials.js

@@ -1,30 +0,0 @@
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-const CREDENTIALS_PATH = join(homedir(), ".nova-ai", "credentials.json");
-/**
- * Single place that owns "how we get the Nova API key", so swapping this for
- * an OAuth-based Agent Auth flow later only touches this file.
- */
-export function readCredentials() {
-    const envApiKey = process.env.NOVA_API_KEY;
-    if (envApiKey) {
-        return { apiKey: envApiKey, defaultModel: process.env.NOVA_MODEL };
-    }
-    try {
-        const raw = readFileSync(CREDENTIALS_PATH, "utf8");
-        return JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-}
-export function writeCredentials(credentials) {
-    mkdirSync(dirname(CREDENTIALS_PATH), { recursive: true });
-    writeFileSync(CREDENTIALS_PATH, JSON.stringify(credentials, null, 2), {
-        mode: 0o600,
-    });
-}
-export function credentialsPath() {
-    return CREDENTIALS_PATH;
-}

package/dist/acp/index.d.ts

@@ -1,2 +0,0 @@
-declare function runAcp(...args: string[]): Promise<void>;
-export default runAcp;

package/dist/acp/index.js

@@ -1,21 +0,0 @@
-import { Readable, Writable } from "node:stream";
-import * as acp from "@agentclientprotocol/sdk";
-import { NovaAgent } from "./agent.js";
-async function runAcp(...args) {
-    const agentImpl = new NovaAgent();
-    const output = Writable.toWeb(process.stdout);
-    const input = Readable.toWeb(process.stdin);
-    const stream = acp.ndJsonStream(output, input);
-    acp
-        .agent({ name: "nova-ai-cli" })
-        .onRequest("initialize", (ctx) => agentImpl.initialize(ctx.params))
-        .onRequest("session/new", (ctx) => agentImpl.newSession(ctx.params))
-        .onRequest("session/load", (ctx) => agentImpl.loadSession(ctx.params, ctx.client))
-        .onRequest("session/list", (ctx) => agentImpl.listSessions(ctx.params))
-        .onRequest("session/close", (ctx) => agentImpl.closeSession(ctx.params))
-        .onRequest("authenticate", (ctx) => agentImpl.authenticate(ctx.params))
-        .onRequest("session/prompt", (ctx) => agentImpl.prompt(ctx.params, ctx.client))
-        .onNotification("session/cancel", (ctx) => agentImpl.cancel(ctx.params))
-        .connect(stream);
-}
-export default runAcp;

package/dist/acp/mcp.d.ts

@@ -1,11 +0,0 @@
-import type * as acp from "@agentclientprotocol/sdk";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import type { ToolDefinition } from "./tools/types.js";
-export type McpConnection = {
-    serverName: string;
-    client: Client;
-    close(): Promise<void>;
-};
-export declare function connectMcpServers(servers: acp.McpServer[]): Promise<McpConnection[]>;
-export declare function closeMcpConnections(connections: McpConnection[]): Promise<void>;
-export declare function listMcpTools(connections: McpConnection[]): Promise<ToolDefinition[]>;

package/dist/acp/mcp.js

@@ -1,90 +0,0 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-const TOOL_NAME_PREFIX = "mcp__";
-function sanitize(name) {
-    return name.replace(/[^a-zA-Z0-9_-]/g, "_");
-}
-function headersToRecord(headers) {
-    return Object.fromEntries(headers.map((h) => [h.name, h.value]));
-}
-function buildTransport(server) {
-    if ("type" in server && server.type === "http") {
-        return new StreamableHTTPClientTransport(new URL(server.url), {
-            requestInit: { headers: headersToRecord(server.headers) },
-        });
-    }
-    if ("type" in server && server.type === "sse") {
-        return new SSEClientTransport(new URL(server.url), {
-            requestInit: { headers: headersToRecord(server.headers) },
-        });
-    }
-    const stdio = server;
-    return new StdioClientTransport({
-        command: stdio.command,
-        args: stdio.args,
-        env: Object.fromEntries(stdio.env.map((e) => [e.name, e.value])),
-    });
-}
-export async function connectMcpServers(servers) {
-    const connections = [];
-    for (const server of servers) {
-        if ("type" in server && server.type === "acp")
-            continue; // experimental ACP-transport MCP, not yet supported
-        const client = new Client({ name: "nova-ai-cli", version: "1.0.0" });
-        const transport = buildTransport(server);
-        try {
-            await client.connect(transport);
-            connections.push({ serverName: server.name, client, close: () => client.close() });
-        }
-        catch (err) {
-            console.error(`Failed to connect MCP server "${server.name}": ${err.message}`);
-        }
-    }
-    return connections;
-}
-export async function closeMcpConnections(connections) {
-    await Promise.all(connections.map((c) => c.close().catch(() => { })));
-}
-function toToolResult(result) {
-    const text = Array.isArray(result.content)
-        ? result.content
-            .map((block) => {
-            if (typeof block === "object" && block !== null && "type" in block && block.type === "text") {
-                return block.text;
-            }
-            return "";
-        })
-            .filter(Boolean)
-            .join("\n")
-        : "";
-    if (result.isError)
-        return { error: text || "MCP tool call failed." };
-    return { output: text };
-}
-export async function listMcpTools(connections) {
-    const tools = [];
-    for (const connection of connections) {
-        const { tools: serverTools } = await connection.client.listTools();
-        for (const tool of serverTools) {
-            const qualifiedName = `${TOOL_NAME_PREFIX}${sanitize(connection.serverName)}__${sanitize(tool.name)}`;
-            tools.push({
-                name: qualifiedName,
-                description: `${qualifiedName}: ${tool.description ?? tool.name} (from MCP server "${connection.serverName}")`,
-                requiredCapability: () => true,
-                mutating: true,
-                async execute(_ctx, args) {
-                    try {
-                        const result = await connection.client.callTool({ name: tool.name, arguments: args });
-                        return toToolResult(result);
-                    }
-                    catch (err) {
-                        return { error: err.message };
-                    }
-                },
-            });
-        }
-    }
-    return tools;
-}

package/dist/acp/sessions.d.ts

@@ -1,20 +0,0 @@
-import type { ChatMessage } from "@datalabrotterdam/nova-sdk";
-export type StoredSession = {
-    sessionId: string;
-    cwd: string;
-    title: string | null;
-    updatedAt: string;
-    messages: ChatMessage[];
-};
-export declare function loadStoredSession(sessionId: string): StoredSession | null;
-/**
- * Each turn is appended as its own line rather than rewriting the whole
- * session file, so persisting after every prompt stays O(1) instead of
- * O(history length).
- */
-export declare function appendSessionTurn(sessionId: string, header: {
-    cwd: string;
-    title: string | null;
-}, newMessages: ChatMessage[]): void;
-export declare function listStoredSessions(cwd?: string): StoredSession[];
-export declare function deriveTitle(messages: ChatMessage[]): string | null;

package/dist/acp/sessions.js

@@ -1,91 +0,0 @@
-import { appendFileSync, mkdirSync, readdirSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-const SESSIONS_DIR = join(homedir(), ".nova-ai", "sessions");
-function sessionFilePath(sessionId) {
-    return join(SESSIONS_DIR, `${sessionId}.jsonl`);
-}
-function parseSessionFile(raw) {
-    let header = null;
-    const messages = [];
-    let updatedAt = "";
-    for (const line of raw.split("\n")) {
-        if (!line.trim())
-            continue;
-        const parsed = JSON.parse(line);
-        if (parsed.kind === "header") {
-            header = parsed;
-        }
-        else {
-            messages.push(parsed.message);
-            updatedAt = parsed.updatedAt;
-        }
-    }
-    if (!header)
-        return null;
-    return { sessionId: "", cwd: header.cwd, title: header.title, updatedAt, messages };
-}
-export function loadStoredSession(sessionId) {
-    try {
-        const raw = readFileSync(sessionFilePath(sessionId), "utf8");
-        const session = parseSessionFile(raw);
-        return session ? { ...session, sessionId } : null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Each turn is appended as its own line rather than rewriting the whole
- * session file, so persisting after every prompt stays O(1) instead of
- * O(history length).
- */
-export function appendSessionTurn(sessionId, header, newMessages) {
-    mkdirSync(SESSIONS_DIR, { recursive: true });
-    const path = sessionFilePath(sessionId);
-    const updatedAt = new Date().toISOString();
-    const lines = [];
-    // Re-stating the header is cheap and keeps title updates (set once the
-    // first user message arrives) visible without rewriting prior lines.
-    lines.push(JSON.stringify({ kind: "header", cwd: header.cwd, title: header.title }));
-    for (const message of newMessages) {
-        lines.push(JSON.stringify({ kind: "message", updatedAt, message }));
-    }
-    appendFileSync(path, `${lines.join("\n")}\n`);
-}
-export function listStoredSessions(cwd) {
-    let files;
-    try {
-        files = readdirSync(SESSIONS_DIR);
-    }
-    catch {
-        return [];
-    }
-    const sessions = [];
-    for (const file of files) {
-        if (!file.endsWith(".jsonl"))
-            continue;
-        const sessionId = file.slice(0, -".jsonl".length);
-        try {
-            const raw = readFileSync(join(SESSIONS_DIR, file), "utf8");
-            const session = parseSessionFile(raw);
-            if (!session)
-                continue;
-            if (!cwd || session.cwd === cwd)
-                sessions.push({ ...session, sessionId });
-        }
-        catch {
-            // Skip corrupt/partial session files rather than failing the whole listing.
-        }
-    }
-    return sessions.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
-}
-export function deriveTitle(messages) {
-    const firstUser = messages.find((m) => m.role === "user");
-    if (!firstUser || typeof firstUser.content !== "string")
-        return null;
-    const text = firstUser.content.trim();
-    if (!text)
-        return null;
-    return text.length > 60 ? `${text.slice(0, 60)}…` : text;
-}

package/dist/acp/tools/index.d.ts

@@ -1,6 +0,0 @@
-export { extractToolCall, hasPendingFence } from "./marker.js";
-export { requestPermissionIfNeeded } from "./permission.js";
-export { availableTools, findTool } from "./registry.js";
-export { sendToolCallPending, sendToolCallUpdate } from "./reporting.js";
-export { buildToolsSystemPrompt } from "./system-prompt.js";
-export type { ToolContext, ToolDefinition, ToolResult } from "./types.js";

package/dist/acp/tools/index.js

@@ -1,5 +0,0 @@
-export { extractToolCall, hasPendingFence } from "./marker.js";
-export { requestPermissionIfNeeded } from "./permission.js";
-export { availableTools, findTool } from "./registry.js";
-export { sendToolCallPending, sendToolCallUpdate } from "./reporting.js";
-export { buildToolsSystemPrompt } from "./system-prompt.js";

package/dist/acp/tools/marker.d.ts

@@ -1,17 +0,0 @@
-export type ParsedToolCall = {
-    name: string;
-    args: Record<string, unknown>;
-    matchStart: number;
-    matchEnd: number;
-};
-/**
- * Looks for one complete ```tool_call fenced block in the accumulated stream
- * buffer. Returns null while the block hasn't fully arrived yet (it may be
- * split across multiple stream chunks).
- */
-export declare function extractToolCall(buffer: string): ParsedToolCall | null;
-/**
- * True once the buffer contains the fence start, or ends with a prefix of it
- * (the opening marker may itself be split across stream chunks).
- */
-export declare function hasPendingFence(buffer: string): boolean;

package/dist/acp/tools/marker.js

@@ -1,43 +0,0 @@
-// Greedy match: takes the LAST closing ``` in the buffer, not the first. The
-// JSON payload (e.g. write_file content) may itself contain literal ``` runs
-// (markdown snippets, code fences) — a lazy match would close on those and
-// truncate/corrupt the JSON.
-const FENCE_RE = /```tool_call\s*\n([\s\S]*)\n```/;
-/**
- * Looks for one complete ```tool_call fenced block in the accumulated stream
- * buffer. Returns null while the block hasn't fully arrived yet (it may be
- * split across multiple stream chunks).
- */
-export function extractToolCall(buffer) {
-    const match = FENCE_RE.exec(buffer);
-    if (!match)
-        return null;
-    try {
-        const parsed = JSON.parse(match[1]);
-        if (typeof parsed?.name !== "string")
-            return null;
-        return {
-            name: parsed.name,
-            args: typeof parsed.args === "object" && parsed.args !== null ? parsed.args : parsed,
-            matchStart: match.index,
-            matchEnd: match.index + match[0].length,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-const FENCE_START = "```tool_call";
-/**
- * True once the buffer contains the fence start, or ends with a prefix of it
- * (the opening marker may itself be split across stream chunks).
- */
-export function hasPendingFence(buffer) {
-    if (buffer.includes(FENCE_START))
-        return true;
-    for (let len = Math.min(FENCE_START.length, buffer.length); len > 0; len--) {
-        if (buffer.endsWith(FENCE_START.slice(0, len)))
-            return true;
-    }
-    return false;
-}

package/dist/acp/tools/permission.d.ts

@@ -1,2 +0,0 @@
-import type { ToolContext, ToolDefinition } from "./types.js";
-export declare function requestPermissionIfNeeded(ctx: ToolContext, toolCallId: string, tool: ToolDefinition, args: Record<string, unknown>): Promise<boolean>;

package/dist/acp/tools/permission.js

@@ -1,20 +0,0 @@
-import * as acp from "@agentclientprotocol/sdk";
-export async function requestPermissionIfNeeded(ctx, toolCallId, tool, args) {
-    if (!tool.mutating)
-        return true;
-    const response = await ctx.client.request(acp.methods.client.session.requestPermission, {
-        sessionId: ctx.sessionId,
-        toolCall: {
-            toolCallId,
-            title: tool.name,
-            kind: "execute",
-            status: "pending",
-            rawInput: args,
-        },
-        options: [
-            { optionId: "allow", name: "Allow", kind: "allow_once" },
-            { optionId: "reject", name: "Reject", kind: "reject_once" },
-        ],
-    }, { cancellationSignal: ctx.signal });
-    return response.outcome.outcome === "selected" && response.outcome.optionId === "allow";
-}

package/dist/acp/tools/read-file.d.ts

@@ -1,2 +0,0 @@
-import type { ToolDefinition } from "./types.js";
-export declare const readFileTool: ToolDefinition;

package/dist/acp/tools/read-file.js

@@ -1,20 +0,0 @@
-import * as acp from "@agentclientprotocol/sdk";
-export const readFileTool = {
-    name: "read_file",
-    description: 'read_file: {"path": "<absolute path>"} — read a text file in the workspace.',
-    requiredCapability: (caps) => !!caps?.fs?.readTextFile,
-    mutating: false,
-    async execute({ client, sessionId, signal }, args) {
-        const path = typeof args.path === "string" ? args.path : "";
-        if (!path)
-            return { error: "read_file requires a 'path' argument." };
-        try {
-            const result = await client.request(acp.methods.client.fs.readTextFile, { sessionId, path }, { cancellationSignal: signal });
-            return { output: result.content };
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : "Failed to read file.";
-            return { error: `${message} (path tried: ${path})` };
-        }
-    },
-};

package/dist/acp/tools/registry.d.ts

@@ -1,4 +0,0 @@
-import type * as acp from "@agentclientprotocol/sdk";
-import type { ToolDefinition } from "./types.js";
-export declare function availableTools(caps: acp.ClientCapabilities | undefined): ToolDefinition[];
-export declare function findTool(name: string): ToolDefinition | undefined;

package/dist/acp/tools/registry.js

@@ -1,10 +0,0 @@
-import { readFileTool } from "./read-file.js";
-import { runCommandTool } from "./run-command.js";
-import { writeFileTool } from "./write-file.js";
-const TOOLS = [readFileTool, writeFileTool, runCommandTool];
-export function availableTools(caps) {
-    return TOOLS.filter((tool) => tool.requiredCapability(caps));
-}
-export function findTool(name) {
-    return TOOLS.find((tool) => tool.name === name);
-}

package/dist/acp/tools/reporting.d.ts

@@ -1,3 +0,0 @@
-import type { ToolContext, ToolDefinition } from "./types.js";
-export declare function sendToolCallPending(ctx: ToolContext, toolCallId: string, tool: ToolDefinition, args: Record<string, unknown>): Promise<void>;
-export declare function sendToolCallUpdate(ctx: ToolContext, toolCallId: string, status: "completed" | "failed", output: string): Promise<void>;

package/dist/acp/tools/reporting.js

@@ -1,26 +0,0 @@
-import * as acp from "@agentclientprotocol/sdk";
-export async function sendToolCallPending(ctx, toolCallId, tool, args) {
-    await ctx.client.notify(acp.methods.client.session.update, {
-        sessionId: ctx.sessionId,
-        update: {
-            sessionUpdate: "tool_call",
-            toolCallId,
-            title: tool.name,
-            kind: tool.mutating ? "execute" : "read",
-            status: "pending",
-            rawInput: args,
-        },
-    });
-}
-export async function sendToolCallUpdate(ctx, toolCallId, status, output) {
-    await ctx.client.notify(acp.methods.client.session.update, {
-        sessionId: ctx.sessionId,
-        update: {
-            sessionUpdate: "tool_call_update",
-            toolCallId,
-            status,
-            content: [{ type: "content", content: { type: "text", text: output } }],
-            rawOutput: { output },
-        },
-    });
-}

package/dist/acp/tools/run-command.d.ts

@@ -1,2 +0,0 @@
-import type { ToolDefinition } from "./types.js";
-export declare const runCommandTool: ToolDefinition;

package/dist/acp/tools/run-command.js

@@ -1,29 +0,0 @@
-import * as acp from "@agentclientprotocol/sdk";
-export const runCommandTool = {
-    name: "run_command",
-    description: 'run_command: {"command": "<shell command>"} — run a shell command in the workspace and return its output.',
-    requiredCapability: (caps) => !!caps?.terminal,
-    mutating: true,
-    async execute({ client, sessionId, signal }, args) {
-        const command = typeof args.command === "string" ? args.command : "";
-        if (!command)
-            return { error: "run_command requires a 'command' argument." };
-        let terminalId;
-        try {
-            const created = await client.request(acp.methods.client.terminal.create, { sessionId, command }, { cancellationSignal: signal });
-            terminalId = created.terminalId;
-            const exit = await client.request(acp.methods.client.terminal.waitForExit, { sessionId, terminalId }, { cancellationSignal: signal });
-            const { output, truncated } = await client.request(acp.methods.client.terminal.output, { sessionId, terminalId }, { cancellationSignal: signal });
-            const exitNote = exit.exitCode !== undefined && exit.exitCode !== null ? ` (exit code ${exit.exitCode})` : "";
-            return { output: `${output}${truncated ? "\n[output truncated]" : ""}${exitNote}` };
-        }
-        catch (err) {
-            return { error: err instanceof Error ? err.message : "Failed to run command." };
-        }
-        finally {
-            if (terminalId) {
-                void client.request(acp.methods.client.terminal.release, { sessionId, terminalId }).catch(() => { });
-            }
-        }
-    },
-};

package/dist/acp/tools/system-prompt.d.ts

@@ -1,2 +0,0 @@
-import type { ToolDefinition } from "./types.js";
-export declare function buildToolsSystemPrompt(tools: ToolDefinition[], cwd: string): string | null;

package/dist/acp/tools/system-prompt.js

@@ -1,23 +0,0 @@
-export function buildToolsSystemPrompt(tools, cwd) {
-    if (tools.length === 0)
-        return null;
-    const toolList = tools.map((tool) => `- ${tool.description}`).join("\n");
-    return [
-        `The user's workspace root is: ${cwd}`,
-        "Always use absolute paths rooted there (e.g. resolve a file named X to the corresponding path under that root). Never guess or invent a path like /home/user/... — use the workspace root given above.",
-        "You can use tools to read/write files or run shell commands in the user's workspace.",
-        "To use a tool, emit exactly this fenced block and nothing else after it in your turn:",
-        "```tool_call",
-        '{"name": "<tool name>", "args": { ... }}',
-        "```",
-        "STRICT rules for this JSON:",
-        "- All tool arguments go INSIDE the \"args\" object. Never put them at the top level next to \"name\".",
-        "- Include every argument the tool needs, exactly as named below. Do not omit \"path\", \"content\", or \"command\".",
-        "- Example for write_file: ```tool_call",
-        '{"name": "write_file", "args": {"path": "' + cwd.replace(/\\/g, "\\\\") + '/example.txt", "content": "file contents here"}}',
-        "```",
-        "- One tool call per turn. After the result comes back, continue or call another tool.",
-        "Wait for the tool's result before continuing. Available tools:",
-        toolList,
-    ].join("\n");
-}

package/dist/acp/tools/types.d.ts

@@ -1,18 +0,0 @@
-import type * as acp from "@agentclientprotocol/sdk";
-export type ToolContext = {
-    client: acp.AgentContext;
-    sessionId: string;
-    signal: AbortSignal;
-};
-export type ToolResult = {
-    output: string;
-} | {
-    error: string;
-};
-export type ToolDefinition = {
-    name: string;
-    description: string;
-    requiredCapability: (caps: acp.ClientCapabilities | undefined) => boolean;
-    mutating: boolean;
-    execute(ctx: ToolContext, args: Record<string, unknown>): Promise<ToolResult>;
-};

package/dist/acp/tools/types.js

@@ -1 +0,0 @@
-export {};

package/dist/acp/tools/write-file.d.ts

@@ -1,2 +0,0 @@
-import type { ToolDefinition } from "./types.js";
-export declare const writeFileTool: ToolDefinition;

package/dist/acp/tools/write-file.js

@@ -1,20 +0,0 @@
-import * as acp from "@agentclientprotocol/sdk";
-export const writeFileTool = {
-    name: "write_file",
-    description: 'write_file: {"path": "<absolute path>", "content": "<full file content>"} — overwrite a text file in the workspace.',
-    requiredCapability: (caps) => !!caps?.fs?.writeTextFile,
-    mutating: true,
-    async execute({ client, sessionId, signal }, args) {
-        const path = typeof args.path === "string" ? args.path : "";
-        const content = typeof args.content === "string" ? args.content : "";
-        if (!path)
-            return { error: "write_file requires a 'path' argument." };
-        try {
-            await client.request(acp.methods.client.fs.writeTextFile, { sessionId, path, content }, { cancellationSignal: signal });
-            return { output: `Wrote ${content.length} characters to ${path}.` };
-        }
-        catch (err) {
-            return { error: err instanceof Error ? err.message : "Failed to write file." };
-        }
-    },
-};

package/dist/tui/index.d.ts

@@ -1,7 +0,0 @@
-/**
- * Placeholder for the interactive terminal chat mode (nova-ai-cli's primary
- * entrypoint, mirroring `claude`/`codex`). ACP mode in index.ts is the
- * machine-facing counterpart of this same auth/credentials plumbing.
- */
-export declare function runChat(...args: string[]): Promise<void>;
-export default runChat;

package/dist/tui/index.js

@@ -1,11 +0,0 @@
-/**
- * Placeholder for the interactive terminal chat mode (nova-ai-cli's primary
- * entrypoint, mirroring `claude`/`codex`). ACP mode in index.ts is the
- * machine-facing counterpart of this same auth/credentials plumbing.
- */
-export async function runChat(...args) {
-    console.log("nova-ai-cli is a work in progress — interactive chat isn't built yet.");
-    console.log("Right now it only works in ACP mode: run `nova-ai-cli --acp` (or point your ACP client at this binary).");
-    console.log("Run `nova-ai-cli --setup` first to connect your Nova API key.");
-}
-export default runChat;

package/dist/webui/index.d.ts

@@ -1,6 +0,0 @@
-/**
- * Placeholder for the standalone browser-based agent UI (nova-ai-cli --web),
- * separate from src/acp/web which only handles the --setup auth page.
- */
-declare function runWebUi(...args: string[]): Promise<void>;
-export default runWebUi;

package/dist/webui/index.js

@@ -1,9 +0,0 @@
-/**
- * Placeholder for the standalone browser-based agent UI (nova-ai-cli --web),
- * separate from src/acp/web which only handles the --setup auth page.
- */
-async function runWebUi(...args) {
-    console.log("nova-ai-cli --web is a work in progress — the browser UI isn't built yet.");
-    console.log("Use `nova-ai-cli` for the terminal chat, or `nova-ai-cli --acp` for ACP mode.");
-}
-export default runWebUi;