notoken-core 1.0.0 → 1.2.0

package/dist/healing/claudeHealer.d.ts

@@ -12,6 +12,6 @@
  *
  * Usage:
  *   npx tsx src/healing/claudeHealer.ts [--promote] [--dry-run]
- *   MYCLI_LLM_CLI=claude npm run heal:claude
+ *   NOTOKEN_LLM_CLI=claude npm run heal:claude
  */
 export {};

package/dist/healing/claudeHealer.js

@@ -12,7 +12,7 @@
  *
  * Usage:
  *   npx tsx src/healing/claudeHealer.ts [--promote] [--dry-run]
- *   MYCLI_LLM_CLI=claude npm run heal:claude
+ *   NOTOKEN_LLM_CLI=claude npm run heal:claude
  */
 import { execSync, execFileSync } from "node:child_process";
 import { readFileSync, existsSync } from "node:fs";
@@ -34,7 +34,7 @@ async function main() {
         execSync("command -v claude", { stdio: "pipe" });
     }
     catch {
-        console.error(`${c.red}Claude CLI not found. Install it or set MYCLI_LLM_CLI=claude.${c.reset}`);
+        console.error(`${c.red}Claude CLI not found. Install it or set NOTOKEN_LLM_CLI=claude.${c.reset}`);
         process.exit(1);
     }
     // Gather context

package/dist/healing/ruleBuilder.js

@@ -4,14 +4,14 @@ import { RulePatch as RulePatchSchema } from "../types/rules.js";
  * RuleBuilder: asks an LLM to propose new rules from a set of example phrases.
  */
 export async function buildRulesFromExamples(examples) {
-    const endpoint = process.env.MYCLI_LLM_ENDPOINT;
+    const endpoint = process.env.NOTOKEN_LLM_ENDPOINT;
     if (!endpoint) {
-        console.error("Set MYCLI_LLM_ENDPOINT to use the RuleBuilder.");
+        console.error("Set NOTOKEN_LLM_ENDPOINT to use the RuleBuilder.");
         return null;
     }
     const rules = loadRules();
     const intents = loadIntents();
-    const apiKey = process.env.MYCLI_LLM_API_KEY ?? "";
+    const apiKey = process.env.NOTOKEN_LLM_API_KEY ?? "";
     const intentList = intents.map((i) => `- ${i.name}: ${i.description}`).join("\n");
     const prompt = `You are a rule builder for a CLI command parser.
 
@@ -56,7 +56,7 @@ Rules:
                 ...(apiKey ? { Authorization: `Bearer ${apiKey}`, "x-api-key": apiKey } : {}),
             },
             body: JSON.stringify({
-                model: process.env.MYCLI_LLM_MODEL ?? "claude-sonnet-4-20250514",
+                model: process.env.NOTOKEN_LLM_MODEL ?? "claude-sonnet-4-20250514",
                 max_tokens: 1024,
                 messages: [{ role: "user", content: prompt }],
             }),

package/dist/index.d.ts

@@ -44,6 +44,7 @@ export { formatExplain } from "./utils/explain.js";
 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 { logFailure, loadFailures, clearFailures } from "./utils/logger.js";
 export { logUncertainty, loadUncertaintyLog, getUncertaintySummary } from "./nlp/uncertainty.js";
 export { recordHistory, loadHistory, getRecentHistory, searchHistory } from "./context/history.js";

package/dist/index.js

@@ -56,6 +56,8 @@ export { formatParsedCommand } from "./utils/output.js";
 export { Spinner, withSpinner, progressBar } from "./utils/spinner.js";
 // ── Auto-backup ──
 export { createBackup, rollback, listBackups, cleanExpiredBackups, formatBackupList } from "./utils/autoBackup.js";
+// ── Updates ──
+export { checkForUpdate, checkForUpdateSync, runUpdate, formatUpdateBanner } from "./utils/updater.js";
 // ── Logging ──
 export { logFailure, loadFailures, clearFailures } from "./utils/logger.js";
 export { logUncertainty, loadUncertaintyLog, getUncertaintySummary } from "./nlp/uncertainty.js";

package/dist/nlp/llmFallback.d.ts

@@ -2,8 +2,8 @@
  * LLM fallback for unrecognized prompts.
  *
  * ONLY fires when an LLM is actually configured:
- * - MYCLI_LLM_ENDPOINT env var is set (for API), OR
- * - MYCLI_LLM_CLI=claude|chatgpt is set (for CLI tools)
+ * - NOTOKEN_LLM_ENDPOINT env var is set (for API), OR
+ * - NOTOKEN_LLM_CLI=claude|chatgpt is set (for CLI tools)
  *
  * Otherwise returns null immediately — no noise, no "trying fallback" messages.
  */

package/dist/nlp/llmFallback.js

@@ -2,8 +2,8 @@
  * LLM fallback for unrecognized prompts.
  *
  * ONLY fires when an LLM is actually configured:
- * - MYCLI_LLM_ENDPOINT env var is set (for API), OR
- * - MYCLI_LLM_CLI=claude|chatgpt is set (for CLI tools)
+ * - NOTOKEN_LLM_ENDPOINT env var is set (for API), OR
+ * - NOTOKEN_LLM_CLI=claude|chatgpt is set (for CLI tools)
  *
  * Otherwise returns null immediately — no noise, no "trying fallback" messages.
  */
@@ -18,13 +18,13 @@ import { detectLocalPlatform } from "../utils/platform.js";
  * Order: explicit config → auto-detect Ollama → nothing.
  */
 export function isLLMConfigured() {
-    return !!(process.env.MYCLI_LLM_ENDPOINT || process.env.MYCLI_LLM_CLI || detectOllama());
+    return !!(process.env.NOTOKEN_LLM_ENDPOINT || process.env.NOTOKEN_LLM_CLI || detectOllama());
 }
 /** Which LLM backend is active? */
 export function getLLMBackend() {
-    if (process.env.MYCLI_LLM_CLI)
-        return process.env.MYCLI_LLM_CLI;
-    if (process.env.MYCLI_LLM_ENDPOINT)
+    if (process.env.NOTOKEN_LLM_CLI)
+        return process.env.NOTOKEN_LLM_CLI;
+    if (process.env.NOTOKEN_LLM_ENDPOINT)
         return "api";
     if (detectOllama())
         return "ollama";
@@ -56,13 +56,13 @@ export async function llmFallback(rawText, context) {
     if (!isLLMConfigured())
         return null;
     // Try CLI tool if configured
-    if (process.env.MYCLI_LLM_CLI) {
+    if (process.env.NOTOKEN_LLM_CLI) {
         const cliResult = await tryLLMCli(rawText, context);
         if (cliResult)
             return cliResult;
     }
     // Try API endpoint if configured
-    if (process.env.MYCLI_LLM_ENDPOINT) {
+    if (process.env.NOTOKEN_LLM_ENDPOINT) {
         const apiResult = await tryApiEndpoint(rawText, context);
         if (apiResult)
             return apiResult;
@@ -76,7 +76,7 @@ export async function llmFallback(rawText, context) {
     return null;
 }
 async function tryLLMCli(rawText, context) {
-    const cli = process.env.MYCLI_LLM_CLI;
+    const cli = process.env.NOTOKEN_LLM_CLI;
     if (!cli)
         return null;
     try {
@@ -131,11 +131,11 @@ async function tryLLMCli(rawText, context) {
     }
 }
 async function tryApiEndpoint(rawText, context) {
-    const endpoint = process.env.MYCLI_LLM_ENDPOINT;
+    const endpoint = process.env.NOTOKEN_LLM_ENDPOINT;
     if (!endpoint)
         return null;
-    const apiKey = process.env.MYCLI_LLM_API_KEY ?? "";
-    const model = process.env.MYCLI_LLM_MODEL ?? "claude-sonnet-4-20250514";
+    const apiKey = process.env.NOTOKEN_LLM_API_KEY ?? "";
+    const model = process.env.NOTOKEN_LLM_MODEL ?? "claude-sonnet-4-20250514";
     const prompt = buildPrompt(rawText, context);
     try {
         const response = await fetch(endpoint, {
@@ -164,7 +164,7 @@ async function tryApiEndpoint(rawText, context) {
 }
 async function tryOllama(rawText, context) {
     const prompt = buildPrompt(rawText, context);
-    const model = process.env.MYCLI_OLLAMA_MODEL ?? "llama3.2";
+    const model = process.env.NOTOKEN_OLLAMA_MODEL ?? "llama3.2";
     try {
         const response = await fetch("http://localhost:11434/api/generate", {
             method: "POST",

package/dist/nlp/llmParser.d.ts

@@ -3,6 +3,6 @@ import type { DynamicIntent } from "../types/intent.js";
  * LLM-based fallback parser.
  *
  * Sends the raw text + context to an LLM and asks for structured JSON.
- * Set MYCLI_LLM_ENDPOINT and optionally MYCLI_LLM_API_KEY in env.
+ * Set NOTOKEN_LLM_ENDPOINT and optionally NOTOKEN_LLM_API_KEY in env.
  */
 export declare function parseByLLM(rawText: string): Promise<DynamicIntent | null>;

package/dist/nlp/llmParser.js

@@ -5,13 +5,13 @@ import { loadRules } from "../utils/config.js";
  * LLM-based fallback parser.
  *
  * Sends the raw text + context to an LLM and asks for structured JSON.
- * Set MYCLI_LLM_ENDPOINT and optionally MYCLI_LLM_API_KEY in env.
+ * Set NOTOKEN_LLM_ENDPOINT and optionally NOTOKEN_LLM_API_KEY in env.
  */
 export async function parseByLLM(rawText) {
-    const endpoint = process.env.MYCLI_LLM_ENDPOINT;
+    const endpoint = process.env.NOTOKEN_LLM_ENDPOINT;
     if (!endpoint)
         return null;
-    const apiKey = process.env.MYCLI_LLM_API_KEY ?? "";
+    const apiKey = process.env.NOTOKEN_LLM_API_KEY ?? "";
     const rules = loadRules();
     const intents = loadIntents();
     const systemPrompt = buildSystemPrompt(intents, rules);
@@ -24,7 +24,7 @@ export async function parseByLLM(rawText) {
                 ...(apiKey ? { Authorization: `Bearer ${apiKey}`, "x-api-key": apiKey } : {}),
             },
             body: JSON.stringify({
-                model: process.env.MYCLI_LLM_MODEL ?? "claude-sonnet-4-20250514",
+                model: process.env.NOTOKEN_LLM_MODEL ?? "claude-sonnet-4-20250514",
                 max_tokens: 512,
                 messages: [
                     { role: "system", content: systemPrompt },

package/dist/utils/paths.d.ts

@@ -1,14 +1,15 @@
 /**
  * Centralized path resolution.
  *
- * Single source of truth for all directory paths used by mycli.
- * Supports three modes:
- *   1. Development (tsx): src/utils/paths.ts → resolve("../..")
- *   2. npm package: dist/utils/paths.js → resolve("../..")
- *   3. SEA binary: embedded assets, writable dirs in ~/.mycli/
+ * Single source of truth for all directory paths used by notoken.
+ * Everything lives under ~/.notoken/
  *
- * Writable directories (data, logs) always go to ~/.mycli/ so they
- * work in all modes. Config is read-only and ships with the package.
+ * ~/.notoken/
+ *   data/              — history, sessions
+ *   logs/              — failures, uncertainty
+ *   backups/           — auto-backups before file modifications
+ *   conversations/     — conversation persistence
+ *   .update-check.json — update cache
  */
 /** Whether running as a Node.js Single Executable Application */
 export declare function isSEA(): boolean;
@@ -16,7 +17,7 @@ export declare function isSEA(): boolean;
 export declare const PACKAGE_ROOT: string;
 /** Read-only config directory (ships with the package) */
 export declare const CONFIG_DIR: string;
-/** User data root — writable, lives in home directory */
+/** User home — everything writable lives here: ~/.notoken/ */
 export declare const USER_HOME: string;
 /** Writable data directory (history, sessions) */
 export declare const DATA_DIR: string;

package/dist/utils/paths.js

@@ -1,14 +1,15 @@
 /**
  * Centralized path resolution.
  *
- * Single source of truth for all directory paths used by mycli.
- * Supports three modes:
- *   1. Development (tsx): src/utils/paths.ts → resolve("../..")
- *   2. npm package: dist/utils/paths.js → resolve("../..")
- *   3. SEA binary: embedded assets, writable dirs in ~/.mycli/
+ * Single source of truth for all directory paths used by notoken.
+ * Everything lives under ~/.notoken/
  *
- * Writable directories (data, logs) always go to ~/.mycli/ so they
- * work in all modes. Config is read-only and ships with the package.
+ * ~/.notoken/
+ *   data/              — history, sessions
+ *   logs/              — failures, uncertainty
+ *   backups/           — auto-backups before file modifications
+ *   conversations/     — conversation persistence
+ *   .update-check.json — update cache
  */
 import { resolve, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -19,8 +20,6 @@ const __dirname = dirname(__filename);
 /** Whether running as a Node.js Single Executable Application */
 export function isSEA() {
     try {
-        // node:sea module only exists when running as a SEA binary
-        // Use globalThis to check for the injected fuse
         return !!globalThis.__sea_resources__;
     }
     catch {
@@ -31,8 +30,8 @@ export function isSEA() {
 export const PACKAGE_ROOT = resolve(__dirname, "../..");
 /** Read-only config directory (ships with the package) */
 export const CONFIG_DIR = resolve(PACKAGE_ROOT, "config");
-/** User data root — writable, lives in home directory */
-export const USER_HOME = resolve(process.env.MYCLI_DATA_DIR ?? resolve(homedir(), ".mycli"));
+/** User home — everything writable lives here: ~/.notoken/ */
+export const USER_HOME = resolve(process.env.NOTOKEN_HOME ?? resolve(homedir(), ".notoken"));
 /** Writable data directory (history, sessions) */
 export const DATA_DIR = resolve(USER_HOME, "data");
 /** Writable logs directory (failures, uncertainty) */

package/dist/utils/updater.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Update checker.
+ *
+ * Checks notoken.sh/api/version (primary) or npm registry (fallback)
+ * for the latest version. Caches result for 1 hour.
+ *
+ * Used by both CLI (startup banner) and desktop app (badge).
+ */
+export interface UpdateInfo {
+    current: string;
+    latest: string;
+    updateAvailable: boolean;
+    checkedAt: string;
+}
+/**
+ * Check for updates. Returns cached result if fresh.
+ * Non-blocking — never throws, returns null on failure.
+ */
+export declare function checkForUpdate(): Promise<UpdateInfo | null>;
+/**
+ * Synchronous check — reads cache only, no network.
+ * Use this for startup banner (non-blocking).
+ */
+export declare function checkForUpdateSync(): UpdateInfo | null;
+/**
+ * Run the actual update.
+ */
+export declare function runUpdate(): string;
+/**
+ * Format update banner for terminal.
+ */
+export declare function formatUpdateBanner(info: UpdateInfo): string;

package/dist/utils/updater.js

@@ -0,0 +1,157 @@
+/**
+ * Update checker.
+ *
+ * Checks notoken.sh/api/version (primary) or npm registry (fallback)
+ * for the latest version. Caches result for 1 hour.
+ *
+ * Used by both CLI (startup banner) and desktop app (badge).
+ */
+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 CACHE_FILE = resolve(USER_HOME, ".update-check.json");
+const CACHE_TTL = 3600_000; // 1 hour
+const CURRENT_VERSION = getInstalledVersion();
+/**
+ * Check for updates. Returns cached result if fresh.
+ * Non-blocking — never throws, returns null on failure.
+ */
+export async function checkForUpdate() {
+    try {
+        // Check cache first
+        const cached = readCache();
+        if (cached)
+            return cached;
+        // Fetch latest version
+        const latest = await fetchLatestVersion();
+        if (!latest)
+            return null;
+        const info = {
+            current: CURRENT_VERSION,
+            latest,
+            updateAvailable: isNewer(latest, CURRENT_VERSION),
+            checkedAt: new Date().toISOString(),
+        };
+        writeCache(info);
+        return info;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Synchronous check — reads cache only, no network.
+ * Use this for startup banner (non-blocking).
+ */
+export function checkForUpdateSync() {
+    return readCache();
+}
+/**
+ * Run the actual update.
+ */
+export function runUpdate() {
+    try {
+        const result = execSync("npm install -g notoken@latest", {
+            encoding: "utf-8",
+            timeout: 120_000,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        // Clear cache so next check picks up new version
+        clearCache();
+        return result;
+    }
+    catch (err) {
+        throw new Error(`Update failed: ${err instanceof Error ? err.message : err}`);
+    }
+}
+/**
+ * Format update banner for terminal.
+ */
+export function formatUpdateBanner(info) {
+    if (!info.updateAvailable)
+        return "";
+    return `\x1b[33m⬆ Update available: ${info.current} → ${info.latest}\x1b[0m \x1b[2m(notoken update)\x1b[0m`;
+}
+// ─── Internals ──────────────────────────────────────────────────────────────
+async function fetchLatestVersion() {
+    // Try notoken.sh API first
+    try {
+        const response = await fetch("https://notoken.sh/api/version", { signal: AbortSignal.timeout(5000) });
+        if (response.ok) {
+            const data = (await response.json());
+            if (data.version)
+                return data.version;
+        }
+    }
+    catch { }
+    // Fallback: npm registry
+    try {
+        const response = await fetch("https://registry.npmjs.org/notoken/latest", { signal: AbortSignal.timeout(5000) });
+        if (response.ok) {
+            const data = (await response.json());
+            if (data.version)
+                return data.version;
+        }
+    }
+    catch { }
+    // Fallback: npm CLI
+    try {
+        const result = execSync("npm view notoken version", { encoding: "utf-8", timeout: 10_000, stdio: ["pipe", "pipe", "pipe"] });
+        return result.trim() || null;
+    }
+    catch { }
+    return null;
+}
+function getInstalledVersion() {
+    try {
+        // Read from our own package.json
+        const pkg = JSON.parse(execSync("npm list -g notoken --json --depth=0 2>/dev/null", { encoding: "utf-8", timeout: 5000 }));
+        return pkg.dependencies?.notoken?.version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+function isNewer(latest, current) {
+    const l = latest.split(".").map(Number);
+    const c = current.split(".").map(Number);
+    for (let i = 0; i < 3; i++) {
+        if ((l[i] ?? 0) > (c[i] ?? 0))
+            return true;
+        if ((l[i] ?? 0) < (c[i] ?? 0))
+            return false;
+    }
+    return false;
+}
+function readCache() {
+    try {
+        if (!existsSync(CACHE_FILE))
+            return null;
+        const raw = JSON.parse(readFileSync(CACHE_FILE, "utf-8"));
+        const age = Date.now() - new Date(raw.checkedAt).getTime();
+        if (age > CACHE_TTL)
+            return null;
+        // Refresh current version in case user updated
+        raw.current = CURRENT_VERSION;
+        raw.updateAvailable = isNewer(raw.latest, CURRENT_VERSION);
+        return raw;
+    }
+    catch {
+        return null;
+    }
+}
+function writeCache(info) {
+    try {
+        mkdirSync(USER_HOME, { recursive: true });
+        writeFileSync(CACHE_FILE, JSON.stringify(info));
+    }
+    catch { }
+}
+function clearCache() {
+    try {
+        if (existsSync(CACHE_FILE))
+            writeFileSync(CACHE_FILE, "{}");
+    }
+    catch { }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "notoken-core",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Shared engine for notoken — NLP parsing, execution, detection, analysis",
   "type": "module",
   "license": "MIT",
@@ -16,7 +16,10 @@
   "exports": {
     ".": "./dist/index.js"
   },
-  "files": ["dist/", "config/"],
+  "files": [
+    "dist/",
+    "config/"
+  ],
   "scripts": {
     "build": "tsc",
     "test": "vitest run"