notoken-core 1.6.0 → 2.0.0

package/dist/nlp/multiIntent.js

@@ -0,0 +1,154 @@
+/**
+ * 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
+ */
+import { parseByRules } from "./ruleParser.js";
+import { routeByConcepts } from "./conceptRouter.js";
+import { getIntentDef } from "../utils/config.js";
+const c = {
+    reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+    green: "\x1b[32m", yellow: "\x1b[33m", cyan: "\x1b[36m",
+};
+// ─── Sentence Splitting ────────────────────────────────────────────────────
+// Conjunctions that typically join separate commands
+const SPLIT_PATTERNS = [
+    /\s+and\s+(?:also\s+)?(?:then\s+)?(?:can\s+you\s+)?/i,
+    /\s+also\s+/i,
+    /\s+then\s+/i,
+    /\s+after\s+that\s+/i,
+    /\s*;\s*/,
+    /\s*,\s+(?:and\s+)?(?:also\s+)?(?:then\s+)?(?:can\s+you\s+)?/i,
+    /\s+but\s+(?:first\s+)?(?:also\s+)?/i,
+];
+// Don't split on "and" that joins nouns (e.g., "cats and dogs", "videos and photos")
+const NOUN_AND_PATTERN = /^[a-z]+\s+and\s+[a-z]+$/i;
+/**
+ * Split a compound sentence into parts.
+ */
+export function splitCompoundSentence(text) {
+    let parts = [text.trim()];
+    for (const pattern of SPLIT_PATTERNS) {
+        const newParts = [];
+        for (const part of parts) {
+            const splits = part.split(pattern).map(s => s.trim()).filter(s => s.length > 2);
+            if (splits.length > 1) {
+                // Check if this is just noun joining (don't split "videos and photos")
+                const isNounJoin = splits.length === 2 && NOUN_AND_PATTERN.test(part);
+                if (isNounJoin) {
+                    newParts.push(part);
+                }
+                else {
+                    newParts.push(...splits);
+                }
+            }
+            else {
+                newParts.push(part);
+            }
+        }
+        parts = newParts;
+    }
+    // Clean up: remove leading filler words
+    return parts.map(p => p.replace(/^(can you|could you|please|will you|would you)\s+/i, "").trim()).filter(p => p.length > 2);
+}
+// ─── Multi-Intent Parsing ──────────────────────────────────────────────────
+/**
+ * Parse a potentially compound sentence into a multi-step plan.
+ * Returns a single-step plan if only one intent is found.
+ */
+export function parseMultiIntent(rawText) {
+    const parts = splitCompoundSentence(rawText);
+    // If only one part, it's a single intent
+    if (parts.length <= 1) {
+        const intent = resolveIntent(rawText);
+        return {
+            steps: intent ? [intentToStep(intent, rawText)] : [],
+            originalText: rawText,
+            isSingleIntent: true,
+        };
+    }
+    // Parse each part independently
+    const steps = [];
+    const seenIntents = new Set();
+    for (const part of parts) {
+        const intent = resolveIntent(part);
+        if (intent && !seenIntents.has(intent.intent)) {
+            steps.push(intentToStep(intent, part));
+            seenIntents.add(intent.intent);
+        }
+    }
+    return {
+        steps,
+        originalText: rawText,
+        isSingleIntent: steps.length <= 1,
+    };
+}
+function resolveIntent(text) {
+    // Try rule parser first
+    const rule = parseByRules(text);
+    if (rule && rule.confidence >= 0.6)
+        return rule;
+    // Then concept router
+    const concept = routeByConcepts(text);
+    if (concept && concept.confidence >= 0.5) {
+        return {
+            intent: concept.intent,
+            rawText: text,
+            confidence: concept.confidence,
+            fields: {},
+        };
+    }
+    return null;
+}
+function intentToStep(intent, rawText) {
+    const def = getIntentDef(intent.intent);
+    return {
+        intent: intent.intent,
+        rawText,
+        confidence: intent.confidence,
+        description: def?.description ?? intent.intent,
+        requiresConfirmation: def?.requiresConfirmation ?? false,
+        riskLevel: def?.riskLevel ?? "low",
+    };
+}
+// ─── Plan Formatting ───────────────────────────────────────────────────────
+export function formatPlanSteps(plan) {
+    const lines = [];
+    if (plan.steps.length === 0) {
+        return `${c.dim}Could not create a plan from: "${plan.originalText}"${c.reset}`;
+    }
+    if (plan.isSingleIntent) {
+        return ""; // Don't show plan for single intents
+    }
+    const hasWrite = plan.steps.some(s => s.requiresConfirmation || s.riskLevel !== "low");
+    lines.push(`${c.bold}${c.cyan}Plan (${plan.steps.length} steps):${c.reset}`);
+    if (hasWrite) {
+        lines.push(`${c.yellow}⚠ Some steps modify your system — confirmation required${c.reset}`);
+    }
+    lines.push("");
+    for (let i = 0; i < plan.steps.length; i++) {
+        const step = plan.steps[i];
+        const num = `${c.cyan}${i + 1}.${c.reset}`;
+        const risk = step.riskLevel !== "low" ? ` ${c.yellow}[${step.riskLevel}]${c.reset}` : "";
+        const confirm = step.requiresConfirmation ? ` ${c.yellow}(needs confirmation)${c.reset}` : "";
+        lines.push(`  ${num} ${c.bold}${step.intent}${c.reset}${risk}${confirm}`);
+        lines.push(`     ${c.dim}${step.description}${c.reset}`);
+        lines.push(`     ${c.dim}"${step.rawText}"${c.reset}`);
+    }
+    return lines.join("\n");
+}

package/dist/nlp/parseIntent.d.ts

@@ -1,2 +1,7 @@
 import type { ParsedCommand } from "../types/intent.js";
-export declare function parseIntent(rawText: string): Promise<ParsedCommand>;
+import { type MultiIntentPlan } from "./multiIntent.js";
+/** Result from parseIntent — may contain a multi-step plan */
+export type { MultiIntentPlan };
+export declare function parseIntent(rawText: string): Promise<ParsedCommand & {
+    plan?: MultiIntentPlan;
+}>;

package/dist/nlp/parseIntent.js

@@ -2,22 +2,194 @@ import { parseByRules } from "./ruleParser.js";
 import { parseByLLM } from "./llmParser.js";
 import { disambiguate } from "./disambiguate.js";
 import { logFailure } from "../utils/logger.js";
+import { classifyMulti } from "./multiClassifier.js";
+import { lookupUnknownNouns } from "./wikidata.js";
+import { routeByConcepts } from "./conceptRouter.js";
+import { parseMultiIntent } from "./multiIntent.js";
+import { isAffirmation, consumePendingAction, isRedirectingPendingAction } from "../conversation/pendingActions.js";
 export async function parseIntent(rawText) {
-    // Stage 1: deterministic rule parser
+    // Stage -2: Knowledge graph reference resolution
+    // Only resolve if coreference hasn't already handled it (avoid double resolution).
+    // Coreference runs in interactive mode (interactive.ts), knowledge graph here covers one-shot mode.
+    // Stage -2: Knowledge graph reference resolution with candidate scoring
+    const hasPronouns = /\b(it|that|this)\b/i.test(rawText) && !/\b(it's|that's|this is)\b/i.test(rawText);
+    if (hasPronouns) {
+        try {
+            const { resolveCandidates } = await import("./knowledgeGraph.js");
+            const { getOrCreateConversation, getRecentEntities } = await import("../conversation/store.js");
+            const conv = getOrCreateConversation(process.cwd());
+            const recentEnts = getRecentEntities(conv, 5).map((e) => e.entity);
+            const words = rawText.split(/\s+/);
+            let resolved = rawText;
+            for (const word of words) {
+                if (/^(it|that|this)$/i.test(word)) {
+                    const candidates = resolveCandidates(word, recentEnts);
+                    if (candidates.length > 0) {
+                        const best = candidates[0];
+                        // Only resolve if confident (score > 0.5) or clear winner (gap > 0.2)
+                        const gap = candidates.length > 1 ? best.score - candidates[1].score : 1;
+                        if (best.score > 0.5 || gap > 0.2) {
+                            resolved = resolved.replace(new RegExp(`\\b${word}\\b`, "i"), best.entity.name);
+                            // Show candidates if close (for transparency)
+                            if (candidates.length > 1 && gap < 0.3) {
+                                const alt = candidates.slice(0, 3).map(c => `${c.entity.name} (${(c.score * 100).toFixed(0)}%)`).join(", ");
+                                console.error(`\x1b[2mResolved "${word}" → ${best.entity.name} (candidates: ${alt})\x1b[0m`);
+                            }
+                        }
+                    }
+                }
+            }
+            if (resolved !== rawText) {
+                const resolvedResult = parseByRules(resolved);
+                if (resolvedResult && resolvedResult.confidence >= 0.7) {
+                    resolvedResult.rawText = rawText;
+                    return disambiguate(resolvedResult);
+                }
+            }
+        }
+        catch { /* knowledge graph not available */ }
+    }
+    // Stage -1a: check if user is redirecting a pending action ("put it on F drive")
+    const redirect = isRedirectingPendingAction(rawText);
+    if (redirect) {
+        consumePendingAction();
+        // Re-parse with the new location context
+        const reParsed = parseByRules(redirect);
+        if (reParsed && reParsed.confidence >= 0.5)
+            return disambiguate(reParsed);
+        // Fall through to normal parsing with the redirected text
+        rawText = redirect;
+    }
+    // Stage -1b: check if user is affirming a pending action ("ok", "try it", "do it")
+    if (isAffirmation(rawText)) {
+        const pending = consumePendingAction();
+        if (pending) {
+            if (pending.type === "intent") {
+                const reParsed = parseByRules(pending.action);
+                if (reParsed && reParsed.confidence >= 0.5) {
+                    return disambiguate(reParsed);
+                }
+            }
+            return disambiguate({
+                intent: pending.action.includes(".") ? pending.action : "unknown",
+                rawText: pending.action,
+                confidence: 0.8,
+                fields: pending.fields ?? {},
+            });
+        }
+    }
+    // Stage 0: check for compound sentences (multi-intent)
+    // "check disk and show me containers and list crontabs"
+    const multiPlan = parseMultiIntent(rawText);
+    if (!multiPlan.isSingleIntent && multiPlan.steps.length >= 2) {
+        // Check if one step is just a location modifier (not a real separate command)
+        // "do it offline and put files on D drive" → single intent with drive modifier
+        const locationStep = multiPlan.steps.find(s => /\b(put|place|install|store)\b.*\b(on|in|at)\s+[a-z]\s*drive\b/i.test(s.rawText)
+            || /\b(on|in|at)\s+\/\S+/i.test(s.rawText));
+        const actionStep = multiPlan.steps.find(s => s !== locationStep);
+        if (locationStep && actionStep && multiPlan.steps.length === 2) {
+            // Merge: use the action step's intent but the full original text
+            // so the executor can extract the drive from "on D drive"
+            const result = disambiguate({
+                intent: actionStep.intent,
+                rawText, // full original text
+                confidence: actionStep.confidence,
+                fields: {},
+            });
+            return result; // single intent, no plan
+        }
+        // Real multi-intent plan
+        const firstStep = multiPlan.steps[0];
+        const result = disambiguate({
+            intent: firstStep.intent,
+            rawText, // full original text
+            confidence: firstStep.confidence,
+            fields: {},
+        });
+        return { ...result, plan: multiPlan };
+    }
+    // Stage 1: deterministic rule parser (synonym matching + spell correction)
     const ruleResult = parseByRules(rawText);
     if (ruleResult && ruleResult.confidence >= 0.7) {
         return disambiguate(ruleResult);
     }
-    // Stage 2: LLM fallback
+    // Stage 2: concept router — understands topics/domains, not just phrases
+    // Handles: "is this offline or cloud", "check my crontabs", etc.
+    const conceptResult = routeByConcepts(rawText);
+    if (conceptResult && conceptResult.confidence >= 0.6) {
+        return disambiguate({
+            intent: conceptResult.intent,
+            rawText,
+            confidence: conceptResult.confidence,
+            fields: {},
+        });
+    }
+    // Stage 2.5: multi-classifier (synonym + semantic + vector + fuzzy voting)
+    const multiResult = classifyMulti(rawText);
+    if (multiResult.best && multiResult.best.score >= 0.6 && !multiResult.ambiguous) {
+        const mFields = ruleResult?.fields ?? {};
+        return disambiguate({
+            intent: multiResult.best.intent,
+            rawText,
+            confidence: Math.min(0.95, multiResult.best.score),
+            fields: mFields,
+        });
+    }
+    // Stage 2.75: semantic similarity — catches paraphrases that exact matching misses
+    try {
+        const { findSimilarIntents } = await import("./semanticSimilarity.js");
+        const similar = findSimilarIntents(rawText, 3);
+        if (similar.length > 0 && similar[0].score >= 0.4) {
+            // Only use if it's clearly the best match (gap > 0.1 from second)
+            const gap = similar.length > 1 ? similar[0].score - similar[1].score : 1;
+            if (gap > 0.08 || similar[0].score >= 0.6) {
+                return disambiguate({
+                    intent: similar[0].intent,
+                    rawText,
+                    confidence: Math.min(0.85, similar[0].score + 0.3),
+                    fields: {},
+                });
+            }
+        }
+    }
+    catch { /* semantic similarity not available */ }
+    // Stage 3: LLM fallback
     const llmResult = await parseByLLM(rawText);
     if (llmResult && llmResult.confidence >= 0.5) {
         return disambiguate(llmResult);
     }
-    // Stage 3: if rule parser had a low-confidence result, use it anyway
+    // Stage 4: if rule parser had a low-confidence result, use it anyway
     if (ruleResult) {
         return disambiguate(ruleResult);
     }
-    // Stage 4: unknown — log the failure for auto-learning
+    // Stage 4: check if the input looks like a "what is X" knowledge query
+    // If it contains unknown nouns, try Wikidata lookup and route to knowledge.lookup
+    const looksLikeQuestion = /^(what|who|tell|define|explain|info|facts|learn)\b/i.test(rawText.trim());
+    if (looksLikeQuestion) {
+        const topic = rawText.replace(/^(what|who)\s+(is|are|was|were)\s+/i, "")
+            .replace(/^(tell me about|define|explain|info about|facts about|learn about)\s+/i, "")
+            .replace(/\?$/, "").trim();
+        if (topic.length >= 2) {
+            return disambiguate({
+                intent: "knowledge.lookup",
+                rawText,
+                confidence: 0.6,
+                fields: { topic },
+            });
+        }
+    }
+    // Stage 5: for completely unknown input, try to identify unknown nouns via Wikidata
+    // and attach the context to the unknown result so the user gets useful info
+    const words = rawText.toLowerCase().split(/\s+/);
+    let wikiContext;
+    try {
+        const entities = await lookupUnknownNouns(words);
+        if (entities.length > 0) {
+            wikiContext = entities.map(e => `${e.label}: ${e.description}`).join("; ");
+        }
+    }
+    catch { }
+    // Stage 6: unknown — log the failure for auto-learning
     logFailure({
         rawText,
         timestamp: new Date().toISOString(),
@@ -29,6 +201,9 @@ export async function parseIntent(rawText) {
         intent: "unknown",
         rawText,
         confidence: 0,
-        fields: { reason: "No supported intent matched" },
+        fields: {
+            reason: "No supported intent matched",
+            ...(wikiContext ? { wikiContext } : {}),
+        },
     });
 }