nou-cli 0.1.0 → 0.2.1

package/README.md

@@ -1,55 +1,166 @@
-# Nou
+<p align="center">
+  <img src="https://raw.githubusercontent.com/JorgeOchoaReyes/nou/HEAD/docs/banner.svg" alt="Nou: your AI coding companion, right in the terminal" width="100%">
+</p>
 
-An IDE-style AI coding assistant that lives in your terminal: file explorer, code view with live side-by-side diffs, a built-in editor, and a chat with an agent that reads, edits and runs things in your project. Works with local models (Ollama, LM Studio, llama.cpp) and cloud ones (Claude, OpenAI, Gemini, OpenRouter, Groq, DeepSeek).
+<p align="center">
+  <a href="https://www.npmjs.com/package/nou-cli"><img src="https://img.shields.io/npm/v/nou-cli?style=for-the-badge&color=bb9af7&labelColor=1a1b26&logo=npm&logoColor=white" alt="npm version"></a>
+  <a href="https://github.com/JorgeOchoaReyes/nou/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/JorgeOchoaReyes/nou/ci.yml?branch=master&style=for-the-badge&label=CI&labelColor=1a1b26&color=9ece6a&logo=githubactions&logoColor=white" alt="CI"></a>
+  <img src="https://img.shields.io/node/v/nou-cli?style=for-the-badge&color=7dcfff&labelColor=1a1b26&logo=nodedotjs&logoColor=white" alt="node version">
+  <img src="https://img.shields.io/npm/l/nou-cli?style=for-the-badge&color=e0af68&labelColor=1a1b26" alt="license">
+</p>
 
-```
+<p align="center">
+  <img src="https://img.shields.io/badge/Ollama-local-9ece6a?style=flat-square&logo=ollama&logoColor=white&labelColor=1a1b26" alt="Ollama">
+  <img src="https://img.shields.io/badge/LM%20Studio-local-9ece6a?style=flat-square&labelColor=1a1b26" alt="LM Studio">
+  <img src="https://img.shields.io/badge/Claude-cloud-bb9af7?style=flat-square&logo=anthropic&logoColor=white&labelColor=1a1b26" alt="Claude">
+  <img src="https://img.shields.io/badge/OpenAI-cloud-bb9af7?style=flat-square&labelColor=1a1b26" alt="OpenAI">
+  <img src="https://img.shields.io/badge/Gemini-cloud-bb9af7?style=flat-square&logo=googlegemini&logoColor=white&labelColor=1a1b26" alt="Gemini">
+  <img src="https://img.shields.io/badge/OpenRouter%20·%20Groq%20·%20DeepSeek-cloud-bb9af7?style=flat-square&labelColor=1a1b26" alt="More providers">
+</p>
+
+<p align="center">
+  <b>An IDE that lives in your terminal.</b> Browse your code, watch the AI's edits as live side-by-side diffs,<br>
+  approve them with a keypress, edit files yourself, and switch between local and cloud models on the fly.
+</p>
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/JorgeOchoaReyes/nou/HEAD/docs/screenshot.svg" alt="Nou proposing an edit as a side-by-side diff, with the file tree and chat" width="100%">
+</p>
+
+---
+
+## ⚡ Quick start
+
+```bash
 npm install -g nou-cli
 cd your-project
 nou
 ```
 
-Needs Node 20.12+ and an interactive terminal (Windows Terminal, PowerShell, macOS/Linux terminals). For local models, install [Ollama](https://ollama.com) and pull a model, e.g. `ollama pull qwen3:8b` (the default).
+> [!TIP]
+> Want it fully local and free? Install [Ollama](https://ollama.com), run `ollama pull qwen3:8b`, and you're set. That's the default model.
+
+Needs **Node 22.12+** and an interactive terminal (Windows Terminal, PowerShell, macOS/Linux terminals).
+
+## ✨ What it does
+
+| | |
+| --- | --- |
+| 🗂️ **File explorer** | Browse your project with file icons and git status (`M` modified, `?` new). Press <kbd>c</kbd> to see only changed files. |
+| 🔀 **Live diffs** | Every edit Nou proposes shows up side by side. <kbd>y</kbd> accepts, <kbd>n</kbd> rejects. Nothing touches disk without you. |
+| ✍️ **Built-in editor** | Press <kbd>e</kbd> to edit the open file yourself, with undo/redo and **auto-save**. |
+| ↶ **Undo anything** | Every change, Nou's or yours, is recorded. <kbd>u</kbd> undoes Nou's last edit, `/rewind` undoes its whole last turn, and your own later edits are kept. |
+| 🩺 **Problems, live** | Syntax errors instantly, plus ESLint, TypeScript, Ruff and language servers when your project has them. Shown in the gutter, inline, and in a <kbd>p</kbd> Problems panel. |
+| 🤖 **Self-correcting** | Nou checks its own edits: you see "⚠ +1 problem" *before* approving, and any problems it introduced are fed back so it fixes them. |
+| 🎨 **Real syntax highlighting** | tree-sitter parsing for 14 languages (TS, JS, Python, Go, Rust, Java, C, JSON, YAML…). |
+| 🧭 **Code intelligence** | <kbd>Ctrl</kbd>+<kbd>K</kbd> hover info and <kbd>Ctrl</kbd>+<kbd>G</kbd> go-to-definition via language servers (typescript-language-server, pyright, rust-analyzer, gopls, clangd). |
+| 👀 **Knows what you're looking at** | The open file, visible lines, your cursor and unsaved edits ride along with each message. "Fix this function" just works. |
+| 🌿 **Git aware** | Sees your branch, uncommitted changes and recent commits, and can diff on its own. Press <kbd>v</kbd> to diff any file against `HEAD`. |
+| 🔌 **Any model** | Local (Ollama, LM Studio, llama.cpp) or cloud (Claude, OpenAI, Gemini, OpenRouter, Groq, DeepSeek). Switch mid-conversation. |
+| 🧩 **Plugins** | Add your own tools and slash commands with a single file. |
+| 🔎 **Quick open** | <kbd>Ctrl</kbd>+<kbd>P</kbd> fuzzy-finds any file. |
+
+Every change is reviewed like a code review:
+
+```diff
+ function resolveInProject(filePath: string): string {
+-  const fullPath = path.resolve(process.cwd(), filePath);
++  const root = realpathSync(process.cwd());
++  const fullPath = path.resolve(root, filePath);
+```
 
-## Using it
+## ⌨️ Keys
 
 | Key | Does |
 | --- | --- |
-| `Tab` | switch between files, code and chat |
-| `Ctrl+P` | fuzzy-find a file |
-| `e` | edit the open file (`Ctrl+S` save, `Ctrl+Z` undo, `Esc` close) |
-| `v` | diff the open file against git `HEAD` (or Nou's last edit) |
-| `c` | in the file tree, show only changed files |
-| `f` | follow mode: jump to files Nou is reading/editing |
-| `s` or `/settings` | settings: model, preferences, plugins |
-| `y` / `n` | accept / reject a proposed edit or command |
-| `Esc` | stop Nou, close a diff, back to chat |
+| 🖱️ Mouse | wheel scrolls the pane under the pointer · click a pane to focus it · click a file to open it (hold <kbd>Shift</kbd> to select text; turn off in settings) |
+| <kbd>Shift</kbd>+<kbd>↑</kbd>/<kbd>↓</kbd>, <kbd>PgUp</kbd>/<kbd>PgDn</kbd> | scroll the chat history |
+| <kbd>Tab</kbd> | switch between files, code and chat |
+| <kbd>Ctrl</kbd>+<kbd>P</kbd> | fuzzy-find a file |
+| <kbd>e</kbd> | edit the open file (<kbd>Ctrl</kbd>+<kbd>S</kbd> save · <kbd>Ctrl</kbd>+<kbd>Z</kbd>/<kbd>Y</kbd> undo/redo · <kbd>Ctrl</kbd>+<kbd>K</kbd> info · <kbd>Ctrl</kbd>+<kbd>G</kbd> definition · <kbd>Esc</kbd> close) |
+| <kbd>p</kbd> | Problems panel: every error and warning, <kbd>Enter</kbd> jumps to it |
+| <kbd>u</kbd> | undo Nou's last edit |
+| <kbd>v</kbd> | diff the open file vs git `HEAD` (or Nou's last edit) · <kbd>n</kbd>/<kbd>N</kbd> jump between changes |
+| <kbd>c</kbd> | in the file tree: show only changed files |
+| <kbd>f</kbd> | follow mode: jump to files as Nou reads and edits them |
+| <kbd>s</kbd> | settings: model, preferences, plugins |
+| <kbd>y</kbd> / <kbd>n</kbd> | accept / reject a proposed edit or command |
+| <kbd>Esc</kbd> | stop Nou · close a diff · back to chat |
+| <kbd>Ctrl</kbd>+<kbd>C</kbd> | stop Nou while it works · press twice to quit |
 
-Nou sees what you're looking at: the open file and visible lines (or your cursor line and unsaved edits while editing) are attached to each message, so "explain this function" just works. In a git repo it also gets your branch, uncommitted changes and recent commits, plus `git_status` / `git_diff` / `git_log` tools.
+Chat commands: `/settings` · `/model [provider:model]` · `/models [provider]` · `/undo` · `/rewind` · `/history` · `/problems` · `/clear` · `/help`
 
-Chat commands: `/settings`, `/model [provider:model]`, `/models [provider]`, `/clear`, `/help`.
+## 🧠 Models
 
-## Models
+Pick one in <kbd>s</kbd> settings, with `/model anthropic` or `/model ollama:qwen3:8b`, or set `NOU_MODEL=provider:model`. API keys come from your environment or a `.env` file in your project; see [.env.example](.env.example).
 
-Pick one in `/settings`, with `/model anthropic`, `/model ollama:qwen3:8b`, or `NOU_MODEL=provider:model`. API keys come from your environment or a `.env` file in the project; see [.env.example](.env.example).
+<details>
+<summary><b>All providers and how to set them up</b></summary>
 
-| Provider | Setup |
-| --- | --- |
-| Ollama (default) | runs locally, `OLLAMA_HOST` to change |
-| LM Studio, llama.cpp | start their local server |
-| Any OpenAI-compatible server | `NOU_BASE_URL`, optional `NOU_API_KEY` |
-| Anthropic | `ANTHROPIC_API_KEY` |
-| OpenAI / Gemini / OpenRouter / Groq / DeepSeek | `OPENAI_API_KEY` / `GEMINI_API_KEY` / `OPENROUTER_API_KEY` / `GROQ_API_KEY` / `DEEPSEEK_API_KEY` |
+| Provider | Type | Setup |
+| --- | --- | --- |
+| 🦙 Ollama *(default)* | 🟢 local | runs locally · `OLLAMA_HOST` to change |
+| 🖥️ LM Studio | 🟢 local | start its local server |
+| ⚙️ llama.cpp server | 🟢 local | start `llama-server` |
+| 🔧 Any OpenAI-compatible server | 🟢 local | `NOU_BASE_URL`, optional `NOU_API_KEY` |
+| 🟣 Anthropic (Claude) | ☁️ cloud | `ANTHROPIC_API_KEY` |
+| ⚪ OpenAI | ☁️ cloud | `OPENAI_API_KEY` |
+| 🔷 Google Gemini | ☁️ cloud | `GEMINI_API_KEY` |
+| 🔀 OpenRouter | ☁️ cloud | `OPENROUTER_API_KEY` |
+| ⚡ Groq | ☁️ cloud | `GROQ_API_KEY` |
+| 🐋 DeepSeek | ☁️ cloud | `DEEPSEEK_API_KEY` |
+
+</details>
+
+## 🔄 Updating
+
+Nou checks npm once a day and offers to update when a new version is out (one keypress, then it restarts itself). Or run it yourself:
+
+```bash
+nou update          # or: npm install -g nou-cli@latest
+nou --version
+```
 
-## Plugins (early)
+Set `NOU_NO_UPDATE_CHECK=1` to turn the check off.
 
-Drop a `.js`/`.mjs` file into `.nou/plugins/` (project) or `~/.nou/plugins/` (everywhere), then enable it in `/settings → Plugins`. A plugin can add tools for the model, slash commands, and system prompt text. See [examples/plugins/word-count.mjs](examples/plugins/word-count.mjs). Plugins run code on your machine, so they stay off until you enable them.
+## 🧩 Plugins *(early)*
 
-## Development
+Drop a `.js` / `.mjs` file into `.nou/plugins/` (this project) or `~/.nou/plugins/` (everywhere), then switch it on in <kbd>s</kbd> settings → **Plugins**. A plugin can give the model new tools, add slash commands, add to the system prompt, and add **checkers** (linters) whose problems show in the editor. The built-in ESLint, TypeScript, Ruff, syntax and language-server checkers are plugins too, so you can switch any of them off.
 
+```js
+export default {
+  name: "word-count",
+  tools: [{ readOnly: true, definition: { name: "word_count", /* ... */ }, run: (args) => "42 words" }],
+  commands: [{ name: "wc", description: "Count words", run: (args) => "42 words" }],
+  diagnostics: [{
+    id: "todo", name: "TODOs", checksText: true, matches: (f) => f.endsWith(".ts"), available: () => true,
+    check: async (file, text) => text.split("\n").flatMap((l, i) => l.includes("TODO")
+      ? [{ file, line: i + 1, col: 1, severity: "info", message: "TODO left here", source: "todo" }] : []),
+  }],
+};
 ```
+
+Full example: [examples/plugins/word-count.mjs](examples/plugins/word-count.mjs).
+
+> [!WARNING]
+> Plugins run code on your machine, so they stay **off** until you enable them.
+
+## 🛠️ Development
+
+```bash
 npm install
-npm run dev        # run from source
-npm run build      # compile to dist/
+npm run dev          # run from source
+npm run build        # compile to dist/ (and copy the syntax grammars)
+npm test             # end-to-end tests: drives the real UI with simulated keys
+npm run screenshot   # regenerate docs/screenshot.svg
 ```
 
-Releases: create a GitHub release tagged `vX.Y.Z` and the Publish workflow builds and publishes that version to npm (needs an `NPM_TOKEN` secret in the `production` environment).
+Releasing: bump `version` in `package.json`, merge to `master`, then run **Actions → Publish to npm**. It tests, publishes with provenance, and creates the git tag and GitHub Release. (Or publish a GitHub release tagged `vX.Y.Z`.) The token lives in the `production` environment as `NPM_TOKEN`.
+
+Upkeep runs on its own:
+- **CI** on every PR: type-check, lint, build, unit and end-to-end tests on Linux, macOS and Windows (Node 22.12 and 24 too), plus installing the packed tarball to check the package works.
+- **Dependabot** opens weekly PRs for dependency and GitHub Actions updates.
+- **CodeQL** scans for security issues on every PR and weekly.
+- **npm audit** fails CI if a dependency users install has a high-severity vulnerability.
+
+<p align="center"><sub>Made with 🌞 by <a href="https://github.com/JorgeOchoaReyes">Jorge Ochoa-Reyes</a></sub></p>

package/dist/index.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import { existsSync } from "fs";
+// Must stay the first import: loads .env before any provider reads its keys and URLs.
+import "./src/env.js";
 import { createElement } from "react";
 import { render } from "ink";
 import * as p from "@clack/prompts";
@@ -7,16 +8,61 @@ import chalk from "chalk";
 import { artWork } from "./src/util/index.js";
 import { ensureProjectContext, loadPermanentContext } from "./src/context/index.js";
 import { describe, initialModel, resolveModel } from "./src/providers/index.js";
+import { checkForUpdate, currentVersion, installUpdate, relaunch } from "./src/update/index.js";
+import { lsp } from "./src/lsp/index.js";
 import { App } from "./src/ui/App.js";
+const HELP = `nou ${currentVersion()}: an AI coding assistant for your terminal
+
+Usage:
+  nou              open Nou in the current folder
+  nou update       update to the latest version
+  nou --version    print the version
+  nou --help       show this help
+
+Settings live in ~/.nou/config.json (or press s inside Nou). Set NOU_NO_UPDATE_CHECK=1 to skip update checks.`;
 async function main() {
+    const args = process.argv.slice(2);
+    if (args.includes("--version") || args.includes("-v")) {
+        console.log(currentVersion());
+        return;
+    }
+    if (args.includes("--help") || args.includes("-h")) {
+        console.log(HELP);
+        return;
+    }
+    if (args[0] === "update") {
+        const latest = await checkForUpdate({ force: true, timeout: 10_000 });
+        if (!latest) {
+            console.log(`nou ${currentVersion()} is up to date.`);
+            return;
+        }
+        console.log(`Updating nou ${currentVersion()} → ${latest}...`);
+        if (await installUpdate(latest))
+            process.exit(0);
+        if (process.platform !== "win32")
+            console.log("If that was a permissions error, run: sudo npm install -g nou-cli@latest");
+        process.exit(1);
+    }
     if (!process.stdin.isTTY) {
-        console.error("Nou needs an interactive terminal (try Windows Terminal / PowerShell).");
+        console.error("Nou needs an interactive terminal (try Windows Terminal, PowerShell, or Terminal/iTerm on macOS).");
         process.exit(1);
     }
-    // API keys can live in a .env next to the project (it's gitignored).
-    if (existsSync(".env"))
-        process.loadEnvFile(".env");
-    p.intro(chalk.cyan(`${artWork} \n Hello I am Nou! 🌞`));
+    p.intro(chalk.cyan(`${artWork} \n Hello I am Nou! 🌞  ${chalk.dim(`v${currentVersion()}`)}`));
+    const latest = await checkForUpdate();
+    if (latest) {
+        const update = await p.confirm({ message: `Nou ${chalk.green(latest)} is available (you have ${currentVersion()}). Update now?` });
+        if (update === true) {
+            const ok = await installUpdate(latest);
+            if (ok) {
+                p.log.success(`Updated to ${latest}. Restarting...`);
+                relaunch();
+                return;
+            }
+            p.log.warn(process.platform === "win32"
+                ? "The update failed. You can retry later with: npm install -g nou-cli@latest"
+                : "The update failed. If it was a permissions error, run: sudo npm install -g nou-cli@latest");
+        }
+    }
     let choice = initialModel();
     const problem = choice.provider.unavailable();
     if (problem) {
@@ -26,10 +72,13 @@ async function main() {
     p.log.info(`Model: ${chalk.yellow(describe(choice))}  (change it any time with /model)`);
     await ensureProjectContext(choice);
     const permContext = await loadPermanentContext();
+    // Ctrl+C is handled inside the app: press it twice to quit, so a stray press doesn't lose work.
     const app = render(createElement(App, { initialModel: choice, permContext }), {
         alternateScreen: true,
+        exitOnCtrlC: false,
     });
     await app.waitUntilExit();
+    lsp.stopAll();
     p.outro(chalk.cyan("Bye bye!"));
 }
 main().catch(console.error);

package/dist/src/agent/index.js

@@ -1,6 +1,7 @@
 import { toolDefs } from "../tools/index.js";
 import { applyChange, fileTree, proposeEdit, proposeWrite, readFile, runCommand, toRelative, } from "../commands/index.js";
 import { describe } from "../providers/index.js";
+import { newCallId } from "../providers/ids.js";
 const MAX_STEPS = 25;
 export function buildSystemPrompt(permContext, extras = []) {
     return `You are Nou, a coding assistant running in the user's terminal, working in ${process.cwd()}.
@@ -32,6 +33,14 @@ export class Agent {
     controller = null;
     extraTools = [];
     effort;
+    notes = [];
+    /** Increments per user message; tags changes so a whole turn can be rewound. */
+    turn = 0;
+    /** Distinguishes this run from earlier ones, since turn numbers restart at 1 every session. */
+    session = `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`;
+    get turnId() {
+        return `${this.session}:${this.turn}`;
+    }
     constructor(choice, system, hooks) {
         this.choice = choice;
         this.system = system;
@@ -54,13 +63,21 @@ export class Agent {
     }
     clear() {
         this.messages = [];
+        this.notes = [];
+    }
+    /** Something the model should know before the next message (e.g. the user undid its edit). */
+    note(text) {
+        this.notes.push(text);
     }
     cancel() {
         this.controller?.abort();
     }
     /** `context` (what the user is looking at) is sent to the model but not shown in the chat. */
     async send(text, context) {
-        this.messages.push({ role: "user", content: context ? `${text}\n\n${context}` : text });
+        this.turn++;
+        const notes = this.notes.length ? `${this.notes.map((n) => `[Note: ${n}]`).join("\n")}\n\n` : "";
+        this.notes = [];
+        this.messages.push({ role: "user", content: `${notes}${text}${context ? `\n\n${context}` : ""}` });
         this.controller = new AbortController();
         const { signal } = this.controller;
         try {
@@ -80,6 +97,15 @@ export class Agent {
                     },
                 });
                 this.hooks.onStream("");
+                // Tool-call ids must be unique across the conversation (results are matched by id, and some APIs
+                // reject duplicates). Some providers reuse ids, so rename any repeat. Claude's own copy of the turn
+                // (raw) keeps its ids, which the API guarantees are unique.
+                const used = new Set(this.messages.flatMap((m) => (m.role === "assistant" ? m.toolCalls.map((c) => c.id) : [])));
+                for (const call of result.toolCalls) {
+                    if (used.has(call.id) && !result.raw)
+                        call.id = newCallId();
+                    used.add(call.id);
+                }
                 this.messages.push({
                     role: "assistant",
                     content: result.text,
@@ -199,16 +225,22 @@ export class Agent {
         }
     }
     async reviewChange(change) {
-        this.hooks.onChange(change, "pending");
+        this.hooks.onChange(change, "pending", this.turnId);
         const ok = await this.hooks.approve({ kind: "change", change });
         if (!ok) {
-            this.hooks.onChange(change, "rejected");
+            this.hooks.onChange(change, "rejected", this.turnId);
             this.hooks.onEntry({ kind: "tool", text: `Rejected edit to ${change.path}` });
             return "User rejected this change. Ask them what they would like instead.";
         }
         const result = await applyChange(change);
-        this.hooks.onChange(change, "applied");
+        this.hooks.onChange(change, "applied", this.turnId);
         this.hooks.onEntry({ kind: "tool", text: result });
-        return result;
+        if (result.startsWith("Failed"))
+            return result;
+        this.hooks.onBusy(`Checking ${change.path} for problems...`);
+        const problems = await this.hooks.checkChange?.(change).catch(() => null);
+        if (problems)
+            this.hooks.onEntry({ kind: "error", text: `New problems in ${change.path}:\n${problems}` });
+        return problems ? `${result}\n\nThis edit introduced problems; fix them:\n${problems}` : result;
     }
 }

package/dist/src/commands/index.js

@@ -63,12 +63,22 @@ export function fileTree(dir = ".", maxDepth = 3) {
     walk(path.resolve(process.cwd(), dir), 1, "");
     return lines.join("\n") || "(empty)";
 }
-function cleanContent(content) {
-    return content
-        .replace(/\\n/g, "\n")
-        .replace(/^```[a-z]*\n/i, "")
-        .replace(/\n```$/g, "")
-        .trim() + "\n";
+/**
+ * Undoes common model mistakes in write_file content without touching real code:
+ * - a whole file sent as one line with literal "\n" escapes (no real newlines at all) is unescaped;
+ *   files that already have real newlines are left alone, so "\n" inside strings and regexes survives
+ * - a whole file wrapped in a markdown code fence is unwrapped
+ * Indentation and blank lines are kept; a final newline is added if missing.
+ */
+export function cleanContent(content) {
+    let text = content;
+    if (!text.includes("\n") && text.includes("\\n")) {
+        text = text.replace(/\\r\\n|\\n/g, "\n").replace(/\\t/g, "\t");
+    }
+    const fenced = text.match(/^\s*```[\w+-]*\r?\n([\s\S]*?)\r?\n```\s*$/);
+    if (fenced)
+        text = fenced[1];
+    return text.endsWith("\n") || text === "" ? text : `${text}\n`;
 }
 async function readOrEmpty(fullPath) {
     try {

package/dist/src/config/index.js

@@ -4,6 +4,7 @@ import path from "path";
 export const NOU_HOME = path.join(os.homedir(), ".nou");
 const CONFIG_PATH = path.join(NOU_HOME, "config.json");
 export const EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+export const AUTO_SAVE = ["delay", "focus", "off"];
 export const DEFAULT_SETTINGS = {
     model: "",
     effort: "high",
@@ -11,15 +12,18 @@ export const DEFAULT_SETTINGS = {
     autoApproveEdits: false,
     autoApproveCommands: false,
     gitContext: true,
+    autoSave: "delay",
+    mouse: true,
     plugins: {},
+    trustedPlugins: {},
 };
 export function loadSettings() {
     try {
         const saved = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
-        return { ...DEFAULT_SETTINGS, ...saved, plugins: { ...saved.plugins } };
+        return { ...DEFAULT_SETTINGS, ...saved, plugins: { ...saved.plugins }, trustedPlugins: { ...saved.trustedPlugins } };
     }
     catch {
-        return { ...DEFAULT_SETTINGS, plugins: {} };
+        return { ...DEFAULT_SETTINGS, plugins: {}, trustedPlugins: {} };
     }
 }
 export function saveSettings(patch) {