notoken-core 1.0.0

package/dist/utils/autoBackup.js

@@ -0,0 +1,144 @@
+/**
+ * Auto-backup system.
+ *
+ * Before any file modification (copy, move, remove, env.set),
+ * creates a timestamped backup in ~/.notoken/backups/.
+ * Backups are kept for a configurable number of hours (default: 6).
+ *
+ * Also supports manual rollback.
+ */
+import { existsSync, mkdirSync, copyFileSync, unlinkSync, readFileSync } from "node:fs";
+import { resolve, basename } from "node:path";
+import { homedir } from "node:os";
+const BACKUP_ROOT = resolve(homedir(), ".notoken", "backups");
+const DEFAULT_RETENTION_HOURS = 6;
+function ensureBackupDir() {
+    if (!existsSync(BACKUP_ROOT)) {
+        mkdirSync(BACKUP_ROOT, { recursive: true });
+    }
+}
+/**
+ * Create a backup of a file before modifying it.
+ * Returns the backup record, or null if the file doesn't exist.
+ */
+export function createBackup(originalPath, intent, retentionHours = DEFAULT_RETENTION_HOURS) {
+    // For remote files, we can't backup locally — this is for local files
+    if (!existsSync(originalPath))
+        return null;
+    ensureBackupDir();
+    const ts = new Date().toISOString().replace(/[:.]/g, "-");
+    const name = basename(originalPath);
+    const id = `${name}_${ts}`;
+    const backupPath = resolve(BACKUP_ROOT, id);
+    copyFileSync(originalPath, backupPath);
+    const record = {
+        id,
+        originalPath,
+        backupPath,
+        timestamp: new Date().toISOString(),
+        intent,
+        expiresAt: new Date(Date.now() + retentionHours * 3600_000).toISOString(),
+    };
+    // Save record index
+    const index = loadIndex();
+    index.push(record);
+    saveIndex(index);
+    return record;
+}
+/**
+ * Generate the remote backup command to run before modifying a file.
+ * This returns a shell command string that creates a backup on the remote server.
+ */
+export function getRemoteBackupCommand(filePath) {
+    const ts = "$(date +%Y%m%d-%H%M%S)";
+    const backupDir = "/tmp/.notoken-backups";
+    const name = filePath.split("/").pop() ?? "file";
+    return `mkdir -p ${backupDir} && cp -a ${filePath} ${backupDir}/${name}.${ts}.bak 2>/dev/null; `;
+}
+/**
+ * Rollback a file from backup.
+ */
+export function rollback(id) {
+    const index = loadIndex();
+    const record = index.find((r) => r.id === id);
+    if (!record)
+        return false;
+    if (!existsSync(record.backupPath))
+        return false;
+    // Backup the current file before rolling back (safety)
+    if (existsSync(record.originalPath)) {
+        const safetyBackup = record.backupPath + ".pre-rollback";
+        copyFileSync(record.originalPath, safetyBackup);
+    }
+    copyFileSync(record.backupPath, record.originalPath);
+    return true;
+}
+/**
+ * List all current backups.
+ */
+export function listBackups() {
+    const index = loadIndex();
+    // Filter out expired
+    const now = new Date();
+    return index.filter((r) => new Date(r.expiresAt) > now && existsSync(r.backupPath));
+}
+/**
+ * Clean up expired backups.
+ */
+export function cleanExpiredBackups() {
+    const index = loadIndex();
+    const now = new Date();
+    let cleaned = 0;
+    const remaining = index.filter((r) => {
+        if (new Date(r.expiresAt) <= now) {
+            try {
+                if (existsSync(r.backupPath))
+                    unlinkSync(r.backupPath);
+            }
+            catch { }
+            cleaned++;
+            return false;
+        }
+        return true;
+    });
+    saveIndex(remaining);
+    return cleaned;
+}
+/**
+ * Format backup list for display.
+ */
+export function formatBackupList(records) {
+    const c = { reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m", cyan: "\x1b[36m", yellow: "\x1b[33m", green: "\x1b[32m" };
+    if (records.length === 0)
+        return `${c.dim}No backups available.${c.reset}`;
+    const lines = [`${c.bold}Auto-backups:${c.reset}`];
+    for (const r of records) {
+        const age = Math.round((Date.now() - new Date(r.timestamp).getTime()) / 60000);
+        const ageStr = age < 60 ? `${age}m ago` : `${Math.round(age / 60)}h ago`;
+        const expires = Math.round((new Date(r.expiresAt).getTime() - Date.now()) / 60000);
+        const expiresStr = expires < 60 ? `${expires}m left` : `${Math.round(expires / 60)}h left`;
+        lines.push(`  ${c.cyan}${r.id}${c.reset}`);
+        lines.push(`    ${r.originalPath} → ${c.dim}${r.backupPath}${c.reset}`);
+        lines.push(`    ${c.dim}${ageStr} | ${expiresStr} | ${r.intent}${c.reset}`);
+    }
+    lines.push(`\n  ${c.dim}Rollback: :rollback <id>${c.reset}`);
+    return lines.join("\n");
+}
+// ─── Index management ────────────────────────────────────────────────────────
+const INDEX_FILE = resolve(BACKUP_ROOT, "index.json");
+function loadIndex() {
+    ensureBackupDir();
+    if (!existsSync(INDEX_FILE))
+        return [];
+    try {
+        return JSON.parse(readFileSync(INDEX_FILE, "utf-8"));
+    }
+    catch {
+        return [];
+    }
+}
+function saveIndex(records) {
+    ensureBackupDir();
+    const { writeFileSync } = require("node:fs");
+    writeFileSync(INDEX_FILE, JSON.stringify(records, null, 2));
+}

package/dist/utils/config.d.ts

@@ -0,0 +1,11 @@
+import { RulesConfig } from "../types/rules.js";
+import { type IntentDef } from "../types/intent.js";
+export declare function loadRules(forceReload?: boolean): RulesConfig;
+export declare function loadIntents(forceReload?: boolean): IntentDef[];
+export declare function getIntentDef(name: string): IntentDef | undefined;
+export declare function loadHosts(): Record<string, {
+    host: string;
+    description: string;
+}>;
+export declare function getConfigDir(): string;
+export { CONFIG_DIR, DATA_DIR, LOG_DIR, PACKAGE_ROOT, USER_HOME } from "./paths.js";

package/dist/utils/config.js

@@ -0,0 +1,32 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { RulesConfig } from "../types/rules.js";
+import { IntentsConfig } from "../types/intent.js";
+import { CONFIG_DIR } from "./paths.js";
+let cachedRules = null;
+let cachedIntents = null;
+export function loadRules(forceReload = false) {
+    if (cachedRules && !forceReload)
+        return cachedRules;
+    const raw = readFileSync(resolve(CONFIG_DIR, "rules.json"), "utf-8");
+    cachedRules = RulesConfig.parse(JSON.parse(raw));
+    return cachedRules;
+}
+export function loadIntents(forceReload = false) {
+    if (cachedIntents && !forceReload)
+        return cachedIntents.intents;
+    const raw = readFileSync(resolve(CONFIG_DIR, "intents.json"), "utf-8");
+    cachedIntents = IntentsConfig.parse(JSON.parse(raw));
+    return cachedIntents.intents;
+}
+export function getIntentDef(name) {
+    return loadIntents().find((i) => i.name === name);
+}
+export function loadHosts() {
+    const raw = readFileSync(resolve(CONFIG_DIR, "hosts.json"), "utf-8");
+    return JSON.parse(raw);
+}
+export function getConfigDir() {
+    return CONFIG_DIR;
+}
+export { CONFIG_DIR, DATA_DIR, LOG_DIR, PACKAGE_ROOT, USER_HOME } from "./paths.js";

package/dist/utils/dirAnalysis.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Directory analysis.
+ *
+ * When listing files in a directory, detects:
+ * - Project type (Node.js, Next.js, Python, PHP, WordPress, Laravel, Go, Rust, etc.)
+ * - File type breakdown (code, config, data, logs, images, etc.)
+ * - Notable files (README, Dockerfile, CI configs, env files)
+ * - Directory size assessment
+ */
+export interface ProjectDetection {
+    type: string;
+    confidence: number;
+    indicators: string[];
+}
+export interface FileTypeBreakdown {
+    category: string;
+    count: number;
+    extensions: string[];
+}
+/**
+ * Analyze ls -la output and return commentary.
+ */
+export declare function analyzeDirectory(output: string): string;

package/dist/utils/dirAnalysis.js

@@ -0,0 +1,192 @@
+/**
+ * Directory analysis.
+ *
+ * When listing files in a directory, detects:
+ * - Project type (Node.js, Next.js, Python, PHP, WordPress, Laravel, Go, Rust, etc.)
+ * - File type breakdown (code, config, data, logs, images, etc.)
+ * - Notable files (README, Dockerfile, CI configs, env files)
+ * - Directory size assessment
+ */
+const c = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    red: "\x1b[31m",
+    cyan: "\x1b[36m",
+    magenta: "\x1b[35m",
+};
+// ─── Project Detection ───────────────────────────────────────────────────────
+const PROJECT_SIGNATURES = [
+    { name: "Next.js", files: ["next.config.js", "next.config.ts", "next.config.mjs"], dirs: [".next"], priority: 10 },
+    { name: "Nuxt.js", files: ["nuxt.config.ts", "nuxt.config.js"], dirs: [".nuxt"], priority: 10 },
+    { name: "SvelteKit", files: ["svelte.config.js"], dirs: [], priority: 10 },
+    { name: "Remix", files: ["remix.config.js"], dirs: [], priority: 10 },
+    { name: "Astro", files: ["astro.config.mjs"], dirs: [], priority: 10 },
+    { name: "React (CRA)", files: ["react-scripts"], dirs: [], priority: 8 },
+    { name: "Vue.js", files: ["vue.config.js"], dirs: [], priority: 8 },
+    { name: "Angular", files: ["angular.json"], dirs: [], priority: 8 },
+    { name: "Node.js", files: ["package.json"], dirs: ["node_modules"], priority: 5 },
+    { name: "TypeScript", files: ["tsconfig.json"], dirs: [], priority: 4 },
+    { name: "Deno", files: ["deno.json", "deno.jsonc"], dirs: [], priority: 8 },
+    { name: "Bun", files: ["bunfig.toml"], dirs: [], priority: 8 },
+    { name: "Python", files: ["requirements.txt", "pyproject.toml", "setup.py", "Pipfile"], dirs: ["__pycache__", "venv", ".venv"], priority: 5 },
+    { name: "Django", files: ["manage.py"], dirs: [], priority: 8 },
+    { name: "Flask", files: ["app.py", "wsgi.py"], dirs: [], priority: 6 },
+    { name: "FastAPI", files: ["main.py"], dirs: [], priority: 5 },
+    { name: "PHP", files: ["composer.json", "index.php"], dirs: ["vendor"], priority: 5 },
+    { name: "WordPress", files: ["wp-config.php", "wp-login.php"], dirs: ["wp-content", "wp-admin", "wp-includes"], priority: 10 },
+    { name: "Laravel", files: ["artisan"], dirs: ["app", "bootstrap", "routes"], priority: 9 },
+    { name: "Symfony", files: ["symfony.lock"], dirs: ["src", "config"], priority: 8 },
+    { name: "Go", files: ["go.mod", "go.sum"], dirs: [], priority: 7 },
+    { name: "Rust", files: ["Cargo.toml", "Cargo.lock"], dirs: ["target"], priority: 7 },
+    { name: "Java/Maven", files: ["pom.xml"], dirs: ["src/main"], priority: 7 },
+    { name: "Java/Gradle", files: ["build.gradle", "build.gradle.kts"], dirs: [], priority: 7 },
+    { name: "Ruby on Rails", files: ["Gemfile", "Rakefile"], dirs: ["app", "config", "db"], priority: 7 },
+    { name: "Ruby", files: ["Gemfile"], dirs: [], priority: 4 },
+    { name: ".NET/C#", files: ["*.csproj", "*.sln"], dirs: ["bin", "obj"], priority: 7 },
+    { name: "Docker project", files: ["Dockerfile", "docker-compose.yml", "docker-compose.yaml"], dirs: [], priority: 3 },
+    { name: "Terraform", files: ["main.tf", "terraform.tfstate"], dirs: [".terraform"], priority: 8 },
+    { name: "Ansible", files: ["ansible.cfg", "playbook.yml"], dirs: ["roles"], priority: 8 },
+    { name: "Shell scripts", files: ["*.sh"], dirs: [], priority: 2 },
+    { name: "Batch scripts", files: ["*.bat", "*.cmd", "*.ps1"], dirs: [], priority: 2 },
+];
+// ─── File Categories ─────────────────────────────────────────────────────────
+const FILE_CATEGORIES = {
+    "Code": [".js", ".ts", ".jsx", ".tsx", ".py", ".rb", ".go", ".rs", ".java", ".c", ".cpp", ".cs", ".php", ".swift", ".kt"],
+    "Config": [".json", ".yml", ".yaml", ".toml", ".ini", ".cfg", ".conf", ".env", ".xml"],
+    "Web": [".html", ".htm", ".css", ".scss", ".sass", ".less", ".svg"],
+    "Data": [".csv", ".sql", ".db", ".sqlite", ".parquet"],
+    "Documents": [".md", ".txt", ".doc", ".docx", ".pdf", ".rtf"],
+    "Images": [".jpg", ".jpeg", ".png", ".gif", ".webp", ".ico", ".bmp", ".tiff"],
+    "Archives": [".zip", ".tar", ".gz", ".bz2", ".xz", ".rar", ".7z"],
+    "Logs": [".log"],
+    "Scripts": [".sh", ".bash", ".zsh", ".bat", ".cmd", ".ps1"],
+    "Build": [".o", ".class", ".pyc", ".wasm"],
+};
+const NOTABLE_FILES = new Set([
+    "README.md", "README", "LICENSE", "CHANGELOG.md",
+    "Dockerfile", "docker-compose.yml", "docker-compose.yaml",
+    ".env", ".env.local", ".env.production",
+    ".gitignore", ".dockerignore", ".editorconfig",
+    "Makefile", "Procfile", "Vagrantfile",
+    ".github", ".gitlab-ci.yml", "Jenkinsfile",
+    "package.json", "tsconfig.json", "requirements.txt",
+]);
+/**
+ * Analyze ls -la output and return commentary.
+ */
+export function analyzeDirectory(output) {
+    const lines = [];
+    const entries = parseLsOutput(output);
+    if (entries.length === 0)
+        return "";
+    const files = entries.filter((e) => e.type === "file");
+    const dirs = entries.filter((e) => e.type === "directory");
+    const fileNames = files.map((e) => e.name);
+    const dirNames = dirs.map((e) => e.name);
+    const allNames = [...fileNames, ...dirNames];
+    lines.push(`\n${c.bold}${c.cyan}── Analysis ──${c.reset}`);
+    lines.push(`  ${files.length} file(s), ${dirs.length} directory(ies)`);
+    // Detect project type
+    const detected = detectProjects(fileNames, dirNames);
+    if (detected.length > 0) {
+        lines.push(`\n  ${c.bold}Project detected:${c.reset}`);
+        for (const d of detected) {
+            lines.push(`  ${c.magenta}${d.type}${c.reset} — ${d.indicators.join(", ")}`);
+        }
+    }
+    // File type breakdown
+    const breakdown = categorizeFiles(fileNames);
+    if (breakdown.length > 0) {
+        lines.push(`\n  ${c.bold}File types:${c.reset}`);
+        for (const b of breakdown.slice(0, 6)) {
+            const bar = "█".repeat(Math.min(20, Math.round((b.count / files.length) * 20)));
+            lines.push(`  ${c.dim}${bar}${c.reset} ${b.category}: ${b.count} (${b.extensions.join(", ")})`);
+        }
+    }
+    // Notable files
+    const notable = allNames.filter((n) => NOTABLE_FILES.has(n));
+    if (notable.length > 0) {
+        lines.push(`\n  ${c.bold}Notable:${c.reset} ${notable.join(", ")}`);
+    }
+    // Warnings
+    if (dirNames.includes("node_modules")) {
+        lines.push(`  ${c.yellow}⚠ node_modules present — may be large${c.reset}`);
+    }
+    if (fileNames.some((f) => f === ".env" || f.startsWith(".env."))) {
+        lines.push(`  ${c.yellow}⚠ .env file(s) present — check they're in .gitignore${c.reset}`);
+    }
+    return lines.join("\n");
+}
+function detectProjects(files, dirs) {
+    const results = [];
+    for (const sig of PROJECT_SIGNATURES) {
+        const matchedFiles = sig.files.filter((f) => {
+            if (f.startsWith("*")) {
+                const ext = f.slice(1);
+                return files.some((name) => name.endsWith(ext));
+            }
+            return files.includes(f);
+        });
+        const matchedDirs = sig.dirs.filter((d) => dirs.includes(d));
+        if (matchedFiles.length > 0 || matchedDirs.length > 0) {
+            results.push({
+                type: sig.name,
+                confidence: sig.priority / 10,
+                indicators: [...matchedFiles, ...matchedDirs.map((d) => `${d}/`)],
+            });
+        }
+    }
+    // Sort by priority, take top 3
+    results.sort((a, b) => b.confidence - a.confidence);
+    return results.slice(0, 3);
+}
+function categorizeFiles(files) {
+    const counts = new Map();
+    for (const file of files) {
+        const dot = file.lastIndexOf(".");
+        const ext = dot >= 0 ? file.slice(dot).toLowerCase() : "";
+        let category = "Other";
+        for (const [cat, exts] of Object.entries(FILE_CATEGORIES)) {
+            if (exts.includes(ext)) {
+                category = cat;
+                break;
+            }
+        }
+        const entry = counts.get(category) ?? { count: 0, extensions: new Set() };
+        entry.count++;
+        if (ext)
+            entry.extensions.add(ext);
+        counts.set(category, entry);
+    }
+    return Array.from(counts.entries())
+        .map(([category, { count, extensions }]) => ({
+        category,
+        count,
+        extensions: Array.from(extensions).slice(0, 5),
+    }))
+        .sort((a, b) => b.count - a.count);
+}
+function parseLsOutput(output) {
+    const entries = [];
+    for (const line of output.split("\n")) {
+        // Match: drwxr-xr-x  2 root root 4096 Jan 1 12:00 dirname
+        // Match: -rw-r--r--  1 root root 1234 Jan 1 12:00 filename
+        const match = line.match(/^([dlcbsp-])([rwxsStT-]{9})\s+\d+\s+\S+\s+\S+\s+(\S+)\s+\S+\s+\d+\s+[\d:]+\s+(.+)$/);
+        if (!match)
+            continue;
+        const typeChar = match[1];
+        const name = match[4].trim();
+        if (name === "." || name === "..")
+            continue;
+        entries.push({
+            type: typeChar === "d" ? "directory" : typeChar === "l" ? "symlink" : typeChar === "-" ? "file" : "other",
+            permissions: match[1] + match[2],
+            name,
+            size: match[3],
+        });
+    }
+    return entries;
+}

package/dist/utils/explain.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Explain mode.
+ *
+ * Shows WHY a command was chosen, what alternatives exist,
+ * what could go wrong, and the full decision chain.
+ */
+import type { ParsedCommand } from "../types/intent.js";
+export declare function formatExplain(parsed: ParsedCommand, rawText: string): string;

package/dist/utils/explain.js

@@ -0,0 +1,145 @@
+/**
+ * Explain mode.
+ *
+ * Shows WHY a command was chosen, what alternatives exist,
+ * what could go wrong, and the full decision chain.
+ */
+import { getIntentDef } from "./config.js";
+import { classifyMulti } from "../nlp/multiClassifier.js";
+import { detectLocalPlatform } from "./platform.js";
+const c = {
+    reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m",
+    green: "\x1b[32m", yellow: "\x1b[33m", red: "\x1b[31m", cyan: "\x1b[36m", magenta: "\x1b[35m",
+};
+export function formatExplain(parsed, rawText) {
+    const { intent } = parsed;
+    const def = getIntentDef(intent.intent);
+    const lines = [];
+    lines.push(`${c.bold}${c.magenta}── Explain ──${c.reset}\n`);
+    // 1. What was understood
+    lines.push(`${c.bold}What I understood:${c.reset}`);
+    lines.push(`  Input: "${rawText}"`);
+    lines.push(`  Intent: ${c.cyan}${intent.intent}${c.reset} (${(intent.confidence * 100).toFixed(0)}% confidence)`);
+    if (def) {
+        lines.push(`  Description: ${def.description}`);
+    }
+    // 2. Why this intent was chosen
+    lines.push(`\n${c.bold}Why this intent:${c.reset}`);
+    const multi = classifyMulti(rawText);
+    if (multi.votes.length > 0) {
+        // Group by classifier
+        const byClassifier = new Map();
+        for (const v of multi.votes) {
+            const list = byClassifier.get(v.classifier) ?? [];
+            list.push(v);
+            byClassifier.set(v.classifier, list);
+        }
+        for (const [classifier, votes] of byClassifier) {
+            const top = votes.sort((a, b) => b.confidence - a.confidence)[0];
+            const weight = { synonym: "1.0x", semantic: "0.8x", context: "0.6x", fuzzy: "0.5x" }[classifier] ?? "?";
+            lines.push(`  ${c.cyan}${classifier}${c.reset} (${weight}): ${top.intent} — ${top.reason}`);
+        }
+    }
+    if (multi.ambiguous) {
+        lines.push(`  ${c.yellow}⚠ Ambiguous — top intents scored similarly. May benefit from rephrasing.${c.reset}`);
+    }
+    // 3. Alternatives considered
+    if (multi.scores.length > 1) {
+        lines.push(`\n${c.bold}Alternatives considered:${c.reset}`);
+        for (const s of multi.scores.slice(1, 4)) {
+            const altDef = getIntentDef(s.intent);
+            lines.push(`  ${c.dim}${s.intent}${c.reset} (${(s.score * 100).toFixed(0)}%) — ${altDef?.description ?? "unknown"}`);
+        }
+    }
+    // 4. Fields extracted
+    const fields = Object.entries(intent.fields).filter(([, v]) => v !== undefined && v !== "");
+    if (fields.length > 0) {
+        lines.push(`\n${c.bold}Fields extracted:${c.reset}`);
+        for (const [key, value] of fields) {
+            const fieldDef = def?.fields[key];
+            const src = wasExplicit(rawText, String(value)) ? "from input" : "default";
+            lines.push(`  ${key}: ${c.bold}${value}${c.reset} ${c.dim}(${fieldDef?.type ?? "?"}, ${src})${c.reset}`);
+        }
+    }
+    if (parsed.missingFields.length > 0) {
+        lines.push(`  ${c.yellow}Missing: ${parsed.missingFields.join(", ")}${c.reset}`);
+    }
+    // 5. What will happen
+    if (def) {
+        lines.push(`\n${c.bold}What will happen:${c.reset}`);
+        lines.push(`  Execution: ${def.execution === "local" ? "runs locally" : "runs via SSH"}`);
+        lines.push(`  Risk: ${formatRisk(def.riskLevel)}`);
+        lines.push(`  Confirmation: ${def.requiresConfirmation ? "yes (will ask)" : "no"}`);
+        // Command preview
+        let cmd = def.command;
+        for (const [k, v] of fields) {
+            if (v !== undefined)
+                cmd = cmd.replaceAll(`{{${k}}}`, String(v));
+        }
+        cmd = cmd.replace(/\{\{[a-zA-Z_]+\}\}/g, "").trim();
+        if (cmd.length <= 120) {
+            lines.push(`  Command: ${c.dim}${cmd}${c.reset}`);
+        }
+        else {
+            lines.push(`  Command: ${c.dim}${cmd.slice(0, 117)}...${c.reset}`);
+        }
+        if (def.allowlist && def.allowlist.length > 0) {
+            lines.push(`  Allowlist: ${def.allowlist.join(", ")}`);
+        }
+    }
+    // 6. What could go wrong
+    lines.push(`\n${c.bold}What could go wrong:${c.reset}`);
+    const risks = getKnownRisks(intent.intent, intent.fields);
+    if (risks.length > 0) {
+        for (const risk of risks) {
+            lines.push(`  ${c.yellow}⚠${c.reset} ${risk}`);
+        }
+    }
+    else {
+        lines.push(`  ${c.green}Low risk — read-only or safe operation.${c.reset}`);
+    }
+    // 7. Platform context
+    const platform = detectLocalPlatform();
+    lines.push(`\n${c.bold}Platform:${c.reset}`);
+    lines.push(`  ${platform.distro}${platform.isWSL ? " (WSL)" : ""} | ${platform.packageManager} | ${platform.initSystem}`);
+    return lines.join("\n");
+}
+function wasExplicit(rawText, value) {
+    return rawText.toLowerCase().includes(value.toLowerCase());
+}
+function formatRisk(level) {
+    if (level === "high")
+        return `${c.red}HIGH${c.reset} — destructive, requires confirmation`;
+    if (level === "medium")
+        return `${c.yellow}MEDIUM${c.reset} — modifies state`;
+    return `${c.green}LOW${c.reset} — read-only or safe`;
+}
+function getKnownRisks(intentName, fields) {
+    const risks = [];
+    const env = fields.environment;
+    if (env === "prod") {
+        risks.push("Running on PRODUCTION — ensure this is intentional.");
+    }
+    if (intentName.includes("restart") || intentName.includes("stop")) {
+        risks.push("Service will be temporarily unavailable during restart.");
+    }
+    if (intentName.includes("remove") || intentName.includes("delete") || intentName.includes("prune")) {
+        risks.push("Data will be permanently deleted. Auto-backup runs first if enabled.");
+    }
+    if (intentName.includes("deploy")) {
+        risks.push("Deployment may affect live users. Rollback available if it fails.");
+    }
+    if (intentName.includes("chmod") || intentName.includes("chown")) {
+        risks.push("Permission changes can lock you out if applied incorrectly.");
+    }
+    if (intentName.includes("reboot") || intentName.includes("shutdown")) {
+        risks.push("Server will be unreachable during reboot. Ensure you have console access.");
+    }
+    if (intentName === "docker.prune") {
+        risks.push("Removes ALL unused containers, images, and volumes. Data in unnamed volumes is lost.");
+    }
+    if (intentName === "git.reset") {
+        risks.push("May discard uncommitted changes. Ensure work is saved.");
+    }
+    return risks;
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,5 @@
+import type { FailureLog } from "../types/rules.js";
+export declare function logFailure(entry: FailureLog): void;
+export declare function loadFailures(): FailureLog[];
+export declare function clearFailures(): void;
+export declare function log(level: "info" | "warn" | "error", message: string): void;

package/dist/utils/logger.js

@@ -0,0 +1,29 @@
+import { writeFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { LOG_DIR } from "./paths.js";
+const FAILURE_LOG = resolve(LOG_DIR, "failures.json");
+function ensureLogDir() {
+    if (!existsSync(LOG_DIR)) {
+        mkdirSync(LOG_DIR, { recursive: true });
+    }
+}
+export function logFailure(entry) {
+    ensureLogDir();
+    const existing = loadFailures();
+    existing.push(entry);
+    writeFileSync(FAILURE_LOG, JSON.stringify(existing, null, 2));
+}
+export function loadFailures() {
+    if (!existsSync(FAILURE_LOG))
+        return [];
+    const raw = readFileSync(FAILURE_LOG, "utf-8");
+    return JSON.parse(raw);
+}
+export function clearFailures() {
+    ensureLogDir();
+    writeFileSync(FAILURE_LOG, "[]");
+}
+export function log(level, message) {
+    const prefix = level === "error" ? "ERROR" : level === "warn" ? "WARN" : "INFO";
+    console.error(`[${prefix}] ${message}`);
+}

package/dist/utils/output.d.ts

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

package/dist/utils/output.js

@@ -0,0 +1,26 @@
+export function formatParsedCommand(cmd) {
+    const lines = [];
+    const { intent } = cmd;
+    lines.push(`Intent:      ${intent.intent}`);
+    lines.push(`Confidence:  ${(intent.confidence * 100).toFixed(0)}%`);
+    const entries = Object.entries(intent.fields).filter(([, v]) => v !== undefined);
+    if (entries.length > 0) {
+        lines.push("Fields:");
+        for (const [k, v] of entries) {
+            lines.push(`  ${k}: ${v}`);
+        }
+    }
+    if (cmd.missingFields.length > 0) {
+        lines.push(`Missing:     ${cmd.missingFields.join(", ")}`);
+    }
+    if (cmd.ambiguousFields.length > 0) {
+        lines.push("Ambiguous:");
+        for (const a of cmd.ambiguousFields) {
+            lines.push(`  ${a.field}: ${a.candidates.join(" | ")}`);
+        }
+    }
+    if (cmd.needsClarification) {
+        lines.push("=> Clarification needed before execution.");
+    }
+    return lines.join("\n");
+}

package/dist/utils/paths.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Centralized path resolution.
+ *
+ * Single source of truth for all directory paths used by mycli.
+ * Supports three modes:
+ *   1. Development (tsx): src/utils/paths.ts → resolve("../..")
+ *   2. npm package: dist/utils/paths.js → resolve("../..")
+ *   3. SEA binary: embedded assets, writable dirs in ~/.mycli/
+ *
+ * Writable directories (data, logs) always go to ~/.mycli/ so they
+ * work in all modes. Config is read-only and ships with the package.
+ */
+/** Whether running as a Node.js Single Executable Application */
+export declare function isSEA(): boolean;
+/** Package root: two levels up from dist/utils/ or src/utils/ */
+export declare const PACKAGE_ROOT: string;
+/** Read-only config directory (ships with the package) */
+export declare const CONFIG_DIR: string;
+/** User data root — writable, lives in home directory */
+export declare const USER_HOME: string;
+/** Writable data directory (history, sessions) */
+export declare const DATA_DIR: string;
+/** Writable logs directory (failures, uncertainty) */
+export declare const LOG_DIR: string;
+/** Ensure writable directories exist */
+export declare function ensureUserDirs(): void;