notoken-core 1.0.0

package/dist/healing/ruleBuilder.js

@@ -0,0 +1,111 @@
+import { loadRules, loadIntents } from "../utils/config.js";
+import { RulePatch as RulePatchSchema } from "../types/rules.js";
+/**
+ * RuleBuilder: asks an LLM to propose new rules from a set of example phrases.
+ */
+export async function buildRulesFromExamples(examples) {
+    const endpoint = process.env.MYCLI_LLM_ENDPOINT;
+    if (!endpoint) {
+        console.error("Set MYCLI_LLM_ENDPOINT to use the RuleBuilder.");
+        return null;
+    }
+    const rules = loadRules();
+    const intents = loadIntents();
+    const apiKey = process.env.MYCLI_LLM_API_KEY ?? "";
+    const intentList = intents.map((i) => `- ${i.name}: ${i.description}`).join("\n");
+    const prompt = `You are a rule builder for a CLI command parser.
+
+Current rules config:
+${JSON.stringify(rules, null, 2)}
+
+Supported intents (from intents.json):
+${intentList}
+
+The following user phrases were NOT understood by the current parser:
+${examples.map((e) => `- "${e}"`).join("\n")}
+
+Analyze each phrase and propose a structured patch to expand the rules.
+
+Return a JSON object with this exact schema:
+{
+  "summary": "what this patch does",
+  "confidence": 0.0-1.0,
+  "changes": [
+    { "type": "add_intent_synonym", "intent": "...", "phrase": "..." },
+    { "type": "add_env_alias", "canonical": "...", "alias": "..." },
+    { "type": "add_service_alias", "canonical": "...", "alias": "..." }
+  ],
+  "tests": [
+    { "input": "...", "expectedIntent": "...", "expectedFields": {} },
+    { "input": "...", "shouldReject": true }
+  ],
+  "warnings": ["any overlap or risk concerns"]
+}
+
+Rules:
+- Only add synonyms/aliases that clearly map to existing intents or entities.
+- Include at least one positive and one negative test per change.
+- Warn if a new synonym could overlap with another intent.
+- Do NOT invent new intents.
+- Return ONLY the JSON object.`;
+    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: 1024,
+                messages: [{ role: "user", content: prompt }],
+            }),
+        });
+        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;
+        const parsed = RulePatchSchema.safeParse(json);
+        if (!parsed.success) {
+            console.error("LLM returned invalid patch:", parsed.error.message);
+            return null;
+        }
+        return parsed.data;
+    }
+    catch (err) {
+        console.error("RuleBuilder error:", err);
+        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;
+    }
+    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/healing/ruleRepairer.d.ts

@@ -0,0 +1,8 @@
+import type { RulePatch } from "../types/rules.js";
+/**
+ * RuleRepairer: reads the failure log and proposes patches to fix unmatched inputs.
+ *
+ * It batches recent failures, deduplicates, and sends them to the RuleBuilder
+ * which uses an LLM to propose structured changes.
+ */
+export declare function repairFromFailures(maxFailures?: number): Promise<RulePatch | null>;

package/dist/healing/ruleRepairer.js

@@ -0,0 +1,29 @@
+import { loadFailures } from "../utils/logger.js";
+import { buildRulesFromExamples } from "./ruleBuilder.js";
+/**
+ * RuleRepairer: reads the failure log and proposes patches to fix unmatched inputs.
+ *
+ * It batches recent failures, deduplicates, and sends them to the RuleBuilder
+ * which uses an LLM to propose structured changes.
+ */
+export async function repairFromFailures(maxFailures = 20) {
+    const failures = loadFailures();
+    if (failures.length === 0) {
+        console.log("No failures to repair.");
+        return null;
+    }
+    // Deduplicate by rawText, take the most recent N
+    const unique = deduplicateFailures(failures);
+    const batch = unique.slice(-maxFailures);
+    console.log(`Repairing from ${batch.length} unique failure(s)...`);
+    const examples = batch.map((f) => f.rawText);
+    return buildRulesFromExamples(examples);
+}
+function deduplicateFailures(failures) {
+    const seen = new Map();
+    for (const f of failures) {
+        const key = f.rawText.trim().toLowerCase();
+        seen.set(key, f); // keep latest
+    }
+    return Array.from(seen.values());
+}

package/dist/healing/ruleValidator.d.ts

@@ -0,0 +1,22 @@
+import type { RulePatch } from "../types/rules.js";
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+    testResults: Array<{
+        input: string;
+        passed: boolean;
+        reason?: string;
+    }>;
+}
+/**
+ * RuleValidator: checks a proposed patch for safety before promotion.
+ *
+ * Validates:
+ * - No overlapping synonyms across different intents
+ * - All referenced intents exist
+ * - All referenced environments/services exist
+ * - Test cases pass against the patched rule set
+ * - No dangerous broadening of high-risk intents
+ */
+export declare function validatePatch(patch: RulePatch): ValidationResult;

package/dist/healing/ruleValidator.js

@@ -0,0 +1,145 @@
+import { loadRules, loadIntents } from "../utils/config.js";
+import { parseByRules } from "../nlp/ruleParser.js";
+/**
+ * RuleValidator: checks a proposed patch for safety before promotion.
+ *
+ * Validates:
+ * - No overlapping synonyms across different intents
+ * - All referenced intents exist
+ * - All referenced environments/services exist
+ * - Test cases pass against the patched rule set
+ * - No dangerous broadening of high-risk intents
+ */
+export function validatePatch(patch) {
+    const rules = loadRules();
+    const errors = [];
+    const warnings = [...patch.warnings];
+    // Check each change
+    for (const change of patch.changes) {
+        switch (change.type) {
+            case "add_intent_synonym": {
+                const knownIntent = rules.intentSynonyms[change.intent] || loadIntents().some((i) => i.name === change.intent);
+                if (!knownIntent) {
+                    errors.push(`Unknown intent: ${change.intent}`);
+                }
+                // Check for overlap with other intents
+                const overlap = findSynonymOverlap(change.phrase, change.intent, rules);
+                if (overlap) {
+                    errors.push(`Synonym "${change.phrase}" overlaps with intent "${overlap}"`);
+                }
+                // Check for overly broad synonyms
+                if (change.phrase.length <= 2) {
+                    errors.push(`Synonym "${change.phrase}" is too short / too broad`);
+                }
+                break;
+            }
+            case "add_env_alias": {
+                if (!rules.environmentAliases[change.canonical]) {
+                    errors.push(`Unknown environment: ${change.canonical}`);
+                }
+                break;
+            }
+            case "add_service_alias": {
+                if (!rules.serviceAliases[change.canonical]) {
+                    errors.push(`Unknown service: ${change.canonical}`);
+                }
+                break;
+            }
+            case "remove_intent_synonym": {
+                const existing = rules.intentSynonyms[change.intent];
+                if (!existing?.includes(change.phrase)) {
+                    warnings.push(`Synonym "${change.phrase}" not found in intent "${change.intent}"`);
+                }
+                break;
+            }
+        }
+    }
+    // Simulate applying the patch and run tests
+    const patchedRules = simulateApply(rules, patch);
+    const testResults = runTests(patch, patchedRules);
+    const failedTests = testResults.filter((t) => !t.passed);
+    if (failedTests.length > 0) {
+        errors.push(`${failedTests.length} test(s) failed`);
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+        testResults,
+    };
+}
+function findSynonymOverlap(phrase, excludeIntent, rules) {
+    // Check rules.json synonyms
+    for (const [intent, phrases] of Object.entries(rules.intentSynonyms)) {
+        if (intent === excludeIntent)
+            continue;
+        if (phrases.includes(phrase))
+            return intent;
+    }
+    // Also check intents.json synonyms (primary source now)
+    for (const def of loadIntents()) {
+        if (def.name === excludeIntent)
+            continue;
+        if (def.synonyms.includes(phrase))
+            return def.name;
+    }
+    return null;
+}
+function simulateApply(rules, patch) {
+    const clone = JSON.parse(JSON.stringify(rules));
+    for (const change of patch.changes) {
+        switch (change.type) {
+            case "add_intent_synonym":
+                if (clone.intentSynonyms[change.intent]) {
+                    clone.intentSynonyms[change.intent].push(change.phrase);
+                }
+                break;
+            case "add_env_alias":
+                if (clone.environmentAliases[change.canonical]) {
+                    clone.environmentAliases[change.canonical].push(change.alias);
+                }
+                break;
+            case "add_service_alias":
+                if (clone.serviceAliases[change.canonical]) {
+                    clone.serviceAliases[change.canonical].push(change.alias);
+                }
+                break;
+            case "remove_intent_synonym":
+                if (clone.intentSynonyms[change.intent]) {
+                    clone.intentSynonyms[change.intent] = clone.intentSynonyms[change.intent].filter((p) => p !== change.phrase);
+                }
+                break;
+        }
+    }
+    return clone;
+}
+function runTests(patch, _patchedRules) {
+    // We test against current loaded rules + patch applied
+    // For now, we use parseByRules which reads from loadRules()
+    // In a full implementation, you'd inject the patched rules
+    return patch.tests.map((test) => {
+        const result = parseByRules(test.input);
+        if (test.shouldReject) {
+            return {
+                input: test.input,
+                passed: result === null || result.intent === "unknown",
+                reason: result ? `Matched as ${result.intent} but should reject` : undefined,
+            };
+        }
+        if (!result) {
+            return {
+                input: test.input,
+                passed: false,
+                reason: "No parse result",
+            };
+        }
+        if (test.expectedIntent && result.intent !== test.expectedIntent) {
+            return {
+                input: test.input,
+                passed: false,
+                reason: `Expected ${test.expectedIntent}, got ${result.intent}`,
+            };
+        }
+        return { input: test.input, passed: true };
+    });
+}

package/dist/healing/runHealer.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env tsx
+/**
+ * Standalone healer script.
+ *
+ * Reads the failure log, asks the LLM to propose fixes, validates,
+ * and optionally promotes the patch.
+ *
+ * Usage:
+ *   npx tsx src/healing/runHealer.ts [--promote] [--force] [--dry-run]
+ */
+export {};

package/dist/healing/runHealer.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env tsx
+/**
+ * Standalone healer script.
+ *
+ * Reads the failure log, asks the LLM to propose fixes, validates,
+ * and optionally promotes the patch.
+ *
+ * Usage:
+ *   npx tsx src/healing/runHealer.ts [--promote] [--force] [--dry-run]
+ */
+import { repairFromFailures } from "./ruleRepairer.js";
+import { validatePatch } from "./ruleValidator.js";
+import { promotePatch } from "./patchPromoter.js";
+import { clearFailures } from "../utils/logger.js";
+async function main() {
+    const args = process.argv.slice(2);
+    const shouldPromote = args.includes("--promote");
+    const force = args.includes("--force");
+    const dryRun = args.includes("--dry-run");
+    console.log("=== Auto-Learning Rule Repairer ===\n");
+    const patch = await repairFromFailures();
+    if (!patch) {
+        console.log("No patch generated.");
+        return;
+    }
+    console.log("\n--- Proposed Patch ---");
+    console.log(`Summary: ${patch.summary}`);
+    console.log(`Confidence: ${(patch.confidence * 100).toFixed(0)}%`);
+    console.log(`Changes: ${patch.changes.length}`);
+    for (const c of patch.changes) {
+        console.log(`  [${c.type}] ${JSON.stringify(c)}`);
+    }
+    console.log(`\nTests: ${patch.tests.length}`);
+    for (const t of patch.tests) {
+        const label = t.shouldReject ? "REJECT" : t.expectedIntent ?? "?";
+        console.log(`  "${t.input}" => ${label}`);
+    }
+    if (patch.warnings.length > 0) {
+        console.log(`\nWarnings:`);
+        for (const w of patch.warnings)
+            console.log(`  - ${w}`);
+    }
+    console.log("\n--- Validation ---");
+    const validation = validatePatch(patch);
+    console.log(`Valid: ${validation.valid}`);
+    if (validation.errors.length > 0) {
+        console.log("Errors:");
+        for (const e of validation.errors)
+            console.log(`  - ${e}`);
+    }
+    console.log("Test results:");
+    for (const t of validation.testResults) {
+        console.log(`  ${t.passed ? "PASS" : "FAIL"} "${t.input}"${t.reason ? ` (${t.reason})` : ""}`);
+    }
+    if (shouldPromote) {
+        console.log("\n--- Promoting ---");
+        const result = promotePatch(patch, { force, dryRun });
+        if (result.promoted) {
+            console.log("Patch applied successfully.");
+            clearFailures();
+            console.log("Failure log cleared.");
+        }
+        else {
+            console.log("Patch not promoted.");
+        }
+    }
+    else {
+        console.log("\nRun with --promote to apply this patch.");
+    }
+}
+main().catch((err) => {
+    console.error("Healer error:", err);
+    process.exit(1);
+});

package/dist/index.d.ts

@@ -0,0 +1,51 @@
+/**
+ * notoken-core — shared library.
+ *
+ * Exports the core engine that both CLI and Electron app use.
+ * This is the single source of truth for all notoken functionality.
+ *
+ * Usage:
+ *   import { parse, execute, detect, install, doctor } from "notoken/core";
+ */
+export { parseIntent } from "./nlp/parseIntent.js";
+export { parseByRules } from "./nlp/ruleParser.js";
+export { disambiguate } from "./nlp/disambiguate.js";
+export { classifyMulti } from "./nlp/multiClassifier.js";
+export { semanticParse, tokenize, keyboardDistance, fuzzyMatch } from "./nlp/semantic.js";
+export { analyzeUncertainty, getUncoveredSpans } from "./nlp/uncertainty.js";
+export { llmFallback, isLLMConfigured, getLLMBackend, formatLLMFallback } from "./nlp/llmFallback.js";
+export { executeIntent } from "./handlers/executor.js";
+export { runRemoteCommand, runLocalCommand } from "./execution/ssh.js";
+export { loadRules, loadIntents, getIntentDef, loadHosts, getConfigDir } from "./utils/config.js";
+export { CONFIG_DIR, DATA_DIR, LOG_DIR, PACKAGE_ROOT, USER_HOME, isSEA, ensureUserDirs } from "./utils/paths.js";
+export { detectLocalPlatform, getInstallCommand, getServiceCommand, getPackageForCommand, formatPlatform } from "./utils/platform.js";
+export type { PlatformInfo } from "./utils/platform.js";
+export { winToLinux, linuxToWin, normalizePath, getUserDirs, isWSL, isWindows } from "./utils/wslPaths.js";
+export { getLocalPermissions, getRemotePermissions, checkAccessForIntent, parsePermissionRequest, formatPermissionsDisplay } from "./utils/permissions.js";
+export { analyzeOutput, analyzeLoad, analyzeDisk, analyzeMemory } from "./utils/analysis.js";
+export { analyzeDirectory } from "./utils/dirAnalysis.js";
+export { smartRead, smartSearch, getFileInfo } from "./utils/smartFile.js";
+export { parseFile, formatParsedFile, detectFileType } from "./parsers/index.js";
+export { findKnownLocations, searchRemoteFile } from "./parsers/fileFinder.js";
+export { getOrCreateConversation, addUserTurn, addSystemTurn, saveConversation, getLastEntity, getRecentEntities, listConversations } from "./conversation/store.js";
+export type { Conversation, ConversationTurn, KnowledgeNode, UncertaintyReport } from "./conversation/store.js";
+export { resolveCoreferences, extractEntitiesFromFields } from "./conversation/coreference.js";
+export { redactSecrets, listSecrets, clearSecrets, saveSecretsToFile, resolvePlaceholders } from "./conversation/secrets.js";
+export { taskRunner, type BackgroundTask } from "./agents/taskRunner.js";
+export { agentSpawner, type AgentHandle } from "./agents/agentSpawner.js";
+export { createPlan, formatPlan } from "./agents/planner.js";
+export { loadPlaybooks, getPlaybook, runPlaybook, formatPlaybookList } from "./agents/playbookRunner.js";
+export { validatePatch } from "./healing/ruleValidator.js";
+export { promotePatch } from "./healing/patchPromoter.js";
+export { validateIntent, isDangerous, getRiskLevel } from "./policy/safety.js";
+export { askForConfirmation, askForChoice } from "./policy/confirm.js";
+export { formatVerbose, formatTaskNotification, formatJobsList } from "./utils/verbose.js";
+export { formatExplain } from "./utils/explain.js";
+export { formatParsedCommand } from "./utils/output.js";
+export { Spinner, withSpinner, progressBar } from "./utils/spinner.js";
+export { createBackup, rollback, listBackups, cleanExpiredBackups, formatBackupList } from "./utils/autoBackup.js";
+export { logFailure, loadFailures, clearFailures } from "./utils/logger.js";
+export { logUncertainty, loadUncertaintyLog, getUncertaintySummary } from "./nlp/uncertainty.js";
+export { recordHistory, loadHistory, getRecentHistory, searchHistory } from "./context/history.js";
+export type { DynamicIntent, ParsedCommand, IntentDef, FieldDef, EnvironmentName } from "./types/intent.js";
+export type { RulePatch, RulePatchChange, FailureLog, RulesConfig } from "./types/rules.js";

package/dist/index.js

@@ -0,0 +1,62 @@
+/**
+ * notoken-core — shared library.
+ *
+ * Exports the core engine that both CLI and Electron app use.
+ * This is the single source of truth for all notoken functionality.
+ *
+ * Usage:
+ *   import { parse, execute, detect, install, doctor } from "notoken/core";
+ */
+// ── NLP & Parsing ──
+export { parseIntent } from "./nlp/parseIntent.js";
+export { parseByRules } from "./nlp/ruleParser.js";
+export { disambiguate } from "./nlp/disambiguate.js";
+export { classifyMulti } from "./nlp/multiClassifier.js";
+export { semanticParse, tokenize, keyboardDistance, fuzzyMatch } from "./nlp/semantic.js";
+export { analyzeUncertainty, getUncoveredSpans } from "./nlp/uncertainty.js";
+export { llmFallback, isLLMConfigured, getLLMBackend, formatLLMFallback } from "./nlp/llmFallback.js";
+// ── Execution ──
+export { executeIntent } from "./handlers/executor.js";
+export { runRemoteCommand, runLocalCommand } from "./execution/ssh.js";
+// ── Config ──
+export { loadRules, loadIntents, getIntentDef, loadHosts, getConfigDir } from "./utils/config.js";
+export { CONFIG_DIR, DATA_DIR, LOG_DIR, PACKAGE_ROOT, USER_HOME, isSEA, ensureUserDirs } from "./utils/paths.js";
+// ── Platform & Detection ──
+export { detectLocalPlatform, getInstallCommand, getServiceCommand, getPackageForCommand, formatPlatform } from "./utils/platform.js";
+// ── Paths ──
+export { winToLinux, linuxToWin, normalizePath, getUserDirs, isWSL, isWindows } from "./utils/wslPaths.js";
+// ── Permissions ──
+export { getLocalPermissions, getRemotePermissions, checkAccessForIntent, parsePermissionRequest, formatPermissionsDisplay } from "./utils/permissions.js";
+// ── Analysis ──
+export { analyzeOutput, analyzeLoad, analyzeDisk, analyzeMemory } from "./utils/analysis.js";
+export { analyzeDirectory } from "./utils/dirAnalysis.js";
+// ── File Operations ──
+export { smartRead, smartSearch, getFileInfo } from "./utils/smartFile.js";
+export { parseFile, formatParsedFile, detectFileType } from "./parsers/index.js";
+export { findKnownLocations, searchRemoteFile } from "./parsers/fileFinder.js";
+// ── Conversation ──
+export { getOrCreateConversation, addUserTurn, addSystemTurn, saveConversation, getLastEntity, getRecentEntities, listConversations } from "./conversation/store.js";
+export { resolveCoreferences, extractEntitiesFromFields } from "./conversation/coreference.js";
+export { redactSecrets, listSecrets, clearSecrets, saveSecretsToFile, resolvePlaceholders } from "./conversation/secrets.js";
+// ── Agents & Background ──
+export { taskRunner } from "./agents/taskRunner.js";
+export { agentSpawner } from "./agents/agentSpawner.js";
+export { createPlan, formatPlan } from "./agents/planner.js";
+export { loadPlaybooks, getPlaybook, runPlaybook, formatPlaybookList } from "./agents/playbookRunner.js";
+// ── Healing / Learning ──
+export { validatePatch } from "./healing/ruleValidator.js";
+export { promotePatch } from "./healing/patchPromoter.js";
+// ── Safety ──
+export { validateIntent, isDangerous, getRiskLevel } from "./policy/safety.js";
+export { askForConfirmation, askForChoice } from "./policy/confirm.js";
+// ── UI Helpers ──
+export { formatVerbose, formatTaskNotification, formatJobsList } from "./utils/verbose.js";
+export { formatExplain } from "./utils/explain.js";
+export { formatParsedCommand } from "./utils/output.js";
+export { Spinner, withSpinner, progressBar } from "./utils/spinner.js";
+// ── Auto-backup ──
+export { createBackup, rollback, listBackups, cleanExpiredBackups, formatBackupList } from "./utils/autoBackup.js";
+// ── Logging ──
+export { logFailure, loadFailures, clearFailures } from "./utils/logger.js";
+export { logUncertainty, loadUncertaintyLog, getUncertaintySummary } from "./nlp/uncertainty.js";
+export { recordHistory, loadHistory, getRecentHistory, searchHistory } from "./context/history.js";

package/dist/intents/catalog.d.ts

@@ -0,0 +1,4 @@
+import type { IntentDef } from "../types/intent.js";
+export type { IntentDef };
+export declare function getIntentCatalog(): IntentDef[];
+export declare function getCatalogEntry(intentName: string): IntentDef | undefined;

package/dist/intents/catalog.js

@@ -0,0 +1,7 @@
+import { loadIntents, getIntentDef } from "../utils/config.js";
+export function getIntentCatalog() {
+    return loadIntents();
+}
+export function getCatalogEntry(intentName) {
+    return getIntentDef(intentName);
+}

package/dist/nlp/disambiguate.d.ts

@@ -0,0 +1,2 @@
+import type { DynamicIntent, ParsedCommand } from "../types/intent.js";
+export declare function disambiguate(intent: DynamicIntent): ParsedCommand;

package/dist/nlp/disambiguate.js

@@ -0,0 +1,46 @@
+import { getIntentDef } from "../utils/config.js";
+import { loadRules } from "../utils/config.js";
+const CONFIDENCE_THRESHOLD = 0.6;
+export function disambiguate(intent) {
+    const def = getIntentDef(intent.intent);
+    const missingFields = [];
+    const ambiguousFields = [];
+    if (def) {
+        for (const [fieldName, fieldDef] of Object.entries(def.fields)) {
+            if (fieldDef.required && intent.fields[fieldName] === undefined) {
+                missingFields.push(fieldName);
+            }
+        }
+        // Check for ambiguous service references
+        for (const [fieldName, fieldDef] of Object.entries(def.fields)) {
+            if (fieldDef.type === "service" && intent.fields[fieldName]) {
+                const candidates = findServiceCandidates(intent.fields[fieldName]);
+                if (candidates.length > 1) {
+                    ambiguousFields.push({ field: fieldName, candidates });
+                }
+            }
+        }
+    }
+    const needsClarification = missingFields.length > 0 ||
+        ambiguousFields.length > 0 ||
+        intent.confidence < CONFIDENCE_THRESHOLD;
+    return {
+        intent,
+        missingFields,
+        ambiguousFields,
+        needsClarification,
+    };
+}
+function findServiceCandidates(input) {
+    const rules = loadRules();
+    const matches = [];
+    for (const [canonical, aliases] of Object.entries(rules.serviceAliases)) {
+        for (const alias of aliases) {
+            if (alias.includes(input) || input.includes(alias)) {
+                matches.push(canonical);
+                break;
+            }
+        }
+    }
+    return matches;
+}

package/dist/nlp/fuzzyResolver.d.ts

@@ -0,0 +1,14 @@
+import type { DynamicIntent } from "../types/intent.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 declare function resolveFuzzyFields(intent: DynamicIntent): Promise<DynamicIntent>;