notoken-core 1.6.0 → 1.8.1

package/dist/nlp/llmFallback.js

@@ -10,6 +10,18 @@
 import { execSync } from "node:child_process";
 import { loadIntents } from "../utils/config.js";
 import { detectLocalPlatform } from "../utils/platform.js";
+/** Conversation history for multi-turn LLM disambiguation */
+const _llmConversation = [];
+/** Add a turn to the LLM conversation for multi-turn context */
+export function addLLMContext(role, content) {
+    _llmConversation.push({ role, content });
+    if (_llmConversation.length > 10)
+        _llmConversation.splice(0, _llmConversation.length - 10);
+}
+/** Clear LLM conversation when topic changes */
+export function clearLLMContext() { _llmConversation.length = 0; }
+/** Get conversation for context in multi-turn */
+export function getLLMContext() { return [..._llmConversation]; }
 /**
  * Check if any LLM is configured.
  */
@@ -18,7 +30,7 @@ import { detectLocalPlatform } from "../utils/platform.js";
  * Order: explicit config → auto-detect Ollama → nothing.
  */
 export function isLLMConfigured() {
-    return !!(process.env.NOTOKEN_LLM_ENDPOINT || process.env.NOTOKEN_LLM_CLI || detectOllama());
+    return !!(process.env.NOTOKEN_LLM_ENDPOINT || process.env.NOTOKEN_LLM_CLI || detectOllama() || detectCodex());
 }
 /** Which LLM backend is active? */
 export function getLLMBackend() {
@@ -28,8 +40,25 @@ export function getLLMBackend() {
         return "api";
     if (detectOllama())
         return "ollama";
+    if (detectCodex())
+        return "codex";
     return null;
 }
+let codexChecked = false;
+let codexAvailable = false;
+function detectCodex() {
+    if (codexChecked)
+        return codexAvailable;
+    codexChecked = true;
+    try {
+        execSync("command -v codex", { timeout: 1000, stdio: "pipe" });
+        codexAvailable = true;
+    }
+    catch {
+        codexAvailable = false;
+    }
+    return codexAvailable;
+}
 let ollamaChecked = false;
 let ollamaAvailable = false;
 function detectOllama() {
@@ -67,6 +96,12 @@ export async function llmFallback(rawText, context) {
         if (apiResult)
             return apiResult;
     }
+    // Try Codex (auto-detected local)
+    if (detectCodex()) {
+        const codexResult = await tryLLMCli(rawText, { ...context, _cli: "codex" });
+        if (codexResult)
+            return codexResult;
+    }
     // Try Ollama (auto-detected local)
     if (detectOllama()) {
         const ollamaResult = await tryOllama(rawText, context);
@@ -75,6 +110,55 @@ export async function llmFallback(rawText, context) {
     }
     return null;
 }
+/**
+ * Multi-turn LLM disambiguation.
+ *
+ * 1. Ask the LLM what to do
+ * 2. If it needs more info → run gatherCommands → feed results back
+ * 3. Repeat up to maxTurns times
+ * 4. Return the final result
+ */
+export async function llmMultiTurn(rawText, context, options) {
+    const maxTurns = options?.maxTurns ?? 3;
+    const onProgress = options?.onProgress ?? (() => { });
+    // Turn 1: initial LLM call
+    onProgress("Asking LLM to interpret...");
+    let result = await llmFallback(rawText, context);
+    if (!result)
+        return null;
+    // Multi-turn loop: if LLM needs more info, run commands and ask again
+    for (let turn = 1; turn < maxTurns && result?.needsMoreInfo && result.gatherCommands?.length; turn++) {
+        const commands = result.gatherCommands;
+        onProgress(`Turn ${turn + 1}: Running ${commands.length} command(s) to gather info...`);
+        // Run each gather command
+        const commandResults = [];
+        for (const cmd of commands) {
+            onProgress(`  Running: ${cmd.command}`);
+            try {
+                const { execSync } = await import("node:child_process");
+                const output = execSync(cmd.command, {
+                    encoding: "utf-8",
+                    timeout: 15_000,
+                    stdio: ["pipe", "pipe", "pipe"],
+                }).trim();
+                commandResults.push({ ...cmd, output: output.substring(0, 1000) });
+            }
+            catch (err) {
+                const e = err;
+                commandResults.push({ ...cmd, output: `ERROR: ${e.message?.split("\n")[0] ?? "failed"}` });
+            }
+        }
+        // Build follow-up prompt with command outputs
+        const outputSummary = commandResults.map(r => `Command: ${r.command}\nPurpose: ${r.purpose}\nOutput:\n${r.output}`).join("\n\n");
+        const followUpText = `${rawText}\n\n--- COMMAND OUTPUTS ---\n${outputSummary}\n\nBased on these results, complete this JSON template. Replace FILL with values:\n\`\`\`json\n{"understood": FILL, "restatement": "FILL", "suggestedIntents": [{"intent": "FILL", "fields": {}, "confidence": FILL, "reasoning": "FILL"}], "needsMoreInfo": false}\n\`\`\``;
+        onProgress("Analyzing results...");
+        result = await llmFallback(followUpText, context);
+        // Track conversation
+        addLLMContext("user", rawText);
+        addLLMContext("assistant", JSON.stringify(commandResults));
+    }
+    return result;
+}
 async function tryLLMCli(rawText, context) {
     const cli = process.env.NOTOKEN_LLM_CLI;
     if (!cli)
@@ -91,6 +175,10 @@ async function tryLLMCli(rawText, context) {
             execSync("command -v chatgpt", { stdio: "pipe" });
             cmd = `chatgpt ${JSON.stringify(prompt)}`;
         }
+        else if (cli === "codex") {
+            execSync("command -v codex", { stdio: "pipe" });
+            cmd = `codex ${JSON.stringify(prompt)}`;
+        }
         else {
             return null;
         }
@@ -166,16 +254,21 @@ async function tryOllama(rawText, context) {
     const prompt = buildPrompt(rawText, context);
     const model = process.env.NOTOKEN_OLLAMA_MODEL ?? "llama3.2";
     try {
-        const response = await fetch("http://localhost:11434/api/generate", {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 90_000);
+        // Use 127.0.0.1 explicitly — Node 18 fetch resolves localhost to IPv6 ::1 which Ollama doesn't listen on
+        const response = await fetch("http://127.0.0.1:11434/api/generate", {
             method: "POST",
             headers: { "Content-Type": "application/json" },
+            signal: controller.signal,
             body: JSON.stringify({
                 model,
                 prompt,
                 stream: false,
-                options: { temperature: 0.1, num_predict: 1024 },
+                options: { temperature: 0.1, num_predict: 512 },
             }),
         });
+        clearTimeout(timeout);
         if (!response.ok)
             return null;
         const data = (await response.json());
@@ -184,7 +277,8 @@ async function tryOllama(rawText, context) {
             return null;
         return parseResponse(text);
     }
-    catch {
+    catch (err) {
+        console.error(`\x1b[2m[llm-ollama] ${err.message?.substring(0, 100)}\x1b[0m`);
         return null;
     }
 }
@@ -207,7 +301,7 @@ export function isOllamaInstalled() {
  */
 export async function getOllamaModels() {
     try {
-        const response = await fetch("http://localhost:11434/api/tags");
+        const response = await fetch("http://127.0.0.1:11434/api/tags");
         if (!response.ok)
             return [];
         const data = (await response.json());
@@ -219,50 +313,95 @@ export async function getOllamaModels() {
 }
 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.
+    // Group intents by domain — much shorter than listing all 298
+    const domains = new Map();
+    for (const i of intents) {
+        const domain = i.name.split(".")[0];
+        if (!domains.has(domain))
+            domains.set(domain, []);
+        domains.get(domain).push(`${i.name}: ${i.description}`);
+    }
+    // Only include top-level summary + relevant domains based on user input
+    const relevantDomains = [];
+    const inputLower = rawText.toLowerCase();
+    for (const [domain, items] of domains) {
+        // Include domains that might be relevant to the query
+        const domainKeywords = {
+            service: ["service", "restart", "start", "stop", "status", "running"],
+            server: ["server", "cpu", "memory", "disk", "load", "uptime"],
+            docker: ["docker", "container", "image", "compose"],
+            network: ["network", "ip", "port", "ping", "dns", "curl", "speed"],
+            git: ["git", "commit", "push", "pull", "branch", "merge"],
+            deploy: ["deploy", "release", "rollback"],
+            logs: ["log", "error", "tail", "search"],
+            security: ["security", "attack", "firewall", "scan", "block"],
+            disk: ["disk", "space", "cleanup", "scan", "drive"],
+            db: ["database", "mysql", "postgres", "query", "sql"],
+            openclaw: ["openclaw", "claw", "gateway", "discord"],
+            ollama: ["ollama", "llm", "model"],
+            ai: ["image", "generate", "stable diffusion"],
+            files: ["file", "find", "copy", "move", "delete"],
+            process: ["process", "kill", "pid"],
+            user: ["user", "who", "login"],
+            backup: ["backup", "restore", "snapshot"],
+            notoken: ["notoken", "status", "version", "update", "help"],
+        };
+        const keywords = domainKeywords[domain] ?? [domain];
+        if (keywords.some(k => inputLower.includes(k)) || items.length <= 5) {
+            relevantDomains.push(`\n  [${domain}] (${items.length} commands)\n${items.slice(0, 8).map(i => `    ${i}`).join("\n")}`);
+        }
+    }
+    // If no relevant domains found, include a general summary
+    if (relevantDomains.length === 0) {
+        for (const [domain, items] of [...domains].slice(0, 10)) {
+            relevantDomains.push(`  [${domain}]: ${items.slice(0, 3).map(i => i.split(":")[0]).join(", ")}...`);
+        }
+    }
+    // Recent conversation context
+    const recentIntents = context.recentIntents ?? [];
+    const recentContext = recentIntents.length > 0
+        ? `\nRECENT COMMANDS (what the user has been doing):\n  ${recentIntents.slice(0, 5).join(", ")}\n`
+        : "";
+    // Known entities
+    const entities = context.knownEntities ?? [];
+    const entityContext = entities.length > 0
+        ? `\nKNOWN ENTITIES:\n  ${entities.slice(0, 10).map(e => `${e.entity} (${e.type})`).join(", ")}\n`
+        : "";
+    return `You are NoToken, a server operations CLI assistant. The user said something my NLP couldn't parse. Help me understand what they want.
 
 ENVIRONMENT:
-  OS: ${platform.distro}${platform.isWSL ? " (WSL)" : ""}
-  Kernel: ${platform.kernel}
-  Arch: ${platform.arch}
-  Shell: ${platform.shell}
-  Package manager: ${platform.packageManager}
-  Init system: ${platform.initSystem}
-
+  OS: ${platform.distro}${platform.isWSL ? " (WSL)" : ""} | Shell: ${platform.shell}
+  Package manager: ${platform.packageManager} | Init: ${platform.initSystem}
+${recentContext}${entityContext}
 USER INPUT: "${rawText}"
 
-CONTEXT:
-${JSON.stringify(context, null, 2)}
+AVAILABLE COMMANDS (grouped by domain — ${intents.length} total):
+${relevantDomains.join("\n")}
 
-AVAILABLE INTENTS (these are the tools I can execute):
-${intentSummary}
+Complete this JSON template. Replace every FILL with actual values based on the user's input. Remove fields you don't need. Output ONLY the completed JSON:
 
-Respond with ONLY a JSON object:
+\`\`\`json
 {
-  "understood": true/false,
-  "restatement": "In plain English, what the user wants to do",
+  "understood": FILL_true_or_false,
+  "restatement": "FILL_what_user_wants_in_plain_english",
   "suggestedIntents": [
-    {
-      "intent": "intent.name from list above",
-      "fields": { "field": "value" },
-      "confidence": 0.0-1.0,
-      "reasoning": "why this intent"
-    }
+    {"intent": "FILL_best_matching_command_from_list_above", "fields": {}, "confidence": FILL_0_to_1, "reasoning": "FILL_why_this_command"}
   ],
-  "todoSteps": [
-    { "step": 1, "description": "what to do first", "intent": "optional intent name" }
+  "needsMoreInfo": FILL_true_if_you_need_to_run_commands_first,
+  "gatherCommands": [
+    {"command": "FILL_shell_command_to_run", "purpose": "FILL_why_run_this"}
   ],
-  "missingInfo": ["things I'd need to ask the user"]
+  "shellCommands": ["FILL_raw_shell_command_if_no_intent_fits"],
+  "missingInfo": ["FILL_question_to_ask_user_if_unclear"]
 }
+\`\`\`
 
-Return ONLY JSON.`;
+Rules:
+- If one of my commands fits, use suggestedIntents and set needsMoreInfo=false.
+- If you need to investigate first, set needsMoreInfo=true and list gatherCommands with real shell commands (uptime, df -h, ps aux, curl, etc).
+- I will run those commands and send you the output for a second round.
+- Remove empty arrays. Output ONLY the JSON.`;
 }
 function parseResponse(raw) {
     try {

package/dist/nlp/llmParser.d.ts

@@ -5,4 +5,8 @@ import type { DynamicIntent } from "../types/intent.js";
  * Sends the raw text + context to an LLM and asks for structured JSON.
  * Set NOTOKEN_LLM_ENDPOINT and optionally NOTOKEN_LLM_API_KEY in env.
  */
-export declare function parseByLLM(rawText: string): Promise<DynamicIntent | null>;
+export declare function parseByLLM(rawText: string, nearMisses?: Array<{
+    intent: string;
+    score: number;
+    source: string;
+}>): Promise<DynamicIntent | null>;

package/dist/nlp/llmParser.js

@@ -7,14 +7,14 @@ import { loadRules } from "../utils/config.js";
  * Sends the raw text + context to an LLM and asks for structured JSON.
  * Set NOTOKEN_LLM_ENDPOINT and optionally NOTOKEN_LLM_API_KEY in env.
  */
-export async function parseByLLM(rawText) {
+export async function parseByLLM(rawText, nearMisses) {
     const endpoint = process.env.NOTOKEN_LLM_ENDPOINT;
     if (!endpoint)
         return null;
     const apiKey = process.env.NOTOKEN_LLM_API_KEY ?? "";
     const rules = loadRules();
     const intents = loadIntents();
-    const systemPrompt = buildSystemPrompt(intents, rules);
+    const systemPrompt = buildSystemPrompt(intents, rules, nearMisses);
     const userPrompt = `Parse this command into structured intent JSON:\n\n"${rawText}"`;
     try {
         const response = await fetch(endpoint, {
@@ -59,35 +59,54 @@ export async function parseByLLM(rawText) {
         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");
+function buildSystemPrompt(intents, rules, nearMisses) {
+    // Build a concise intent list grouped by domain
+    const domains = new Map();
+    for (const i of intents) {
+        const domain = i.name.split(".")[0];
+        if (!domains.has(domain))
+            domains.set(domain, []);
+        const fields = Object.entries(i.fields).map(([k, v]) => `${k}:${v.type}`).join(", ");
+        domains.get(domain).push(`${i.name}${fields ? ` [${fields}]` : ""}`);
+    }
+    // If we have near-misses, show their full details + related intents
+    let nearMissSection = "";
+    if (nearMisses && nearMisses.length > 0) {
+        const nearMissDetails = nearMisses
+            .filter((v, i, a) => a.findIndex(x => x.intent === v.intent) === i) // dedup
+            .slice(0, 5)
+            .map(nm => {
+            const def = intents.find(i => i.name === nm.intent);
+            const fields = def ? Object.entries(def.fields).map(([k, v]) => `${k}:${v.type}`).join(", ") : "";
+            return `  - ${nm.intent} (${(nm.score * 100).toFixed(0)}% from ${nm.source}): ${def?.description ?? ""}${fields ? ` [${fields}]` : ""}`;
+        }).join("\n");
+        // Also include related intents from the same domains
+        const nearDomains = new Set(nearMisses.map(nm => nm.intent.split(".")[0]));
+        const relatedIntents = [...nearDomains].flatMap(d => (domains.get(d) ?? []).slice(0, 5)).join("\n    ");
+        nearMissSection = `\nNEAR MATCHES (my classifiers think it might be one of these — pick the best or suggest another):
+${nearMissDetails}
+
+RELATED COMMANDS in those domains:
+    ${relatedIntents}\n`;
+    }
+    // Compact domain summary for everything else
+    const domainSummary = [...domains].map(([d, items]) => `  [${d}]: ${items.slice(0, 4).join(", ")}${items.length > 4 ? ` +${items.length - 4} more` : ""}`).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}
+    return `You are NoToken, a server operations CLI command parser.
+Parse the user's natural language into a structured JSON intent.
+${nearMissSection}
+ALL AVAILABLE COMMANDS (${intents.length} total):
+${domainSummary}
 
 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"}}
+Return ONLY valid JSON:
+{"intent": "domain.command", "confidence": 0.0-1.0, "fields": {"field": "value"}}
 
-If you cannot determine the intent, return: {"intent": "unknown", "confidence": 0.1, "fields": {"reason": "..."}}
-Return ONLY the JSON object, no markdown.`;
+If unclear, return: {"intent": "unknown", "confidence": 0.1, "fields": {"reason": "...", "clarification": "What did you mean? Did you want to..."}}
+Return ONLY JSON, no markdown.`;
 }
 function extractContent(data) {
     if (data.choices && Array.isArray(data.choices)) {

package/dist/nlp/multiClassifier.js

@@ -1,9 +1,14 @@
 import { loadIntents, loadRules } from "../utils/config.js";
 import { semanticParse, fuzzyMatch } from "./semantic.js";
 import { parseByRules } from "./ruleParser.js";
+import { existsSync, readFileSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { expandQuery } from "./conceptExpansion.js";
 const CLASSIFIER_WEIGHTS = {
     synonym: 1.0,
     semantic: 0.8,
+    vector: 0.7,
     context: 0.6,
     fuzzy: 0.5,
 };
@@ -12,8 +17,24 @@ const CLASSIFIER_WEIGHTS = {
  */
 export function classifyMulti(rawText, recentIntents) {
     const votes = [];
-    // 1. Synonym classifier (existing rule parser)
+    // 0. Expand query with synonym clusters for better matching
+    // "reboot the server" → "reboot the server restart cycle reload bounce"
+    let expandedText = rawText;
+    try {
+        expandedText = expandQuery(rawText);
+    }
+    catch { /* concept expansion not available */ }
+    // 1. Synonym classifier — run on both original AND expanded text
     votes.push(...classifySynonym(rawText));
+    if (expandedText !== rawText) {
+        // Run again on expanded text but with lower weight
+        const expandedVotes = classifySynonym(expandedText);
+        for (const v of expandedVotes) {
+            v.confidence *= 0.7; // Expansion matches are less certain
+            v.reason += " (expanded)";
+        }
+        votes.push(...expandedVotes);
+    }
     // 2. Semantic classifier (compromise-powered)
     votes.push(...classifySemantic(rawText));
     // 3. Context classifier (recent history)
@@ -22,19 +43,23 @@ export function classifyMulti(rawText, recentIntents) {
     }
     // 4. Fuzzy classifier (keyboard distance)
     votes.push(...classifyFuzzy(rawText));
-    // Merge votes into weighted scores
+    // 5. Vector classifier (precomputed TF-IDF cosine similarity)
+    votes.push(...classifyVector(rawText));
+    // Merge votes: max weighted score + bonus for agreement
     const scoreMap = new Map();
     for (const vote of votes) {
         const weight = CLASSIFIER_WEIGHTS[vote.classifier] ?? 1.0;
-        const existing = scoreMap.get(vote.intent) ?? { total: 0, count: 0 };
-        existing.total += vote.confidence * weight;
+        const weighted = vote.confidence * weight;
+        const existing = scoreMap.get(vote.intent) ?? { maxWeighted: 0, totalWeighted: 0, count: 0 };
+        existing.maxWeighted = Math.max(existing.maxWeighted, weighted);
+        existing.totalWeighted += weighted;
         existing.count += 1;
         scoreMap.set(vote.intent, existing);
     }
     const scores = Array.from(scoreMap.entries())
-        .map(([intent, { total, count }]) => ({
+        .map(([intent, { maxWeighted, count }]) => ({
         intent,
-        score: total / count,
+        score: maxWeighted + Math.min(0.15, (count - 1) * 0.05),
         votes: count,
     }))
         .sort((a, b) => b.score - a.score);
@@ -179,3 +204,63 @@ function scoreEntityMatch(parse, def) {
     }
     return matches / total;
 }
+let _vectorData = null;
+function loadVectors() {
+    if (_vectorData)
+        return _vectorData;
+    const paths = [
+        resolve(dirname(fileURLToPath(import.meta.url)), "../../config/intent-vectors.json"),
+        resolve(process.cwd(), "config/intent-vectors.json"),
+    ];
+    for (const p of paths) {
+        if (existsSync(p)) {
+            try {
+                _vectorData = JSON.parse(readFileSync(p, "utf-8"));
+                return _vectorData;
+            }
+            catch { /* skip */ }
+        }
+    }
+    return null;
+}
+const VECTOR_STOP = new Set(["a", "an", "the", "is", "it", "in", "on", "to", "for", "of", "and", "or", "my", "me", "i", "we", "you", "do", "does", "did", "be", "am", "are", "was", "were", "have", "has", "had", "this", "that", "what", "which", "who", "how", "where", "when", "why", "not", "no", "but", "if", "so", "at", "by", "with", "from", "up", "out", "can", "could", "would", "should", "will", "may", "might", "just", "about", "all", "please"]);
+function classifyVector(rawText) {
+    const data = loadVectors();
+    if (!data)
+        return [];
+    const tokens = rawText.toLowerCase().replace(/[^a-z0-9_.\-\/]/g, " ").split(/\s+/).filter((w) => w.length > 1 && !VECTOR_STOP.has(w));
+    if (tokens.length === 0)
+        return [];
+    const vocabIndex = new Map(data.vocab.map((v, i) => [v, i]));
+    const inputVec = {};
+    let magnitude = 0;
+    const tf = new Map();
+    for (const t of tokens)
+        tf.set(t, (tf.get(t) ?? 0) + 1);
+    for (const [term, count] of tf) {
+        const idx = vocabIndex.get(term);
+        if (idx !== undefined) {
+            inputVec[idx] = count;
+            magnitude += count * count;
+        }
+    }
+    magnitude = Math.sqrt(magnitude);
+    if (magnitude === 0)
+        return [];
+    for (const idx of Object.keys(inputVec))
+        inputVec[Number(idx)] /= magnitude;
+    const votes = [];
+    for (const [intentName, intentVec] of Object.entries(data.vectors)) {
+        let dot = 0;
+        for (const [idx, val] of Object.entries(inputVec)) {
+            const iv = intentVec[idx];
+            if (iv)
+                dot += val * iv;
+        }
+        if (dot > 0.1) {
+            votes.push({ classifier: "vector", intent: intentName, confidence: Math.min(0.95, dot), reason: `TF-IDF cosine: ${dot.toFixed(3)}` });
+        }
+    }
+    votes.sort((a, b) => b.confidence - a.confidence);
+    return votes.slice(0, 3);
+}

package/dist/nlp/multiIntent.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Multi-intent parser.
+ *
+ * Splits compound sentences into individual intents and creates a plan.
+ *
+ * "check if the firewall is blocking port 443 and also check dns for my domain"
+ * →  Step 1: firewall.list (check port 443)
+ *    Step 2: dns.lookup (check domain)
+ *
+ * "show me disk usage, check memory, and list running containers"
+ * →  Step 1: server.check_disk
+ *    Step 2: server.check_memory
+ *    Step 3: docker.list
+ *
+ * Splitting rules:
+ *   - Split on: "and", "also", "then", "after that", ",", ";"
+ *   - But NOT inside quoted strings or after "and" that joins nouns ("cats and dogs")
+ *   - Each part is parsed independently through rule parser + concept router
+ *   - Only creates a plan if 2+ distinct intents are found
+ */
+export interface PlanStep {
+    intent: string;
+    rawText: string;
+    confidence: number;
+    description: string;
+    requiresConfirmation: boolean;
+    riskLevel: string;
+}
+export interface MultiIntentPlan {
+    steps: PlanStep[];
+    originalText: string;
+    isSingleIntent: boolean;
+}
+/**
+ * Split a compound sentence into parts.
+ */
+export declare function splitCompoundSentence(text: string): string[];
+/**
+ * Parse a potentially compound sentence into a multi-step plan.
+ * Returns a single-step plan if only one intent is found.
+ */
+export declare function parseMultiIntent(rawText: string): MultiIntentPlan;
+export declare function formatPlanSteps(plan: MultiIntentPlan): string;