notoken-core 1.0.0

package/dist/handlers/executor.js

@@ -0,0 +1,216 @@
+import { getIntentDef, loadHosts } from "../utils/config.js";
+import { runRemoteCommand, runLocalCommand } from "../execution/ssh.js";
+import { gitStatus, gitLog, gitDiff, gitPull, gitPush, gitBranch, gitCheckout, gitCommit, gitAdd, gitStash, gitReset, } from "../execution/git.js";
+import { resolveFuzzyFields } from "../nlp/fuzzyResolver.js";
+import { recordHistory } from "../context/history.js";
+import { createBackup, getRemoteBackupCommand } from "../utils/autoBackup.js";
+import { detectLocalPlatform, getPackageForCommand, getInstallCommand } from "../utils/platform.js";
+import { withSpinner } from "../utils/spinner.js";
+import { analyzeOutput } from "../utils/analysis.js";
+import { smartRead, smartSearch } from "../utils/smartFile.js";
+/**
+ * Generic command executor.
+ *
+ * For git.* intents, uses simple-git for richer programmatic output.
+ * For everything else, interpolates command templates and runs via shell.
+ */
+export async function executeIntent(intent) {
+    const def = getIntentDef(intent.intent);
+    if (!def) {
+        throw new Error(`No intent definition found for: ${intent.intent}`);
+    }
+    // Fuzzy resolve file paths if needed
+    const resolved = await resolveFuzzyFields(intent);
+    const fields = resolved.fields;
+    const environment = fields.environment ?? "local";
+    // "local" environment means run on this machine, not SSH
+    // Also run locally if no real hosts are configured (placeholder hosts)
+    const isLocal = def.execution === "local"
+        || environment === "local"
+        || environment === "localhost"
+        || !hasRealHost(environment);
+    let result;
+    let command;
+    // Auto-backup before destructive file operations
+    const destructiveIntents = ["files.copy", "files.move", "files.remove", "env.set"];
+    if (destructiveIntents.includes(intent.intent)) {
+        const targetFile = (fields.source ?? fields.target ?? fields.path);
+        if (targetFile) {
+            if (def.execution === "local") {
+                const backup = createBackup(targetFile, intent.intent);
+                if (backup) {
+                    console.error(`\x1b[2m[auto-backup] ${backup.originalPath} → ${backup.backupPath}\x1b[0m`);
+                }
+            }
+            // For remote: prepend backup command
+        }
+    }
+    // Smart file reading — size check, sampling, context search
+    if (intent.intent === "file.read" || intent.intent === "file.parse") {
+        const filePath = fields.path ?? "";
+        if (filePath) {
+            command = `[smart-read] ${filePath}`;
+            result = await withSpinner(`Reading ${filePath}...`, () => smartRead(filePath, !isLocal, isLocal ? undefined : environment));
+            recordHistory({ timestamp: new Date().toISOString(), rawText: intent.rawText, intent: intent.intent, fields, command, environment, success: true });
+            return result;
+        }
+    }
+    if (intent.intent === "file.search_in") {
+        const filePath = fields.path ?? "";
+        const query = fields.query ?? "";
+        if (filePath && query) {
+            command = `[smart-search] ${query} in ${filePath}`;
+            result = await withSpinner(`Searching "${query}" in ${filePath}...`, () => smartSearch(filePath, query, !isLocal, isLocal ? undefined : environment));
+            recordHistory({ timestamp: new Date().toISOString(), rawText: intent.rawText, intent: intent.intent, fields, command, environment, success: true });
+            return result;
+        }
+    }
+    // Route git intents through simple-git for better output
+    if (intent.intent.startsWith("git.")) {
+        command = `[simple-git] ${intent.intent}`;
+        result = await withSpinner(`${intent.intent}...`, () => executeGitIntent(intent.intent, fields));
+    }
+    else {
+        command = interpolateCommand(def, fields);
+        // For remote destructive ops, prepend a backup command
+        if (destructiveIntents.includes(intent.intent) && !isLocal) {
+            const targetFile = (fields.source ?? fields.target ?? fields.path);
+            if (targetFile) {
+                command = getRemoteBackupCommand(targetFile) + command;
+            }
+        }
+        const spinnerMsg = isLocal
+            ? `${intent.intent}...`
+            : `${intent.intent} on ${environment}...`;
+        try {
+            result = await withSpinner(spinnerMsg, async () => {
+                if (isLocal) {
+                    return runLocalCommand(command);
+                }
+                else {
+                    return runRemoteCommand(environment, command);
+                }
+            });
+        }
+        catch (err) {
+            // Auto-detect missing commands and suggest install
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg.includes("command not found") || msg.includes("not found")) {
+                const missingCmd = extractMissingCommand(msg);
+                if (missingCmd) {
+                    const platform = detectLocalPlatform();
+                    const pkg = getPackageForCommand(missingCmd, platform);
+                    const installCmd = getInstallCommand(pkg ?? missingCmd, platform);
+                    throw new Error(`${msg}\n\nMissing command: ${missingCmd}\nInstall with: ${installCmd}`);
+                }
+            }
+            throw err;
+        }
+    }
+    recordHistory({
+        timestamp: new Date().toISOString(),
+        rawText: intent.rawText,
+        intent: intent.intent,
+        fields,
+        command,
+        environment,
+        success: true,
+    });
+    // Append intelligent analysis if applicable
+    const analysis = analyzeOutput(intent.intent, result, fields);
+    if (analysis) {
+        result += "\n" + analysis;
+    }
+    return result;
+}
+async function executeGitIntent(intentName, fields) {
+    const path = fields.path ?? ".";
+    switch (intentName) {
+        case "git.status":
+            return gitStatus(path);
+        case "git.log":
+            return gitLog(path, fields.count ?? 10);
+        case "git.diff":
+            return gitDiff(path, fields.target);
+        case "git.pull":
+            return gitPull(path, fields.remote ?? "origin", fields.branch);
+        case "git.push":
+            return gitPush(path, fields.remote ?? "origin", fields.branch);
+        case "git.branch":
+            return gitBranch(path);
+        case "git.checkout":
+            return gitCheckout(fields.branch, path);
+        case "git.commit":
+            return gitCommit(fields.message, path);
+        case "git.add":
+            return gitAdd(fields.target ?? ".", path);
+        case "git.stash":
+            return gitStash(fields.action ?? "push", path);
+        case "git.reset":
+            return gitReset(fields.target ?? "HEAD", path);
+        default:
+            throw new Error(`Unknown git intent: ${intentName}`);
+    }
+}
+function interpolateCommand(def, fields) {
+    let cmd = def.command;
+    for (const [key, value] of Object.entries(fields)) {
+        if (value !== undefined && value !== null) {
+            const safe = sanitize(String(value));
+            cmd = cmd.replaceAll(`{{${key}}}`, safe);
+        }
+    }
+    for (const [fieldName, fieldDef] of Object.entries(def.fields)) {
+        if (fieldDef.default !== undefined) {
+            const safe = sanitize(String(fieldDef.default));
+            cmd = cmd.replaceAll(`{{${fieldName}}}`, safe);
+        }
+    }
+    cmd = cmd.replace(/\{\{[a-zA-Z_]+\}\}/g, "");
+    return cmd.trim();
+}
+function sanitize(value) {
+    if (value === "")
+        return "";
+    if (!/^[a-zA-Z0-9_.\/\\\- :@~]+$/.test(value)) {
+        throw new Error(`Unsafe field value rejected: "${value}"`);
+    }
+    return value;
+}
+function extractMissingCommand(errorMsg) {
+    const match1 = errorMsg.match(/bash: (\w+): command not found/);
+    if (match1)
+        return match1[1];
+    const match2 = errorMsg.match(/sh: \d+: (\w+): not found/);
+    if (match2)
+        return match2[1];
+    const match3 = errorMsg.match(/\/bin\/\w+: (\w+): not found/);
+    if (match3)
+        return match3[1];
+    return null;
+}
+/**
+ * Check if a real (non-placeholder) SSH host is configured for an environment.
+ * Placeholder hosts like "user@dev-server" are detected and treated as unconfigured.
+ */
+function hasRealHost(environment) {
+    try {
+        const hosts = loadHosts();
+        const entry = hosts[environment];
+        if (!entry)
+            return false;
+        const host = entry.host;
+        // Detect common placeholder patterns
+        const placeholders = [
+            /user@(dev|staging|prod|test)-server$/,
+            /user@(dev|staging|prod|test)$/,
+            /example\.com$/,
+            /localhost$/,
+            /127\.0\.0\.1$/,
+        ];
+        return !placeholders.some((p) => p.test(host));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/healing/claudeHealer.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env tsx
+/**
+ * Claude-powered auto-learning.
+ *
+ * Uses Claude CLI to:
+ * 1. Read the current rules.json and intents.json structure
+ * 2. Read the failure log (phrases that didn't match)
+ * 3. Read the uncertainty log (phrases with low confidence)
+ * 4. Analyze gaps and propose structured changes
+ * 5. Let Claude request to see/grep specific files
+ * 6. Validate and apply the changes
+ *
+ * Usage:
+ *   npx tsx src/healing/claudeHealer.ts [--promote] [--dry-run]
+ *   MYCLI_LLM_CLI=claude npm run heal:claude
+ */
+export {};

package/dist/healing/claudeHealer.js

@@ -0,0 +1,300 @@
+#!/usr/bin/env tsx
+/**
+ * Claude-powered auto-learning.
+ *
+ * Uses Claude CLI to:
+ * 1. Read the current rules.json and intents.json structure
+ * 2. Read the failure log (phrases that didn't match)
+ * 3. Read the uncertainty log (phrases with low confidence)
+ * 4. Analyze gaps and propose structured changes
+ * 5. Let Claude request to see/grep specific files
+ * 6. Validate and apply the changes
+ *
+ * Usage:
+ *   npx tsx src/healing/claudeHealer.ts [--promote] [--dry-run]
+ *   MYCLI_LLM_CLI=claude npm run heal:claude
+ */
+import { execSync, execFileSync } from "node:child_process";
+import { readFileSync, existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { validatePatch } from "./ruleValidator.js";
+import { promotePatch } from "./patchPromoter.js";
+import { CONFIG_DIR, PACKAGE_ROOT } from "../utils/paths.js";
+import { clearFailures, loadFailures } from "../utils/logger.js";
+import { loadUncertaintyLog } from "../nlp/uncertainty.js";
+const c = { reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m", green: "\x1b[32m", yellow: "\x1b[33m", red: "\x1b[31m", cyan: "\x1b[36m" };
+async function main() {
+    const args = process.argv.slice(2);
+    const shouldPromote = args.includes("--promote");
+    const dryRun = args.includes("--dry-run");
+    const force = args.includes("--force");
+    console.log(`${c.bold}${c.cyan}=== Claude Auto-Learning ====${c.reset}\n`);
+    // Check Claude CLI
+    try {
+        execSync("command -v claude", { stdio: "pipe" });
+    }
+    catch {
+        console.error(`${c.red}Claude CLI not found. Install it or set MYCLI_LLM_CLI=claude.${c.reset}`);
+        process.exit(1);
+    }
+    // Gather context
+    const failures = loadFailures();
+    const uncertainty = loadUncertaintyLog();
+    const rulesJson = readFileSync(resolve(CONFIG_DIR, "rules.json"), "utf-8");
+    const intentsJson = readFileSync(resolve(CONFIG_DIR, "intents.json"), "utf-8");
+    // Summarize intents (don't send the whole 70KB file)
+    const intents = JSON.parse(intentsJson);
+    const intentSummary = intents.intents.map((i) => ({
+        name: i.name,
+        synonyms: i.synonyms,
+        description: i.description,
+    }));
+    if (failures.length === 0 && uncertainty.length === 0) {
+        console.log(`${c.green}✓ No failures or uncertainty to fix.${c.reset}`);
+        return;
+    }
+    console.log(`${c.dim}Failures: ${failures.length} | Uncertain phrases: ${uncertainty.length}${c.reset}\n`);
+    // Build the prompt for Claude
+    const prompt = buildHealerPrompt(failures, uncertainty, rulesJson, intentSummary);
+    console.log(`${c.dim}Asking Claude to analyze...${c.reset}\n`);
+    // Call Claude CLI
+    const response = callClaude(prompt);
+    if (!response) {
+        console.error(`${c.red}Claude returned no response.${c.reset}`);
+        return;
+    }
+    // Extract the JSON patch from Claude's response
+    const patch = extractPatch(response);
+    if (!patch) {
+        // Claude might want to see a file first — check for requests
+        const fileRequest = extractFileRequest(response);
+        if (fileRequest) {
+            console.log(`${c.cyan}Claude wants to see: ${fileRequest}${c.reset}`);
+            const fileContent = readRequestedFile(fileRequest);
+            // Follow up with the file content
+            const followUp = `Here is the content of ${fileRequest}:\n\n${fileContent}\n\nNow based on this, provide the structured JSON patch as described.`;
+            const response2 = callClaude(followUp);
+            const patch2 = response2 ? extractPatch(response2) : null;
+            if (patch2) {
+                applyPatch(patch2, shouldPromote, dryRun, force);
+            }
+            else {
+                console.log(`\n${c.bold}Claude's analysis:${c.reset}`);
+                console.log(response2 ?? response);
+            }
+        }
+        else {
+            // Just show Claude's analysis
+            console.log(`\n${c.bold}Claude's analysis:${c.reset}`);
+            console.log(response);
+        }
+        return;
+    }
+    applyPatch(patch, shouldPromote, dryRun, force);
+}
+function buildHealerPrompt(failures, uncertainty, rulesJson, intentSummary) {
+    const failureList = failures.slice(-20).map((f) => `  - "${f.rawText}"`).join("\n");
+    const uncertainList = uncertainty.slice(-15).map((u) => `  - "${u.rawText}" (conf: ${(u.overallConfidence * 100).toFixed(0)}%, unknown: ${u.unknownTokens.join(", ") || "none"})`).join("\n");
+    return `You are analyzing an NLP-based CLI tool that parses natural language into server operation commands.
+
+## HOW THE SYSTEM WORKS
+
+The CLI has two config files:
+
+1. **rules.json** — contains environment aliases (prod, staging, dev) and service aliases (nginx, redis, api, etc.)
+   These are used to extract entities from user input.
+
+2. **intents.json** — each intent has:
+   - "name": the intent identifier (e.g., "service.restart")
+   - "synonyms": an array of phrases that trigger this intent via substring matching
+   - "fields": what gets extracted (service, environment, path, etc.)
+   - "command": the shell command template with {{field}} placeholders
+
+   **The parser matches by finding the LONGEST synonym substring in the user's input.**
+   So if user says "restart nginx on prod", and "restart" (7 chars) is a synonym for service.restart,
+   it matches. If another intent had "restart nginx" (13 chars), that would win.
+
+## CURRENT RULES.JSON
+${rulesJson}
+
+## CURRENT INTENTS (${intentSummary.length} total)
+${JSON.stringify(intentSummary, null, 2)}
+
+## FAILED PHRASES (these didn't match any intent)
+${failureList || "  (none)"}
+
+## UNCERTAIN PHRASES (matched but with low confidence or unknown tokens)
+${uncertainList || "  (none)"}
+
+## YOUR TASK
+
+Analyze the failures and uncertainties. Propose a JSON patch to fix them.
+
+You can:
+1. Add new synonyms to existing intents (most common fix)
+2. Add new service/environment aliases to rules.json
+3. Suggest new intents if truly needed
+
+**IMPORTANT**: Synonyms work by substring matching. A synonym like "check" will match ANY text containing "check".
+Short synonyms can cause false positives. Prefer longer, more specific synonyms.
+
+If you need to see a specific file to understand the system better, say:
+"I need to see: <filepath>"
+
+Otherwise, return a JSON patch in this format:
+\`\`\`json
+{
+  "summary": "what this patch does",
+  "confidence": 0.0-1.0,
+  "changes": [
+    { "type": "add_intent_synonym", "intent": "service.restart", "phrase": "recycle" },
+    { "type": "add_env_alias", "canonical": "prod", "alias": "production-server" },
+    { "type": "add_service_alias", "canonical": "nginx", "alias": "webserver" }
+  ],
+  "tests": [
+    { "input": "recycle nginx on prod", "expectedIntent": "service.restart" },
+    { "input": "random unrelated phrase", "shouldReject": true }
+  ],
+  "warnings": ["any concerns about these changes"]
+}
+\`\`\`
+
+Be conservative. Only add changes that clearly fix the reported failures.`;
+}
+function callClaude(prompt) {
+    try {
+        const result = execFileSync("claude", ["-p", prompt, "--no-session-persistence", "--max-turns", "2",
+            "--append-system-prompt", "IMPORTANT: Do NOT use any tools. Do NOT read files. All the context you need is in the prompt. Respond with ONLY the JSON patch object. No explanation, just JSON."], {
+            encoding: "utf-8",
+            timeout: 180_000,
+            stdio: ["pipe", "pipe", "pipe"],
+            cwd: PACKAGE_ROOT,
+            maxBuffer: 10 * 1024 * 1024,
+        });
+        return result.trim();
+    }
+    catch (err) {
+        const e = err;
+        if (e.stdout && e.stdout.trim())
+            return e.stdout.trim();
+        const msg = e.stderr ?? e.message ?? String(err);
+        console.error(`${c.red}Claude error: ${msg.split("\n")[0]}${c.reset}`);
+        return null;
+    }
+}
+function extractPatch(response) {
+    // Try JSON code block
+    const jsonMatch = response.match(/```json\s*([\s\S]*?)```/);
+    if (jsonMatch) {
+        try {
+            const parsed = JSON.parse(jsonMatch[1].trim());
+            if (parsed.changes && Array.isArray(parsed.changes)) {
+                return { ...parsed, warnings: parsed.warnings ?? [] };
+            }
+        }
+        catch { }
+    }
+    // Try raw JSON
+    const rawMatch = response.match(/\{[\s\S]*"changes"[\s\S]*\}/);
+    if (rawMatch) {
+        try {
+            const parsed = JSON.parse(rawMatch[0]);
+            if (parsed.changes)
+                return { ...parsed, warnings: parsed.warnings ?? [] };
+        }
+        catch { }
+    }
+    return null;
+}
+function extractFileRequest(response) {
+    const match = response.match(/I need to see:\s*(\S+)/i);
+    if (match)
+        return match[1];
+    const match2 = response.match(/(?:show me|let me see|can I see|read)\s+(\S+\.\w+)/i);
+    if (match2)
+        return match2[1];
+    return null;
+}
+function readRequestedFile(request) {
+    // Try relative to config dir, then project root, then absolute
+    const candidates = [
+        resolve(CONFIG_DIR, request),
+        resolve(CONFIG_DIR, "..", request),
+        request,
+    ];
+    for (const path of candidates) {
+        if (existsSync(path)) {
+            const content = readFileSync(path, "utf-8");
+            // Truncate if huge
+            if (content.length > 10000) {
+                return content.slice(0, 10000) + `\n\n... (truncated, ${content.length} total chars)`;
+            }
+            return content;
+        }
+    }
+    return `File not found: ${request}`;
+}
+function applyPatch(patch, shouldPromote, dryRun, force = false) {
+    console.log(`\n${c.bold}--- Proposed Patch ---${c.reset}`);
+    console.log(`${c.cyan}Summary:${c.reset} ${patch.summary}`);
+    console.log(`${c.cyan}Confidence:${c.reset} ${(patch.confidence * 100).toFixed(0)}%`);
+    console.log(`${c.cyan}Changes:${c.reset} ${patch.changes.length}`);
+    for (const change of patch.changes) {
+        switch (change.type) {
+            case "add_intent_synonym":
+                console.log(`  ${c.green}+${c.reset} synonym "${change.phrase}" → ${change.intent}`);
+                break;
+            case "add_env_alias":
+                console.log(`  ${c.green}+${c.reset} env alias "${change.alias}" → ${change.canonical}`);
+                break;
+            case "add_service_alias":
+                console.log(`  ${c.green}+${c.reset} service alias "${change.alias}" → ${change.canonical}`);
+                break;
+            case "remove_intent_synonym":
+                console.log(`  ${c.red}-${c.reset} remove synonym "${change.phrase}" from ${change.intent}`);
+                break;
+        }
+    }
+    if (patch.tests.length > 0) {
+        console.log(`\n${c.cyan}Tests:${c.reset} ${patch.tests.length}`);
+        for (const t of patch.tests) {
+            const label = t.shouldReject ? `${c.red}REJECT${c.reset}` : `${c.green}${t.expectedIntent}${c.reset}`;
+            console.log(`  "${t.input}" → ${label}`);
+        }
+    }
+    if (patch.warnings.length > 0) {
+        console.log(`\n${c.yellow}Warnings:${c.reset}`);
+        for (const w of patch.warnings)
+            console.log(`  - ${w}`);
+    }
+    // Validate
+    console.log(`\n${c.bold}--- Validation ---${c.reset}`);
+    const validation = validatePatch(patch);
+    console.log(`Valid: ${validation.valid ? `${c.green}yes${c.reset}` : `${c.red}no${c.reset}`}`);
+    if (validation.errors.length > 0) {
+        for (const e of validation.errors)
+            console.log(`  ${c.red}✗ ${e}${c.reset}`);
+    }
+    for (const t of validation.testResults) {
+        console.log(`  ${t.passed ? `${c.green}✓${c.reset}` : `${c.red}✗${c.reset}`} "${t.input}"${t.reason ? ` (${t.reason})` : ""}`);
+    }
+    if (shouldPromote) {
+        console.log(`\n${c.bold}--- Promoting ---${c.reset}`);
+        const result = promotePatch(patch, { force, dryRun });
+        if (result.promoted) {
+            console.log(`${c.green}✓ Patch applied. Rules updated to v${result.newVersion}${c.reset}`);
+            clearFailures();
+            console.log(`${c.green}✓ Failure log cleared.${c.reset}`);
+        }
+        else {
+            console.log(`${c.yellow}Patch not promoted.${c.reset}`);
+        }
+    }
+    else {
+        console.log(`\n${c.dim}Run with --promote to apply. Add --dry-run for safe preview.${c.reset}`);
+    }
+}
+main().catch((err) => {
+    console.error(`${c.red}Healer error:${c.reset}`, err.message ?? err);
+    process.exit(1);
+});

package/dist/healing/patchPromoter.d.ts

@@ -0,0 +1,25 @@
+import type { RulePatch } from "../types/rules.js";
+import { type ValidationResult } from "./ruleValidator.js";
+export interface PromotionResult {
+    promoted: boolean;
+    validation: ValidationResult;
+    backupPath?: string;
+    newVersion?: string;
+}
+/**
+ * PatchPromoter: validates and applies a rule patch to the live config.
+ *
+ * Flow:
+ * 1. Validate the patch
+ * 2. If valid, back up current rules
+ * 3. Apply changes to rules.json
+ * 4. Bump version
+ *
+ * Options:
+ * - force: skip validation (not recommended)
+ * - dryRun: validate but don't write
+ */
+export declare function promotePatch(patch: RulePatch, options?: {
+    force?: boolean;
+    dryRun?: boolean;
+}): PromotionResult;

package/dist/healing/patchPromoter.js

@@ -0,0 +1,118 @@
+import { readFileSync, writeFileSync, copyFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { RulesConfig } from "../types/rules.js";
+import { getConfigDir } from "../utils/config.js";
+import { validatePatch } from "./ruleValidator.js";
+/**
+ * PatchPromoter: validates and applies a rule patch to the live config.
+ *
+ * Flow:
+ * 1. Validate the patch
+ * 2. If valid, back up current rules
+ * 3. Apply changes to rules.json
+ * 4. Bump version
+ *
+ * Options:
+ * - force: skip validation (not recommended)
+ * - dryRun: validate but don't write
+ */
+export function promotePatch(patch, options = {}) {
+    const validation = validatePatch(patch);
+    if (!validation.valid && !options.force) {
+        return { promoted: false, validation };
+    }
+    if (validation.warnings.length > 0) {
+        console.log("Warnings:");
+        for (const w of validation.warnings)
+            console.log(`  - ${w}`);
+    }
+    if (options.dryRun) {
+        console.log("Dry run — patch is valid but not applied.");
+        return { promoted: false, validation };
+    }
+    const configDir = getConfigDir();
+    const rulesPath = resolve(configDir, "rules.json");
+    const raw = readFileSync(rulesPath, "utf-8");
+    const rules = RulesConfig.parse(JSON.parse(raw));
+    // Backup
+    const backupPath = resolve(configDir, `rules.backup.${Date.now()}.json`);
+    copyFileSync(rulesPath, backupPath);
+    // Also load intents.json for synonym changes (primary source now)
+    const intentsPath = resolve(configDir, "intents.json");
+    const intentsRaw = JSON.parse(readFileSync(intentsPath, "utf-8"));
+    const intentsBackup = resolve(configDir, `intents.backup.${Date.now()}.json`);
+    copyFileSync(intentsPath, intentsBackup);
+    let intentsChanged = false;
+    // Apply changes
+    for (const change of patch.changes) {
+        switch (change.type) {
+            case "add_intent_synonym": {
+                // Add to intents.json (primary)
+                const intentDef = intentsRaw.intents?.find((i) => i.name === change.intent);
+                if (intentDef && Array.isArray(intentDef.synonyms)) {
+                    if (!intentDef.synonyms.includes(change.phrase)) {
+                        intentDef.synonyms.push(change.phrase);
+                        intentsChanged = true;
+                    }
+                }
+                // Also add to rules.json if the intent exists there (backward compat)
+                if (rules.intentSynonyms[change.intent]) {
+                    if (!rules.intentSynonyms[change.intent].includes(change.phrase)) {
+                        rules.intentSynonyms[change.intent].push(change.phrase);
+                    }
+                }
+                break;
+            }
+            case "add_env_alias":
+                if (rules.environmentAliases[change.canonical]) {
+                    if (!rules.environmentAliases[change.canonical].includes(change.alias)) {
+                        rules.environmentAliases[change.canonical].push(change.alias);
+                    }
+                }
+                break;
+            case "add_service_alias":
+                if (rules.serviceAliases[change.canonical]) {
+                    if (!rules.serviceAliases[change.canonical].includes(change.alias)) {
+                        rules.serviceAliases[change.canonical].push(change.alias);
+                    }
+                }
+                break;
+            case "remove_intent_synonym": {
+                // Remove from intents.json
+                const rmDef = intentsRaw.intents?.find((i) => i.name === change.intent);
+                if (rmDef && Array.isArray(rmDef.synonyms)) {
+                    rmDef.synonyms = rmDef.synonyms.filter((s) => s !== change.phrase);
+                    intentsChanged = true;
+                }
+                // Also remove from rules.json
+                if (rules.intentSynonyms[change.intent]) {
+                    rules.intentSynonyms[change.intent] = rules.intentSynonyms[change.intent].filter((p) => p !== change.phrase);
+                }
+                break;
+            }
+        }
+    }
+    // Write intents.json if changed
+    if (intentsChanged) {
+        writeFileSync(intentsPath, JSON.stringify(intentsRaw, null, 2) + "\n");
+        console.log(`Intents updated. Backup: ${intentsBackup}`);
+    }
+    // Bump version
+    const newVersion = bumpVersion(rules.version);
+    rules.version = newVersion;
+    // Write
+    writeFileSync(rulesPath, JSON.stringify(rules, null, 2) + "\n");
+    console.log(`Patch promoted. Rules updated to v${newVersion}`);
+    console.log(`Backup saved: ${backupPath}`);
+    return {
+        promoted: true,
+        validation,
+        backupPath,
+        newVersion,
+    };
+}
+function bumpVersion(version) {
+    const parts = version.split(".").map(Number);
+    parts[2] = (parts[2] ?? 0) + 1;
+    return parts.join(".");
+}

package/dist/healing/ruleBuilder.d.ts

@@ -0,0 +1,5 @@
+import type { RulePatch } from "../types/rules.js";
+/**
+ * RuleBuilder: asks an LLM to propose new rules from a set of example phrases.
+ */
+export declare function buildRulesFromExamples(examples: string[]): Promise<RulePatch | null>;