notoken-core 1.6.0 → 1.8.0

package/dist/utils/achievements.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Achievement tracker — gamify CLI usage.
+ *
+ * Tracks milestones and shows achievements when hit:
+ *   "🏆 First Command!" — ran your first command
+ *   "🔥 10 Streak!" — 10 commands in one session
+ *   "🌍 World Traveler" — connected to 5 different servers
+ */
+interface UsageStats {
+    totalCommands: number;
+    sessionCommands: number;
+    uniqueIntents: string[];
+    uniqueServers: string[];
+    firstCommandDate?: string;
+    streakDays: number;
+    lastActiveDate?: string;
+    achievements: string[];
+}
+interface Achievement {
+    id: string;
+    name: string;
+    emoji: string;
+    description: string;
+}
+/**
+ * Record a command execution and check for new achievements.
+ * Returns newly unlocked achievements (if any).
+ */
+export declare function recordCommand(intent: string, environment?: string): Achievement[];
+/** Get all achievements (unlocked and locked). */
+export declare function getAchievements(): Array<Achievement & {
+    unlocked: boolean;
+}>;
+/** Get usage stats for display. */
+export declare function getUsageStats(): UsageStats;
+/** Flush stats to disk. */
+export declare function flushStats(): void;
+export {};

package/dist/utils/achievements.js

@@ -0,0 +1,126 @@
+/**
+ * Achievement tracker — gamify CLI usage.
+ *
+ * Tracks milestones and shows achievements when hit:
+ *   "🏆 First Command!" — ran your first command
+ *   "🔥 10 Streak!" — 10 commands in one session
+ *   "🌍 World Traveler" — connected to 5 different servers
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+const STATS_PATH = resolve(homedir(), ".notoken", "usage-stats.json");
+let _stats = null;
+function loadStats() {
+    if (_stats)
+        return _stats;
+    if (existsSync(STATS_PATH)) {
+        try {
+            _stats = JSON.parse(readFileSync(STATS_PATH, "utf-8"));
+            return _stats;
+        }
+        catch { }
+    }
+    _stats = { totalCommands: 0, sessionCommands: 0, uniqueIntents: [], uniqueServers: [], streakDays: 0, achievements: [] };
+    return _stats;
+}
+function saveStats() {
+    const dir = resolve(STATS_PATH, "..");
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(STATS_PATH, JSON.stringify(loadStats(), null, 2));
+}
+const ACHIEVEMENTS = [
+    { id: "first_command", name: "First Steps", emoji: "🎯", description: "Ran your first command" },
+    { id: "10_commands", name: "Getting Started", emoji: "🚀", description: "Ran 10 commands" },
+    { id: "50_commands", name: "Power User", emoji: "⚡", description: "Ran 50 commands" },
+    { id: "100_commands", name: "Command Master", emoji: "🏆", description: "Ran 100 commands" },
+    { id: "500_commands", name: "Terminal Legend", emoji: "👑", description: "Ran 500 commands" },
+    { id: "1000_commands", name: "CLI God", emoji: "🌟", description: "Ran 1000 commands" },
+    { id: "10_intents", name: "Explorer", emoji: "🗺️", description: "Used 10 different commands" },
+    { id: "25_intents", name: "Versatile", emoji: "🎭", description: "Used 25 different commands" },
+    { id: "50_intents", name: "Jack of All Trades", emoji: "🃏", description: "Used 50 different commands" },
+    { id: "first_server", name: "Remote Access", emoji: "🌐", description: "Connected to a remote server" },
+    { id: "5_servers", name: "World Traveler", emoji: "✈️", description: "Connected to 5 different servers" },
+    { id: "3_day_streak", name: "Consistent", emoji: "🔥", description: "Used notoken 3 days in a row" },
+    { id: "7_day_streak", name: "Dedicated", emoji: "💪", description: "Used notoken 7 days in a row" },
+    { id: "30_day_streak", name: "Unstoppable", emoji: "🏅", description: "Used notoken 30 days in a row" },
+    { id: "night_owl", name: "Night Owl", emoji: "🦉", description: "Used notoken after midnight" },
+    { id: "early_bird", name: "Early Bird", emoji: "🐦", description: "Used notoken before 6 AM" },
+    { id: "first_joke", name: "Comedy Fan", emoji: "😂", description: "Asked for a joke" },
+    { id: "first_image", name: "Artist", emoji: "🎨", description: "Generated an image" },
+];
+/**
+ * Record a command execution and check for new achievements.
+ * Returns newly unlocked achievements (if any).
+ */
+export function recordCommand(intent, environment) {
+    const stats = loadStats();
+    const newAchievements = [];
+    stats.totalCommands++;
+    stats.sessionCommands++;
+    if (!stats.firstCommandDate)
+        stats.firstCommandDate = new Date().toISOString();
+    if (!stats.uniqueIntents.includes(intent))
+        stats.uniqueIntents.push(intent);
+    if (environment && environment !== "local" && environment !== "localhost" && environment !== "dev") {
+        if (!stats.uniqueServers.includes(environment))
+            stats.uniqueServers.push(environment);
+    }
+    // Update streak
+    const today = new Date().toISOString().split("T")[0];
+    if (stats.lastActiveDate) {
+        const last = new Date(stats.lastActiveDate);
+        const diff = Math.floor((Date.now() - last.getTime()) / 86400000);
+        if (diff === 1)
+            stats.streakDays++;
+        else if (diff > 1)
+            stats.streakDays = 1;
+    }
+    else {
+        stats.streakDays = 1;
+    }
+    stats.lastActiveDate = today;
+    // Check achievements
+    const check = (id, condition) => {
+        if (condition && !stats.achievements.includes(id)) {
+            stats.achievements.push(id);
+            const a = ACHIEVEMENTS.find(a => a.id === id);
+            if (a)
+                newAchievements.push(a);
+        }
+    };
+    check("first_command", stats.totalCommands >= 1);
+    check("10_commands", stats.totalCommands >= 10);
+    check("50_commands", stats.totalCommands >= 50);
+    check("100_commands", stats.totalCommands >= 100);
+    check("500_commands", stats.totalCommands >= 500);
+    check("1000_commands", stats.totalCommands >= 1000);
+    check("10_intents", stats.uniqueIntents.length >= 10);
+    check("25_intents", stats.uniqueIntents.length >= 25);
+    check("50_intents", stats.uniqueIntents.length >= 50);
+    check("first_server", stats.uniqueServers.length >= 1);
+    check("5_servers", stats.uniqueServers.length >= 5);
+    check("3_day_streak", stats.streakDays >= 3);
+    check("7_day_streak", stats.streakDays >= 7);
+    check("30_day_streak", stats.streakDays >= 30);
+    check("night_owl", new Date().getHours() >= 0 && new Date().getHours() < 4);
+    check("early_bird", new Date().getHours() >= 4 && new Date().getHours() < 6);
+    check("first_joke", intent === "chat.joke");
+    check("first_image", intent === "ai.generate_image");
+    // Save periodically
+    if (stats.totalCommands % 5 === 0)
+        saveStats();
+    return newAchievements;
+}
+/** Get all achievements (unlocked and locked). */
+export function getAchievements() {
+    const stats = loadStats();
+    return ACHIEVEMENTS.map(a => ({ ...a, unlocked: stats.achievements.includes(a.id) }));
+}
+/** Get usage stats for display. */
+export function getUsageStats() {
+    return { ...loadStats() };
+}
+/** Flush stats to disk. */
+export function flushStats() { saveStats(); }

package/dist/utils/aliases.d.ts

@@ -0,0 +1,5 @@
+export declare function loadAliases(): Record<string, string>;
+export declare function resolveAlias(text: string): string;
+export declare function saveAlias(name: string, command: string): void;
+export declare function removeAlias(name: string): boolean;
+export declare function listAliases(): Record<string, string>;

package/dist/utils/aliases.js

@@ -0,0 +1,39 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { USER_HOME } from "./paths.js";
+const ALIASES_FILE = resolve(USER_HOME, "aliases.json");
+function ensureDir() {
+    if (!existsSync(USER_HOME))
+        mkdirSync(USER_HOME, { recursive: true });
+}
+export function loadAliases() {
+    try {
+        const raw = readFileSync(ALIASES_FILE, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+export function resolveAlias(text) {
+    const aliases = loadAliases();
+    return aliases[text] ?? text;
+}
+export function saveAlias(name, command) {
+    ensureDir();
+    const aliases = loadAliases();
+    aliases[name] = command;
+    writeFileSync(ALIASES_FILE, JSON.stringify(aliases, null, 2) + "\n", "utf-8");
+}
+export function removeAlias(name) {
+    const aliases = loadAliases();
+    if (!(name in aliases))
+        return false;
+    delete aliases[name];
+    ensureDir();
+    writeFileSync(ALIASES_FILE, JSON.stringify(aliases, null, 2) + "\n", "utf-8");
+    return true;
+}
+export function listAliases() {
+    return loadAliases();
+}

package/dist/utils/analysis.js

@@ -8,6 +8,7 @@
  * - Directory: detects project types, file breakdowns
  */
 import { analyzeDirectory as analyzeDirectoryImpl } from "./dirAnalysis.js";
+import { detectLocalPlatform } from "./platform.js";
 function analyzeDirectoryOutput(output) {
     return analyzeDirectoryImpl(output);
 }
@@ -74,6 +75,29 @@ export function analyzeLoad(output) {
     else {
         lines.push(`  ${c.dim}→ Load is stable.${c.reset}`);
     }
+    // Extract top CPU-heavy processes from the output
+    const psLines = output.split("\n").filter(l => /^\S+\s+\d+\s+\d+/.test(l));
+    const heavyProcs = psLines
+        .map(l => {
+        const parts = l.trim().split(/\s+/);
+        const cpu = parseFloat(parts[2]);
+        const mem = parseFloat(parts[3]);
+        const cmd = parts.slice(10).join(" ").replace(/^\/\S+\//, "").split(" ")[0]; // basename
+        return { user: parts[0], pid: parts[1], cpu, mem, cmd };
+    })
+        .filter(p => p.cpu > 5) // Only show processes using >5% CPU
+        .filter((p, i, arr) => arr.findIndex(x => x.pid === p.pid) === i) // Dedup by PID
+        .slice(0, 5);
+    if (heavyProcs.length > 0) {
+        lines.push(`\n  ${c.bold}Heavy processes:${c.reset}`);
+        for (const p of heavyProcs) {
+            const cpuBar = p.cpu > 50 ? c.red : p.cpu > 20 ? c.yellow : c.dim;
+            lines.push(`    ${cpuBar}${p.cpu.toFixed(0)}% CPU${c.reset}  ${p.mem.toFixed(0)}% RAM  ${c.bold}${p.cmd}${c.reset} ${c.dim}(${p.user}, PID ${p.pid})${c.reset}`);
+        }
+    }
+    else if (ratio1 < 0.3) {
+        lines.push(`\n  ${c.green}No heavy processes — system is idle.${c.reset}`);
+    }
     return lines.join("\n");
 }
 export function analyzeDisk(output, specificPath) {
@@ -103,17 +127,24 @@ export function analyzeDisk(output, specificPath) {
         !p.filesystem.startsWith("none") &&
         !p.filesystem.startsWith("rootfs") &&
         p.mountPoint !== "/snap" &&
-        !p.mountPoint.startsWith("/snap/"));
+        !p.mountPoint.startsWith("/snap/") &&
+        !p.mountPoint.includes("docker-desktop/cli-tools") &&
+        !p.filesystem.startsWith("/dev/loop"));
     for (const p of realPartitions) {
-        if (p.usePercent >= 95) {
-            lines.push(`  ${c.red}⚠ CRITICAL: ${p.mountPoint} is ${p.usePercent}% full (${p.available} free)${c.reset}`);
+        // Use absolute free space (GB) for thresholds — percentage is misleading on large drives
+        // e.g. 97% on 2TB = 60GB free (fine), 95% on 100GB = 5GB free (critical)
+        const freeGB = parseFloat(p.available.replace(/[^\d.]/g, ""));
+        const freeUnit = p.available.replace(/[\d.]/g, "").trim().toUpperCase();
+        const freeGBNorm = freeUnit.startsWith("T") ? freeGB * 1024 : freeUnit.startsWith("M") ? freeGB / 1024 : freeGB;
+        if (freeGBNorm < 5) {
+            lines.push(`  ${c.red}⚠ CRITICAL: ${p.mountPoint} has only ${p.available} free (${p.usePercent}% used)${c.reset}`);
             criticalCount++;
         }
-        else if (p.usePercent >= 85) {
-            lines.push(`  ${c.yellow}⚠ WARNING: ${p.mountPoint} is ${p.usePercent}% full (${p.available} free)${c.reset}`);
+        else if (freeGBNorm < 20 && p.usePercent >= 90) {
+            lines.push(`  ${c.yellow}⚠ WARNING: ${p.mountPoint} has ${p.available} free (${p.usePercent}% used)${c.reset}`);
             warningCount++;
         }
-        else if (p.usePercent >= 70) {
+        else if (p.usePercent >= 85) {
             lines.push(`  ${c.dim}  ${p.mountPoint}: ${p.usePercent}% used (${p.available} free)${c.reset}`);
         }
     }
@@ -127,7 +158,29 @@ export function analyzeDisk(output, specificPath) {
         if (warningCount > 0) {
             lines.push(`  ${c.yellow}  ${warningCount} partition(s) approaching full.${c.reset}`);
         }
-        lines.push(`  ${c.dim}  Tip: Run "disk analysis" playbook for detailed breakdown.${c.reset}`);
+        if (criticalCount > 0) {
+            lines.push(`  ${c.yellow}${c.bold}  → Try "free up space" or "disk cleanup" to scan for reclaimable space.${c.reset}`);
+            // WSL-specific: warn about I/O errors and need to restart WSL
+            const platform = detectLocalPlatform();
+            if (platform.isWSL) {
+                const windowsDriveFull = realPartitions.some((p) => {
+                    if (!p.mountPoint.startsWith("/mnt/"))
+                        return false;
+                    const fGB = parseFloat(p.available.replace(/[^\d.]/g, ""));
+                    const fU = p.available.replace(/[\d.]/g, "").trim().toUpperCase();
+                    const freeNorm = fU.startsWith("T") ? fGB * 1024 : fU.startsWith("M") ? fGB / 1024 : fGB;
+                    return freeNorm < 5;
+                });
+                if (windowsDriveFull) {
+                    lines.push(`\n  ${c.red}${c.bold}  ⚠ WSL WARNING:${c.reset} Windows drive is critically full.`);
+                    lines.push(`  ${c.yellow}  WSL shares disk with Windows — I/O errors and instability are likely.${c.reset}`);
+                    lines.push(`  ${c.yellow}  Run "free up space" to clean and optionally restart WSL.${c.reset}`);
+                }
+            }
+        }
+        else {
+            lines.push(`  ${c.dim}  Tip: Run "disk analysis" playbook for detailed breakdown.${c.reset}`);
+        }
     }
     // Highlight largest partitions
     const sorted = [...realPartitions].sort((a, b) => b.usePercent - a.usePercent);
@@ -173,10 +226,10 @@ function findPartitionForPath(partitions, path) {
         "var": ["/var"],
         "log": ["/var/log", "/var"],
         "www": ["/var/www"],
-        "c drive": ["/mnt/c"],
-        "d drive": ["/mnt/d"],
-        "e drive": ["/mnt/e"],
-        "f drive": ["/mnt/f"],
+        "c drive": ["/mnt/c", "C:\\"],
+        "d drive": ["/mnt/d", "D:\\"],
+        "e drive": ["/mnt/e", "E:\\"],
+        "f drive": ["/mnt/f", "F:\\"],
     };
     // Check aliases first
     for (const [alias, paths] of Object.entries(aliases)) {
@@ -199,10 +252,13 @@ function findPartitionForPath(partitions, path) {
     return null;
 }
 function formatPartitionHealth(p) {
-    if (p.usePercent >= 95)
-        return `${c.red}⚠ CRITICAL: ${p.usePercent}% full! Only ${p.available} free on ${p.size} total.${c.reset}`;
-    if (p.usePercent >= 85)
-        return `${c.yellow}⚠ WARNING: ${p.usePercent}% full. ${p.available} free on ${p.size} total.${c.reset}`;
+    const fGB = parseFloat(p.available.replace(/[^\d.]/g, ""));
+    const fU = p.available.replace(/[\d.]/g, "").trim().toUpperCase();
+    const freeNorm = fU.startsWith("T") ? fGB * 1024 : fU.startsWith("M") ? fGB / 1024 : fGB;
+    if (freeNorm < 5)
+        return `${c.red}⚠ CRITICAL: Only ${p.available} free on ${p.size} total (${p.usePercent}% used).${c.reset}`;
+    if (freeNorm < 20 && p.usePercent >= 90)
+        return `${c.yellow}⚠ WARNING: ${p.available} free on ${p.size} total (${p.usePercent}% used).${c.reset}`;
     if (p.usePercent >= 70)
         return `${c.dim}Moderate: ${p.usePercent}% full. ${p.available} free on ${p.size} total.${c.reset}`;
     return `${c.green}✓ Healthy: ${p.usePercent}% used. ${p.available} free on ${p.size} total.${c.reset}`;

package/dist/utils/bookmarks.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Bookmarks — save / list / retrieve / remove named commands.
+ *
+ * Stored in ~/.notoken/bookmarks.json as a simple { name: command } map.
+ */
+/** Save a command under a bookmark name. */
+export declare function saveBookmark(name: string, command: string): void;
+/** List all bookmarks as a formatted string. */
+export declare function listBookmarks(): string;
+/** Get the command for a bookmark (or undefined). */
+export declare function getBookmark(name: string): string | undefined;
+/** Remove a bookmark by name. Returns true if it existed. */
+export declare function removeBookmark(name: string): boolean;

package/dist/utils/bookmarks.js

@@ -0,0 +1,51 @@
+/**
+ * Bookmarks — save / list / retrieve / remove named commands.
+ *
+ * Stored in ~/.notoken/bookmarks.json as a simple { name: command } map.
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { resolve } from "node:path";
+const home = process.env.HOME ?? process.env.USERPROFILE ?? ".";
+const dir = resolve(home, ".notoken");
+const file = resolve(dir, "bookmarks.json");
+function load() {
+    if (!existsSync(file))
+        return {};
+    try {
+        return JSON.parse(readFileSync(file, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function save(data) {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(file, JSON.stringify(data, null, 2), "utf-8");
+}
+/** Save a command under a bookmark name. */
+export function saveBookmark(name, command) {
+    const bk = load();
+    bk[name] = command;
+    save(bk);
+}
+/** List all bookmarks as a formatted string. */
+export function listBookmarks() {
+    const bk = load();
+    const keys = Object.keys(bk);
+    if (keys.length === 0)
+        return "No bookmarks saved.";
+    return keys.map((k) => `  ${k}  →  ${bk[k]}`).join("\n");
+}
+/** Get the command for a bookmark (or undefined). */
+export function getBookmark(name) {
+    return load()[name];
+}
+/** Remove a bookmark by name. Returns true if it existed. */
+export function removeBookmark(name) {
+    const bk = load();
+    if (!(name in bk))
+        return false;
+    delete bk[name];
+    save(bk);
+    return true;
+}

package/dist/utils/browser.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Browser Manager.
+ *
+ * Detects, installs, and launches browser automation engines.
+ *
+ * Priority:
+ *   1. Patchright (patched Playwright — anti-detection)
+ *   2. Playwright
+ *   3. Docker (browserless/chromium container)
+ *   4. System browser (xdg-open / open / start)
+ *
+ * Usage:
+ *   notoken browse <url>
+ *   notoken browse install
+ *   notoken browse status
+ *   "open google.com"
+ *   "take screenshot of example.com"
+ *   "browse to localhost:3000"
+ */
+export type BrowserEngine = "patchright" | "playwright" | "docker" | "system";
+export interface BrowserStatus {
+    engine: BrowserEngine;
+    available: boolean;
+    version?: string;
+    browsersInstalled?: boolean;
+    dockerImage?: string;
+}
+export interface BrowseOptions {
+    url: string;
+    headless?: boolean;
+    screenshot?: boolean;
+    screenshotPath?: string;
+    waitFor?: number;
+    userAgent?: string;
+    viewport?: {
+        width: number;
+        height: number;
+    };
+}
+export interface BrowseResult {
+    engine: BrowserEngine;
+    url: string;
+    title?: string;
+    screenshotPath?: string;
+    error?: string;
+}
+export declare function detectBrowserEngines(): BrowserStatus[];
+/**
+ * Get the best available engine.
+ */
+export declare function getBestEngine(): BrowserStatus | null;
+export interface InstallResult {
+    success: boolean;
+    engine: BrowserEngine;
+    message: string;
+}
+export declare function installBrowserEngine(engine?: BrowserEngine): Promise<InstallResult>;
+/**
+ * Open a URL using the best available engine.
+ */
+export declare function browse(opts: BrowseOptions): Promise<BrowseResult>;
+export declare function normalizeUrl(url: string): string;
+export declare function formatBrowserStatus(engines: BrowserStatus[]): string;
+export declare function stopDockerBrowser(): string;