@bonginkan/maria 2.1.0 → 2.1.2

package/dist/services/linux-command-intelligence/command-knowledge-base.d.ts

@@ -0,0 +1,96 @@
+import { EventEmitter } from 'events';
+import { CommandCategory, RiskLevel, LinuxCommand } from './context-analyzer.js';
+
+interface CommandDefinition {
+    name: string;
+    description: string;
+    category: CommandCategory;
+    riskLevel: RiskLevel;
+    syntax: string;
+    commonFlags: FlagDefinition[];
+    examples: CommandExample[];
+    manPage?: string;
+    requiresSudo: boolean;
+    alternatives: string[];
+    safetyNotes: string[];
+    platform: string[];
+}
+interface FlagDefinition {
+    flag: string;
+    description: string;
+    argument?: string;
+    riskModifier?: number;
+}
+interface CommandExample {
+    command: string;
+    description: string;
+    risk: RiskLevel;
+    output?: string;
+}
+interface CommandSequence {
+    name: string;
+    description: string;
+    steps: LinuxCommand[];
+    rollback?: LinuxCommand[];
+    conditions?: ExecutionCondition[];
+}
+interface ExecutionCondition {
+    type: 'pre' | 'post' | 'between';
+    check: string;
+    onFail?: 'abort' | 'skip' | 'continue';
+}
+interface SafetyGuideline {
+    command: string;
+    guidelines: string[];
+    forbiddenPatterns: RegExp[];
+    requiresConfirmation: boolean;
+    backupRequired: boolean;
+}
+interface CommandAlternative {
+    original: string;
+    alternatives: AlternativeOption[];
+}
+interface AlternativeOption {
+    command: string;
+    reason: string;
+    pros: string[];
+    cons: string[];
+    preferredWhen: string;
+}
+declare class CommandKnowledgeBase extends EventEmitter {
+    private commands;
+    private workflows;
+    private safetyGuidelines;
+    private alternatives;
+    constructor();
+    private initializeKnowledgeBase;
+    private initializeFileCommands;
+    private initializeProcessCommands;
+    private initializeNetworkCommands;
+    private initializeSystemCommands;
+    private initializeWorkflows;
+    private initializeSafetyGuidelines;
+    private initializeAlternatives;
+    private createCommand;
+    getCommand(name: string | undefined): CommandDefinition | undefined;
+    getWorkflow(name: string): CommandSequence | undefined;
+    getSafetyGuidelines(command: string): SafetyGuideline | undefined;
+    getAlternatives(command: string): CommandAlternative | undefined;
+    searchCommands(query: string): CommandDefinition[];
+    getCommandsByCategory(category: CommandCategory): CommandDefinition[];
+    getCommandsByRiskLevel(maxRisk: RiskLevel): CommandDefinition[];
+    validateCommand(commandString: string): {
+        valid: boolean;
+        risk: RiskLevel;
+        warnings: string[];
+    };
+    suggestAlternative(command: string): AlternativeOption[];
+    getAllWorkflows(): CommandSequence[];
+    exportKnowledge(): {
+        commands: CommandDefinition[];
+        workflows: CommandSequence[];
+        guidelines: SafetyGuideline[];
+    };
+}
+
+export { type AlternativeOption, type CommandAlternative, type CommandDefinition, type CommandExample, CommandKnowledgeBase, type CommandSequence, type ExecutionCondition, type FlagDefinition, type SafetyGuideline };

package/dist/services/linux-command-intelligence/command-knowledge-base.js

@@ -0,0 +1,597 @@
+'use strict';
+
+var events = require('events');
+var child_process = require('child_process');
+var util = require('util');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+util.promisify(child_process.exec);
+
+// src/services/linux-command-intelligence/command-knowledge-base.ts
+var CommandKnowledgeBase = class extends events.EventEmitter {
+  static {
+    __name(this, "CommandKnowledgeBase");
+  }
+  commands;
+  workflows;
+  safetyGuidelines;
+  alternatives;
+  constructor() {
+    super();
+    this.commands = /* @__PURE__ */ new Map();
+    this.workflows = /* @__PURE__ */ new Map();
+    this.safetyGuidelines = /* @__PURE__ */ new Map();
+    this.alternatives = /* @__PURE__ */ new Map();
+    this.initializeKnowledgeBase();
+  }
+  initializeKnowledgeBase() {
+    this.initializeFileCommands();
+    this.initializeProcessCommands();
+    this.initializeNetworkCommands();
+    this.initializeSystemCommands();
+    this.initializeWorkflows();
+    this.initializeSafetyGuidelines();
+    this.initializeAlternatives();
+  }
+  initializeFileCommands() {
+    this.commands.set("ls", {
+      name: "ls",
+      description: "List directory contents",
+      category: "READ_ONLY" /* READ_ONLY */,
+      riskLevel: "SAFE" /* SAFE */,
+      syntax: "ls [OPTIONS] [FILE]...",
+      commonFlags: [
+        { flag: "-l", description: "Long format listing" },
+        { flag: "-a", description: "Show all files including hidden" },
+        { flag: "-h", description: "Human readable sizes" },
+        { flag: "-R", description: "Recursive listing" },
+        { flag: "-t", description: "Sort by modification time" },
+        { flag: "-S", description: "Sort by file size" }
+      ],
+      examples: [
+        { command: "ls -la", description: "List all files in long format", risk: "SAFE" /* SAFE */ },
+        { command: "ls -lah /var/log", description: "List log files with sizes", risk: "SAFE" /* SAFE */ }
+      ],
+      requiresSudo: false,
+      alternatives: ["dir", "find", "tree"],
+      safetyNotes: ["Safe for all operations", "No data modification"],
+      platform: ["linux", "darwin", "unix"]
+    });
+    this.commands.set("rm", {
+      name: "rm",
+      description: "Remove files or directories",
+      category: "DELETE" /* DELETE */,
+      riskLevel: "HIGH" /* HIGH */,
+      syntax: "rm [OPTIONS] FILE...",
+      commonFlags: [
+        { flag: "-r", description: "Recursive removal", riskModifier: 2 },
+        { flag: "-f", description: "Force removal without prompt", riskModifier: 2 },
+        { flag: "-i", description: "Interactive mode", riskModifier: -1 },
+        { flag: "-v", description: "Verbose output" }
+      ],
+      examples: [
+        { command: "rm file.txt", description: "Remove single file", risk: "MEDIUM" /* MEDIUM */ },
+        { command: "rm -rf directory/", description: "Force remove directory", risk: "CRITICAL" /* CRITICAL */ }
+      ],
+      requiresSudo: false,
+      alternatives: ["trash", "mv to /tmp", "unlink"],
+      safetyNotes: [
+        "IRREVERSIBLE operation",
+        "Always verify path before execution",
+        "Consider using trash instead",
+        "Never use rm -rf / or rm -rf /*"
+      ],
+      platform: ["linux", "darwin", "unix"]
+    });
+    this.commands.set("find", {
+      name: "find",
+      description: "Search for files and directories",
+      category: "READ_ONLY" /* READ_ONLY */,
+      riskLevel: "SAFE" /* SAFE */,
+      syntax: "find [PATH] [OPTIONS] [EXPRESSION]",
+      commonFlags: [
+        { flag: "-name", description: "Search by name pattern", argument: "pattern" },
+        { flag: "-type", description: "Search by type", argument: "f|d|l" },
+        { flag: "-size", description: "Search by size", argument: "+/-size" },
+        { flag: "-mtime", description: "Modified time", argument: "+/-days" },
+        { flag: "-exec", description: "Execute command on results", argument: "command", riskModifier: 3 },
+        { flag: "-delete", description: "Delete found files", riskModifier: 5 }
+      ],
+      examples: [
+        { command: 'find . -name "*.log"', description: "Find all log files", risk: "SAFE" /* SAFE */ },
+        { command: "find /tmp -mtime +7 -delete", description: "Delete old temp files", risk: "HIGH" /* HIGH */ }
+      ],
+      requiresSudo: false,
+      alternatives: ["locate", "fd", "grep -r"],
+      safetyNotes: [
+        "Be careful with -exec and -delete flags",
+        "Test with -print first before destructive operations",
+        "Use -maxdepth to limit recursion"
+      ],
+      platform: ["linux", "darwin", "unix"]
+    });
+    this.commands.set("chmod", {
+      name: "chmod",
+      description: "Change file permissions",
+      category: "WRITE" /* WRITE */,
+      riskLevel: "MEDIUM" /* MEDIUM */,
+      syntax: "chmod [OPTIONS] MODE FILE...",
+      commonFlags: [
+        { flag: "-R", description: "Recursive change", riskModifier: 2 },
+        { flag: "-v", description: "Verbose output" },
+        { flag: "-c", description: "Report only changes" },
+        { flag: "--preserve-root", description: "Fail on root", riskModifier: -2 }
+      ],
+      examples: [
+        { command: "chmod 644 file.txt", description: "Set read/write for owner, read for others", risk: "LOW" /* LOW */ },
+        { command: "chmod +x script.sh", description: "Make file executable", risk: "MEDIUM" /* MEDIUM */ },
+        { command: "chmod -R 777 /", description: "DANGEROUS: Open all permissions", risk: "CRITICAL" /* CRITICAL */ }
+      ],
+      requiresSudo: false,
+      alternatives: ["setfacl", "chown"],
+      safetyNotes: [
+        "Incorrect permissions can break system",
+        "Never use 777 on system files",
+        "Understand octal notation before use",
+        "Can affect security if misused"
+      ],
+      platform: ["linux", "darwin", "unix"]
+    });
+  }
+  initializeProcessCommands() {
+    this.commands.set("ps", {
+      name: "ps",
+      description: "Display process status",
+      category: "READ_ONLY" /* READ_ONLY */,
+      riskLevel: "SAFE" /* SAFE */,
+      syntax: "ps [OPTIONS]",
+      commonFlags: [
+        { flag: "aux", description: "All processes with details" },
+        { flag: "-ef", description: "Full format listing" },
+        { flag: "-p", description: "Select by PID", argument: "pid" },
+        { flag: "-u", description: "Select by user", argument: "user" }
+      ],
+      examples: [
+        { command: "ps aux", description: "Show all processes", risk: "SAFE" /* SAFE */ },
+        { command: "ps -ef | grep nginx", description: "Find nginx processes", risk: "SAFE" /* SAFE */ }
+      ],
+      requiresSudo: false,
+      alternatives: ["top", "htop", "pgrep"],
+      safetyNotes: ["Read-only operation", "Safe for monitoring"],
+      platform: ["linux", "darwin", "unix"]
+    });
+    this.commands.set("kill", {
+      name: "kill",
+      description: "Terminate processes",
+      category: "PROCESS" /* PROCESS */,
+      riskLevel: "HIGH" /* HIGH */,
+      syntax: "kill [OPTIONS] PID...",
+      commonFlags: [
+        { flag: "-9", description: "Force kill (SIGKILL)", riskModifier: 2 },
+        { flag: "-15", description: "Graceful termination (SIGTERM)" },
+        { flag: "-l", description: "List signal names" },
+        { flag: "-s", description: "Specify signal", argument: "signal" }
+      ],
+      examples: [
+        { command: "kill 1234", description: "Terminate process 1234", risk: "MEDIUM" /* MEDIUM */ },
+        { command: "kill -9 1234", description: "Force kill process 1234", risk: "HIGH" /* HIGH */ }
+      ],
+      requiresSudo: false,
+      alternatives: ["killall", "pkill", "systemctl stop"],
+      safetyNotes: [
+        "Can cause data loss if process is writing",
+        "Try graceful termination first",
+        "Never kill system critical processes",
+        "Verify PID before killing"
+      ],
+      platform: ["linux", "darwin", "unix"]
+    });
+    this.commands.set("systemctl", {
+      name: "systemctl",
+      description: "Control systemd services",
+      category: "SYSTEM_MODIFY" /* SYSTEM_MODIFY */,
+      riskLevel: "MEDIUM" /* MEDIUM */,
+      syntax: "systemctl [OPTIONS] COMMAND [SERVICE]",
+      commonFlags: [
+        { flag: "status", description: "Show service status" },
+        { flag: "start", description: "Start service", riskModifier: 1 },
+        { flag: "stop", description: "Stop service", riskModifier: 2 },
+        { flag: "restart", description: "Restart service", riskModifier: 2 },
+        { flag: "enable", description: "Enable at boot", riskModifier: 1 },
+        { flag: "disable", description: "Disable at boot", riskModifier: 1 }
+      ],
+      examples: [
+        { command: "systemctl status nginx", description: "Check nginx status", risk: "SAFE" /* SAFE */ },
+        { command: "systemctl restart mysql", description: "Restart MySQL", risk: "MEDIUM" /* MEDIUM */ }
+      ],
+      requiresSudo: true,
+      alternatives: ["service", "init.d scripts", "supervisorctl"],
+      safetyNotes: [
+        "Can affect system availability",
+        "Check dependencies before stopping",
+        "Some services are critical for system operation"
+      ],
+      platform: ["linux"]
+    });
+  }
+  initializeNetworkCommands() {
+    this.commands.set("netstat", {
+      name: "netstat",
+      description: "Display network connections",
+      category: "READ_ONLY" /* READ_ONLY */,
+      riskLevel: "SAFE" /* SAFE */,
+      syntax: "netstat [OPTIONS]",
+      commonFlags: [
+        { flag: "-t", description: "TCP connections" },
+        { flag: "-u", description: "UDP connections" },
+        { flag: "-l", description: "Listening ports" },
+        { flag: "-n", description: "Numerical addresses" },
+        { flag: "-p", description: "Show process info" },
+        { flag: "-a", description: "All connections" }
+      ],
+      examples: [
+        { command: "netstat -tuln", description: "Show listening ports", risk: "SAFE" /* SAFE */ },
+        { command: "netstat -anp | grep :80", description: "Find process on port 80", risk: "SAFE" /* SAFE */ }
+      ],
+      requiresSudo: false,
+      alternatives: ["ss", "lsof -i", "sockstat"],
+      safetyNotes: ["Read-only operation", "May require sudo for process info"],
+      platform: ["linux", "darwin", "unix"]
+    });
+    this.commands.set("iptables", {
+      name: "iptables",
+      description: "Configure Linux firewall",
+      category: "SECURITY" /* SECURITY */,
+      riskLevel: "CRITICAL" /* CRITICAL */,
+      syntax: "iptables [OPTIONS] [CHAIN] [RULE]",
+      commonFlags: [
+        { flag: "-L", description: "List rules" },
+        { flag: "-A", description: "Append rule", riskModifier: 3 },
+        { flag: "-D", description: "Delete rule", riskModifier: 3 },
+        { flag: "-F", description: "Flush all rules", riskModifier: 5 },
+        { flag: "-P", description: "Set default policy", riskModifier: 4 }
+      ],
+      examples: [
+        { command: "iptables -L", description: "List firewall rules", risk: "SAFE" /* SAFE */ },
+        { command: "iptables -A INPUT -p tcp --dport 22 -j ACCEPT", description: "Allow SSH", risk: "HIGH" /* HIGH */ }
+      ],
+      requiresSudo: true,
+      alternatives: ["ufw", "firewalld", "nftables"],
+      safetyNotes: [
+        "Can lock you out of system",
+        "Always have backup access",
+        "Test rules before applying permanently",
+        "Incorrect rules can break networking"
+      ],
+      platform: ["linux"]
+    });
+  }
+  initializeSystemCommands() {
+    this.commands.set("df", {
+      name: "df",
+      description: "Display disk space usage",
+      category: "READ_ONLY" /* READ_ONLY */,
+      riskLevel: "SAFE" /* SAFE */,
+      syntax: "df [OPTIONS] [FILE]...",
+      commonFlags: [
+        { flag: "-h", description: "Human readable sizes" },
+        { flag: "-T", description: "Show filesystem type" },
+        { flag: "-i", description: "Show inode information" },
+        { flag: "-a", description: "Include all filesystems" }
+      ],
+      examples: [
+        { command: "df -h", description: "Show disk usage in human format", risk: "SAFE" /* SAFE */ },
+        { command: "df -hT /", description: "Show root filesystem details", risk: "SAFE" /* SAFE */ }
+      ],
+      requiresSudo: false,
+      alternatives: ["du", "lsblk", "fdisk -l"],
+      safetyNotes: ["Read-only operation", "Safe for all users"],
+      platform: ["linux", "darwin", "unix"]
+    });
+    this.commands.set("mount", {
+      name: "mount",
+      description: "Mount filesystems",
+      category: "SYSTEM_MODIFY" /* SYSTEM_MODIFY */,
+      riskLevel: "HIGH" /* HIGH */,
+      syntax: "mount [OPTIONS] DEVICE MOUNTPOINT",
+      commonFlags: [
+        { flag: "-t", description: "Filesystem type", argument: "type" },
+        { flag: "-o", description: "Mount options", argument: "options" },
+        { flag: "-r", description: "Read-only mount", riskModifier: -1 },
+        { flag: "-a", description: "Mount all in fstab", riskModifier: 2 }
+      ],
+      examples: [
+        { command: "mount", description: "Show mounted filesystems", risk: "SAFE" /* SAFE */ },
+        { command: "mount /dev/sdb1 /mnt", description: "Mount device to /mnt", risk: "HIGH" /* HIGH */ }
+      ],
+      requiresSudo: true,
+      alternatives: ["umount", "findmnt", "lsblk"],
+      safetyNotes: [
+        "Can overwrite existing mount points",
+        "Verify device before mounting",
+        "Incorrect options can corrupt data",
+        "Always unmount before removal"
+      ],
+      platform: ["linux", "unix"]
+    });
+  }
+  initializeWorkflows() {
+    this.workflows.set("system-health-check", {
+      name: "system-health-check",
+      description: "Comprehensive system health assessment",
+      steps: [
+        this.createCommand("uptime", [], "SAFE" /* SAFE */),
+        this.createCommand("free", ["-h"], "SAFE" /* SAFE */),
+        this.createCommand("df", ["-h"], "SAFE" /* SAFE */),
+        this.createCommand("ps", ["aux", "--sort=-pcpu", "|", "head", "-10"], "SAFE" /* SAFE */),
+        this.createCommand("netstat", ["-tuln"], "SAFE" /* SAFE */),
+        this.createCommand("systemctl", ["list-units", "--failed"], "SAFE" /* SAFE */)
+      ],
+      conditions: [
+        {
+          type: "pre",
+          check: "command -v systemctl",
+          onFail: "skip"
+        }
+      ]
+    });
+    this.workflows.set("disk-cleanup", {
+      name: "disk-cleanup",
+      description: "Free up disk space safely",
+      steps: [
+        this.createCommand("df", ["-h"], "SAFE" /* SAFE */),
+        this.createCommand("du", ["-sh", "/var/log/*"], "SAFE" /* SAFE */),
+        this.createCommand("find", ["/tmp", "-type", "f", "-mtime", "+7", "-size", "+10M"], "SAFE" /* SAFE */),
+        this.createCommand("journalctl", ["--vacuum-time=7d"], "MEDIUM" /* MEDIUM */),
+        this.createCommand("apt", ["autoremove", "-y"], "MEDIUM" /* MEDIUM */),
+        this.createCommand("apt", ["clean"], "LOW" /* LOW */)
+      ],
+      rollback: [
+        this.createCommand("echo", ["Cleanup completed, no rollback needed"], "SAFE" /* SAFE */)
+      ],
+      conditions: [
+        {
+          type: "pre",
+          check: 'test $(df / | awk "NR==2 {print $5}" | sed "s/%//") -gt 80',
+          onFail: "abort"
+        }
+      ]
+    });
+    this.workflows.set("security-audit", {
+      name: "security-audit",
+      description: "Basic security assessment",
+      steps: [
+        this.createCommand("who", [], "SAFE" /* SAFE */),
+        this.createCommand("last", ["-10"], "SAFE" /* SAFE */),
+        this.createCommand("netstat", ["-tuln"], "SAFE" /* SAFE */),
+        this.createCommand("ps", ["aux", "|", "grep", "root"], "SAFE" /* SAFE */),
+        this.createCommand("find", ["/", "-perm", "-4000", "-type", "f", "2>/dev/null"], "SAFE" /* SAFE */),
+        this.createCommand("iptables", ["-L", "-n"], "SAFE" /* SAFE */)
+      ]
+    });
+  }
+  initializeSafetyGuidelines() {
+    this.safetyGuidelines.set("rm", {
+      command: "rm",
+      guidelines: [
+        "Always use absolute paths when possible",
+        "Verify path with ls first",
+        "Use -i flag for interactive confirmation",
+        "Consider using trash-cli instead",
+        "Never use variables in rm commands without validation"
+      ],
+      forbiddenPatterns: [
+        /rm\s+-rf\s+\/$/,
+        /rm\s+-rf\s+\/\*/,
+        /rm\s+-rf\s+~$/,
+        /rm\s+-rf\s+\$HOME$/
+      ],
+      requiresConfirmation: true,
+      backupRequired: true
+    });
+    this.safetyGuidelines.set("chmod", {
+      command: "chmod",
+      guidelines: [
+        "Understand permission implications",
+        "Never use 777 on system files",
+        "Test on non-critical files first",
+        "Use symbolic notation when unsure"
+      ],
+      forbiddenPatterns: [
+        /chmod\s+777\s+\//,
+        /chmod\s+-R\s+777/,
+        /chmod\s+000\s+\//
+      ],
+      requiresConfirmation: true,
+      backupRequired: false
+    });
+    this.safetyGuidelines.set("dd", {
+      command: "dd",
+      guidelines: [
+        "Double-check input and output devices",
+        "Never confuse if= and of=",
+        "Use conv=sync,noerror for recovery",
+        "Always specify block size"
+      ],
+      forbiddenPatterns: [
+        /dd\s+.*of=\/dev\/[sh]da$/
+      ],
+      requiresConfirmation: true,
+      backupRequired: true
+    });
+  }
+  initializeAlternatives() {
+    this.alternatives.set("rm", {
+      original: "rm",
+      alternatives: [
+        {
+          command: "trash-cli",
+          reason: "Moves files to trash instead of permanent deletion",
+          pros: ["Recoverable", "Safer", "User-friendly"],
+          cons: ["Requires installation", "Uses more disk space temporarily"],
+          preferredWhen: "Working with important files or uncertain about deletion"
+        },
+        {
+          command: "mv to /tmp",
+          reason: "Move files to temp directory for later cleanup",
+          pros: ["Recoverable until reboot", "No additional tools needed"],
+          cons: ["Manual cleanup needed", "/tmp has size limits"],
+          preferredWhen: "Need temporary safety net without installing tools"
+        }
+      ]
+    });
+    this.alternatives.set("netstat", {
+      original: "netstat",
+      alternatives: [
+        {
+          command: "ss",
+          reason: "Modern replacement for netstat with better performance",
+          pros: ["Faster", "More features", "Better TCP state info"],
+          cons: ["Different syntax", "Not available on older systems"],
+          preferredWhen: "Working on modern Linux systems"
+        },
+        {
+          command: "lsof -i",
+          reason: "Shows network connections with process details",
+          pros: ["Detailed process info", "Cross-platform"],
+          cons: ["Slower", "More verbose output"],
+          preferredWhen: "Need detailed process and file descriptor info"
+        }
+      ]
+    });
+    this.alternatives.set("ps", {
+      original: "ps",
+      alternatives: [
+        {
+          command: "top",
+          reason: "Real-time process monitoring",
+          pros: ["Live updates", "Interactive", "CPU/Memory sorting"],
+          cons: ["Not scriptable", "Terminal-based only"],
+          preferredWhen: "Interactive monitoring and troubleshooting"
+        },
+        {
+          command: "htop",
+          reason: "Enhanced interactive process viewer",
+          pros: ["Better UI", "Tree view", "Mouse support"],
+          cons: ["Requires installation", "Not scriptable"],
+          preferredWhen: "Interactive monitoring with better visualization"
+        },
+        {
+          command: "pgrep/pkill",
+          reason: "Process selection by pattern",
+          pros: ["Simple pattern matching", "Scriptable"],
+          cons: ["Limited output format", "Less detail"],
+          preferredWhen: "Finding or killing processes by name"
+        }
+      ]
+    });
+  }
+  createCommand(command, args, risk) {
+    return {
+      command,
+      args,
+      flags: [],
+      sudo: false,
+      risk,
+      category: "READ_ONLY" /* READ_ONLY */,
+      description: ""
+    };
+  }
+  getCommand(name) {
+    if (!name) return void 0;
+    return this.commands.get(name);
+  }
+  getWorkflow(name) {
+    return this.workflows.get(name);
+  }
+  getSafetyGuidelines(command) {
+    return this.safetyGuidelines.get(command);
+  }
+  getAlternatives(command) {
+    return this.alternatives.get(command);
+  }
+  searchCommands(query) {
+    const results = [];
+    const lowerQuery = query.toLowerCase();
+    for (const cmd of this.commands.values()) {
+      if (cmd.name.includes(lowerQuery) || cmd.description.toLowerCase().includes(lowerQuery)) {
+        results.push(cmd);
+      }
+    }
+    return results;
+  }
+  getCommandsByCategory(category) {
+    return Array.from(this.commands.values()).filter(
+      (cmd) => cmd.category === category
+    );
+  }
+  getCommandsByRiskLevel(maxRisk) {
+    const riskOrder = {
+      ["SAFE" /* SAFE */]: 0,
+      ["LOW" /* LOW */]: 1,
+      ["MEDIUM" /* MEDIUM */]: 2,
+      ["HIGH" /* HIGH */]: 3,
+      ["CRITICAL" /* CRITICAL */]: 4
+    };
+    const maxRiskValue = riskOrder[maxRisk];
+    return Array.from(this.commands.values()).filter(
+      (cmd) => riskOrder[cmd.riskLevel] <= maxRiskValue
+    );
+  }
+  validateCommand(commandString) {
+    const parts = commandString.split(/\s+/);
+    const cmdName = parts[0];
+    const cmd = cmdName ? this.commands.get(cmdName) : void 0;
+    if (!cmd) {
+      return {
+        valid: false,
+        risk: "SAFE" /* SAFE */,
+        warnings: [`Unknown command: ${cmdName}`]
+      };
+    }
+    const warnings = [];
+    const guidelines = cmdName ? this.safetyGuidelines.get(cmdName) : void 0;
+    if (guidelines) {
+      for (const pattern of guidelines.forbiddenPatterns) {
+        if (pattern.test(commandString)) {
+          warnings.push(`DANGEROUS: This command matches forbidden pattern: ${pattern}`);
+        }
+      }
+    }
+    let risk = cmd ? cmd.riskLevel : "SAFE" /* SAFE */;
+    for (const part of parts.slice(1)) {
+      for (const flag of cmd ? cmd.commonFlags : []) {
+        if (part === flag.flag && flag.riskModifier) {
+          const riskOrder = ["SAFE" /* SAFE */, "LOW" /* LOW */, "MEDIUM" /* MEDIUM */, "HIGH" /* HIGH */, "CRITICAL" /* CRITICAL */];
+          const currentIndex = riskOrder.indexOf(risk);
+          const newIndex = Math.min(4, Math.max(0, currentIndex + flag.riskModifier));
+          risk = riskOrder[newIndex] || "SAFE" /* SAFE */;
+        }
+      }
+    }
+    return {
+      valid: warnings.length === 0,
+      risk,
+      warnings
+    };
+  }
+  suggestAlternative(command) {
+    const alt = this.alternatives.get(command);
+    return alt ? alt.alternatives : [];
+  }
+  getAllWorkflows() {
+    return Array.from(this.workflows.values());
+  }
+  exportKnowledge() {
+    return {
+      commands: Array.from(this.commands.values()),
+      workflows: Array.from(this.workflows.values()),
+      guidelines: Array.from(this.safetyGuidelines.values())
+    };
+  }
+};
+
+exports.CommandKnowledgeBase = CommandKnowledgeBase;
+//# sourceMappingURL=command-knowledge-base.js.map
+//# sourceMappingURL=command-knowledge-base.js.map