notoken-core 1.0.0

package/dist/nlp/fuzzyResolver.js

@@ -0,0 +1,108 @@
+import { runRemoteCommand, runLocalCommand } from "../execution/ssh.js";
+import { getIntentDef } from "../utils/config.js";
+/**
+ * Fuzzy file resolver.
+ *
+ * When an intent has fuzzyResolve fields, this attempts to find the actual
+ * file path on the target server using a combination of:
+ * - exact match
+ * - find by filename
+ * - find by partial name (fuzzy)
+ * - locate database
+ *
+ * Returns the intent with resolved file paths in the fields.
+ */
+export async function resolveFuzzyFields(intent) {
+    const def = getIntentDef(intent.intent);
+    if (!def?.fuzzyResolve || def.fuzzyResolve.length === 0)
+        return intent;
+    const env = intent.fields.environment ?? "dev";
+    const execution = def.execution;
+    const fields = { ...intent.fields };
+    for (const fieldName of def.fuzzyResolve) {
+        const rawValue = fields[fieldName];
+        if (!rawValue)
+            continue;
+        // If it already looks like an absolute path, keep it
+        if (rawValue.startsWith("/"))
+            continue;
+        const resolved = await fuzzyFindFile(rawValue, env, execution);
+        if (resolved) {
+            fields[fieldName] = resolved;
+        }
+    }
+    return { ...intent, fields };
+}
+async function fuzzyFindFile(filename, environment, execution) {
+    const run = execution === "local" ? runLocalCommand : (cmd) => runRemoteCommand(environment, cmd);
+    // Strategy 1: find by exact name in common locations
+    const searchPaths = ["/etc", "/var/log", "/var", "/srv", "/opt", "/tmp", "/root", "/home"];
+    const findCmd = `find ${searchPaths.join(" ")} -maxdepth 4 -name '${sanitizeForShell(filename)}' 2>/dev/null | head -10`;
+    try {
+        const result = (await run(findCmd)).trim();
+        if (result) {
+            const matches = result.split("\n").filter(Boolean);
+            if (matches.length === 1)
+                return matches[0];
+            if (matches.length > 1) {
+                // Return best match — prefer shorter path (closer to root of search)
+                return rankMatches(filename, matches);
+            }
+        }
+    }
+    catch { }
+    // Strategy 2: fuzzy — find by partial name
+    const baseName = filename.replace(/\.[^.]+$/, ""); // strip extension
+    const fuzzyCmd = `find ${searchPaths.join(" ")} -maxdepth 4 -iname '*${sanitizeForShell(baseName)}*' 2>/dev/null | head -10`;
+    try {
+        const result = (await run(fuzzyCmd)).trim();
+        if (result) {
+            const matches = result.split("\n").filter(Boolean);
+            if (matches.length > 0) {
+                return rankMatches(filename, matches);
+            }
+        }
+    }
+    catch { }
+    // Strategy 3: locate (if available)
+    try {
+        const result = (await run(`locate -i '${sanitizeForShell(filename)}' 2>/dev/null | head -10`)).trim();
+        if (result) {
+            const matches = result.split("\n").filter(Boolean);
+            if (matches.length > 0) {
+                return rankMatches(filename, matches);
+            }
+        }
+    }
+    catch { }
+    return null;
+}
+/**
+ * Rank file path matches by similarity to the query.
+ * Prefers: exact basename match > shorter path > alphabetical
+ */
+function rankMatches(query, matches) {
+    const queryLower = query.toLowerCase();
+    const scored = matches.map((m) => {
+        const basename = m.split("/").pop()?.toLowerCase() ?? "";
+        let score = 0;
+        // Exact basename match
+        if (basename === queryLower)
+            score += 100;
+        // Basename starts with query
+        else if (basename.startsWith(queryLower))
+            score += 50;
+        // Basename contains query
+        else if (basename.includes(queryLower))
+            score += 25;
+        // Prefer shorter paths (more specific location)
+        score -= m.split("/").length;
+        return { path: m, score };
+    });
+    scored.sort((a, b) => b.score - a.score);
+    return scored[0].path;
+}
+function sanitizeForShell(value) {
+    // Strip anything that isn't alphanumeric, dot, dash, underscore, star
+    return value.replace(/[^a-zA-Z0-9._*\-]/g, "");
+}

package/dist/nlp/llmFallback.d.ts

@@ -0,0 +1,63 @@
+/**
+ * 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)
+ *
+ * Otherwise returns null immediately — no noise, no "trying fallback" messages.
+ */
+export interface LLMFallbackResult {
+    understood: boolean;
+    restatement: string;
+    suggestedIntents: Array<{
+        intent: string;
+        fields: Record<string, unknown>;
+        confidence: number;
+        reasoning: string;
+    }>;
+    todoSteps?: Array<{
+        step: number;
+        description: string;
+        intent?: string;
+        command?: string;
+    }>;
+    missingInfo?: string[];
+}
+/**
+ * Check if any LLM is configured.
+ */
+/**
+ * Check if any LLM is available.
+ * Order: explicit config → auto-detect Ollama → nothing.
+ */
+export declare function isLLMConfigured(): boolean;
+/** Which LLM backend is active? */
+export declare function getLLMBackend(): string | null;
+/**
+ * Ask the LLM to interpret an unrecognized prompt.
+ * Returns null immediately if no LLM is available.
+ *
+ * Priority: CLI (claude/chatgpt) → API endpoint → Ollama (local) → null
+ */
+export declare function llmFallback(rawText: string, context: {
+    recentIntents?: string[];
+    knownEntities?: Array<{
+        entity: string;
+        type: string;
+    }>;
+    uncertainTokens?: string[];
+}): Promise<LLMFallbackResult | null>;
+/**
+ * Check if Ollama is installed (not just running).
+ * Used by doctor and interactive mode to offer installation.
+ */
+export declare function isOllamaInstalled(): boolean;
+/**
+ * Check if Ollama has any models pulled.
+ */
+export declare function getOllamaModels(): Promise<string[]>;
+/**
+ * Format an LLM fallback result for display.
+ */
+export declare function formatLLMFallback(result: LLMFallbackResult): string;

package/dist/nlp/llmFallback.js

@@ -0,0 +1,338 @@
+/**
+ * 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)
+ *
+ * Otherwise returns null immediately — no noise, no "trying fallback" messages.
+ */
+import { execSync } from "node:child_process";
+import { loadIntents } from "../utils/config.js";
+import { detectLocalPlatform } from "../utils/platform.js";
+/**
+ * Check if any LLM is configured.
+ */
+/**
+ * Check if any LLM is available.
+ * Order: explicit config → auto-detect Ollama → nothing.
+ */
+export function isLLMConfigured() {
+    return !!(process.env.MYCLI_LLM_ENDPOINT || process.env.MYCLI_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)
+        return "api";
+    if (detectOllama())
+        return "ollama";
+    return null;
+}
+let ollamaChecked = false;
+let ollamaAvailable = false;
+function detectOllama() {
+    if (ollamaChecked)
+        return ollamaAvailable;
+    ollamaChecked = true;
+    try {
+        execSync("command -v ollama", { timeout: 1000, stdio: "pipe" });
+        execSync("curl -sf --max-time 1 http://localhost:11434/api/tags >/dev/null 2>&1", { timeout: 2000, stdio: "pipe" });
+        ollamaAvailable = true;
+    }
+    catch {
+        ollamaAvailable = false;
+    }
+    return ollamaAvailable;
+}
+/**
+ * Ask the LLM to interpret an unrecognized prompt.
+ * Returns null immediately if no LLM is available.
+ *
+ * Priority: CLI (claude/chatgpt) → API endpoint → Ollama (local) → null
+ */
+export async function llmFallback(rawText, context) {
+    if (!isLLMConfigured())
+        return null;
+    // Try CLI tool if configured
+    if (process.env.MYCLI_LLM_CLI) {
+        const cliResult = await tryLLMCli(rawText, context);
+        if (cliResult)
+            return cliResult;
+    }
+    // Try API endpoint if configured
+    if (process.env.MYCLI_LLM_ENDPOINT) {
+        const apiResult = await tryApiEndpoint(rawText, context);
+        if (apiResult)
+            return apiResult;
+    }
+    // Try Ollama (auto-detected local)
+    if (detectOllama()) {
+        const ollamaResult = await tryOllama(rawText, context);
+        if (ollamaResult)
+            return ollamaResult;
+    }
+    return null;
+}
+async function tryLLMCli(rawText, context) {
+    const cli = process.env.MYCLI_LLM_CLI;
+    if (!cli)
+        return null;
+    try {
+        const { execSync } = await import("node:child_process");
+        const prompt = buildPrompt(rawText, context);
+        let cmd;
+        if (cli === "claude") {
+            execSync("command -v claude", { stdio: "pipe" });
+            cmd = `claude -p ${JSON.stringify(prompt)} --output-format json --max-turns 1 --no-session-persistence`;
+        }
+        else if (cli === "chatgpt") {
+            execSync("command -v chatgpt", { stdio: "pipe" });
+            cmd = `chatgpt ${JSON.stringify(prompt)}`;
+        }
+        else {
+            return null;
+        }
+        const rawResult = execSync(cmd, {
+            encoding: "utf-8",
+            timeout: 60_000,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        // Claude CLI --output-format json wraps the response; extract the text content
+        let result = rawResult;
+        try {
+            const parsed = JSON.parse(rawResult);
+            // Claude CLI json format: { result: "...", ... } or { content: [{text: "..."}] }
+            if (parsed.result && typeof parsed.result === "string") {
+                result = parsed.result;
+            }
+            else if (Array.isArray(parsed)) {
+                // Array of messages — find the assistant message
+                const assistant = parsed.find((m) => m.role === "assistant");
+                if (assistant?.content) {
+                    if (typeof assistant.content === "string")
+                        result = assistant.content;
+                    else if (Array.isArray(assistant.content)) {
+                        const textBlock = assistant.content.find((b) => b.type === "text");
+                        if (textBlock?.text)
+                            result = textBlock.text;
+                    }
+                }
+            }
+        }
+        catch {
+            // Not JSON — use as-is (text mode fallback)
+        }
+        return parseResponse(result);
+    }
+    catch {
+        return null;
+    }
+}
+async function tryApiEndpoint(rawText, context) {
+    const endpoint = process.env.MYCLI_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 prompt = buildPrompt(rawText, context);
+    try {
+        const response = await fetch(endpoint, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(apiKey ? { Authorization: `Bearer ${apiKey}`, "x-api-key": apiKey } : {}),
+            },
+            body: JSON.stringify({
+                model,
+                max_tokens: 1024,
+                messages: [{ role: "user", content: prompt }],
+            }),
+        });
+        if (!response.ok)
+            return null;
+        const data = (await response.json());
+        const content = extractContent(data);
+        if (!content)
+            return null;
+        return parseResponse(content);
+    }
+    catch {
+        return null;
+    }
+}
+async function tryOllama(rawText, context) {
+    const prompt = buildPrompt(rawText, context);
+    const model = process.env.MYCLI_OLLAMA_MODEL ?? "llama3.2";
+    try {
+        const response = await fetch("http://localhost:11434/api/generate", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                model,
+                prompt,
+                stream: false,
+                options: { temperature: 0.1, num_predict: 1024 },
+            }),
+        });
+        if (!response.ok)
+            return null;
+        const data = (await response.json());
+        const text = data.response;
+        if (!text)
+            return null;
+        return parseResponse(text);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if Ollama is installed (not just running).
+ * Used by doctor and interactive mode to offer installation.
+ */
+export function isOllamaInstalled() {
+    try {
+        const { execSync } = require("node:child_process");
+        execSync("command -v ollama", { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if Ollama has any models pulled.
+ */
+export async function getOllamaModels() {
+    try {
+        const response = await fetch("http://localhost:11434/api/tags");
+        if (!response.ok)
+            return [];
+        const data = (await response.json());
+        return (data.models ?? []).map((m) => m.name);
+    }
+    catch {
+        return [];
+    }
+}
+function buildPrompt(rawText, context) {
+    const intents = loadIntents();
+    const intentSummary = intents.map((i) => {
+        const fields = Object.entries(i.fields)
+            .map(([k, v]) => `${k}:${v.type}${v.required ? "*" : ""}`)
+            .join(", ");
+        return `  ${i.name}: ${i.description} [${fields}]`;
+    }).join("\n");
+    const platform = detectLocalPlatform();
+    return `You are a server operations CLI assistant. The user said something I couldn't parse with my rule-based system.
+
+ENVIRONMENT:
+  OS: ${platform.distro}${platform.isWSL ? " (WSL)" : ""}
+  Kernel: ${platform.kernel}
+  Arch: ${platform.arch}
+  Shell: ${platform.shell}
+  Package manager: ${platform.packageManager}
+  Init system: ${platform.initSystem}
+
+USER INPUT: "${rawText}"
+
+CONTEXT:
+${JSON.stringify(context, null, 2)}
+
+AVAILABLE INTENTS (these are the tools I can execute):
+${intentSummary}
+
+Respond with ONLY a JSON object:
+{
+  "understood": true/false,
+  "restatement": "In plain English, what the user wants to do",
+  "suggestedIntents": [
+    {
+      "intent": "intent.name from list above",
+      "fields": { "field": "value" },
+      "confidence": 0.0-1.0,
+      "reasoning": "why this intent"
+    }
+  ],
+  "todoSteps": [
+    { "step": 1, "description": "what to do first", "intent": "optional intent name" }
+  ],
+  "missingInfo": ["things I'd need to ask the user"]
+}
+
+Return ONLY JSON.`;
+}
+function parseResponse(raw) {
+    try {
+        const json = JSON.parse(raw.trim());
+        if (json.understood !== undefined)
+            return json;
+    }
+    catch { }
+    const match = raw.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (match) {
+        try {
+            return JSON.parse(match[1].trim());
+        }
+        catch { }
+    }
+    const jsonMatch = raw.match(/\{[\s\S]*"understood"[\s\S]*\}/);
+    if (jsonMatch) {
+        try {
+            return JSON.parse(jsonMatch[0]);
+        }
+        catch { }
+    }
+    return null;
+}
+function extractContent(data) {
+    if (data.choices && Array.isArray(data.choices)) {
+        const msg = data.choices[0]?.message;
+        if (msg?.content && typeof msg.content === "string")
+            return msg.content;
+    }
+    if (data.content && Array.isArray(data.content)) {
+        const block = data.content[0];
+        if (block?.text && typeof block.text === "string")
+            return block.text;
+    }
+    if (typeof data.result === "string")
+        return data.result;
+    return null;
+}
+/**
+ * Format an LLM fallback result for display.
+ */
+export function formatLLMFallback(result) {
+    const c = { reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m", cyan: "\x1b[36m", yellow: "\x1b[33m", green: "\x1b[32m" };
+    const lines = [];
+    lines.push(`${c.bold}${c.cyan}LLM Interpretation:${c.reset}`);
+    lines.push(`  ${result.restatement}`);
+    if (result.suggestedIntents.length > 0) {
+        lines.push(`\n${c.bold}Suggested actions:${c.reset}`);
+        for (const s of result.suggestedIntents) {
+            const conf = (s.confidence * 100).toFixed(0);
+            lines.push(`  ${c.green}${s.intent}${c.reset} (${conf}%) — ${s.reasoning}`);
+            const fields = Object.entries(s.fields);
+            if (fields.length > 0) {
+                lines.push(`    ${fields.map(([k, v]) => `${k}=${v}`).join(", ")}`);
+            }
+        }
+    }
+    if (result.todoSteps && result.todoSteps.length > 0) {
+        lines.push(`\n${c.bold}Plan:${c.reset}`);
+        for (const step of result.todoSteps) {
+            const intent = step.intent ? ` ${c.dim}[${step.intent}]${c.reset}` : "";
+            lines.push(`  ${c.cyan}${step.step}.${c.reset} ${step.description}${intent}`);
+        }
+    }
+    if (result.missingInfo && result.missingInfo.length > 0) {
+        lines.push(`\n${c.yellow}Need more info:${c.reset}`);
+        for (const q of result.missingInfo) {
+            lines.push(`  ? ${q}`);
+        }
+    }
+    return lines.join("\n");
+}

package/dist/nlp/llmParser.d.ts

@@ -0,0 +1,8 @@
+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.
+ */
+export declare function parseByLLM(rawText: string): Promise<DynamicIntent | null>;

package/dist/nlp/llmParser.js

@@ -0,0 +1,118 @@
+import { DynamicIntent as DynamicIntentSchema } from "../types/intent.js";
+import { loadIntents } from "../utils/config.js";
+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.
+ */
+export async function parseByLLM(rawText) {
+    const endpoint = process.env.MYCLI_LLM_ENDPOINT;
+    if (!endpoint)
+        return null;
+    const apiKey = process.env.MYCLI_LLM_API_KEY ?? "";
+    const rules = loadRules();
+    const intents = loadIntents();
+    const systemPrompt = buildSystemPrompt(intents, rules);
+    const userPrompt = `Parse this command into structured intent JSON:\n\n"${rawText}"`;
+    try {
+        const response = await fetch(endpoint, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(apiKey ? { Authorization: `Bearer ${apiKey}`, "x-api-key": apiKey } : {}),
+            },
+            body: JSON.stringify({
+                model: process.env.MYCLI_LLM_MODEL ?? "claude-sonnet-4-20250514",
+                max_tokens: 512,
+                messages: [
+                    { role: "system", content: systemPrompt },
+                    { role: "user", content: userPrompt },
+                ],
+            }),
+        });
+        if (!response.ok)
+            return null;
+        const data = (await response.json());
+        const content = extractContent(data);
+        if (!content)
+            return null;
+        const json = extractJSON(content);
+        if (!json)
+            return null;
+        // Reshape LLM output into DynamicIntent
+        const intent = json.intent;
+        const confidence = json.confidence;
+        const fields = {};
+        for (const [k, v] of Object.entries(json)) {
+            if (!["intent", "confidence", "rawText"].includes(k)) {
+                fields[k] = v;
+            }
+        }
+        const parsed = DynamicIntentSchema.safeParse({ intent, confidence, rawText, fields });
+        if (!parsed.success)
+            return null;
+        return parsed.data;
+    }
+    catch {
+        return null;
+    }
+}
+function buildSystemPrompt(intents, rules) {
+    const intentList = intents
+        .map((i) => {
+        const fields = Object.entries(i.fields)
+            .map(([k, v]) => `${k}(${v.type}${v.required ? ",required" : ""})`)
+            .join(", ");
+        return `- ${i.name}: ${i.description} [${fields}]`;
+    })
+        .join("\n");
+    const envs = Object.keys(rules.environmentAliases).join(", ");
+    const services = Object.keys(rules.serviceAliases).join(", ");
+    return `You are a command parser for a server operations CLI.
+Parse the user's natural language command into a JSON object.
+
+Supported intents:
+${intentList}
+
+Known environments: ${envs}
+Known services: ${services}
+
+Return ONLY valid JSON with:
+- "intent": one of the intent names above, or "unknown"
+- "confidence": 0.0 to 1.0
+- "fields": object with all relevant fields for that intent
+
+Example: {"intent": "service.restart", "confidence": 0.9, "fields": {"service": "nginx", "environment": "prod"}}
+
+If you cannot determine the intent, return: {"intent": "unknown", "confidence": 0.1, "fields": {"reason": "..."}}
+Return ONLY the JSON object, no markdown.`;
+}
+function extractContent(data) {
+    if (data.choices && Array.isArray(data.choices)) {
+        const msg = data.choices[0]?.message;
+        if (msg?.content && typeof msg.content === "string")
+            return msg.content;
+    }
+    if (data.content && Array.isArray(data.content)) {
+        const block = data.content[0];
+        if (block?.text && typeof block.text === "string")
+            return block.text;
+    }
+    return null;
+}
+function extractJSON(text) {
+    try {
+        return JSON.parse(text.trim());
+    }
+    catch { }
+    const match = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (match) {
+        try {
+            return JSON.parse(match[1].trim());
+        }
+        catch { }
+    }
+    return null;
+}

package/dist/nlp/multiClassifier.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Multi-classifier intent scorer.
+ *
+ * Instead of picking one parser, this runs multiple classifiers in parallel
+ * and merges their scores. Each classifier votes on the likely intent.
+ *
+ * Classifiers:
+ * 1. Synonym matcher — exact/substring synonym matching (fast, deterministic)
+ * 2. Semantic classifier — uses compromise POS + dependency parse
+ * 3. Context classifier — uses conversation history for likely intent
+ * 4. Fuzzy classifier — keyboard-distance matching for typos
+ */
+export interface ClassifierVote {
+    classifier: string;
+    intent: string;
+    confidence: number;
+    reason: string;
+}
+export interface MultiClassifierResult {
+    /** All votes from all classifiers */
+    votes: ClassifierVote[];
+    /** Final merged scores per intent, sorted by score */
+    scores: Array<{
+        intent: string;
+        score: number;
+        votes: number;
+    }>;
+    /** The winning intent (highest merged score) */
+    best: {
+        intent: string;
+        score: number;
+    } | null;
+    /** Whether there was a close second (ambiguous) */
+    ambiguous: boolean;
+}
+/**
+ * Run all classifiers and merge results.
+ */
+export declare function classifyMulti(rawText: string, recentIntents?: string[]): MultiClassifierResult;