notoken-core 1.2.1 → 1.4.0

package/dist/handlers/executor.js

@@ -8,6 +8,7 @@ import { detectLocalPlatform, getPackageForCommand, getInstallCommand } from "..
 import { withSpinner } from "../utils/spinner.js";
 import { analyzeOutput } from "../utils/analysis.js";
 import { smartRead, smartSearch } from "../utils/smartFile.js";
+import { pluginRegistry } from "../plugins/registry.js";
 /**
  * Generic command executor.
  *
@@ -19,6 +20,15 @@ export async function executeIntent(intent) {
     if (!def) {
         throw new Error(`No intent definition found for: ${intent.intent}`);
     }
+    // Plugin beforeExecute hooks — can cancel execution
+    const proceed = await pluginRegistry.runBeforeExecute({
+        intent: intent.intent,
+        fields: intent.fields,
+        rawText: intent.rawText,
+    });
+    if (proceed === false) {
+        return "[cancelled by plugin]";
+    }
     // Fuzzy resolve file paths if needed
     const resolved = await resolveFuzzyFields(intent);
     const fields = resolved.fields;
@@ -121,6 +131,8 @@ export async function executeIntent(intent) {
     if (analysis) {
         result += "\n" + analysis;
     }
+    // Plugin afterExecute hooks
+    await pluginRegistry.runAfterExecute({ intent: intent.intent, fields }, result);
     return result;
 }
 async function executeGitIntent(intentName, fields) {

package/dist/index.d.ts

@@ -45,8 +45,11 @@ export { formatParsedCommand } from "./utils/output.js";
 export { Spinner, withSpinner, progressBar } from "./utils/spinner.js";
 export { createBackup, rollback, listBackups, cleanExpiredBackups, formatBackupList } from "./utils/autoBackup.js";
 export { checkForUpdate, checkForUpdateSync, runUpdate, formatUpdateBanner, type UpdateInfo } from "./utils/updater.js";
+export { detectProviders, formatStatus, goOffline, goOnline, disableLLM, enableLLM, isOfflineMode, isLLMDisabled, recordOfflineCommand, getTokensSaved, formatTokensSaved, formatTokensSavedBrief, saveOnExit, type LLMProvider, type LLMState, } from "./utils/llmManager.js";
 export { logFailure, loadFailures, clearFailures } from "./utils/logger.js";
 export { logUncertainty, loadUncertaintyLog, getUncertaintySummary } from "./nlp/uncertainty.js";
 export { recordHistory, loadHistory, getRecentHistory, searchHistory } from "./context/history.js";
+export { pluginRegistry } from "./plugins/index.js";
+export type { NotokenPlugin, PluginIntent, PluginPlaybook, PluginHooks, LoadedPlugin } from "./plugins/index.js";
 export type { DynamicIntent, ParsedCommand, IntentDef, FieldDef, EnvironmentName } from "./types/intent.js";
 export type { RulePatch, RulePatchChange, FailureLog, RulesConfig } from "./types/rules.js";

package/dist/index.js

@@ -58,7 +58,11 @@ export { Spinner, withSpinner, progressBar } from "./utils/spinner.js";
 export { createBackup, rollback, listBackups, cleanExpiredBackups, formatBackupList } from "./utils/autoBackup.js";
 // ── Updates ──
 export { checkForUpdate, checkForUpdateSync, runUpdate, formatUpdateBanner } from "./utils/updater.js";
+// ── LLM Manager ──
+export { detectProviders, formatStatus, goOffline, goOnline, disableLLM, enableLLM, isOfflineMode, isLLMDisabled, recordOfflineCommand, getTokensSaved, formatTokensSaved, formatTokensSavedBrief, saveOnExit, } from "./utils/llmManager.js";
 // ── Logging ──
 export { logFailure, loadFailures, clearFailures } from "./utils/logger.js";
 export { logUncertainty, loadUncertaintyLog, getUncertaintySummary } from "./nlp/uncertainty.js";
 export { recordHistory, loadHistory, getRecentHistory, searchHistory } from "./context/history.js";
+// ── Plugins ──
+export { pluginRegistry } from "./plugins/index.js";

package/dist/plugins/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Plugin system public API.
+ */
+export { pluginRegistry } from "./registry.js";
+export type { NotokenPlugin, PluginIntent, PluginPlaybook, PluginHooks, PluginAliases, PluginFileHints, LoadedPlugin, } from "./types.js";

package/dist/plugins/index.js

@@ -0,0 +1,4 @@
+/**
+ * Plugin system public API.
+ */
+export { pluginRegistry } from "./registry.js";

package/dist/plugins/registry.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Plugin registry.
+ *
+ * Discovers, loads, validates, and manages plugins.
+ *
+ * Plugin sources (checked in order):
+ * 1. ~/.notoken/plugins/         — local plugins (JS/TS files or directories)
+ * 2. npm: notoken-plugin-*       — installed globally via npm
+ * 3. Built-in plugins            — shipped with notoken-core
+ *
+ * Usage:
+ *   import { pluginRegistry } from "notoken-core";
+ *   await pluginRegistry.loadAll();
+ *   const intents = pluginRegistry.getAllIntents();
+ *   const playbooks = pluginRegistry.getAllPlaybooks();
+ */
+import type { LoadedPlugin } from "./types.js";
+declare class PluginRegistry {
+    private plugins;
+    private loaded;
+    /**
+     * Load all plugins from all sources.
+     */
+    loadAll(): Promise<void>;
+    /**
+     * Load a single plugin by path or module name.
+     */
+    load(nameOrPath: string, source?: "npm" | "local"): Promise<boolean>;
+    /**
+     * Unload a plugin by name.
+     */
+    unload(name: string): Promise<boolean>;
+    /** Get all intents from all plugins + core. */
+    getAllIntents(): Array<{
+        name: string;
+        [k: string]: unknown;
+    }>;
+    /** Get all playbooks from all plugins. */
+    getAllPlaybooks(): Array<{
+        name: string;
+        description: string;
+        steps: Array<{
+            command: string;
+            label: string;
+        }>;
+        _plugin: string;
+    }>;
+    /** Get all service aliases from plugins. */
+    getAllServiceAliases(): Record<string, string[]>;
+    /** Get all environment aliases from plugins. */
+    getAllEnvironmentAliases(): Record<string, string[]>;
+    /** Run all beforeExecute hooks. Returns false if any hook cancels. */
+    runBeforeExecute(intent: {
+        intent: string;
+        fields: Record<string, unknown>;
+        rawText: string;
+    }): Promise<boolean>;
+    /** Run all afterExecute hooks. */
+    runAfterExecute(intent: {
+        intent: string;
+        fields: Record<string, unknown>;
+    }, result: string): Promise<void>;
+    /** Run all onError hooks. */
+    runOnError(intent: {
+        intent: string;
+        fields: Record<string, unknown>;
+    }, error: Error): Promise<void>;
+    /** Run all onUnknown hooks. Returns first non-null result. */
+    runOnUnknown(rawText: string): Promise<{
+        intent: string;
+        fields: Record<string, unknown>;
+        confidence: number;
+    } | null>;
+    /** List all loaded plugins. */
+    list(): LoadedPlugin[];
+    /** Get a plugin by name. */
+    get(name: string): LoadedPlugin | undefined;
+    /** Get count of loaded plugins. */
+    get count(): number;
+    private loadLocalPlugins;
+    private loadNpmPlugins;
+    private validate;
+}
+/** Singleton plugin registry. */
+export declare const pluginRegistry: PluginRegistry;
+export {};

package/dist/plugins/registry.js

@@ -0,0 +1,280 @@
+/**
+ * Plugin registry.
+ *
+ * Discovers, loads, validates, and manages plugins.
+ *
+ * Plugin sources (checked in order):
+ * 1. ~/.notoken/plugins/         — local plugins (JS/TS files or directories)
+ * 2. npm: notoken-plugin-*       — installed globally via npm
+ * 3. Built-in plugins            — shipped with notoken-core
+ *
+ * Usage:
+ *   import { pluginRegistry } from "notoken-core";
+ *   await pluginRegistry.loadAll();
+ *   const intents = pluginRegistry.getAllIntents();
+ *   const playbooks = pluginRegistry.getAllPlaybooks();
+ */
+import { existsSync, readdirSync } from "node:fs";
+import { resolve, join } from "node:path";
+import { execSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { USER_HOME } from "../utils/paths.js";
+const require = createRequire(import.meta.url);
+const PLUGIN_DIR = resolve(USER_HOME, "plugins");
+class PluginRegistry {
+    plugins = new Map();
+    loaded = false;
+    /**
+     * Load all plugins from all sources.
+     */
+    async loadAll() {
+        if (this.loaded)
+            return;
+        this.loaded = true;
+        // 1. Local plugins
+        await this.loadLocalPlugins();
+        // 2. npm global plugins
+        await this.loadNpmPlugins();
+        // Report
+        if (this.plugins.size > 0) {
+            const names = Array.from(this.plugins.keys());
+            console.error(`\x1b[2m[plugins] Loaded ${names.length}: ${names.join(", ")}\x1b[0m`);
+        }
+    }
+    /**
+     * Load a single plugin by path or module name.
+     */
+    async load(nameOrPath, source = "local") {
+        try {
+            let plugin = null;
+            let pluginPath = nameOrPath;
+            // Try CJS require first (works for .js with module.exports), then ESM import
+            try {
+                const mod = require(nameOrPath);
+                plugin = (mod && typeof mod.name === "string") ? mod :
+                    (mod?.default && typeof mod.default.name === "string") ? mod.default : null;
+            }
+            catch {
+                // Fall back to ESM import
+                try {
+                    const mod = await import(nameOrPath);
+                    plugin = (mod.default && typeof mod.default.name === "string" ? mod.default :
+                        typeof mod.name === "string" ? mod :
+                            null);
+                }
+                catch { }
+            }
+            if (!plugin || !plugin.name) {
+                console.error(`[plugins] Invalid plugin (no name): ${nameOrPath}`);
+                return false;
+            }
+            // Validate
+            if (!this.validate(plugin))
+                return false;
+            this.plugins.set(plugin.name, {
+                plugin: plugin,
+                source,
+                path: pluginPath,
+                enabled: true,
+            });
+            // Call onLoad hook
+            if (plugin.hooks?.onLoad) {
+                await plugin.hooks.onLoad();
+            }
+            return true;
+        }
+        catch (err) {
+            console.error(`[plugins] Failed to load ${nameOrPath}: ${err.message}`);
+            return false;
+        }
+    }
+    /**
+     * Unload a plugin by name.
+     */
+    async unload(name) {
+        const loaded = this.plugins.get(name);
+        if (!loaded)
+            return false;
+        if (loaded.plugin.hooks?.onUnload) {
+            await loaded.plugin.hooks.onUnload();
+        }
+        this.plugins.delete(name);
+        return true;
+    }
+    // ── Getters ──
+    /** Get all intents from all plugins + core. */
+    getAllIntents() {
+        const intents = [];
+        for (const { plugin, enabled } of this.plugins.values()) {
+            if (!enabled || !plugin.intents)
+                continue;
+            for (const intent of plugin.intents) {
+                intents.push({
+                    ...intent,
+                    fields: intent.fields ?? {},
+                    execution: intent.execution ?? "local",
+                    requiresConfirmation: intent.requiresConfirmation ?? false,
+                    riskLevel: intent.riskLevel ?? "low",
+                    examples: intent.examples ?? [],
+                    _plugin: plugin.name,
+                });
+            }
+        }
+        return intents;
+    }
+    /** Get all playbooks from all plugins. */
+    getAllPlaybooks() {
+        const playbooks = [];
+        for (const { plugin, enabled } of this.plugins.values()) {
+            if (!enabled || !plugin.playbooks)
+                continue;
+            for (const pb of plugin.playbooks) {
+                playbooks.push({ ...pb, _plugin: plugin.name });
+            }
+        }
+        return playbooks;
+    }
+    /** Get all service aliases from plugins. */
+    getAllServiceAliases() {
+        const aliases = {};
+        for (const { plugin, enabled } of this.plugins.values()) {
+            if (!enabled || !plugin.aliases?.services)
+                continue;
+            for (const [service, aliasList] of Object.entries(plugin.aliases.services)) {
+                aliases[service] = [...(aliases[service] ?? []), ...aliasList];
+            }
+        }
+        return aliases;
+    }
+    /** Get all environment aliases from plugins. */
+    getAllEnvironmentAliases() {
+        const aliases = {};
+        for (const { plugin, enabled } of this.plugins.values()) {
+            if (!enabled || !plugin.aliases?.environments)
+                continue;
+            for (const [env, aliasList] of Object.entries(plugin.aliases.environments)) {
+                aliases[env] = [...(aliases[env] ?? []), ...aliasList];
+            }
+        }
+        return aliases;
+    }
+    /** Run all beforeExecute hooks. Returns false if any hook cancels. */
+    async runBeforeExecute(intent) {
+        for (const { plugin, enabled } of this.plugins.values()) {
+            if (!enabled || !plugin.hooks?.beforeExecute)
+                continue;
+            const result = await plugin.hooks.beforeExecute(intent);
+            if (result === false)
+                return false;
+        }
+        return true;
+    }
+    /** Run all afterExecute hooks. */
+    async runAfterExecute(intent, result) {
+        for (const { plugin, enabled } of this.plugins.values()) {
+            if (!enabled || !plugin.hooks?.afterExecute)
+                continue;
+            try {
+                await plugin.hooks.afterExecute(intent, result);
+            }
+            catch { }
+        }
+    }
+    /** Run all onError hooks. */
+    async runOnError(intent, error) {
+        for (const { plugin, enabled } of this.plugins.values()) {
+            if (!enabled || !plugin.hooks?.onError)
+                continue;
+            try {
+                await plugin.hooks.onError(intent, error);
+            }
+            catch { }
+        }
+    }
+    /** Run all onUnknown hooks. Returns first non-null result. */
+    async runOnUnknown(rawText) {
+        for (const { plugin, enabled } of this.plugins.values()) {
+            if (!enabled || !plugin.hooks?.onUnknown)
+                continue;
+            try {
+                const result = await plugin.hooks.onUnknown(rawText);
+                if (result)
+                    return result;
+            }
+            catch { }
+        }
+        return null;
+    }
+    /** List all loaded plugins. */
+    list() {
+        return Array.from(this.plugins.values());
+    }
+    /** Get a plugin by name. */
+    get(name) {
+        return this.plugins.get(name);
+    }
+    /** Get count of loaded plugins. */
+    get count() {
+        return this.plugins.size;
+    }
+    // ── Private ──
+    async loadLocalPlugins() {
+        if (!existsSync(PLUGIN_DIR))
+            return;
+        const entries = readdirSync(PLUGIN_DIR, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = resolve(PLUGIN_DIR, entry.name);
+            if (entry.isDirectory()) {
+                // Directory plugin — look for index.js or index.mjs
+                const indexPath = [
+                    join(fullPath, "index.js"),
+                    join(fullPath, "index.mjs"),
+                    join(fullPath, "index.cjs"),
+                ].find((p) => existsSync(p));
+                if (indexPath)
+                    await this.load(indexPath, "local");
+            }
+            else if (entry.name.endsWith(".js") || entry.name.endsWith(".mjs")) {
+                await this.load(fullPath, "local");
+            }
+        }
+    }
+    async loadNpmPlugins() {
+        try {
+            const result = execSync("npm list -g --depth=0 --json 2>/dev/null", {
+                encoding: "utf-8",
+                timeout: 10_000,
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+            const parsed = JSON.parse(result);
+            const deps = Object.keys(parsed.dependencies ?? {});
+            for (const dep of deps) {
+                if (dep.startsWith("notoken-plugin-")) {
+                    await this.load(dep, "npm");
+                }
+            }
+        }
+        catch { }
+    }
+    validate(plugin) {
+        if (!plugin.name || typeof plugin.name !== "string") {
+            console.error("[plugins] Plugin missing name");
+            return false;
+        }
+        if (plugin.name.includes(" ") || plugin.name.includes("/")) {
+            console.error(`[plugins] Invalid plugin name: "${plugin.name}" (no spaces or slashes)`);
+            return false;
+        }
+        if (plugin.intents) {
+            for (const intent of plugin.intents) {
+                if (!intent.name || !intent.command) {
+                    console.error(`[plugins] Plugin "${plugin.name}" has intent missing name or command`);
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}
+/** Singleton plugin registry. */
+export const pluginRegistry = new PluginRegistry();

package/dist/plugins/types.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Plugin type definitions.
+ *
+ * A plugin is a plain object that conforms to this interface.
+ * Minimum: { name, intents }
+ * Everything else is optional.
+ */
+export interface PluginIntent {
+    name: string;
+    description: string;
+    synonyms: string[];
+    fields?: Record<string, {
+        type: string;
+        required: boolean;
+        default?: unknown;
+    }>;
+    command: string;
+    execution?: "local" | "remote";
+    requiresConfirmation?: boolean;
+    riskLevel?: "low" | "medium" | "high";
+    allowlist?: string[];
+    examples?: string[];
+}
+export interface PluginPlaybook {
+    name: string;
+    description: string;
+    steps: Array<{
+        command: string;
+        label: string;
+    }>;
+}
+export interface PluginHooks {
+    /** Called before any intent executes. Return false to cancel. */
+    beforeExecute?: (intent: {
+        intent: string;
+        fields: Record<string, unknown>;
+        rawText: string;
+    }) => Promise<boolean | void>;
+    /** Called after any intent executes successfully. */
+    afterExecute?: (intent: {
+        intent: string;
+        fields: Record<string, unknown>;
+    }, result: string) => Promise<void>;
+    /** Called when an intent execution fails. */
+    onError?: (intent: {
+        intent: string;
+        fields: Record<string, unknown>;
+    }, error: Error) => Promise<void>;
+    /** Called when no intent matches. Return a result to handle it, or null to pass. */
+    onUnknown?: (rawText: string) => Promise<{
+        intent: string;
+        fields: Record<string, unknown>;
+        confidence: number;
+    } | null>;
+    /** Called on startup. */
+    onLoad?: () => Promise<void>;
+    /** Called on shutdown. */
+    onUnload?: () => Promise<void>;
+}
+export interface PluginAliases {
+    services?: Record<string, string[]>;
+    environments?: Record<string, string[]>;
+}
+export interface PluginFileHints {
+    [category: string]: {
+        aliases: string[];
+        configs?: Array<{
+            path: string;
+            description: string;
+        }>;
+        logs?: Array<{
+            path: string;
+            description: string;
+        }>;
+    };
+}
+export interface NotokenPlugin {
+    /** Unique plugin name (e.g., "aws", "mycompany", "slack") */
+    name: string;
+    /** Plugin version */
+    version?: string;
+    /** Description */
+    description?: string;
+    /** Author */
+    author?: string;
+    /** New intents this plugin adds */
+    intents?: PluginIntent[];
+    /** New playbooks */
+    playbooks?: PluginPlaybook[];
+    /** Lifecycle hooks */
+    hooks?: PluginHooks;
+    /** New service/environment aliases */
+    aliases?: PluginAliases;
+    /** New file hint locations */
+    fileHints?: PluginFileHints;
+    /** Plugin configuration (user can set via notoken config set plugins.<name>.<key>) */
+    config?: Record<string, unknown>;
+}
+export interface LoadedPlugin {
+    plugin: NotokenPlugin;
+    source: "npm" | "local" | "builtin";
+    path: string;
+    enabled: boolean;
+}

package/dist/plugins/types.js

@@ -0,0 +1,8 @@
+/**
+ * Plugin type definitions.
+ *
+ * A plugin is a plain object that conforms to this interface.
+ * Minimum: { name, intents }
+ * Everything else is optional.
+ */
+export {};

package/dist/utils/config.js

@@ -3,6 +3,7 @@ import { resolve } from "node:path";
 import { RulesConfig } from "../types/rules.js";
 import { IntentsConfig } from "../types/intent.js";
 import { CONFIG_DIR } from "./paths.js";
+import { pluginRegistry } from "../plugins/registry.js";
 let cachedRules = null;
 let cachedIntents = null;
 export function loadRules(forceReload = false) {
@@ -10,6 +11,20 @@ export function loadRules(forceReload = false) {
         return cachedRules;
     const raw = readFileSync(resolve(CONFIG_DIR, "rules.json"), "utf-8");
     cachedRules = RulesConfig.parse(JSON.parse(raw));
+    // Merge plugin aliases into rules
+    const pluginServices = pluginRegistry.getAllServiceAliases();
+    for (const [service, aliases] of Object.entries(pluginServices)) {
+        if (!cachedRules.serviceAliases[service]) {
+            cachedRules.serviceAliases[service] = aliases;
+        }
+        else {
+            for (const alias of aliases) {
+                if (!cachedRules.serviceAliases[service].includes(alias)) {
+                    cachedRules.serviceAliases[service].push(alias);
+                }
+            }
+        }
+    }
     return cachedRules;
 }
 export function loadIntents(forceReload = false) {
@@ -17,6 +32,14 @@ export function loadIntents(forceReload = false) {
         return cachedIntents.intents;
     const raw = readFileSync(resolve(CONFIG_DIR, "intents.json"), "utf-8");
     cachedIntents = IntentsConfig.parse(JSON.parse(raw));
+    // Merge plugin intents
+    const pluginIntents = pluginRegistry.getAllIntents();
+    for (const pi of pluginIntents) {
+        // Don't add duplicates
+        if (!cachedIntents.intents.find((i) => i.name === pi.name)) {
+            cachedIntents.intents.push(pi);
+        }
+    }
     return cachedIntents.intents;
 }
 export function getIntentDef(name) {

package/dist/utils/llmManager.d.ts

@@ -0,0 +1,44 @@
+/**
+ * LLM Manager.
+ *
+ * Manages which LLMs are connected, enabled/disabled, and offline mode.
+ * Also tracks estimated tokens saved by using deterministic mode.
+ *
+ * Commands:
+ *   :status    — show which LLMs are connected
+ *   :offline   — go fully offline (disable all LLMs)
+ *   :online    — re-enable LLMs
+ *   :disable <llm>  — disable a specific LLM
+ *   :enable <llm>   — enable a specific LLM
+ */
+export interface LLMProvider {
+    name: string;
+    type: "cli" | "api" | "local";
+    available: boolean;
+    enabled: boolean;
+    version?: string;
+    model?: string;
+}
+export interface LLMState {
+    offlineMode: boolean;
+    disabled: string[];
+    tokensSaved: number;
+    commandsHandledOffline: number;
+    lastSaved: string;
+}
+export declare function detectProviders(): LLMProvider[];
+export declare function formatStatus(): string;
+export declare function goOffline(): string;
+export declare function goOnline(): string;
+export declare function disableLLM(name: string): string;
+export declare function enableLLM(name: string): string;
+export declare function isOfflineMode(): boolean;
+export declare function isLLMDisabled(name: string): boolean;
+export declare function recordOfflineCommand(): void;
+export declare function getTokensSaved(): {
+    tokens: number;
+    commands: number;
+};
+export declare function formatTokensSaved(): string;
+export declare function formatTokensSavedBrief(): string;
+export declare function saveOnExit(): void;

package/dist/utils/llmManager.js

@@ -0,0 +1,191 @@
+/**
+ * LLM Manager.
+ *
+ * Manages which LLMs are connected, enabled/disabled, and offline mode.
+ * Also tracks estimated tokens saved by using deterministic mode.
+ *
+ * Commands:
+ *   :status    — show which LLMs are connected
+ *   :offline   — go fully offline (disable all LLMs)
+ *   :online    — re-enable LLMs
+ *   :disable <llm>  — disable a specific LLM
+ *   :enable <llm>   — enable a specific LLM
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { execSync } from "node:child_process";
+import { USER_HOME } from "./paths.js";
+const STATE_FILE = resolve(USER_HOME, "llm-state.json");
+const c = {
+    reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+    green: "\x1b[32m", yellow: "\x1b[33m", red: "\x1b[31m", cyan: "\x1b[36m",
+};
+// ─── State Persistence ──────────────────────────────────────────────────────
+function loadState() {
+    try {
+        if (existsSync(STATE_FILE)) {
+            return JSON.parse(readFileSync(STATE_FILE, "utf-8"));
+        }
+    }
+    catch { }
+    return { offlineMode: false, disabled: [], tokensSaved: 0, commandsHandledOffline: 0, lastSaved: new Date().toISOString() };
+}
+function saveState(state) {
+    try {
+        mkdirSync(USER_HOME, { recursive: true });
+        state.lastSaved = new Date().toISOString();
+        writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+    }
+    catch { }
+}
+let state = loadState();
+// ─── Provider Detection ─────────────────────────────────────────────────────
+export function detectProviders() {
+    const providers = [];
+    // Claude CLI
+    const claudeVersion = tryExec("claude --version");
+    providers.push({
+        name: "claude",
+        type: "cli",
+        available: !!claudeVersion,
+        enabled: !state.offlineMode && !state.disabled.includes("claude"),
+        version: claudeVersion ?? undefined,
+    });
+    // Ollama
+    const ollamaVersion = tryExec("ollama --version");
+    let ollamaRunning = false;
+    let ollamaModel;
+    if (ollamaVersion) {
+        try {
+            const tags = tryExec("curl -sf --max-time 1 http://localhost:11434/api/tags");
+            if (tags) {
+                ollamaRunning = true;
+                const parsed = JSON.parse(tags);
+                ollamaModel = parsed.models?.[0]?.name;
+            }
+        }
+        catch { }
+    }
+    providers.push({
+        name: "ollama",
+        type: "local",
+        available: ollamaRunning,
+        enabled: !state.offlineMode && !state.disabled.includes("ollama"),
+        version: ollamaVersion ?? undefined,
+        model: ollamaModel,
+    });
+    // API endpoint
+    const apiEndpoint = process.env.NOTOKEN_LLM_ENDPOINT;
+    providers.push({
+        name: "api",
+        type: "api",
+        available: !!apiEndpoint,
+        enabled: !state.offlineMode && !state.disabled.includes("api") && !!apiEndpoint,
+        version: apiEndpoint ? "configured" : undefined,
+        model: process.env.NOTOKEN_LLM_MODEL,
+    });
+    return providers;
+}
+// ─── Status ─────────────────────────────────────────────────────────────────
+export function formatStatus() {
+    const providers = detectProviders();
+    const lines = [];
+    lines.push(`${c.bold}LLM Status${c.reset}${state.offlineMode ? ` ${c.yellow}[OFFLINE MODE]${c.reset}` : ""}\n`);
+    for (const p of providers) {
+        const icon = p.available && p.enabled ? `${c.green}⬤${c.reset}` :
+            p.available && !p.enabled ? `${c.yellow}⬤${c.reset}` :
+                `${c.dim}○${c.reset}`;
+        const status = p.available && p.enabled ? `${c.green}active${c.reset}` :
+            p.available && !p.enabled ? `${c.yellow}disabled${c.reset}` :
+                `${c.dim}not available${c.reset}`;
+        const detail = [p.version, p.model].filter(Boolean).join(" / ");
+        lines.push(`  ${icon} ${c.bold}${p.name}${c.reset} (${p.type}) — ${status}${detail ? ` ${c.dim}${detail}${c.reset}` : ""}`);
+    }
+    const active = providers.filter(p => p.available && p.enabled);
+    lines.push("");
+    if (active.length > 0) {
+        lines.push(`  ${c.dim}Active chain: ${active.map(p => p.name).join(" → ")}${c.reset}`);
+    }
+    else {
+        lines.push(`  ${c.dim}Running in deterministic mode (no LLM)${c.reset}`);
+    }
+    // Token savings
+    lines.push("");
+    lines.push(`  ${c.cyan}Tokens saved:${c.reset} ~${formatTokens(state.tokensSaved)} (${state.commandsHandledOffline} commands handled offline)`);
+    return lines.join("\n");
+}
+// ─── Controls ───────────────────────────────────────────────────────────────
+export function goOffline() {
+    state.offlineMode = true;
+    saveState(state);
+    return `${c.yellow}Offline mode enabled.${c.reset} All LLM providers disabled. Deterministic engine only.`;
+}
+export function goOnline() {
+    state.offlineMode = false;
+    saveState(state);
+    const providers = detectProviders().filter(p => p.available && p.enabled);
+    return `${c.green}Online mode.${c.reset} Active: ${providers.map(p => p.name).join(", ") || "none detected"}`;
+}
+export function disableLLM(name) {
+    if (!state.disabled.includes(name)) {
+        state.disabled.push(name);
+        saveState(state);
+    }
+    return `${c.yellow}${name} disabled.${c.reset}`;
+}
+export function enableLLM(name) {
+    state.disabled = state.disabled.filter(n => n !== name);
+    saveState(state);
+    return `${c.green}${name} enabled.${c.reset}`;
+}
+export function isOfflineMode() {
+    return state.offlineMode;
+}
+export function isLLMDisabled(name) {
+    return state.offlineMode || state.disabled.includes(name);
+}
+// ─── Token Savings Tracker ──────────────────────────────────────────────────
+// Rough estimate: average LLM call uses ~500 tokens input + ~200 output
+const AVG_TOKENS_PER_CALL = 700;
+export function recordOfflineCommand() {
+    state.commandsHandledOffline++;
+    state.tokensSaved += AVG_TOKENS_PER_CALL;
+    // Save periodically (every 10 commands)
+    if (state.commandsHandledOffline % 10 === 0)
+        saveState(state);
+}
+export function getTokensSaved() {
+    return { tokens: state.tokensSaved, commands: state.commandsHandledOffline };
+}
+export function formatTokensSaved() {
+    const { tokens, commands } = getTokensSaved();
+    if (commands === 0)
+        return "";
+    return `${c.dim}~${formatTokens(tokens)} tokens saved (${commands} commands handled offline)${c.reset}`;
+}
+export function formatTokensSavedBrief() {
+    const { tokens, commands } = getTokensSaved();
+    if (commands === 0)
+        return "";
+    return `${c.dim}Tokens saved: ~${formatTokens(tokens)}${c.reset}`;
+}
+// Save state on exit
+export function saveOnExit() {
+    saveState(state);
+}
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function formatTokens(n) {
+    if (n < 1000)
+        return String(n);
+    if (n < 1_000_000)
+        return `${(n / 1000).toFixed(1)}K`;
+    return `${(n / 1_000_000).toFixed(2)}M`;
+}
+function tryExec(cmd) {
+    try {
+        return execSync(cmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 5000 }).trim() || null;
+    }
+    catch {
+        return null;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "notoken-core",
-  "version": "1.2.1",
+  "version": "1.4.0",
   "description": "Shared engine for notoken — NLP parsing, execution, detection, analysis",
   "type": "module",
   "license": "MIT",