notoken-core 1.5.1 → 2.0.0

package/dist/utils/commandHistory.js

@@ -0,0 +1,108 @@
+/**
+ * Command History — persistent history with search.
+ *
+ * Stores every command typed in interactive mode.
+ * Supports:
+ *   - History file (~/.notoken/command-history.txt)
+ *   - Search (Ctrl+R style fuzzy search)
+ *   - Recent commands for suggestions
+ *   - Dedup consecutive duplicates
+ */
+import { existsSync, readFileSync, appendFileSync, mkdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+const HISTORY_DIR = resolve(homedir(), ".notoken");
+const HISTORY_FILE = resolve(HISTORY_DIR, "command-history.txt");
+const MAX_HISTORY = 2000;
+let _history = null;
+/** Load history from disk. */
+export function loadHistory() {
+    if (_history)
+        return _history;
+    if (!existsSync(HISTORY_DIR))
+        mkdirSync(HISTORY_DIR, { recursive: true });
+    if (existsSync(HISTORY_FILE)) {
+        _history = readFileSync(HISTORY_FILE, "utf-8")
+            .split("\n")
+            .filter(l => l.trim())
+            .slice(-MAX_HISTORY);
+    }
+    else {
+        _history = [];
+    }
+    return _history;
+}
+/** Add a command to history (dedup consecutive). */
+export function addToHistory(command) {
+    const history = loadHistory();
+    const trimmed = command.trim();
+    if (!trimmed)
+        return;
+    // Don't add if it's the same as the last command
+    if (history.length > 0 && history[history.length - 1] === trimmed)
+        return;
+    // Don't add meta commands
+    if (trimmed.startsWith(":") || trimmed.startsWith("/"))
+        return;
+    history.push(trimmed);
+    // Append to file
+    try {
+        appendFileSync(HISTORY_FILE, trimmed + "\n");
+    }
+    catch { }
+    // Trim in memory if too long
+    if (history.length > MAX_HISTORY) {
+        _history = history.slice(-MAX_HISTORY);
+    }
+}
+/** Search history with fuzzy matching. */
+export function searchHistory(query, limit = 10) {
+    const history = loadHistory();
+    const lower = query.toLowerCase();
+    const matches = [];
+    for (let i = history.length - 1; i >= 0; i--) {
+        const cmd = history[i];
+        const cmdLower = cmd.toLowerCase();
+        if (cmdLower.includes(lower)) {
+            // Exact substring match — higher score for more recent
+            const recency = (i / history.length) * 0.3; // 0-0.3
+            const relevance = lower.length / cmdLower.length; // longer match = better
+            matches.push({ cmd, score: 0.5 + recency + relevance * 0.2 });
+        }
+        else {
+            // Check word overlap
+            const queryWords = lower.split(/\s+/);
+            const cmdWords = new Set(cmdLower.split(/\s+/));
+            const overlap = queryWords.filter(w => cmdWords.has(w)).length;
+            if (overlap > 0) {
+                const score = (overlap / queryWords.length) * 0.4 + (i / history.length) * 0.2;
+                matches.push({ cmd, score });
+            }
+        }
+    }
+    // Dedup and sort by score
+    const seen = new Set();
+    return matches
+        .sort((a, b) => b.score - a.score)
+        .filter(m => { if (seen.has(m.cmd))
+        return false; seen.add(m.cmd); return true; })
+        .slice(0, limit)
+        .map(m => m.cmd);
+}
+/** Get the N most recent unique commands. */
+export function getRecentCommands(limit = 10) {
+    const history = loadHistory();
+    const seen = new Set();
+    const recent = [];
+    for (let i = history.length - 1; i >= 0 && recent.length < limit; i--) {
+        if (!seen.has(history[i])) {
+            seen.add(history[i]);
+            recent.push(history[i]);
+        }
+    }
+    return recent;
+}
+/** Get history for readline (returns copy of array for rl.history). */
+export function getReadlineHistory() {
+    return [...loadHistory()].reverse();
+}

package/dist/utils/completer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Tab-completion for notoken interactive mode.
+ *
+ * Builds a flat list of completable phrases from intents, meta commands,
+ * service aliases, common verbs, and recent history.  Cached and rebuilt
+ * every 60 seconds.
+ */
+/**
+ * Build (or rebuild) the flat list of completable strings.
+ */
+export declare function buildCompletions(): string[];
+/**
+ * Readline-compatible completer function.
+ *
+ * Signature: (line: string) => [matches: string[], line: string]
+ */
+export declare function completeInput(line: string): [string[], string];

package/dist/utils/completer.js

@@ -0,0 +1,79 @@
+/**
+ * Tab-completion for notoken interactive mode.
+ *
+ * Builds a flat list of completable phrases from intents, meta commands,
+ * service aliases, common verbs, and recent history.  Cached and rebuilt
+ * every 60 seconds.
+ */
+import { loadIntents } from "./config.js";
+import { loadRules } from "./config.js";
+import { getRecentHistory } from "../context/history.js";
+// ── Cache ───────────────────────────────────────────────────────────────────
+let cached = [];
+let lastBuilt = 0;
+const CACHE_TTL = 60_000; // 60 s
+const META_COMMANDS = [
+    "/jobs", "/help", "/quit", "/output", "/kill",
+    "/aliases", "/history",
+];
+const COMMON_VERBS = [
+    "restart", "check", "show", "list", "install",
+    "diagnose", "monitor",
+];
+/**
+ * Build (or rebuild) the flat list of completable strings.
+ */
+export function buildCompletions() {
+    const set = new Set();
+    // Meta commands
+    for (const cmd of META_COMMANDS)
+        set.add(cmd);
+    // Common verbs
+    for (const v of COMMON_VERBS)
+        set.add(v);
+    // Intent synonyms
+    try {
+        const intents = loadIntents();
+        for (const intent of intents) {
+            for (const syn of intent.synonyms ?? []) {
+                set.add(syn.toLowerCase());
+            }
+        }
+    }
+    catch { /* config may not be loaded yet */ }
+    // Service alias names
+    try {
+        const rules = loadRules();
+        for (const [service, aliases] of Object.entries(rules.serviceAliases)) {
+            set.add(service);
+            for (const a of aliases)
+                set.add(a.toLowerCase());
+        }
+    }
+    catch { /* rules may not be loaded yet */ }
+    // Recent commands from history
+    try {
+        const recent = getRecentHistory(20);
+        for (const entry of recent) {
+            if (entry.rawText)
+                set.add(entry.rawText);
+        }
+    }
+    catch { /* history may be empty */ }
+    cached = [...set].sort();
+    lastBuilt = Date.now();
+    return cached;
+}
+/**
+ * Readline-compatible completer function.
+ *
+ * Signature: (line: string) => [matches: string[], line: string]
+ */
+export function completeInput(line) {
+    if (Date.now() - lastBuilt > CACHE_TTL || cached.length === 0) {
+        buildCompletions();
+    }
+    const lower = line.toLowerCase();
+    const hits = cached.filter((c) => c.toLowerCase().startsWith(lower));
+    return [hits.length > 0 ? hits : cached, line];
+}

package/dist/utils/config.js

@@ -1,8 +1,8 @@
-import { readFileSync } from "node:fs";
+import { readFileSync, existsSync } from "node:fs";
 import { resolve } from "node:path";
 import { RulesConfig } from "../types/rules.js";
 import { IntentsConfig } from "../types/intent.js";
-import { CONFIG_DIR } from "./paths.js";
+import { CONFIG_DIR, USER_HOME } from "./paths.js";
 import { pluginRegistry } from "../plugins/registry.js";
 let cachedRules = null;
 let cachedIntents = null;
@@ -40,6 +40,36 @@ export function loadIntents(forceReload = false) {
             cachedIntents.intents.push(pi);
         }
     }
+    // Merge user custom intents from ~/.notoken/custom-intents.json
+    const customFile = resolve(USER_HOME, "custom-intents.json");
+    if (existsSync(customFile)) {
+        try {
+            const customRaw = readFileSync(customFile, "utf-8");
+            const customData = JSON.parse(customRaw);
+            const customIntents = customData.intents ?? [];
+            for (const ci of customIntents) {
+                const entry = ci;
+                // Build a full IntentDef with sensible defaults for user-defined intents
+                const def = {
+                    name: entry.name,
+                    description: entry.description ?? "",
+                    synonyms: entry.synonyms ?? [],
+                    fields: entry.fields ?? {},
+                    command: entry.command ?? "",
+                    execution: entry.execution ?? "local",
+                    requiresConfirmation: entry.requiresConfirmation ?? true,
+                    riskLevel: entry.riskLevel ?? "medium",
+                    examples: entry.examples ?? entry.synonyms ?? [],
+                };
+                if (!cachedIntents.intents.find((i) => i.name === def.name)) {
+                    cachedIntents.intents.push(def);
+                }
+            }
+        }
+        catch {
+            // Silently ignore malformed custom intents file
+        }
+    }
     return cachedIntents.intents;
 }
 export function getIntentDef(name) {

package/dist/utils/dbQuery.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Natural language → SQL query builder.
+ *
+ * Translates phrases like:
+ *   "look at items and find sally"        → SELECT * FROM items WHERE ... LIKE '%sally%'
+ *   "show me all users"                   → SELECT * FROM users
+ *   "count orders"                        → SELECT COUNT(*) FROM orders
+ *   "show tables"                         → \dt (postgres) or SHOW TABLES (mysql)
+ *   "describe users table"                → \d users or DESCRIBE users
+ *   "find orders where total > 100"       → SELECT * FROM orders WHERE total > 100
+ */
+export type DbType = "postgres" | "mysql";
+export interface DbQueryResult {
+    query: string;
+    command: string;
+    explanation: string;
+}
+/**
+ * Build a SQL query from natural language.
+ */
+export declare function buildQuery(rawText: string, fields: Record<string, unknown>, dbType?: DbType): DbQueryResult;
+/**
+ * Format query result for display — show the SQL, explain it, then run.
+ */
+export declare function formatQueryPlan(result: DbQueryResult): string;

package/dist/utils/dbQuery.js

@@ -0,0 +1,248 @@
+/**
+ * Natural language → SQL query builder.
+ *
+ * Translates phrases like:
+ *   "look at items and find sally"        → SELECT * FROM items WHERE ... LIKE '%sally%'
+ *   "show me all users"                   → SELECT * FROM users
+ *   "count orders"                        → SELECT COUNT(*) FROM orders
+ *   "show tables"                         → \dt (postgres) or SHOW TABLES (mysql)
+ *   "describe users table"                → \d users or DESCRIBE users
+ *   "find orders where total > 100"       → SELECT * FROM orders WHERE total > 100
+ */
+const c = {
+    reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+    green: "\x1b[32m", yellow: "\x1b[33m", cyan: "\x1b[36m", red: "\x1b[31m",
+};
+/**
+ * Build a SQL query from natural language.
+ */
+export function buildQuery(rawText, fields, dbType = "postgres") {
+    const text = rawText.toLowerCase();
+    const table = fields.table ?? extractTable(text);
+    const search = fields.search ?? extractSearchTerm(text);
+    // "show tables" / "list tables"
+    if (text.match(/show\s+tables|list\s+tables|what\s+tables|which\s+tables/)) {
+        return dbType === "postgres"
+            ? { query: "\\dt", command: buildPsqlCmd(fields, "\\dt"), explanation: "List all tables" }
+            : { query: "SHOW TABLES;", command: buildMysqlCmd(fields, "SHOW TABLES;"), explanation: "List all tables" };
+    }
+    // "describe <table>" / "schema of <table>" / "columns in <table>"
+    const describeMatch = text.match(/describe\s+(\w+)|schema\s+(?:of\s+)?(\w+)|columns\s+(?:in\s+|of\s+)?(\w+)|structure\s+(?:of\s+)?(\w+)/);
+    if (describeMatch) {
+        const t = describeMatch[1] || describeMatch[2] || describeMatch[3] || describeMatch[4];
+        return dbType === "postgres"
+            ? { query: `\\d ${t}`, command: buildPsqlCmd(fields, `\\d ${t}`), explanation: `Describe table ${t}` }
+            : { query: `DESCRIBE ${t};`, command: buildMysqlCmd(fields, `DESCRIBE ${t};`), explanation: `Describe table ${t}` };
+    }
+    // "count <table>"
+    if (text.match(/count|how\s+many/)) {
+        if (table) {
+            const where = extractWhere(text, table);
+            const query = where
+                ? `SELECT COUNT(*) FROM ${table} WHERE ${where};`
+                : `SELECT COUNT(*) FROM ${table};`;
+            return {
+                query,
+                command: dbType === "postgres" ? buildPsqlCmd(fields, query) : buildMysqlCmd(fields, query),
+                explanation: `Count rows in ${table}${where ? ` where ${where}` : ""}`,
+            };
+        }
+    }
+    // Search query: "find sally in items" / "look at items find sally"
+    if (table && search) {
+        const query = `SELECT * FROM ${table} WHERE ${buildSearchWhere(search, table, dbType)} LIMIT 50;`;
+        return {
+            query,
+            command: dbType === "postgres" ? buildPsqlCmd(fields, query) : buildMysqlCmd(fields, query),
+            explanation: `Search ${table} for "${search}"`,
+        };
+    }
+    // Search with no table: "find sally" — search across all tables
+    if (search && !table) {
+        if (dbType === "postgres") {
+            // Build a script that searches all tables for the term
+            const query = buildSearchAllTablesPg(search);
+            return {
+                query,
+                command: buildPsqlCmd(fields, query),
+                explanation: `Search ALL tables for "${search}"`,
+            };
+        }
+        else {
+            const query = buildSearchAllTablesMysql(search, fields.database ?? "");
+            return {
+                query,
+                command: buildMysqlCmd(fields, query),
+                explanation: `Search ALL tables for "${search}"`,
+            };
+        }
+    }
+    // Simple select: "show me <table>" / "list <table>" / "all <table>"
+    if (table) {
+        const where = extractWhere(text, table);
+        const limit = extractLimit(text);
+        const query = where
+            ? `SELECT * FROM ${table} WHERE ${where} LIMIT ${limit};`
+            : `SELECT * FROM ${table} LIMIT ${limit};`;
+        return {
+            query,
+            command: dbType === "postgres" ? buildPsqlCmd(fields, query) : buildMysqlCmd(fields, query),
+            explanation: `Show rows from ${table}${where ? ` where ${where}` : ""}`,
+        };
+    }
+    // Fallback: raw query if it looks like SQL
+    if (text.match(/^(select|insert|update|delete|create|alter|drop)\s/i)) {
+        const query = rawText.trim().endsWith(";") ? rawText.trim() : rawText.trim() + ";";
+        return {
+            query,
+            command: dbType === "postgres" ? buildPsqlCmd(fields, query) : buildMysqlCmd(fields, query),
+            explanation: "Raw SQL query",
+        };
+    }
+    return {
+        query: "",
+        command: "",
+        explanation: "Could not build a query. Try: show tables, describe <table>, or select * from <table>",
+    };
+}
+// ─── Extractors ──────────────────────────────────────────────────────────────
+function extractTable(text) {
+    // "in <table>" / "from <table>" / "the <table> table" / "my <table>"
+    const patterns = [
+        /(?:from|in|at|into)\s+(?:the\s+)?(\w+)\s*(?:table)?/,
+        /(?:my|the|all)\s+(\w+)\s*(?:table)?/,
+        /(?:look\s+at|show|list|query|search|find\s+in)\s+(?:the\s+)?(?:my\s+)?(\w+)/,
+        /(\w+)\s+table/,
+    ];
+    for (const p of patterns) {
+        const match = text.match(p);
+        if (match) {
+            const t = match[1].toLowerCase();
+            // Filter out common non-table words
+            if (!["me", "all", "the", "my", "this", "that", "it", "and", "on", "to", "for", "with", "where", "tables", "database"].includes(t)) {
+                return t;
+            }
+        }
+    }
+    return null;
+}
+function extractSearchTerm(text) {
+    // "find <term>" / "has <term>" / "contains <term>" / "with <term>" / "named <term>"
+    const patterns = [
+        /(?:find|has|contains?|with|named|called|matching|like)\s+(?:the\s+)?['"]?(\w[\w\s]*?)['"]?\s*(?:in|$)/,
+        /(?:find|search\s+for|look\s+for)\s+['"]?(\w[\w\s]*?)['"]?\s*(?:in|from|$)/,
+        /(?:that\s+has|that\s+contains?)\s+['"]?(\w[\w\s]*?)['"]?/,
+        /(?:find\s+(?:the\s+)?(?:one\s+)?(?:that\s+)?(?:has\s+)?)?['"]?(\w+)['"]?\s*$/,
+    ];
+    for (const p of patterns) {
+        const match = text.match(p);
+        if (match) {
+            const term = match[1].trim();
+            if (term && !["it", "them", "the", "one", "that"].includes(term.toLowerCase())) {
+                return term;
+            }
+        }
+    }
+    return null;
+}
+function extractWhere(text, table) {
+    // "where <condition>" — pass through
+    const whereMatch = text.match(/where\s+(.+?)(?:\s+limit|\s*$)/);
+    if (whereMatch)
+        return whereMatch[1].trim();
+    return null;
+}
+function extractLimit(text) {
+    const match = text.match(/(?:limit|top|first|last)\s+(\d+)/);
+    if (match)
+        return parseInt(match[1]);
+    // "show me 20 users" / "10 orders"
+    const numMatch = text.match(/(?:show|list|get)\s+(?:me\s+)?(\d+)/);
+    if (numMatch)
+        return parseInt(numMatch[1]);
+    return 50;
+}
+function buildSearchWhere(search, table, dbType) {
+    const escaped = escapeSql(search);
+    if (dbType === "postgres") {
+        // Cast entire row to text and search — works across all columns
+        return `${table}::text ILIKE '%${escaped}%'`;
+    }
+    // MySQL: search common text column names
+    return `CONCAT_WS(' ', COALESCE(name,''), COALESCE(title,''), COALESCE(email,''), COALESCE(description,''), COALESCE(username,''), COALESCE(first_name,''), COALESCE(last_name,'')) LIKE '%${escaped}%'`;
+}
+/**
+ * Postgres: search all tables for a term.
+ * Casts each row to text and checks with ILIKE.
+ */
+function buildSearchAllTablesPg(search) {
+    const escaped = escapeSql(search);
+    // Use a DO block that iterates through all user tables
+    return `DO $$
+DECLARE
+  r RECORD;
+  tbl TEXT;
+  cnt INTEGER;
+BEGIN
+  FOR r IN SELECT tablename FROM pg_tables WHERE schemaname = 'public' LOOP
+    tbl := r.tablename;
+    EXECUTE format('SELECT COUNT(*) FROM %I WHERE %I::text ILIKE $1', tbl, tbl) INTO cnt USING '%${escaped}%';
+    IF cnt > 0 THEN
+      RAISE NOTICE 'Found % match(es) in table: %', cnt, tbl;
+    END IF;
+  END LOOP;
+END $$;`;
+}
+/**
+ * MySQL: search all tables for a term.
+ */
+function buildSearchAllTablesMysql(search, database) {
+    const escaped = escapeSql(search);
+    // MySQL approach: generate SELECT statements for each table
+    return `SELECT TABLE_NAME, COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = '${database || "DATABASE()"}' AND DATA_TYPE IN ('varchar','text','char','longtext','mediumtext') ORDER BY TABLE_NAME;`;
+}
+function escapeSql(val) {
+    return val.replace(/'/g, "''").replace(/\\/g, "\\\\");
+}
+// ─── Command builders ────────────────────────────────────────────────────────
+function buildPsqlCmd(fields, query) {
+    const db = fields.database ?? "";
+    const host = fields.host ?? "";
+    const user = fields.user ?? "";
+    const parts = ["psql"];
+    if (host)
+        parts.push(`-h ${host}`);
+    if (user)
+        parts.push(`-U ${user}`);
+    if (db)
+        parts.push(db);
+    parts.push(`-c ${JSON.stringify(query)}`);
+    return parts.join(" ");
+}
+function buildMysqlCmd(fields, query) {
+    const db = fields.database ?? "";
+    const host = fields.host ?? "";
+    const user = fields.user ?? "";
+    const parts = ["mysql"];
+    if (host)
+        parts.push(`-h ${host}`);
+    if (user)
+        parts.push(`-u ${user}`);
+    if (db)
+        parts.push(db);
+    parts.push(`-e ${JSON.stringify(query)}`);
+    return parts.join(" ");
+}
+/**
+ * Format query result for display — show the SQL, explain it, then run.
+ */
+export function formatQueryPlan(result) {
+    if (!result.query)
+        return result.explanation;
+    const lines = [];
+    lines.push(`\n${c.bold}${c.cyan}── Query Plan ──${c.reset}\n`);
+    lines.push(`  ${c.bold}SQL:${c.reset}  ${c.green}${result.query}${c.reset}`);
+    lines.push(`  ${c.dim}${result.explanation}${c.reset}`);
+    lines.push(`  ${c.dim}Command: ${result.command}${c.reset}`);
+    return lines.join("\n");
+}

package/dist/utils/discordDiag.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Discord bot diagnostics, setup, and auto-fix.
+ *
+ * `diagnoseDiscord()` — runs full checklist and auto-fixes everything:
+ *   1. Token valid?
+ *   2. Bot in guilds? → auto-invite via patchright
+ *   3. Intents enabled in OpenClaw config? → auto-fix
+ *   4. DM/group policy correct? → auto-fix
+ *   5. OpenClaw version check
+ *   6. Restart gateway if config changed
+ *   7. Poll gateway connection up to 60s
+ *   8. If 4014 error → enable intents via patchright → restart → re-poll
+ *   9. Check channels
+ *  10. Auto-approve pairing codes
+ *  11. Send test message + verify response
+ *
+ * The full chain runs end-to-end without stopping.
+ * User only needs to handle captcha/MFA when patchright prompts.
+ */
+/**
+ * Live Discord connection monitor.
+ * Prints real-time status updates as the gateway connects to Discord.
+ * Auto-restarts if stuck, auto-waits through rate limits.
+ *
+ * Usage: "monitor discord" or "watch discord"
+ */
+export declare function monitorDiscord(maxMinutes?: number): Promise<string>;
+/**
+ * Full Discord diagnostic and auto-fix chain.
+ */
+export declare function diagnoseDiscord(): Promise<string>;
+/**
+ * Quick Discord status check.
+ */
+export declare function quickDiscordCheck(): Promise<string>;