@datalabrotterdam/nova-ai-cli 1.0.1-alpha.1

package/dist/acp/credentials.js

@@ -0,0 +1,30 @@
+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

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

package/dist/acp/index.js

@@ -0,0 +1,20 @@
+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("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/sessions.d.ts

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,91 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,43 @@
+// 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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +1,20 @@
+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

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

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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,26 @@
+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

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

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

@@ -0,0 +1,29 @@
+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

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

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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,18 @@
+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

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

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

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

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

@@ -0,0 +1,20 @@
+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/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { runBrowserAuth } from "./acp/auth-server.js";
+import chat from "./tui/index.js";
+import web from "./webui/index.js";
+import acp from "./acp/index.js";
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.includes("--setup")) {
+        await runBrowserAuth();
+        return;
+    }
+    if (args.includes("--acp")) {
+        await acp(...args.slice(1));
+        return;
+    }
+    if (args.includes("--web")) {
+        await web(...args.slice(1));
+        return;
+    }
+    await chat(...args.slice(1));
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/tui/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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

@@ -0,0 +1,11 @@
+/**
+ * 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

@@ -0,0 +1,6 @@
+/**
+ * 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

@@ -0,0 +1,9 @@
+/**
+ * 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;

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@datalabrotterdam/nova-ai-cli",
+  "version": "1.0.1-alpha.1",
+  "description": "CLI for DataLab Rotterdam's Nova AI, with an Agent Client Protocol mode for editors/IDEs, backed by @datalabrotterdam/nova-sdk",
+  "license": "Apache-2.0",
+  "author": "DataLab Rotterdam",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "nova-ai-cli": "dist/index.js",
+    "nova-ai": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "src/acp/web/dist",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Datalab-Rotterdam/nova-ai-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Datalab-Rotterdam/nova-ai-cli/issues"
+  },
+  "homepage": "https://github.com/Datalab-Rotterdam/nova-ai-cli#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "npm install --prefix src/acp/web && npm run build --prefix src/acp/web && tsc -p tsconfig.json",
+    "dev": "tsc -p tsconfig.json --watch",
+    "test": "tsc -p tsconfig.json --noEmit && npm run test:unit",
+    "test:unit": "node -e \"require('fs').rmSync('dist-test',{recursive:true,force:true})\" && tsc -p tsconfig.test.json && node --test \"dist-test/tests/**/*.test.js\""
+  },
+  "dependencies": {
+    "@agentclientprotocol/sdk": "^0.29.0",
+    "@datalabrotterdam/nova-sdk": "^1.3.2",
+    "@sourceregistry/node-webserver": "^1.8.0"
+  },
+  "devDependencies": {
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/npm": "^13.1.5",
+    "@semantic-release/release-notes-generator": "^14.1.0",
+    "@types/node": "^22.20.0",
+    "typescript": "^5.6.0"
+  },
+  "release": {
+    "branches": [
+      "main",
+      {
+        "name": "alpha",
+        "prerelease": true
+      }
+    ],
+    "plugins": [
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      "@semantic-release/changelog",
+      "@semantic-release/npm",
+      [
+        "@semantic-release/git",
+        {
+          "assets": [
+            "package.json",
+            "CHANGELOG.md"
+          ],
+          "message": "nova-ai-cli(release): 🚀 v${nextRelease.version}\n\n${nextRelease.notes}"
+        }
+      ]
+    ]
+  }
+}