notoken-core 1.0.0

package/dist/types/rules.d.ts

@@ -0,0 +1,237 @@
+import { z } from "zod";
+export declare const SynonymEntry: z.ZodObject<{
+    intent: z.ZodString;
+    phrases: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    intent: string;
+    phrases: string[];
+}, {
+    intent: string;
+    phrases: string[];
+}>;
+export declare const AliasEntry: z.ZodObject<{
+    canonical: z.ZodString;
+    aliases: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    canonical: string;
+    aliases: string[];
+}, {
+    canonical: string;
+    aliases: string[];
+}>;
+export declare const RulesConfig: z.ZodObject<{
+    version: z.ZodString;
+    intentSynonyms: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
+    environmentAliases: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
+    serviceAliases: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    intentSynonyms: Record<string, string[]>;
+    environmentAliases: Record<string, string[]>;
+    serviceAliases: Record<string, string[]>;
+}, {
+    version: string;
+    intentSynonyms: Record<string, string[]>;
+    environmentAliases: Record<string, string[]>;
+    serviceAliases: Record<string, string[]>;
+}>;
+export type RulesConfig = z.infer<typeof RulesConfig>;
+export declare const RulePatchChange: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"add_intent_synonym">;
+    intent: z.ZodString;
+    phrase: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "add_intent_synonym";
+    intent: string;
+    phrase: string;
+}, {
+    type: "add_intent_synonym";
+    intent: string;
+    phrase: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"add_env_alias">;
+    canonical: z.ZodString;
+    alias: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "add_env_alias";
+    canonical: string;
+    alias: string;
+}, {
+    type: "add_env_alias";
+    canonical: string;
+    alias: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"add_service_alias">;
+    canonical: z.ZodString;
+    alias: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "add_service_alias";
+    canonical: string;
+    alias: string;
+}, {
+    type: "add_service_alias";
+    canonical: string;
+    alias: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"remove_intent_synonym">;
+    intent: z.ZodString;
+    phrase: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "remove_intent_synonym";
+    intent: string;
+    phrase: string;
+}, {
+    type: "remove_intent_synonym";
+    intent: string;
+    phrase: string;
+}>]>;
+export type RulePatchChange = z.infer<typeof RulePatchChange>;
+export declare const RulePatchTestCase: z.ZodObject<{
+    input: z.ZodString;
+    expectedIntent: z.ZodOptional<z.ZodString>;
+    expectedFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    shouldReject: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    input: string;
+    expectedIntent?: string | undefined;
+    expectedFields?: Record<string, unknown> | undefined;
+    shouldReject?: boolean | undefined;
+}, {
+    input: string;
+    expectedIntent?: string | undefined;
+    expectedFields?: Record<string, unknown> | undefined;
+    shouldReject?: boolean | undefined;
+}>;
+export type RulePatchTestCase = z.infer<typeof RulePatchTestCase>;
+export declare const RulePatch: z.ZodObject<{
+    summary: z.ZodString;
+    confidence: z.ZodNumber;
+    changes: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"add_intent_synonym">;
+        intent: z.ZodString;
+        phrase: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "add_intent_synonym";
+        intent: string;
+        phrase: string;
+    }, {
+        type: "add_intent_synonym";
+        intent: string;
+        phrase: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"add_env_alias">;
+        canonical: z.ZodString;
+        alias: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "add_env_alias";
+        canonical: string;
+        alias: string;
+    }, {
+        type: "add_env_alias";
+        canonical: string;
+        alias: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"add_service_alias">;
+        canonical: z.ZodString;
+        alias: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "add_service_alias";
+        canonical: string;
+        alias: string;
+    }, {
+        type: "add_service_alias";
+        canonical: string;
+        alias: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"remove_intent_synonym">;
+        intent: z.ZodString;
+        phrase: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "remove_intent_synonym";
+        intent: string;
+        phrase: string;
+    }, {
+        type: "remove_intent_synonym";
+        intent: string;
+        phrase: string;
+    }>]>, "many">;
+    tests: z.ZodArray<z.ZodObject<{
+        input: z.ZodString;
+        expectedIntent: z.ZodOptional<z.ZodString>;
+        expectedFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        shouldReject: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        input: string;
+        expectedIntent?: string | undefined;
+        expectedFields?: Record<string, unknown> | undefined;
+        shouldReject?: boolean | undefined;
+    }, {
+        input: string;
+        expectedIntent?: string | undefined;
+        expectedFields?: Record<string, unknown> | undefined;
+        shouldReject?: boolean | undefined;
+    }>, "many">;
+    warnings: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    confidence: number;
+    summary: string;
+    changes: ({
+        type: "add_intent_synonym";
+        intent: string;
+        phrase: string;
+    } | {
+        type: "add_env_alias";
+        canonical: string;
+        alias: string;
+    } | {
+        type: "add_service_alias";
+        canonical: string;
+        alias: string;
+    } | {
+        type: "remove_intent_synonym";
+        intent: string;
+        phrase: string;
+    })[];
+    tests: {
+        input: string;
+        expectedIntent?: string | undefined;
+        expectedFields?: Record<string, unknown> | undefined;
+        shouldReject?: boolean | undefined;
+    }[];
+    warnings: string[];
+}, {
+    confidence: number;
+    summary: string;
+    changes: ({
+        type: "add_intent_synonym";
+        intent: string;
+        phrase: string;
+    } | {
+        type: "add_env_alias";
+        canonical: string;
+        alias: string;
+    } | {
+        type: "add_service_alias";
+        canonical: string;
+        alias: string;
+    } | {
+        type: "remove_intent_synonym";
+        intent: string;
+        phrase: string;
+    })[];
+    tests: {
+        input: string;
+        expectedIntent?: string | undefined;
+        expectedFields?: Record<string, unknown> | undefined;
+        shouldReject?: boolean | undefined;
+    }[];
+    warnings: string[];
+}>;
+export type RulePatch = z.infer<typeof RulePatch>;
+export interface FailureLog {
+    rawText: string;
+    timestamp: string;
+    parsedIntent: string | null;
+    confidence: number;
+    error?: string;
+}

package/dist/types/rules.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+export const SynonymEntry = z.object({
+    intent: z.string(),
+    phrases: z.array(z.string()),
+});
+export const AliasEntry = z.object({
+    canonical: z.string(),
+    aliases: z.array(z.string()),
+});
+export const RulesConfig = z.object({
+    version: z.string(),
+    intentSynonyms: z.record(z.array(z.string())),
+    environmentAliases: z.record(z.array(z.string())),
+    serviceAliases: z.record(z.array(z.string())),
+});
+export const RulePatchChange = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("add_intent_synonym"),
+        intent: z.string(),
+        phrase: z.string(),
+    }),
+    z.object({
+        type: z.literal("add_env_alias"),
+        canonical: z.string(),
+        alias: z.string(),
+    }),
+    z.object({
+        type: z.literal("add_service_alias"),
+        canonical: z.string(),
+        alias: z.string(),
+    }),
+    z.object({
+        type: z.literal("remove_intent_synonym"),
+        intent: z.string(),
+        phrase: z.string(),
+    }),
+]);
+export const RulePatchTestCase = z.object({
+    input: z.string(),
+    expectedIntent: z.string().optional(),
+    expectedFields: z.record(z.unknown()).optional(),
+    shouldReject: z.boolean().optional(),
+});
+export const RulePatch = z.object({
+    summary: z.string(),
+    confidence: z.number(),
+    changes: z.array(RulePatchChange),
+    tests: z.array(RulePatchTestCase),
+    warnings: z.array(z.string()),
+});

package/dist/utils/analysis.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Intelligent output analysis.
+ *
+ * Parses raw command output and adds human-readable commentary:
+ * - Load: checks vCPUs vs load average, flags overload
+ * - Disk: flags partitions above thresholds, checks specific paths
+ * - Memory: flags low memory, high swap usage
+ * - Directory: detects project types, file breakdowns
+ */
+export declare function analyzeLoad(output: string): string;
+export interface DiskPartition {
+    filesystem: string;
+    size: string;
+    used: string;
+    available: string;
+    usePercent: number;
+    mountPoint: string;
+}
+export declare function analyzeDisk(output: string, specificPath?: string): string;
+export declare function analyzeMemory(output: string): string;
+/**
+ * Analyze command output based on intent and add commentary.
+ * Returns empty string if no analysis applicable.
+ */
+export declare function analyzeOutput(intent: string, output: string, fields: Record<string, unknown>): string;

package/dist/utils/analysis.js

@@ -0,0 +1,307 @@
+/**
+ * Intelligent output analysis.
+ *
+ * Parses raw command output and adds human-readable commentary:
+ * - Load: checks vCPUs vs load average, flags overload
+ * - Disk: flags partitions above thresholds, checks specific paths
+ * - Memory: flags low memory, high swap usage
+ * - Directory: detects project types, file breakdowns
+ */
+import { analyzeDirectory as analyzeDirectoryImpl } from "./dirAnalysis.js";
+function analyzeDirectoryOutput(output) {
+    return analyzeDirectoryImpl(output);
+}
+const c = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    red: "\x1b[31m",
+    cyan: "\x1b[36m",
+};
+// ─── Load Analysis ───────────────────────────────────────────────────────────
+export function analyzeLoad(output) {
+    const lines = [];
+    // Extract load averages from uptime output
+    // "load average: 0.52, 0.58, 0.59"
+    const loadMatch = output.match(/load average:\s*([\d.]+),?\s*([\d.]+),?\s*([\d.]+)/);
+    if (!loadMatch)
+        return "";
+    const load1 = parseFloat(loadMatch[1]);
+    const load5 = parseFloat(loadMatch[2]);
+    const load15 = parseFloat(loadMatch[3]);
+    // Extract CPU count from nproc or lscpu output
+    let cpuCount = 1;
+    const nprocMatch = output.match(/^(\d+)$/m);
+    const lscpuMatch = output.match(/CPU\(s\):\s*(\d+)/);
+    if (nprocMatch)
+        cpuCount = parseInt(nprocMatch[1]);
+    else if (lscpuMatch)
+        cpuCount = parseInt(lscpuMatch[1]);
+    // Also try /proc/cpuinfo count
+    const procMatch = output.match(/processor\s*:\s*(\d+)/g);
+    if (procMatch && procMatch.length > cpuCount)
+        cpuCount = procMatch.length;
+    lines.push(`\n${c.bold}${c.cyan}── Analysis ──${c.reset}`);
+    lines.push(`  vCPUs: ${c.bold}${cpuCount}${c.reset}`);
+    lines.push(`  Load:  ${c.bold}${load1}${c.reset} (1m)  ${load5} (5m)  ${load15} (15m)`);
+    // Load ratio: load / cpuCount
+    const ratio1 = load1 / cpuCount;
+    const ratio5 = load5 / cpuCount;
+    if (ratio1 > 2.0) {
+        lines.push(`  ${c.red}⚠ CRITICAL: Load is ${ratio1.toFixed(1)}x your CPU capacity!${c.reset}`);
+        lines.push(`  ${c.red}  System is severely overloaded. Processes are queuing.${c.reset}`);
+    }
+    else if (ratio1 > 1.0) {
+        lines.push(`  ${c.yellow}⚠ HIGH: Load exceeds CPU count (${ratio1.toFixed(1)}x capacity).${c.reset}`);
+        lines.push(`  ${c.yellow}  Some processes are waiting for CPU time.${c.reset}`);
+    }
+    else if (ratio1 > 0.7) {
+        lines.push(`  ${c.yellow}⚠ MODERATE: ${(ratio1 * 100).toFixed(0)}% CPU utilization.${c.reset}`);
+        lines.push(`  ${c.dim}  Approaching capacity — monitor closely.${c.reset}`);
+    }
+    else {
+        lines.push(`  ${c.green}✓ OK: ${(ratio1 * 100).toFixed(0)}% CPU utilization. Healthy.${c.reset}`);
+    }
+    // Trend
+    if (load1 > load15 * 1.5) {
+        lines.push(`  ${c.yellow}↑ Load is trending UP (${load15} → ${load1}).${c.reset}`);
+    }
+    else if (load1 < load15 * 0.5) {
+        lines.push(`  ${c.green}↓ Load is trending DOWN (${load15} → ${load1}).${c.reset}`);
+    }
+    else {
+        lines.push(`  ${c.dim}→ Load is stable.${c.reset}`);
+    }
+    return lines.join("\n");
+}
+export function analyzeDisk(output, specificPath) {
+    const lines = [];
+    const partitions = parseDfOutput(output);
+    if (partitions.length === 0)
+        return "";
+    lines.push(`\n${c.bold}${c.cyan}── Analysis ──${c.reset}`);
+    // If asking about a specific path, find the matching partition
+    if (specificPath) {
+        const match = findPartitionForPath(partitions, specificPath);
+        if (match) {
+            lines.push(`  Path ${c.bold}${specificPath}${c.reset} is on ${c.bold}${match.mountPoint}${c.reset}`);
+            lines.push(`  ${formatPartitionHealth(match)}`);
+            return lines.join("\n");
+        }
+        else {
+            lines.push(`  ${c.yellow}Could not find partition for path: ${specificPath}${c.reset}`);
+        }
+    }
+    // Overall analysis
+    let criticalCount = 0;
+    let warningCount = 0;
+    // Filter to real filesystems (skip snap, tmpfs, etc.)
+    const realPartitions = partitions.filter((p) => !p.filesystem.startsWith("snap") &&
+        !p.filesystem.startsWith("tmpfs") &&
+        !p.filesystem.startsWith("none") &&
+        !p.filesystem.startsWith("rootfs") &&
+        p.mountPoint !== "/snap" &&
+        !p.mountPoint.startsWith("/snap/"));
+    for (const p of realPartitions) {
+        if (p.usePercent >= 95) {
+            lines.push(`  ${c.red}⚠ CRITICAL: ${p.mountPoint} is ${p.usePercent}% full (${p.available} free)${c.reset}`);
+            criticalCount++;
+        }
+        else if (p.usePercent >= 85) {
+            lines.push(`  ${c.yellow}⚠ WARNING: ${p.mountPoint} is ${p.usePercent}% full (${p.available} free)${c.reset}`);
+            warningCount++;
+        }
+        else if (p.usePercent >= 70) {
+            lines.push(`  ${c.dim}  ${p.mountPoint}: ${p.usePercent}% used (${p.available} free)${c.reset}`);
+        }
+    }
+    if (criticalCount === 0 && warningCount === 0) {
+        lines.push(`  ${c.green}✓ All partitions healthy. No space issues.${c.reset}`);
+    }
+    else {
+        if (criticalCount > 0) {
+            lines.push(`  ${c.red}  ${criticalCount} partition(s) critically full!${c.reset}`);
+        }
+        if (warningCount > 0) {
+            lines.push(`  ${c.yellow}  ${warningCount} partition(s) approaching full.${c.reset}`);
+        }
+        lines.push(`  ${c.dim}  Tip: Run "disk analysis" playbook for detailed breakdown.${c.reset}`);
+    }
+    // Highlight largest partitions
+    const sorted = [...realPartitions].sort((a, b) => b.usePercent - a.usePercent);
+    if (sorted.length > 0 && !specificPath) {
+        lines.push(`\n  ${c.bold}Top usage:${c.reset}`);
+        for (const p of sorted.slice(0, 5)) {
+            const bar = usageBar(p.usePercent);
+            lines.push(`  ${bar} ${p.usePercent.toString().padStart(3)}% ${p.mountPoint} (${p.used}/${p.size})`);
+        }
+    }
+    return lines.join("\n");
+}
+function parseDfOutput(output) {
+    const partitions = [];
+    const lines = output.split("\n");
+    for (const line of lines) {
+        // Match df -h output: Filesystem  Size  Used  Avail  Use%  Mounted on
+        const match = line.match(/^(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\d+)%\s+(.+)$/);
+        if (match) {
+            partitions.push({
+                filesystem: match[1],
+                size: match[2],
+                used: match[3],
+                available: match[4],
+                usePercent: parseInt(match[5]),
+                mountPoint: match[6].trim(),
+            });
+        }
+    }
+    return partitions;
+}
+function findPartitionForPath(partitions, path) {
+    // Find the longest matching mount point
+    const lower = path.toLowerCase();
+    // Map common names to paths
+    const aliases = {
+        "documents": ["/home", "/mnt/c/Users", "~/Documents"],
+        "downloads": ["/home", "/mnt/c/Users", "~/Downloads"],
+        "my documents": ["/home", "/mnt/c/Users"],
+        "home": ["/home"],
+        "root": ["/"],
+        "tmp": ["/tmp"],
+        "var": ["/var"],
+        "log": ["/var/log", "/var"],
+        "www": ["/var/www"],
+        "c drive": ["/mnt/c"],
+        "d drive": ["/mnt/d"],
+        "e drive": ["/mnt/e"],
+        "f drive": ["/mnt/f"],
+    };
+    // Check aliases first
+    for (const [alias, paths] of Object.entries(aliases)) {
+        if (lower.includes(alias)) {
+            for (const p of paths) {
+                const match = partitions
+                    .filter((part) => p.startsWith(part.mountPoint) || part.mountPoint.startsWith(p))
+                    .sort((a, b) => b.mountPoint.length - a.mountPoint.length)[0];
+                if (match)
+                    return match;
+            }
+        }
+    }
+    // Direct path match — find longest mount point that is a prefix
+    const sorted = [...partitions].sort((a, b) => b.mountPoint.length - a.mountPoint.length);
+    for (const p of sorted) {
+        if (path.startsWith(p.mountPoint))
+            return p;
+    }
+    return null;
+}
+function formatPartitionHealth(p) {
+    if (p.usePercent >= 95)
+        return `${c.red}⚠ CRITICAL: ${p.usePercent}% full! Only ${p.available} free on ${p.size} total.${c.reset}`;
+    if (p.usePercent >= 85)
+        return `${c.yellow}⚠ WARNING: ${p.usePercent}% full. ${p.available} free on ${p.size} total.${c.reset}`;
+    if (p.usePercent >= 70)
+        return `${c.dim}Moderate: ${p.usePercent}% full. ${p.available} free on ${p.size} total.${c.reset}`;
+    return `${c.green}✓ Healthy: ${p.usePercent}% used. ${p.available} free on ${p.size} total.${c.reset}`;
+}
+function usageBar(percent, width = 20) {
+    const filled = Math.round((percent / 100) * width);
+    const empty = width - filled;
+    const color = percent >= 95 ? c.red : percent >= 85 ? c.yellow : c.green;
+    return `${color}${"█".repeat(filled)}${"░".repeat(empty)}${c.reset}`;
+}
+// ─── Memory Analysis ─────────────────────────────────────────────────────────
+export function analyzeMemory(output) {
+    const lines = [];
+    // Parse "free -h" output
+    // Mem:   31Gi   15Gi   9.5Gi   9.8Mi   6.3Gi   15Gi
+    const memMatch = output.match(/Mem:\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)/);
+    const swapMatch = output.match(/Swap:\s+(\S+)\s+(\S+)\s+(\S+)/);
+    if (!memMatch)
+        return "";
+    const total = memMatch[1];
+    const used = memMatch[2];
+    const free = memMatch[3];
+    const available = memMatch[6];
+    lines.push(`\n${c.bold}${c.cyan}── Analysis ──${c.reset}`);
+    // Calculate percentage from raw values
+    const totalGB = parseSize(total);
+    const usedGB = parseSize(used);
+    const availGB = parseSize(available);
+    if (totalGB > 0) {
+        const usedPercent = Math.round((usedGB / totalGB) * 100);
+        const availPercent = Math.round((availGB / totalGB) * 100);
+        lines.push(`  RAM: ${c.bold}${used}${c.reset} used of ${total} (${availPercent}% available)`);
+        lines.push(`  ${usageBar(usedPercent)}`);
+        if (usedPercent >= 95) {
+            lines.push(`  ${c.red}⚠ CRITICAL: Memory nearly exhausted! OOM killer may activate.${c.reset}`);
+        }
+        else if (usedPercent >= 85) {
+            lines.push(`  ${c.yellow}⚠ HIGH: Memory pressure. Consider scaling up or killing processes.${c.reset}`);
+        }
+        else if (usedPercent >= 70) {
+            lines.push(`  ${c.dim}Moderate memory usage. Normal for most workloads.${c.reset}`);
+        }
+        else {
+            lines.push(`  ${c.green}✓ Memory healthy.${c.reset}`);
+        }
+    }
+    // Swap analysis
+    if (swapMatch) {
+        const swapTotal = swapMatch[1];
+        const swapUsed = swapMatch[2];
+        const swapTotalGB = parseSize(swapTotal);
+        const swapUsedGB = parseSize(swapUsed);
+        if (swapTotalGB > 0) {
+            const swapPercent = Math.round((swapUsedGB / swapTotalGB) * 100);
+            if (swapPercent > 50) {
+                lines.push(`  ${c.yellow}⚠ Swap: ${swapUsed}/${swapTotal} used (${swapPercent}%). Heavy swapping degrades performance.${c.reset}`);
+            }
+            else if (swapUsedGB > 0) {
+                lines.push(`  ${c.dim}Swap: ${swapUsed}/${swapTotal} used. Some swapping is normal.${c.reset}`);
+            }
+            else {
+                lines.push(`  ${c.green}✓ No swap usage.${c.reset}`);
+            }
+        }
+    }
+    return lines.join("\n");
+}
+function parseSize(str) {
+    const match = str.match(/([\d.]+)(\w+)/);
+    if (!match)
+        return 0;
+    const num = parseFloat(match[1]);
+    const unit = match[2].toLowerCase();
+    if (unit.startsWith("t"))
+        return num * 1024;
+    if (unit.startsWith("g"))
+        return num;
+    if (unit.startsWith("m"))
+        return num / 1024;
+    if (unit.startsWith("k"))
+        return num / (1024 * 1024);
+    return num;
+}
+// ─── Router ──────────────────────────────────────────────────────────────────
+/**
+ * Analyze command output based on intent and add commentary.
+ * Returns empty string if no analysis applicable.
+ */
+export function analyzeOutput(intent, output, fields) {
+    switch (intent) {
+        case "server.check_disk":
+            return analyzeDisk(output, fields.target);
+        case "server.check_memory":
+            return analyzeMemory(output);
+        case "server.uptime":
+            return analyzeLoad(output);
+        case "files.list":
+            return analyzeDirectoryOutput(output);
+        default:
+            return "";
+    }
+}

package/dist/utils/autoBackup.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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.
+ */
+export interface BackupRecord {
+    id: string;
+    originalPath: string;
+    backupPath: string;
+    timestamp: string;
+    intent: string;
+    expiresAt: string;
+}
+/**
+ * Create a backup of a file before modifying it.
+ * Returns the backup record, or null if the file doesn't exist.
+ */
+export declare function createBackup(originalPath: string, intent: string, retentionHours?: number): BackupRecord | null;
+/**
+ * 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 declare function getRemoteBackupCommand(filePath: string): string;
+/**
+ * Rollback a file from backup.
+ */
+export declare function rollback(id: string): boolean;
+/**
+ * List all current backups.
+ */
+export declare function listBackups(): BackupRecord[];
+/**
+ * Clean up expired backups.
+ */
+export declare function cleanExpiredBackups(): number;
+/**
+ * Format backup list for display.
+ */
+export declare function formatBackupList(records: BackupRecord[]): string;