@cjhyy/code-shell 0.1.0-alpha.3 → 0.1.5

package/dist/tool-system/context.d.ts

@@ -16,8 +16,37 @@ import type { LLMConfig, StreamCallback } from "../types.js";
 import type { ModelPool } from "../llm/model-pool.js";
 import type { ToolRegistry } from "./registry.js";
 import type { AgentPresetName } from "../preset/index.js";
-/** Function the host UI / server uses to ask the user a question. */
-export type AskUserFn = (question: string) => Promise<string>;
+/** One choice in a multiple-choice AskUserQuestion. */
+export interface AskUserChoice {
+    label: string;
+    description: string;
+}
+/**
+ * Optional rendering hints / multiple-choice options carried alongside the
+ * question. Implementations may ignore unknown fields — they're additive.
+ */
+export interface AskUserOptions {
+    /** Short chip-style label (≤12 chars) shown above the question. */
+    header?: string;
+    /** Multiple-choice options. When omitted, the UI falls back to free-text. */
+    options?: AskUserChoice[];
+    /** Allow the user to pick more than one option. Defaults to false. */
+    multiSelect?: boolean;
+}
+/**
+ * Function the host UI / server uses to ask the user a question.
+ *
+ * Second argument is optional for backwards compatibility — callers that
+ * only need free text can omit it; backends that don't support options
+ * should ignore the field and prompt for free text.
+ *
+ * Return value:
+ *   - Free-text mode: the user's typed answer (or "(user declined to answer)").
+ *   - Multiple-choice mode: the selected label, or comma-separated labels for
+ *     multiSelect, or "Other: <typed>" when the user picks the implicit
+ *     Other... entry.
+ */
+export type AskUserFn = (question: string, opts?: AskUserOptions) => Promise<string>;
 /** Spawn a sub-agent. Returns the produced text or throws. */
 export interface SubAgentSpawnRequest {
     agentId: string;

package/dist/tool-system/executor.d.ts

@@ -7,6 +7,7 @@ import { ToolRegistry } from "./registry.js";
 import { PermissionClassifier } from "./permission.js";
 import { logger as rootLogger } from "../logging/logger.js";
 import type { ToolContext } from "./context.js";
+import type { InvestigationGuard } from "./investigation-guard.js";
 type Logger = typeof rootLogger;
 export declare class ToolExecutor {
     private readonly registry;
@@ -21,7 +22,10 @@ export declare class ToolExecutor {
      * (tests, ad-hoc tool runs) still write log lines, just without turn tags.
      */
     private log;
+    private guard?;
     constructor(registry: ToolRegistry, permission: PermissionClassifier, hooks: HookRegistry);
+    setInvestigationGuard(guard: InvestigationGuard | undefined): void;
+    getInvestigationGuard(): InvestigationGuard | undefined;
     /** Set the abort signal for cascading cancellation. */
     setSignal(signal?: AbortSignal): void;
     /** Set the per-Engine ToolContext (askUser, llmConfig, modelPool, etc.). */

package/dist/tool-system/investigation-guard.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Investigation Guard — runtime enforcement of read budgets.
+ *
+ * Background: prompt rules in coding.md ("never re-read the same file",
+ * "after ~3 read-only calls, change strategy") describe a behavior the model
+ * frequently violates under context pressure. This module turns those soft
+ * rules into in-loop reminders/blocks delivered through tool results.
+ *
+ * Three independent counters share one guard instance per Engine:
+ *   A) dedupe          — same Read offset hit ≥2 times → reminder; ≥3 times → block
+ *   B) read-budget     — N consecutive read-only tools with no side-effecting
+ *                        tool in between → reminder on the next read
+ *   C) silent turns    — N consecutive turns of only read-only tools with no
+ *                        text output → injected into the *next* turn's user
+ *                        message by turn-loop (the guard just tracks state).
+ *
+ * Everything decays naturally on any write/Bash/AskUser tool (state reset).
+ */
+import type { ToolCall, ToolResult } from "../types.js";
+export interface GuardDecision {
+    block?: string;
+    prepend?: string;
+}
+export declare class InvestigationGuard {
+    private readHistory;
+    private consecutiveReads;
+    private silentTurns;
+    private turnHasText;
+    private turnHasSideEffect;
+    private lastReminderSilent;
+    preToolCheck(call: ToolCall): GuardDecision | undefined;
+    noteText(text: string | undefined): void;
+    noteToolResult(_call: ToolCall, _result: ToolResult): void;
+    turnEnded(turnNumber: number): string | undefined;
+    private isMutatingTool;
+    private buildKey;
+}

package/dist/types.d.ts

@@ -65,7 +65,14 @@ export interface TranscriptEvent {
     turnNumber: number;
     data: Record<string, unknown>;
 }
-export type SessionStatus = "active" | "paused" | "completed" | "errored";
+/**
+ * Session lifecycle state persisted in state.json. `"active"` means a run is
+ * currently in flight (or was, at the moment of the last heartbeat). All other
+ * values match the {@link TerminalReason} the last run returned, so callers
+ * can distinguish a user-cancelled session (`"aborted_streaming"`) from an
+ * actual error (`"model_error"`, `"prompt_too_long"`, ...).
+ */
+export type SessionStatus = "active" | "paused" | TerminalReason;
 export interface SessionState {
     sessionId: string;
     cwd: string;
@@ -219,10 +226,14 @@ export type StreamEvent = {
     summary: string;
 } | {
     type: "context_compact";
-    strategy: "summary" | "window" | "snip" | "emergency";
+    strategy: "micro" | "summary" | "window" | "snip" | "emergency";
     before: number;
     after: number;
     agentId?: string;
+} | {
+    type: "usage_update";
+    promptTokens: number;
+    agentId?: string;
 };
 export type StreamCallback = (event: StreamEvent) => void | Promise<void>;
 export interface LLMConfig {

package/dist/ui/components/AskUserPrompt.d.ts

@@ -1,7 +1,14 @@
+interface Choice {
+    label: string;
+    description: string;
+}
 interface AskUserPromptProps {
     question: string;
+    header?: string;
+    options?: Choice[];
+    multiSelect?: boolean;
     onAnswer: (answer: string) => void;
     onCancel: () => void;
 }
-export declare function AskUserPrompt({ question, onAnswer, onCancel }: AskUserPromptProps): import("react/jsx-runtime").JSX.Element;
+export declare function AskUserPrompt({ question, header, options, multiSelect, onAnswer, onCancel, }: AskUserPromptProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/ui/components/DiffLine.d.ts

@@ -0,0 +1,33 @@
+export type DiffKind = "add" | "remove" | "hunk" | "context";
+interface DiffLineProps {
+    kind: DiffKind;
+    /** Raw text WITHOUT the `+ ` / `- ` prefix — DiffLine renders the marker. */
+    text: string;
+    /**
+     * Left indent applied before the marker (and before the gutter, if any).
+     * Defaults to 0; ToolCallResult passes its own padding so diff blocks
+     * line up under the `✓ ToolName` header.
+     */
+    indent?: number;
+    /**
+     * Optional dim leading glyph rendered before the colored band (e.g. the
+     * `⎿ ` connector ToolCallResult uses to group output under its header).
+     * Padding to terminal width accounts for the glyph so the band still
+     * extends to the right edge.
+     */
+    gutter?: string;
+}
+export declare function DiffLine({ kind, text, indent, gutter }: DiffLineProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Classify a raw diff text line. Matches `+\s` / `-\s` (so `+x` identifiers
+ * and `+++ / ---` file headers don't trip it), `@@` hunk markers, and falls
+ * through to context.
+ *
+ * Returns the kind and the text with its marker stripped (since `<DiffLine>`
+ * re-renders the marker itself).
+ */
+export declare function classifyDiffLine(raw: string): {
+    kind: DiffKind;
+    text: string;
+};
+export {};

package/dist/ui/components/ModelManager.d.ts

@@ -15,10 +15,29 @@ export type ArenaParticipantEntry = {
     kind: "object";
     label: string;
 };
+/**
+ * Row data shown in the Providers tab. Counts/timestamps are derived by the
+ * parent from settings.providers[] + the model cache so this component stays
+ * presentational.
+ */
+export interface ProviderManagerEntry {
+    key: string;
+    label: string;
+    kind: string;
+    modelCount: number;
+    cachedModels?: number;
+    cachedAt?: string;
+    baseUrl?: string;
+    apiKey?: string;
+    protocol?: string;
+    modelsPath?: string;
+}
 interface ModelManagerProps {
     entries: ProtocolModelEntry[];
     snapshot: SnapshotInfo;
     arenaParticipants: ArenaParticipantEntry[];
+    /** Providers configured in settings.providers[] (Task 11+). */
+    providers?: ProviderManagerEntry[];
     /** Activate a model. */
     onSwitch: (key: string) => Promise<void>;
     /** Trigger an OpenRouter snapshot refresh. */
@@ -29,7 +48,21 @@ interface ModelManagerProps {
     }>;
     /** Persist updated participant list (string[]) to settings. */
     onSaveArena: (participants: string[]) => Promise<void>;
+    /** Open the parent-rendered ProviderModelFlow (covers both add-provider and add-model). */
+    onOpenFlow?: () => void;
+    /** Force-refresh a provider's cached model list. */
+    onRefreshProvider?: (key: string) => Promise<{
+        count: number;
+        error?: string;
+    }>;
+    /** Delete a provider (blocked if any model references it). */
+    onDeleteProvider?: (key: string) => Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    /** Delete a model entry. */
+    onDeleteModel?: (key: string) => Promise<void>;
     onClose: () => void;
 }
-export declare function ModelManager({ entries, snapshot, arenaParticipants, onSwitch, onSync, onSaveArena, onClose, }: ModelManagerProps): import("react/jsx-runtime").JSX.Element;
+export declare function ModelManager({ entries, snapshot, arenaParticipants, providers, onSwitch, onSync, onSaveArena, onOpenFlow, onRefreshProvider, onDeleteProvider, onDeleteModel, onClose, }: ModelManagerProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/ui/components/OnboardingPrompt.d.ts

@@ -1,7 +1,16 @@
 import { type OnboardingResult } from "../../cli/onboarding.js";
+import type { ProviderConfig } from "../../llm/provider-catalog.js";
 interface OnboardingPromptProps {
     onComplete: (result: OnboardingResult) => void;
     onCancel: () => void;
+    /** Existing providers — surfaces "Use existing" in the flow's first step.
+     *  Optional: empty by default (first-run case). */
+    existingProviders?: ProviderConfig[];
+    /** Existing model aliases — used by the flow to derive unique aliases. */
+    existingModelKeys?: string[];
+    /** Model ids already in settings.models[] — used by the flow to disable
+     *  rows for models the user has already added. */
+    existingModelIds?: string[];
 }
-export declare function OnboardingPrompt({ onComplete, onCancel }: OnboardingPromptProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function OnboardingPrompt({ onComplete, onCancel, existingProviders, existingModelKeys, existingModelIds, }: OnboardingPromptProps): import("react/jsx-runtime").JSX.Element | null;
 export {};

package/dist/ui/components/ProviderModelFlow.d.ts

@@ -0,0 +1,58 @@
+import { type ProviderKindName } from "../../llm/provider-kinds.js";
+import type { ProviderConfig } from "../../llm/provider-catalog.js";
+export interface EnvKeyHint {
+    envKey: string;
+    apiKey: string;
+    kindHint: ProviderKindName;
+}
+export interface FlowResult {
+    addedProvider?: ProviderConfig;
+    /**
+     * Self-describing model entries — credentials are duplicated from the
+     * provider on purpose. The engine reads these without a ProviderCatalog
+     * round-trip; providers[] is kept only as a credential source for the
+     * wizard's future "add model to existing provider" flow.
+     */
+    addedModels: Array<{
+        key: string;
+        label?: string;
+        providerKey: string;
+        /** LLM client/protocol ("openai"/"anthropic"). */
+        protocol: string;
+        /** Legacy mirror of `protocol` for downstream readers that still query it. */
+        provider: string;
+        model: string;
+        baseUrl: string;
+        apiKey?: string;
+        maxContextTokens?: number;
+        maxOutputTokens?: number;
+    }>;
+    activeModelKey?: string;
+}
+export interface ProviderModelFlowProps {
+    existingProviders: ProviderConfig[];
+    existingModelKeys: string[];
+    /**
+     * Model ids (e.g. "deepseek-v4-pro") already present in settings.models[]
+     * under SOME provider. The fetch step uses this to disable rows for
+     * models the user has already added — keeps the menu informative (shows
+     * the full catalog) without letting the user re-add duplicates that
+     * appendOnboardingResult would silently drop.
+     */
+    existingModelIds?: string[];
+    detectedEnvKeys?: EnvKeyHint[];
+    switchToNewModelOnFinish: boolean;
+    onFinish: (r: FlowResult) => void;
+    onCancel: () => void;
+}
+/**
+ * Pool-key generator for wizard-added models. Format is `provider-model` so
+ * the alias self-identifies (e.g. "deepseek-v4-pro", not just "v4-pro" or
+ * "deepseek"). Collisions get a numeric suffix.
+ *
+ * If the model id already starts with `<provider>-`, we don't duplicate.
+ */
+export declare function deriveModelAlias(modelId: string, used: string[], providerKind?: string): string;
+export declare function deriveProviderKey(kindOrUrl: string, used: string[]): string;
+export declare function validateAlias(alias: string, used: string[]): string | null;
+export declare function ProviderModelFlow({ existingProviders, existingModelKeys, existingModelIds, detectedEnvKeys, switchToNewModelOnFinish, onFinish, onCancel, }: ProviderModelFlowProps): import("react/jsx-runtime").JSX.Element;

package/dist/ui/components/UpdateBanner.d.ts

@@ -0,0 +1 @@
+export declare function UpdateBanner(): import("react/jsx-runtime").JSX.Element | null;

package/dist/updater-QW473OF4.cjs

@@ -0,0 +1,17 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+var _chunkR47ROHGLcjs = require('./chunk-R47ROHGL.cjs');
+require('./chunk-KS3RYAYL.cjs');
+
+
+
+
+
+
+
+exports.__internal = _chunkR47ROHGLcjs.__internal; exports.checkForUpdate = _chunkR47ROHGLcjs.checkForUpdate; exports.getAutoUpdateDisabledReason = _chunkR47ROHGLcjs.getAutoUpdateDisabledReason; exports.getCurrentVersion = _chunkR47ROHGLcjs.getCurrentVersion; exports.getUpdateAvailable = _chunkR47ROHGLcjs.getUpdateAvailable; exports.scheduleAutoInstallOnExit = _chunkR47ROHGLcjs.scheduleAutoInstallOnExit;

package/dist/updater-VFUAHCVY.js

@@ -0,0 +1,17 @@
+import {
+  __internal,
+  checkForUpdate,
+  getAutoUpdateDisabledReason,
+  getCurrentVersion,
+  getUpdateAvailable,
+  scheduleAutoInstallOnExit
+} from "./chunk-W22P377T.js";
+import "./chunk-MD32R22I.js";
+export {
+  __internal,
+  checkForUpdate,
+  getAutoUpdateDisabledReason,
+  getCurrentVersion,
+  getUpdateAvailable,
+  scheduleAutoInstallOnExit
+};

package/dist/utils/semver.d.ts

@@ -2,4 +2,5 @@
  * Shim for CC's utils/semver — re-exports semver comparison helpers.
  */
 export declare function gte(a: string, b: string): boolean;
+export declare function gt(a: string, b: string): boolean;
 export declare function lt(a: string, b: string): boolean;

package/dist/utils/task-sanitizer.d.ts

@@ -0,0 +1,6 @@
+export interface NoiseResult {
+    isNoise: boolean;
+    reason: string;
+    cleaned: string;
+}
+export declare function detectPastedNoise(task: string): NoiseResult;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell",
-  "version": "0.1.0-alpha.3",
+  "version": "0.1.5",
   "description": "Code Shell — general-purpose agent orchestration framework with a terminal coding preset",
   "type": "module",
   "main": "./dist/index.cjs",

package/dist/anthropic-P5VETAFI.cjs

@@ -1,10 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-var _chunkBUJ5KYCIcjs = require('./chunk-BUJ5KYCI.cjs');
-require('./chunk-GZBD6QRS.cjs');
-require('./chunk-EL2RL5DG.cjs');
-require('./chunk-JHNCK7JP.cjs');
-require('./chunk-IJSHQGMP.cjs');
-
-
-exports.AnthropicClient = _chunkBUJ5KYCIcjs.AnthropicClient;

package/dist/anthropic-W2GU3D76.js

@@ -1,10 +0,0 @@
-import {
-  AnthropicClient
-} from "./chunk-M2SVOKC6.js";
-import "./chunk-SCDKLTN3.js";
-import "./chunk-FUOKLKR2.js";
-import "./chunk-ZRVPCXI7.js";
-import "./chunk-DI7RDLOS.js";
-export {
-  AnthropicClient
-};

package/dist/chunk-75E4BBFC.js

@@ -1,224 +0,0 @@
-import {
-  init_esm_shims
-} from "./chunk-DI7RDLOS.js";
-
-// src/settings/manager.ts
-init_esm_shims();
-import { readFileSync, existsSync, mkdirSync, writeFileSync, renameSync } from "fs";
-import { join, dirname } from "path";
-import { homedir } from "os";
-
-// src/settings/schema.ts
-init_esm_shims();
-import { z } from "zod";
-var SettingsSchema = z.object({
-  agent: z.object({
-    // Use z.string() instead of z.enum() to allow custom presets registered via registerPreset()
-    preset: z.string().default("terminal-coding"),
-    enabledBuiltinTools: z.array(z.string()).default([]),
-    disabledBuiltinTools: z.array(z.string()).default([]),
-    customSystemPrompt: z.string().optional(),
-    appendSystemPrompt: z.string().optional()
-  }).default({}),
-  model: z.object({
-    provider: z.string().default("openai"),
-    name: z.string().default("anthropic/claude-opus-4-6"),
-    apiKey: z.string().optional(),
-    baseUrl: z.string().default("https://openrouter.ai/api/v1"),
-    temperature: z.number().min(0).max(2).default(0.3),
-    maxTokens: z.number().default(8192)
-  }).default({}),
-  models: z.array(
-    z.object({
-      key: z.string(),
-      label: z.string().optional(),
-      provider: z.string(),
-      model: z.string(),
-      baseUrl: z.string().optional(),
-      apiKey: z.string().optional(),
-      maxOutputTokens: z.number().optional(),
-      maxContextTokens: z.number().optional()
-    })
-  ).default([]),
-  permissions: z.object({
-    defaultMode: z.enum(["default", "acceptEdits", "dontAsk", "bypassPermissions", "auto", "plan"]).default("default"),
-    rules: z.array(
-      z.object({
-        tool: z.string(),
-        argsPattern: z.record(z.string()).optional(),
-        decision: z.enum(["allow", "deny", "ask"]),
-        reason: z.string().optional()
-      })
-    ).default([])
-  }).default({}),
-  context: z.object({
-    maxTokens: z.number().default(2e5),
-    compactAtRatio: z.number().default(0.6),
-    summarizeAtRatio: z.number().default(0.8)
-  }).default({}),
-  session: z.object({
-    storageDir: z.string().optional(),
-    maxHistory: z.number().default(100)
-  }).default({}),
-  mcpServers: z.record(
-    z.object({
-      name: z.string(),
-      command: z.string().optional(),
-      args: z.array(z.string()).optional(),
-      env: z.record(z.string()).optional(),
-      url: z.string().optional(),
-      transport: z.enum(["stdio", "sse", "streamable-http", "inprocess"]).optional(),
-      headers: z.record(z.string()).optional()
-    })
-  ).default({}),
-  instructions: z.object({
-    fileName: z.string().default("CODESHELL.md"),
-    scanDirs: z.array(z.string()).default([]),
-    compatFileNames: z.array(z.string()).default(["CLAUDE.md", "AGENTS.md"]),
-    ignoreGitBoundary: z.boolean().default(false)
-  }).default({}),
-  arena: z.object({
-    participants: z.array(
-      z.union([
-        // Short form: just a model pool key
-        z.string(),
-        // Full form: explicit config (backward compat)
-        z.object({
-          name: z.string(),
-          model: z.string(),
-          provider: z.string().optional(),
-          apiKey: z.string().optional(),
-          baseUrl: z.string().optional()
-        })
-      ])
-    ).default([])
-  }).default({}),
-  search: z.object({
-    provider: z.enum(["serper", "tavily", "searxng"]).default("serper"),
-    apiKey: z.string().optional(),
-    baseUrl: z.string().optional()
-  }).default({}),
-  output: z.object({
-    format: z.enum(["text", "json", "jsonl", "stream-json"]).default("text")
-  }).default({})
-}).passthrough();
-function validateSettings(raw) {
-  return SettingsSchema.parse(raw);
-}
-
-// src/settings/manager.ts
-var SettingsManager = class {
-  constructor(cwd = process.cwd()) {
-    this.cwd = cwd;
-  }
-  sources = [];
-  merged = null;
-  /**
-   * Load settings from all sources.
-   */
-  load(flagOverrides) {
-    this.sources = [];
-    this.loadJsonFile(join(homedir(), ".code-shell", "settings.managed.json"), "managed", 0);
-    this.loadJsonFile(join(homedir(), ".code-shell", "settings.json"), "user", 1);
-    this.loadJsonFile(join(homedir(), ".claude", "settings.json"), "user", 1);
-    this.loadJsonFile(join(this.cwd, ".code-shell", "settings.json"), "project", 2);
-    this.loadJsonFile(join(this.cwd, ".claude", "settings.json"), "project", 2);
-    this.loadJsonFile(join(this.cwd, ".code-shell", "settings.local.json"), "local", 3);
-    this.loadJsonFile(join(this.cwd, ".claude", "settings.local.json"), "local", 3);
-    if (flagOverrides && Object.keys(flagOverrides).length > 0) {
-      this.sources.push({ name: "flag", priority: 4, data: flagOverrides });
-    }
-    this.sources.sort((a, b) => a.priority - b.priority);
-    const raw = this.deepMerge();
-    this.merged = validateSettings(raw);
-    return this.merged;
-  }
-  /**
-   * Get current effective settings.
-   */
-  get() {
-    if (!this.merged) return this.load();
-    return this.merged;
-  }
-  /**
-   * Invalidate cached merge.
-   */
-  invalidate() {
-    this.merged = null;
-  }
-  /**
-   * Persist a single setting (dotted key path) to the user-level config file
-   * at ~/.code-shell/settings.json. Other sources (project / local /
-   * managed) are intentionally untouched: writing back to project/local
-   * would surprise version control, and managed is read-only.
-   *
-   * The merged cache is invalidated so the next get() picks up the change.
-   */
-  saveUserSetting(key, value) {
-    const path = join(homedir(), ".code-shell", "settings.json");
-    let current = {};
-    if (existsSync(path)) {
-      try {
-        const raw = readFileSync(path, "utf-8");
-        const parsed = JSON.parse(raw);
-        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-          current = parsed;
-        }
-      } catch {
-      }
-    }
-    const parts = key.split(".");
-    let target = current;
-    for (let i = 0; i < parts.length - 1; i++) {
-      const seg = parts[i];
-      const next = target[seg];
-      if (!next || typeof next !== "object" || Array.isArray(next)) {
-        target[seg] = {};
-      }
-      target = target[seg];
-    }
-    target[parts[parts.length - 1]] = value;
-    mkdirSync(dirname(path), { recursive: true });
-    const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
-    writeFileSync(tmp, JSON.stringify(current, null, 2), "utf-8");
-    renameSync(tmp, path);
-    this.invalidate();
-  }
-  loadJsonFile(path, name, priority) {
-    if (!existsSync(path)) return;
-    try {
-      const content = readFileSync(path, "utf-8");
-      const data = JSON.parse(content);
-      if (typeof data === "object" && data !== null) {
-        this.sources.push({ name, priority, data });
-      }
-    } catch {
-    }
-  }
-  deepMerge() {
-    let result = {};
-    for (const source of this.sources) {
-      result = merge(result, source.data);
-    }
-    return result;
-  }
-};
-function merge(base, override) {
-  const result = { ...base };
-  for (const [key, value] of Object.entries(override)) {
-    if (value === null) {
-      delete result[key];
-    } else if (typeof value === "object" && !Array.isArray(value) && typeof result[key] === "object" && !Array.isArray(result[key]) && result[key] !== null) {
-      result[key] = merge(result[key], value);
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-
-export {
-  SettingsSchema,
-  validateSettings,
-  SettingsManager
-};