notoken-core 1.5.1 → 2.0.0

package/dist/nlp/correctionLearner.js

@@ -0,0 +1,207 @@
+/**
+ * Correction Learner — learns from user corrections after misrouted intents.
+ *
+ * When the user says "no I meant X" or "not that, I want Y", this module
+ * records the correction and uses it to improve future classifications.
+ * Uses fuzzy matching so similar phrases benefit from past corrections.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+// ─── Constants ──────────────────────────────────────────────────────────────
+const CORRECTIONS_DIR = resolve(homedir(), ".notoken");
+const CORRECTIONS_FILE = resolve(CORRECTIONS_DIR, "learned-corrections.json");
+const MAX_ENTRIES = 500;
+// ─── Persistence ────────────────────────────────────────────────────────────
+function loadCorrections() {
+    if (!existsSync(CORRECTIONS_FILE))
+        return [];
+    try {
+        const data = JSON.parse(readFileSync(CORRECTIONS_FILE, "utf-8"));
+        return Array.isArray(data) ? data : [];
+    }
+    catch {
+        return [];
+    }
+}
+function saveCorrections(corrections) {
+    if (!existsSync(CORRECTIONS_DIR)) {
+        mkdirSync(CORRECTIONS_DIR, { recursive: true });
+    }
+    // Prune to MAX_ENTRIES, keeping most recently seen
+    if (corrections.length > MAX_ENTRIES) {
+        corrections.sort((a, b) => b.lastSeen.localeCompare(a.lastSeen));
+        corrections = corrections.slice(0, MAX_ENTRIES);
+    }
+    writeFileSync(CORRECTIONS_FILE, JSON.stringify(corrections, null, 2));
+}
+// ─── Fuzzy Matching ─────────────────────────────────────────────────────────
+/** Tokenize and normalize text for comparison. */
+function tokenize(text) {
+    return text.toLowerCase().replace(/[^\w\s]/g, "").split(/\s+/).filter(w => w.length > 1);
+}
+/**
+ * Jaccard similarity between two token sets — measures overlap.
+ * Returns 0..1 where 1 = identical token sets.
+ */
+function jaccardSimilarity(a, b) {
+    if (a.length === 0 && b.length === 0)
+        return 1;
+    const setA = new Set(a);
+    const setB = new Set(b);
+    let intersection = 0;
+    for (const token of setA) {
+        if (setB.has(token))
+            intersection++;
+    }
+    const union = setA.size + setB.size - intersection;
+    return union === 0 ? 0 : intersection / union;
+}
+/**
+ * Edit distance between two words (Levenshtein).
+ */
+function editDistance(a, b) {
+    const m = a.length, n = b.length;
+    if (m === 0)
+        return n;
+    if (n === 0)
+        return m;
+    const dp = Array.from({ length: n + 1 }, (_, i) => i);
+    for (let i = 1; i <= m; i++) {
+        let prev = dp[0];
+        dp[0] = i;
+        for (let j = 1; j <= n; j++) {
+            const tmp = dp[j];
+            dp[j] = a[i - 1] === b[j - 1] ? prev : 1 + Math.min(prev, dp[j], dp[j - 1]);
+            prev = tmp;
+        }
+    }
+    return dp[n];
+}
+/**
+ * Fuzzy token similarity — allows minor spelling differences between words.
+ * Each token in A is matched to the closest token in B (edit distance <= 2).
+ */
+function fuzzyTokenOverlap(a, b) {
+    if (a.length === 0 && b.length === 0)
+        return 1;
+    if (a.length === 0 || b.length === 0)
+        return 0;
+    let matches = 0;
+    for (const tokA of a) {
+        for (const tokB of b) {
+            const maxDist = tokA.length <= 4 ? 1 : 2;
+            if (tokA === tokB || editDistance(tokA, tokB) <= maxDist) {
+                matches++;
+                break;
+            }
+        }
+    }
+    return matches / Math.max(a.length, b.length);
+}
+// ─── Public API ─────────────────────────────────────────────────────────────
+/**
+ * Record a user correction. Merges with existing entry if the same
+ * input+wrongIntent+correctIntent triple already exists.
+ */
+export function recordCorrection(input, wrongIntent, correctIntent) {
+    const corrections = loadCorrections();
+    const normalized = input.trim().toLowerCase();
+    const existing = corrections.find(c => c.input === normalized && c.wrongIntent === wrongIntent && c.correctIntent === correctIntent);
+    if (existing) {
+        existing.count++;
+        existing.lastSeen = new Date().toISOString();
+    }
+    else {
+        corrections.push({
+            input: normalized,
+            wrongIntent,
+            correctIntent,
+            count: 1,
+            lastSeen: new Date().toISOString(),
+        });
+    }
+    saveCorrections(corrections);
+}
+/**
+ * Check if a user input matches a previously corrected pattern.
+ * Uses fuzzy matching so synonymous phrases benefit from past corrections.
+ *
+ * Returns the corrected intent with a confidence score, or null if no match.
+ */
+export function checkCorrections(rawText) {
+    const corrections = loadCorrections();
+    if (corrections.length === 0)
+        return null;
+    const inputTokens = tokenize(rawText);
+    if (inputTokens.length === 0)
+        return null;
+    let bestMatch = null;
+    let bestScore = 0;
+    for (const correction of corrections) {
+        const corrTokens = tokenize(correction.input);
+        // Combine Jaccard (exact) and fuzzy overlap for robustness
+        const jaccard = jaccardSimilarity(inputTokens, corrTokens);
+        const fuzzy = fuzzyTokenOverlap(inputTokens, corrTokens);
+        const score = Math.max(jaccard, fuzzy * 0.9);
+        // Boost score for corrections with high count (proven patterns)
+        const boosted = score + Math.min(correction.count * 0.02, 0.1);
+        if (boosted > bestScore && boosted >= 0.55) {
+            bestScore = boosted;
+            bestMatch = correction;
+        }
+    }
+    if (!bestMatch)
+        return null;
+    // Confidence: base from similarity, capped at 0.92
+    const confidence = Math.min(0.92, 0.6 + (bestScore - 0.55) * 0.8);
+    return { intent: bestMatch.correctIntent, confidence };
+}
+/**
+ * Detect if the user is issuing a correction to a previous misroute.
+ *
+ * Patterns detected:
+ *   "no I meant restart the service"
+ *   "not that, I want to check disk"
+ *   "wrong, I wanted to see logs"
+ *   "no, show me the containers"
+ *   "I said restart not status"
+ *
+ * Returns the corrected intent text (the part after the correction marker)
+ * or null if this is not a correction.
+ */
+export function detectCorrection(rawText, lastIntent) {
+    if (!lastIntent)
+        return null;
+    const text = rawText.trim();
+    // Pattern list: correction prefix → capture the intended action
+    const patterns = [
+        /^no[,.]?\s+(?:i\s+)?meant?\s+(?:to\s+)?(.+)/i,
+        /^no[,.]?\s+i\s+want(?:ed)?\s+(?:to\s+)?(.+)/i,
+        /^not\s+that[,.]?\s+(?:i\s+)?want(?:ed)?\s+(?:to\s+)?(.+)/i,
+        /^not\s+that[,.]?\s+(.+)/i,
+        /^wrong[,.]?\s+(?:i\s+)?want(?:ed)?\s+(?:to\s+)?(.+)/i,
+        /^wrong[,.]?\s+(.+)/i,
+        /^no[,.]?\s+(?:do|run|show|check|list|start|stop|restart|open|get)\s+(.+)/i,
+        /^no[,.]?\s+(show|check|list|start|stop|restart|open|get)\s+(.+)/i,
+        /^i\s+said\s+(.+?)(?:\s+not\s+.+)?$/i,
+        /^i\s+meant?\s+(?:to\s+)?(.+)/i,
+        /^that'?s?\s+(?:not\s+)?(?:what\s+i\s+)?(?:meant|wanted)[,.]?\s+(?:i\s+want(?:ed)?\s+(?:to\s+)?)?(.+)/i,
+    ];
+    for (const pattern of patterns) {
+        const match = text.match(pattern);
+        if (match) {
+            // Use the last capture group (some patterns have 2 groups)
+            const captured = match[match.length > 2 ? 2 : 1]?.trim();
+            if (captured && captured.length >= 2) {
+                return captured;
+            }
+        }
+    }
+    // Simple "no" followed by a complete new command on next line or after punctuation
+    // Only bare "no" / "nope" / "wrong" without further text — caller handles next input
+    if (/^(no|nope|wrong|that'?s\s+wrong|not\s+what\s+i\s+(meant|wanted))\.?$/i.test(text)) {
+        return ""; // Signal: user rejected, but correction text is in the next input
+    }
+    return null;
+}

package/dist/nlp/entitySpellCorrect.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Entity spell correction — "restart nignx" → "did you mean nginx?"
+ *
+ * Also does fuzzy entity matching:
+ *   "the web server" → nginx (if nginx is the only web server in the graph)
+ *   "the database" → mysql (if mysql is the only database)
+ */
+import { type GraphEntity } from "./knowledgeGraph.js";
+export interface SpellSuggestion {
+    original: string;
+    suggested: string;
+    distance: number;
+    confidence: number;
+}
+/**
+ * Check if a word is a misspelling of a known entity.
+ * Returns suggestion if distance ≤ 2 and word length ≥ 4.
+ */
+export declare function suggestEntityCorrection(word: string): SpellSuggestion | null;
+/**
+ * Correct entity misspellings in a full text.
+ * Returns corrected text and list of corrections made.
+ */
+export declare function correctEntities(text: string): {
+    corrected: string;
+    corrections: SpellSuggestion[];
+};
+/**
+ * Fuzzy entity description matching.
+ * "the web server" → nginx (if nginx is the only service type entity)
+ * "the database" → mysql (if there's only one database)
+ */
+export declare function resolveDescription(description: string): GraphEntity | null;
+/** Reset cached vocabulary (call after graph changes). */
+export declare function resetEntityVocab(): void;

package/dist/nlp/entitySpellCorrect.js

@@ -0,0 +1,141 @@
+/**
+ * Entity spell correction — "restart nignx" → "did you mean nginx?"
+ *
+ * Also does fuzzy entity matching:
+ *   "the web server" → nginx (if nginx is the only web server in the graph)
+ *   "the database" → mysql (if mysql is the only database)
+ */
+import { loadKnowledgeGraph } from "./knowledgeGraph.js";
+import { loadRules } from "../utils/config.js";
+// ─── Levenshtein distance ───────────────────────────────────────────────────
+function levenshtein(a, b) {
+    const m = a.length, n = b.length;
+    if (m === 0)
+        return n;
+    if (n === 0)
+        return m;
+    const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+    for (let i = 0; i <= m; i++)
+        dp[i][0] = i;
+    for (let j = 0; j <= n; j++)
+        dp[0][j] = j;
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            dp[i][j] = a[i - 1] === b[j - 1]
+                ? dp[i - 1][j - 1]
+                : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+        }
+    }
+    return dp[m][n];
+}
+// ─── Entity vocabulary ──────────────────────────────────────────────────────
+let _entityVocab = null;
+function getEntityVocab() {
+    if (_entityVocab)
+        return _entityVocab;
+    _entityVocab = new Map();
+    // From knowledge graph
+    try {
+        const g = loadKnowledgeGraph();
+        for (const ent of Object.values(g.entities)) {
+            _entityVocab.set(ent.name.toLowerCase(), ent.name);
+            for (const alias of ent.aliases)
+                _entityVocab.set(alias.toLowerCase(), ent.name);
+        }
+    }
+    catch { }
+    // From service aliases
+    try {
+        const rules = loadRules();
+        for (const [svc, aliases] of Object.entries(rules.serviceAliases ?? {})) {
+            _entityVocab.set(svc.toLowerCase(), svc);
+            for (const alias of aliases)
+                _entityVocab.set(alias.toLowerCase(), svc);
+        }
+    }
+    catch { }
+    return _entityVocab;
+}
+/**
+ * Check if a word is a misspelling of a known entity.
+ * Returns suggestion if distance ≤ 2 and word length ≥ 4.
+ */
+export function suggestEntityCorrection(word) {
+    if (word.length < 4)
+        return null;
+    const lower = word.toLowerCase();
+    const vocab = getEntityVocab();
+    // Exact match — no correction needed
+    if (vocab.has(lower))
+        return null;
+    let bestDist = Infinity;
+    let bestMatch = "";
+    for (const [known, canonical] of vocab) {
+        if (Math.abs(known.length - lower.length) > 2)
+            continue; // Skip if lengths too different
+        const dist = levenshtein(lower, known);
+        if (dist < bestDist && dist <= 2) {
+            bestDist = dist;
+            bestMatch = canonical;
+        }
+    }
+    if (bestMatch && bestDist <= 2) {
+        return {
+            original: word,
+            suggested: bestMatch,
+            distance: bestDist,
+            confidence: bestDist === 1 ? 0.9 : 0.7,
+        };
+    }
+    return null;
+}
+/**
+ * Correct entity misspellings in a full text.
+ * Returns corrected text and list of corrections made.
+ */
+export function correctEntities(text) {
+    const words = text.split(/\s+/);
+    const corrections = [];
+    const correctedWords = words.map(word => {
+        const suggestion = suggestEntityCorrection(word.replace(/[.,!?]/g, ""));
+        if (suggestion) {
+            corrections.push(suggestion);
+            return word.replace(suggestion.original, suggestion.suggested);
+        }
+        return word;
+    });
+    return {
+        corrected: correctedWords.join(" "),
+        corrections,
+    };
+}
+/**
+ * Fuzzy entity description matching.
+ * "the web server" → nginx (if nginx is the only service type entity)
+ * "the database" → mysql (if there's only one database)
+ */
+export function resolveDescription(description) {
+    try {
+        const g = loadKnowledgeGraph();
+        const lower = description.toLowerCase();
+        // Type-based resolution
+        const typeMap = {
+            "web server": "service", "api server": "service", "app server": "service",
+            "database": "database", "db": "database",
+            "container": "container", "box": "server", "machine": "server",
+        };
+        for (const [desc, type] of Object.entries(typeMap)) {
+            if (lower.includes(desc)) {
+                const matches = Object.values(g.entities).filter(e => e.type === type);
+                if (matches.length === 1)
+                    return matches[0]; // Only one of that type — must be it
+            }
+        }
+    }
+    catch { }
+    return null;
+}
+/** Reset cached vocabulary (call after graph changes). */
+export function resetEntityVocab() {
+    _entityVocab = null;
+}

package/dist/nlp/knowledgeGraph.d.ts

@@ -0,0 +1,70 @@
+export type EntityType = "service" | "server" | "database" | "port" | "user" | "package" | "container" | "path" | "llm" | "channel";
+export type RelationType = "runs_on" | "depends_on" | "has_port" | "has_ip" | "installed_on" | "uses" | "owned_by" | "connects_to" | "requires";
+export interface GraphEntity {
+    name: string;
+    type: EntityType;
+    aliases: string[];
+    properties: Record<string, string | number | boolean>;
+}
+export interface GraphRelation {
+    from: string;
+    to: string;
+    relation: RelationType;
+    properties?: Record<string, string | number | boolean>;
+}
+export interface KnowledgeGraph {
+    entities: Record<string, GraphEntity>;
+    relations: GraphRelation[];
+    lastBuilt?: string;
+}
+export declare function loadKnowledgeGraph(): KnowledgeGraph;
+export declare function saveKnowledgeGraph(graph?: KnowledgeGraph): void;
+export declare function addEntity(name: string, type: EntityType, aliases?: string[], properties?: Record<string, string | number | boolean>): GraphEntity;
+export declare function addRelation(from: string, to: string, relation: RelationType, properties?: Record<string, string | number | boolean>): GraphRelation;
+/** Find an entity by exact name, alias, or prefix (min 3 chars). */
+export declare function getEntity(name: string): GraphEntity | null;
+/** Find all entities related to entityName, optionally filtered by relation type. */
+export declare function getRelated(entityName: string, relation?: RelationType): Array<{
+    entity: GraphEntity;
+    relation: GraphRelation;
+    direction: "outgoing" | "incoming";
+}>;
+/** A scored candidate for reference resolution. */
+export interface ResolutionCandidate {
+    entity: GraphEntity;
+    score: number;
+    reason: string;
+}
+/**
+ * Resolve "it", "the server", "that service" using graph context + recent entities.
+ * Returns the best candidate. Use resolveCandidates() for all scored options.
+ */
+export declare function resolveReference(text: string, recentEntities: string[]): GraphEntity | null;
+/**
+ * Get all resolution candidates, scored and ranked.
+ * Scores: recent entity = 1.0 - (0.1 * position), type match = +0.2, relation match = +0.15
+ */
+export declare function resolveCandidates(text: string, recentEntities: string[]): ResolutionCandidate[];
+/** Use relationships to infer intent context from tokens. Resolves anaphora and finds target/location. */
+export declare function inferIntent(tokens: string[], recentEntities?: string[]): {
+    resolvedEntities: Array<{
+        token: string;
+        entity: GraphEntity;
+    }>;
+    impliedRelations: GraphRelation[];
+    target?: GraphEntity;
+    location?: GraphEntity;
+};
+/** General-purpose query — find entities by type and/or property filter. */
+export declare function queryGraph(filter: {
+    type?: EntityType;
+    property?: string;
+    value?: string | number | boolean;
+}): GraphEntity[];
+/** Build the full knowledge graph from all sources. */
+export declare function buildGraph(): KnowledgeGraph;
+/** Force a rebuild of the graph from all sources and persist. */
+export declare function rebuildGraph(): KnowledgeGraph;
+export declare function learnFromExecution(intent: string, fields: Record<string, unknown>, rawText: string): void;
+/** Flush any pending graph changes to disk. */
+export declare function flushGraph(): void;