bashio 0.4.0

package/dist/index.js

@@ -0,0 +1,2503 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Builtins, Cli } from "clipanion";
+
+// src/core/config.ts
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+import { join } from "path";
+
+// src/core/types.ts
+import { z } from "zod";
+var ProviderName = z.enum([
+  "claude",
+  "openai",
+  "ollama",
+  "openrouter"
+]);
+var SessionCredentials = z.object({
+  type: z.literal("session"),
+  sessionToken: z.string()
+});
+var ApiKeyCredentials = z.object({
+  type: z.literal("api_key"),
+  apiKey: z.string()
+});
+var LocalCredentials = z.object({
+  type: z.literal("local"),
+  host: z.string().default("http://localhost:11434")
+});
+var Credentials = z.discriminatedUnion("type", [
+  SessionCredentials,
+  ApiKeyCredentials,
+  LocalCredentials
+]);
+var Settings = z.object({
+  confirmBeforeExecute: z.boolean().default(true),
+  historyEnabled: z.boolean().default(true),
+  historyRetentionDays: z.number().default(30),
+  historyMaxEntries: z.number().default(2e3),
+  autoConfirmShortcuts: z.boolean().default(false)
+});
+var Config = z.object({
+  version: z.number().default(1),
+  provider: ProviderName,
+  model: z.string(),
+  credentials: Credentials,
+  settings: Settings.optional()
+});
+var ShortcutDefinition = z.object({
+  template: z.string(),
+  args: z.array(z.string()).default([]),
+  description: z.string().optional()
+});
+var ShortcutsFile = z.object({
+  version: z.number().default(1),
+  shortcuts: z.record(z.string(), ShortcutDefinition)
+});
+var CommandSource = z.enum(["ai", "shortcut"]);
+var HistoryEntry = z.object({
+  id: z.number(),
+  query: z.string(),
+  command: z.string(),
+  source: CommandSource,
+  workingDirectory: z.string(),
+  executed: z.number(),
+  exitCode: z.number().nullable(),
+  createdAt: z.string()
+});
+var QueryStats = z.object({
+  id: z.number(),
+  query: z.string(),
+  command: z.string(),
+  source: CommandSource,
+  useCount: z.number(),
+  successCount: z.number(),
+  suggested: z.number(),
+  firstUsed: z.string(),
+  lastUsed: z.string()
+});
+
+// src/core/config.ts
+var CONFIG_DIR = join(homedir(), ".bashio");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+function ensureConfigDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  }
+}
+function configExists() {
+  return existsSync(CONFIG_FILE);
+}
+function loadConfig() {
+  if (!configExists()) {
+    return null;
+  }
+  try {
+    const raw = readFileSync(CONFIG_FILE, "utf-8");
+    const data = JSON.parse(raw);
+    return Config.parse(data);
+  } catch {
+    return null;
+  }
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  const data = JSON.stringify(config, null, 2);
+  writeFileSync(CONFIG_FILE, data, { encoding: "utf-8", mode: 384 });
+  chmodSync(CONFIG_FILE, 384);
+}
+function getConfigPath() {
+  return CONFIG_FILE;
+}
+function getConfigDir() {
+  return CONFIG_DIR;
+}
+
+// src/core/database.ts
+import { chmodSync as chmodSync2, existsSync as existsSync2 } from "fs";
+import Database from "better-sqlite3";
+var DB_PATH = `${getConfigDir()}/history.db`;
+var db = null;
+var SCHEMA = `
+-- History table: stores recent command history (auto-cleaned based on retention)
+CREATE TABLE IF NOT EXISTS history (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  query TEXT NOT NULL,
+  command TEXT NOT NULL,
+  source TEXT NOT NULL CHECK(source IN ('ai', 'shortcut')),
+  working_directory TEXT NOT NULL,
+  executed INTEGER DEFAULT 0,
+  exit_code INTEGER,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+-- Query stats table: aggregated stats (never deleted, stays tiny)
+-- Keyed by command to handle query variations (typos, synonyms, different phrasings)
+CREATE TABLE IF NOT EXISTS query_stats (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  command TEXT UNIQUE NOT NULL,
+  source TEXT NOT NULL CHECK(source IN ('ai', 'shortcut')),
+  use_count INTEGER DEFAULT 1,
+  success_count INTEGER DEFAULT 0,
+  suggested INTEGER DEFAULT 0,
+  first_used TEXT NOT NULL,
+  last_used TEXT NOT NULL
+);
+
+-- Metadata table for DB version and settings
+CREATE TABLE IF NOT EXISTS metadata (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+
+-- Indexes for performance
+CREATE INDEX IF NOT EXISTS idx_history_created ON history(created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_history_query ON history(query);
+CREATE INDEX IF NOT EXISTS idx_history_working_dir ON history(working_directory);
+CREATE INDEX IF NOT EXISTS idx_stats_use_count ON query_stats(use_count DESC);
+
+-- Initial metadata
+INSERT OR IGNORE INTO metadata (key, value) VALUES ('db_version', '1');
+INSERT OR IGNORE INTO metadata (key, value) VALUES ('last_cleanup', '0');
+`;
+function initDatabase() {
+  if (db) {
+    return db;
+  }
+  ensureConfigDir();
+  const isNew = !existsSync2(DB_PATH);
+  db = new Database(DB_PATH);
+  if (isNew) {
+    chmodSync2(DB_PATH, 384);
+  }
+  db.pragma("journal_mode = WAL");
+  db.exec(SCHEMA);
+  return db;
+}
+function getDatabase() {
+  if (!db) {
+    return initDatabase();
+  }
+  return db;
+}
+function getMetadata(key) {
+  const database = getDatabase();
+  const row = database.prepare("SELECT value FROM metadata WHERE key = ?").get(key);
+  return row?.value ?? null;
+}
+function setMetadata(key, value) {
+  const database = getDatabase();
+  database.prepare("INSERT OR REPLACE INTO metadata (key, value) VALUES (?, ?)").run(key, value);
+}
+
+// src/core/history.ts
+function rowToHistoryEntry(row) {
+  return {
+    id: row.id,
+    query: row.query,
+    command: row.command,
+    source: row.source,
+    workingDirectory: row.working_directory,
+    executed: row.executed,
+    exitCode: row.exit_code,
+    createdAt: row.created_at
+  };
+}
+function recordCommand(data) {
+  const db2 = getDatabase();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const workingDir = data.workingDirectory || process.cwd();
+  const historyResult = db2.prepare(
+    `INSERT INTO history (query, command, source, working_directory, executed, created_at) 
+       VALUES (?, ?, ?, ?, 0, ?)`
+  ).run(data.query, data.command, data.source, workingDir, now);
+  const existingStats = db2.prepare("SELECT id FROM query_stats WHERE command = ?").get(data.command);
+  if (existingStats) {
+    db2.prepare(
+      `UPDATE query_stats 
+       SET use_count = use_count + 1, 
+           last_used = ?
+       WHERE command = ?`
+    ).run(now, data.command);
+  } else {
+    db2.prepare(
+      `INSERT INTO query_stats (command, source, use_count, success_count, suggested, first_used, last_used)
+       VALUES (?, ?, 1, 0, 0, ?, ?)`
+    ).run(data.command, data.source, now, now);
+  }
+  return historyResult.lastInsertRowid;
+}
+function markExecuted(historyId, exitCode) {
+  const db2 = getDatabase();
+  db2.prepare("UPDATE history SET executed = 1, exit_code = ? WHERE id = ?").run(
+    exitCode,
+    historyId
+  );
+  const historyRow = db2.prepare("SELECT command FROM history WHERE id = ?").get(historyId);
+  if (historyRow && exitCode === 0) {
+    db2.prepare(
+      "UPDATE query_stats SET success_count = success_count + 1 WHERE command = ?"
+    ).run(historyRow.command);
+  }
+}
+function getRecentHistory(limit = 20) {
+  const db2 = getDatabase();
+  const rows = db2.prepare("SELECT * FROM history ORDER BY created_at DESC LIMIT ?").all(limit);
+  return rows.map(rowToHistoryEntry);
+}
+function searchHistory(searchTerm, limit = 20) {
+  const db2 = getDatabase();
+  const pattern = `%${searchTerm}%`;
+  const rows = db2.prepare(
+    `SELECT * FROM history 
+       WHERE query LIKE ? OR command LIKE ?
+       ORDER BY created_at DESC 
+       LIMIT ?`
+  ).all(pattern, pattern, limit);
+  return rows.map(rowToHistoryEntry);
+}
+function getStats() {
+  const db2 = getDatabase();
+  const totalResult = db2.prepare("SELECT COUNT(*) as count FROM history").get();
+  const todayResult = db2.prepare(
+    `SELECT COUNT(*) as count FROM history 
+       WHERE date(created_at) = date('now')`
+  ).get();
+  const thisWeekResult = db2.prepare(
+    `SELECT COUNT(*) as count FROM history 
+       WHERE created_at >= datetime('now', '-7 days')`
+  ).get();
+  const executedResult = db2.prepare("SELECT COUNT(*) as count FROM history WHERE executed = 1").get();
+  const aiResult = db2.prepare("SELECT COUNT(*) as count FROM history WHERE source = 'ai'").get();
+  const shortcutResult = db2.prepare("SELECT COUNT(*) as count FROM history WHERE source = 'shortcut'").get();
+  const topCommands = db2.prepare(
+    `SELECT command, use_count, source FROM query_stats 
+       ORDER BY use_count DESC 
+       LIMIT 5`
+  ).all();
+  const total = totalResult.count;
+  const executed = executedResult.count;
+  return {
+    totalCommands: total,
+    todayCommands: todayResult.count,
+    thisWeekCommands: thisWeekResult.count,
+    totalExecuted: executed,
+    executionRate: total > 0 ? Math.round(executed / total * 100) : 0,
+    aiCount: aiResult.count,
+    shortcutCount: shortcutResult.count,
+    topQueries: topCommands.map((c) => ({
+      query: c.command,
+      useCount: c.use_count,
+      source: c.source
+    }))
+  };
+}
+function cleanupHistory(config) {
+  const db2 = getDatabase();
+  const deleteByAgeResult = db2.prepare(
+    `DELETE FROM history 
+       WHERE created_at < datetime('now', '-' || ? || ' days')`
+  ).run(config.retentionDays);
+  const deleteExcessResult = db2.prepare(
+    `DELETE FROM history 
+       WHERE id NOT IN (
+         SELECT id FROM history 
+         ORDER BY created_at DESC 
+         LIMIT ?
+       )`
+  ).run(config.maxEntries);
+  setMetadata("last_cleanup", (/* @__PURE__ */ new Date()).toISOString());
+  return deleteByAgeResult.changes + deleteExcessResult.changes;
+}
+function clearAllHistory() {
+  const db2 = getDatabase();
+  const result = db2.prepare("DELETE FROM history").run();
+  return result.changes;
+}
+function clearHistoryOlderThan(days) {
+  const db2 = getDatabase();
+  const result = db2.prepare(
+    `DELETE FROM history 
+       WHERE created_at < datetime('now', '-' || ? || ' days')`
+  ).run(days);
+  return result.changes;
+}
+function shouldRunCleanup() {
+  const lastCleanup = getMetadata("last_cleanup");
+  if (!lastCleanup || lastCleanup === "0") {
+    return true;
+  }
+  const lastCleanupDate = new Date(lastCleanup);
+  const now = /* @__PURE__ */ new Date();
+  const oneDayMs = 24 * 60 * 60 * 1e3;
+  return now.getTime() - lastCleanupDate.getTime() > oneDayMs;
+}
+function getHistoryCount() {
+  const db2 = getDatabase();
+  const result = db2.prepare("SELECT COUNT(*) as count FROM history").get();
+  return result.count;
+}
+
+// src/cli/commands/AddShortcutCommand.ts
+import { input as input2 } from "@inquirer/prompts";
+import { Command, Option } from "clipanion";
+import pc2 from "picocolors";
+
+// src/core/shortcuts.ts
+import { chmodSync as chmodSync3, existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+import { input } from "@inquirer/prompts";
+var SHORTCUTS_FILE = join2(getConfigDir(), "shortcuts.json");
+function shortcutsFileExists() {
+  return existsSync3(SHORTCUTS_FILE);
+}
+function loadShortcuts() {
+  if (!shortcutsFileExists()) {
+    return { version: 1, shortcuts: {} };
+  }
+  try {
+    const raw = readFileSync2(SHORTCUTS_FILE, "utf-8");
+    const data = JSON.parse(raw);
+    return ShortcutsFile.parse(data);
+  } catch {
+    return { version: 1, shortcuts: {} };
+  }
+}
+function saveShortcuts(shortcuts) {
+  ensureConfigDir();
+  const data = JSON.stringify(shortcuts, null, 2);
+  writeFileSync2(SHORTCUTS_FILE, data, { encoding: "utf-8", mode: 384 });
+  chmodSync3(SHORTCUTS_FILE, 384);
+}
+function getShortcut(name) {
+  const file = loadShortcuts();
+  return file.shortcuts[name] || null;
+}
+function addShortcut(name, definition) {
+  const file = loadShortcuts();
+  file.shortcuts[name] = definition;
+  saveShortcuts(file);
+}
+function removeShortcut(name) {
+  const file = loadShortcuts();
+  if (!file.shortcuts[name]) {
+    return false;
+  }
+  delete file.shortcuts[name];
+  saveShortcuts(file);
+  return true;
+}
+function listShortcuts() {
+  const file = loadShortcuts();
+  return file.shortcuts;
+}
+function getShortcutsFilePath() {
+  return SHORTCUTS_FILE;
+}
+function parseInput(queryParts, expectedArgCount) {
+  if (queryParts.length === 0) {
+    return { name: "", args: [] };
+  }
+  const name = queryParts[0];
+  const remainingParts = queryParts.slice(1);
+  if (remainingParts.length === 0) {
+    return { name, args: [] };
+  }
+  if (expectedArgCount === 1) {
+    return { name, args: [remainingParts.join(" ")] };
+  }
+  return { name, args: remainingParts };
+}
+function fillTemplate(template, argNames, argValues) {
+  let result = template;
+  for (let i = 0; i < argNames.length; i++) {
+    const placeholder = `{{${argNames[i]}}}`;
+    const value = argValues[i] || "";
+    result = result.split(placeholder).join(value);
+  }
+  return result;
+}
+async function tryResolveShortcut(queryParts) {
+  if (queryParts.length === 0) {
+    return null;
+  }
+  const shortcutName = queryParts[0];
+  const shortcut = getShortcut(shortcutName);
+  if (!shortcut) {
+    return null;
+  }
+  const requiredArgs = shortcut.args || [];
+  const { args: providedArgs } = parseInput(queryParts, requiredArgs.length);
+  const finalArgs = [...providedArgs];
+  if (finalArgs.length < requiredArgs.length) {
+    for (let i = finalArgs.length; i < requiredArgs.length; i++) {
+      const argName = requiredArgs[i];
+      const value = await input({
+        message: `Enter ${argName}:`
+      });
+      finalArgs.push(value);
+    }
+  }
+  const command = fillTemplate(shortcut.template, requiredArgs, finalArgs);
+  return {
+    name: shortcutName,
+    command,
+    source: "shortcut"
+  };
+}
+
+// src/utils/logger.ts
+import pc from "picocolors";
+var logger = {
+  info: (msg) => console.log(pc.blue("i"), msg),
+  success: (msg) => console.log(pc.green("\u2713"), msg),
+  warn: (msg) => console.log(pc.yellow("\u26A0"), msg),
+  error: (msg) => console.log(pc.red("\u2717"), msg),
+  command: (cmd) => {
+    console.log(pc.gray(">"), pc.cyan("Will run:"), pc.white(cmd));
+  },
+  output: (text) => {
+    console.log(pc.gray("\u2500".repeat(50)));
+    console.log(text);
+    console.log(pc.gray("\u2500".repeat(50)));
+  },
+  exitCode: (code) => {
+    if (code === 0) {
+      console.log(pc.green("\u2713"), pc.gray(`Done (exit code: ${code})`));
+    } else {
+      console.log(pc.red("\u2717"), pc.gray(`Failed (exit code: ${code})`));
+    }
+  },
+  box: (title, content) => {
+    const lines = content.split("\n");
+    const maxLen = Math.max(title.length, ...lines.map((l) => l.length));
+    const border = "\u2500".repeat(maxLen + 4);
+    console.log(pc.gray(`\u250C${border}\u2510`));
+    console.log(pc.gray("\u2502"), pc.bold(title.padEnd(maxLen + 2)), pc.gray("\u2502"));
+    console.log(pc.gray(`\u251C${border}\u2524`));
+    for (const line of lines) {
+      console.log(pc.gray("\u2502"), line.padEnd(maxLen + 2), pc.gray("\u2502"));
+    }
+    console.log(pc.gray(`\u2514${border}\u2518`));
+  }
+};
+
+// src/cli/commands/AddShortcutCommand.ts
+var AddShortcutCommand = class extends Command {
+  static paths = [["add-shortcut"], ["--add-shortcut"]];
+  static usage = Command.Usage({
+    description: "Add a new shortcut",
+    examples: [
+      ["Interactive mode", "$0 --add-shortcut"],
+      [
+        "One-liner",
+        '$0 --add-shortcut killport "lsof -ti:{{port}} | xargs kill -9" port'
+      ]
+    ]
+  });
+  // Optional positional args for one-liner mode
+  name = Option.String({ required: false });
+  template = Option.String({ required: false });
+  args = Option.String({ required: false });
+  async execute() {
+    let shortcutName;
+    let shortcutTemplate;
+    let shortcutArgs;
+    let shortcutDescription;
+    if (this.name && this.template) {
+      shortcutName = this.name;
+      shortcutTemplate = this.template;
+      shortcutArgs = this.args ? this.args.split(",").map((a) => a.trim()) : [];
+    } else {
+      console.log(pc2.bold("\n  Add New Shortcut\n"));
+      shortcutName = await input2({
+        message: "Shortcut name:",
+        validate: (value) => {
+          if (!value.trim()) return "Name is required";
+          if (value.includes(" ")) return "Name cannot contain spaces";
+          return true;
+        }
+      });
+      if (getShortcut(shortcutName)) {
+        logger.warn(
+          `Shortcut "${shortcutName}" already exists. It will be overwritten.`
+        );
+      }
+      shortcutTemplate = await input2({
+        message: "Command template (use {{arg}} for placeholders):",
+        validate: (value) => {
+          if (!value.trim()) return "Template is required";
+          return true;
+        }
+      });
+      const argsInput = await input2({
+        message: "Arguments (comma-separated, or leave empty):"
+      });
+      shortcutArgs = argsInput ? argsInput.split(",").map((a) => a.trim()).filter(Boolean) : [];
+      shortcutDescription = await input2({
+        message: "Description (optional):"
+      });
+    }
+    const placeholders = shortcutTemplate.match(/\{\{(\w+)\}\}/g) || [];
+    const placeholderNames = placeholders.map((p) => p.replace(/[{}]/g, ""));
+    for (const ph of placeholderNames) {
+      if (!shortcutArgs.includes(ph)) {
+        logger.warn(
+          `Placeholder "{{${ph}}}" found but not in arguments list. Adding it.`
+        );
+        shortcutArgs.push(ph);
+      }
+    }
+    addShortcut(shortcutName, {
+      template: shortcutTemplate,
+      args: shortcutArgs,
+      description: shortcutDescription || void 0
+    });
+    console.log();
+    logger.success(`Shortcut "${shortcutName}" added!`);
+    if (shortcutArgs.length > 0) {
+      console.log(
+        pc2.gray(
+          `  Usage: s ${shortcutName} ${shortcutArgs.map((a) => `<${a}>`).join(" ")}`
+        )
+      );
+    } else {
+      console.log(pc2.gray(`  Usage: s ${shortcutName}`));
+    }
+    console.log();
+    return 0;
+  }
+};
+
+// src/cli/commands/AuthCommand.ts
+import { input as input3, password, select } from "@inquirer/prompts";
+import { Command as Command2 } from "clipanion";
+import pc3 from "picocolors";
+
+// src/providers/base.ts
+var SYSTEM_PROMPT_GENERATE = `You are a shell command generator for macOS/Linux terminals.
+Given a natural language description, return ONLY the shell command.
+Rules:
+- Return ONLY the raw command, nothing else
+- No markdown formatting, no backticks, no explanation
+- No "Here's the command:" or similar prefixes
+- If multiple commands are needed, chain them with && or ;
+- Use common Unix utilities (find, grep, awk, sed, curl, etc.)
+- Prefer simple, portable commands over complex ones`;
+var SYSTEM_PROMPT_EXPLAIN = `You are a shell command expert.
+Explain the given shell command in simple terms.
+Break down each part of the command concisely.
+Format as a simple list without markdown.`;
+
+// src/providers/claude.ts
+var ClaudeProvider = class {
+  name = "Claude";
+  model;
+  apiKey;
+  constructor(config) {
+    this.model = config.model;
+    if (config.credentials.type === "api_key") {
+      this.apiKey = config.credentials.apiKey;
+    } else if (config.credentials.type === "session") {
+      this.apiKey = config.credentials.sessionToken;
+    } else {
+      throw new Error("Claude requires API key or session token");
+    }
+  }
+  async call(systemPrompt, userMessage) {
+    const messages = [
+      { role: "user", content: userMessage }
+    ];
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({
+        model: this.model,
+        max_tokens: 1024,
+        system: systemPrompt,
+        messages
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Claude API error: ${response.status} - ${error}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(`Claude API error: ${data.error.message}`);
+    }
+    const textContent = data.content.find((c) => c.type === "text");
+    if (!textContent) {
+      throw new Error("No text response from Claude");
+    }
+    return textContent.text.trim();
+  }
+  async generateCommand(query, context) {
+    const userMessage = context ? `Context: ${context}
+
+Task: ${query}` : query;
+    return this.call(SYSTEM_PROMPT_GENERATE, userMessage);
+  }
+  async explainCommand(command) {
+    return this.call(SYSTEM_PROMPT_EXPLAIN, `Explain this command: ${command}`);
+  }
+  async validateCredentials() {
+    try {
+      const response = await fetch("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": this.apiKey,
+          "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify({
+          model: this.model,
+          max_tokens: 10,
+          messages: [{ role: "user", content: "hi" }]
+        })
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+};
+var CLAUDE_MODELS = [
+  { value: "claude-sonnet-4-20250514", label: "Claude Sonnet 4 (recommended)" },
+  { value: "claude-3-5-sonnet-20241022", label: "Claude 3.5 Sonnet" },
+  { value: "claude-3-5-haiku-20241022", label: "Claude 3.5 Haiku (fast)" }
+];
+
+// src/providers/ollama.ts
+var OllamaProvider = class {
+  name = "Ollama";
+  model;
+  host;
+  constructor(config) {
+    this.model = config.model;
+    if (config.credentials.type === "local") {
+      this.host = config.credentials.host;
+    } else {
+      this.host = "http://localhost:11434";
+    }
+  }
+  async call(systemPrompt, userMessage) {
+    const response = await fetch(`${this.host}/api/chat`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model: this.model,
+        messages: [
+          { role: "system", content: systemPrompt },
+          { role: "user", content: userMessage }
+        ],
+        stream: false
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Ollama error: ${response.status} - ${error}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(`Ollama error: ${data.error}`);
+    }
+    const content = data.message?.content || data.response;
+    if (!content) {
+      throw new Error("No response from Ollama");
+    }
+    return content.trim();
+  }
+  async generateCommand(query, context) {
+    const userMessage = context ? `Context: ${context}
+
+Task: ${query}` : query;
+    return this.call(SYSTEM_PROMPT_GENERATE, userMessage);
+  }
+  async explainCommand(command) {
+    return this.call(SYSTEM_PROMPT_EXPLAIN, `Explain this command: ${command}`);
+  }
+  async validateCredentials() {
+    try {
+      const response = await fetch(`${this.host}/api/tags`);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  static async getAvailableModels(host = "http://localhost:11434") {
+    try {
+      const response = await fetch(`${host}/api/tags`);
+      if (!response.ok) return [];
+      const data = await response.json();
+      return data.models.map((m) => m.name);
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/providers/openai.ts
+var OpenAIProvider = class {
+  name = "OpenAI";
+  model;
+  apiKey;
+  constructor(config) {
+    this.model = config.model;
+    if (config.credentials.type === "api_key") {
+      this.apiKey = config.credentials.apiKey;
+    } else {
+      throw new Error("OpenAI requires API key");
+    }
+  }
+  async call(systemPrompt, userMessage) {
+    const messages = [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: userMessage }
+    ];
+    const response = await fetch("https://api.openai.com/v1/chat/completions", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        model: this.model,
+        max_tokens: 1024,
+        messages
+      })
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`OpenAI API error: ${response.status} - ${error}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(`OpenAI API error: ${data.error.message}`);
+    }
+    const content = data.choices[0]?.message?.content;
+    if (!content) {
+      throw new Error("No response from OpenAI");
+    }
+    return content.trim();
+  }
+  async generateCommand(query, context) {
+    const userMessage = context ? `Context: ${context}
+
+Task: ${query}` : query;
+    return this.call(SYSTEM_PROMPT_GENERATE, userMessage);
+  }
+  async explainCommand(command) {
+    return this.call(SYSTEM_PROMPT_EXPLAIN, `Explain this command: ${command}`);
+  }
+  async validateCredentials() {
+    try {
+      const response = await fetch("https://api.openai.com/v1/models", {
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`
+        }
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+};
+var OPENAI_MODELS = [
+  { value: "gpt-4o", label: "GPT-4o (recommended)" },
+  { value: "gpt-4o-mini", label: "GPT-4o Mini (fast)" },
+  { value: "gpt-4-turbo", label: "GPT-4 Turbo" }
+];
+
+// src/providers/openrouter.ts
+var OpenRouterProvider = class {
+  name = "OpenRouter";
+  model;
+  apiKey;
+  constructor(config) {
+    this.model = config.model;
+    if (config.credentials.type === "api_key") {
+      this.apiKey = config.credentials.apiKey;
+    } else {
+      throw new Error("OpenRouter requires API key");
+    }
+  }
+  async call(systemPrompt, userMessage) {
+    const messages = [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: userMessage }
+    ];
+    const response = await fetch(
+      "https://openrouter.ai/api/v1/chat/completions",
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`,
+          "HTTP-Referer": "https://github.com/bashio",
+          "X-Title": "Bashio"
+        },
+        body: JSON.stringify({
+          model: this.model,
+          max_tokens: 1024,
+          messages
+        })
+      }
+    );
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`OpenRouter API error: ${response.status} - ${error}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(`OpenRouter API error: ${data.error.message}`);
+    }
+    const content = data.choices[0]?.message?.content;
+    if (!content) {
+      throw new Error("No response from OpenRouter");
+    }
+    return content.trim();
+  }
+  async generateCommand(query, context) {
+    const userMessage = context ? `Context: ${context}
+
+Task: ${query}` : query;
+    return this.call(SYSTEM_PROMPT_GENERATE, userMessage);
+  }
+  async explainCommand(command) {
+    return this.call(SYSTEM_PROMPT_EXPLAIN, `Explain this command: ${command}`);
+  }
+  async validateCredentials() {
+    try {
+      const response = await fetch("https://openrouter.ai/api/v1/models", {
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`
+        }
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+};
+var OPENROUTER_MODELS = [
+  { value: "anthropic/claude-sonnet-4", label: "Claude Sonnet 4" },
+  { value: "anthropic/claude-3.5-sonnet", label: "Claude 3.5 Sonnet" },
+  { value: "openai/gpt-4o", label: "GPT-4o" },
+  { value: "google/gemini-pro-1.5", label: "Gemini Pro 1.5" },
+  { value: "meta-llama/llama-3.1-70b-instruct", label: "Llama 3.1 70B" }
+];
+
+// src/providers/index.ts
+function createProvider(config) {
+  const providerConfig = {
+    model: config.model,
+    credentials: config.credentials
+  };
+  switch (config.provider) {
+    case "claude":
+      return new ClaudeProvider(providerConfig);
+    case "openai":
+      return new OpenAIProvider(providerConfig);
+    case "ollama":
+      return new OllamaProvider(providerConfig);
+    case "openrouter":
+      return new OpenRouterProvider(providerConfig);
+    default:
+      throw new Error(`Unknown provider: ${config.provider}`);
+  }
+}
+
+// src/utils/spinner.ts
+import ora from "ora";
+function createSpinner(text) {
+  return ora({
+    text,
+    spinner: "dots"
+  });
+}
+
+// src/cli/commands/AuthCommand.ts
+var AuthCommand = class extends Command2 {
+  static paths = [["auth"], ["--auth"]];
+  static usage = Command2.Usage({
+    description: "Configure AI provider for Bashio",
+    examples: [["Configure AI provider", "$0 --auth"]]
+  });
+  async execute() {
+    console.log(pc3.bold("\n  Bashio Setup\n"));
+    const provider = await select({
+      message: "Select your AI provider:",
+      choices: [
+        {
+          value: "claude",
+          name: "Claude (Anthropic)",
+          description: "Use Anthropic API key"
+        },
+        {
+          value: "openai",
+          name: "ChatGPT (OpenAI)",
+          description: "Use OpenAI API key"
+        },
+        {
+          value: "ollama",
+          name: "Ollama (Local)",
+          description: "Free, runs on your machine"
+        },
+        {
+          value: "openrouter",
+          name: "OpenRouter",
+          description: "Pay per use, multiple models"
+        }
+      ]
+    });
+    let credentials;
+    let model;
+    switch (provider) {
+      case "claude": {
+        const apiKey = await password({
+          message: "Enter your Anthropic API key:",
+          mask: "*"
+        });
+        credentials = { type: "api_key", apiKey };
+        model = await select({
+          message: "Select model:",
+          choices: CLAUDE_MODELS.map((m) => ({
+            value: m.value,
+            name: m.label
+          }))
+        });
+        break;
+      }
+      case "openai": {
+        const apiKey = await password({
+          message: "Enter your OpenAI API key:",
+          mask: "*"
+        });
+        credentials = { type: "api_key", apiKey };
+        model = await select({
+          message: "Select model:",
+          choices: OPENAI_MODELS.map((m) => ({
+            value: m.value,
+            name: m.label
+          }))
+        });
+        break;
+      }
+      case "ollama": {
+        const host = await input3({
+          message: "Ollama host:",
+          default: "http://localhost:11434"
+        });
+        credentials = { type: "local", host };
+        const spinner2 = createSpinner("Checking Ollama connection...").start();
+        const availableModels = await OllamaProvider.getAvailableModels(host);
+        if (availableModels.length === 0) {
+          spinner2.fail("Could not connect to Ollama or no models installed");
+          console.log(pc3.yellow("\nMake sure Ollama is running: ollama serve"));
+          console.log(pc3.yellow("Install a model: ollama pull llama3.2\n"));
+          return 1;
+        }
+        spinner2.succeed(`Found ${availableModels.length} models`);
+        const modelChoices = availableModels.map((m) => ({
+          value: m,
+          name: m
+        }));
+        model = await select({
+          message: "Select model:",
+          choices: modelChoices
+        });
+        break;
+      }
+      case "openrouter": {
+        const apiKey = await password({
+          message: "Enter your OpenRouter API key:",
+          mask: "*"
+        });
+        credentials = { type: "api_key", apiKey };
+        model = await select({
+          message: "Select model:",
+          choices: OPENROUTER_MODELS.map((m) => ({
+            value: m.value,
+            name: m.label
+          }))
+        });
+        break;
+      }
+      default:
+        throw new Error(`Unknown provider: ${provider}`);
+    }
+    const config = {
+      version: 1,
+      provider,
+      model,
+      credentials,
+      settings: {
+        confirmBeforeExecute: true,
+        historyEnabled: true,
+        historyRetentionDays: 30,
+        historyMaxEntries: 2e3,
+        autoConfirmShortcuts: false
+      }
+    };
+    const spinner = createSpinner("Validating credentials...").start();
+    try {
+      const providerInstance = createProvider(config);
+      const valid = await providerInstance.validateCredentials();
+      if (!valid) {
+        spinner.fail("Invalid credentials");
+        return 1;
+      }
+      spinner.succeed("Credentials valid");
+    } catch (err) {
+      spinner.fail(
+        `Validation failed: ${err instanceof Error ? err.message : "Unknown error"}`
+      );
+      return 1;
+    }
+    saveConfig(config);
+    console.log();
+    logger.success("Configuration saved!");
+    console.log(pc3.gray(`  Provider: ${provider}`));
+    console.log(pc3.gray(`  Model: ${model}`));
+    console.log();
+    console.log(
+      pc3.green("You're all set! Try:"),
+      pc3.cyan("b find all png files")
+    );
+    console.log();
+    return 0;
+  }
+};
+
+// src/cli/commands/ClearHistoryCommand.ts
+import { confirm } from "@inquirer/prompts";
+import { Command as Command3, Option as Option2 } from "clipanion";
+import pc5 from "picocolors";
+
+// src/utils/danger-ui.ts
+import pc4 from "picocolors";
+var renderDangerBanner = (message, label = "DANGER") => {
+  const labelText = ` ${label} `;
+  const spacer = " ";
+  const contentLength = labelText.length + spacer.length + message.length;
+  const innerWidth = contentLength + 2;
+  const border = "\u2500".repeat(innerWidth);
+  const top = pc4.red(`  \u250C${border}\u2510`);
+  const middle = `  ${pc4.red("\u2502 ")}` + pc4.bgRed(pc4.white(labelText)) + pc4.red(`${spacer}${message}`) + pc4.red(" \u2502");
+  const bottom = pc4.red(`  \u2514${border}\u2518`);
+  return [top, middle, bottom];
+};
+
+// src/cli/commands/ClearHistoryCommand.ts
+var ClearHistoryCommand = class extends Command3 {
+  static paths = [["--clear-history"]];
+  static usage = Command3.Usage({
+    description: "Clear command history",
+    examples: [
+      ["Clear all history", "$0 --clear-history --all"],
+      ["Clear entries older than 7 days", "$0 --clear-history --older-than 7"]
+    ]
+  });
+  all = Option2.Boolean("--all,-a", false, {
+    description: "Clear all history entries"
+  });
+  olderThan = Option2.String("--older-than,-o", {
+    description: "Clear entries older than N days"
+  });
+  async execute() {
+    if (!this.all && !this.olderThan) {
+      console.log(pc5.bold("\n  Clear History\n"));
+      console.log(pc5.gray("  Options:"));
+      console.log(pc5.gray("    --all           Clear all history"));
+      console.log(
+        pc5.gray("    --older-than N  Clear entries older than N days")
+      );
+      console.log();
+      console.log(pc5.dim("  Example: s --clear-history --older-than 30\n"));
+      return 1;
+    }
+    const currentCount = getHistoryCount();
+    if (currentCount === 0) {
+      logger.info("History is already empty.");
+      return 0;
+    }
+    if (this.all) {
+      console.log();
+      for (const line of renderDangerBanner(
+        `This will permanently delete ${currentCount} history entries.`
+      )) {
+        console.log(line);
+      }
+      console.log();
+      const confirmed = await confirm({
+        message: "Proceed with clearing all history?",
+        default: false
+      });
+      if (!confirmed) {
+        logger.info("Cancelled.");
+        return 0;
+      }
+      const deleted = clearAllHistory();
+      logger.success(`Cleared ${deleted} history entries.`);
+      return 0;
+    }
+    if (this.olderThan) {
+      const days = Number.parseInt(this.olderThan, 10);
+      if (Number.isNaN(days) || days < 1) {
+        logger.error("Invalid number of days.");
+        return 1;
+      }
+      console.log();
+      for (const line of renderDangerBanner(
+        `This will permanently delete entries older than ${days} days.`
+      )) {
+        console.log(line);
+      }
+      console.log();
+      const confirmed = await confirm({
+        message: `Proceed with clearing entries older than ${days} days?`,
+        default: false
+      });
+      if (!confirmed) {
+        logger.info("Cancelled.");
+        return 0;
+      }
+      const deleted = clearHistoryOlderThan(days);
+      if (deleted === 0) {
+        logger.info(`No entries older than ${days} days.`);
+      } else {
+        logger.success(`Cleared ${deleted} entries older than ${days} days.`);
+      }
+      return 0;
+    }
+    return 0;
+  }
+};
+
+// src/cli/commands/ConfigCommand.ts
+import { Command as Command4 } from "clipanion";
+import pc6 from "picocolors";
+var ConfigCommand = class extends Command4 {
+  static paths = [["config"], ["--config"]];
+  static usage = Command4.Usage({
+    description: "View current Bashio configuration",
+    examples: [["View config", "$0 --config"]]
+  });
+  async execute() {
+    if (!configExists()) {
+      logger.warn("Bashio is not configured yet.");
+      console.log(pc6.gray("Run 'b --auth' to set up your AI provider.\n"));
+      return 1;
+    }
+    const config = loadConfig();
+    if (!config) {
+      logger.error("Failed to load configuration.");
+      return 1;
+    }
+    console.log(pc6.bold("\n  Bashio Configuration\n"));
+    console.log(`  Provider:    ${pc6.cyan(config.provider)}`);
+    console.log(`  Model:       ${pc6.cyan(config.model)}`);
+    console.log(`  Auth:        ${pc6.green("Configured")}`);
+    const settings = config.settings;
+    console.log();
+    console.log(pc6.bold("  Settings"));
+    console.log(
+      `  History:              ${settings?.historyEnabled !== false ? pc6.green("enabled") : pc6.gray("disabled")}`
+    );
+    console.log(
+      `  Auto-confirm shortcuts: ${settings?.autoConfirmShortcuts ? pc6.green("enabled") : pc6.gray("disabled")}`
+    );
+    console.log();
+    console.log(pc6.gray(`  Config file: ${getConfigPath()}`));
+    console.log();
+    return 0;
+  }
+};
+
+// src/cli/commands/DefaultCommand.ts
+import * as readline from "readline";
+import { confirm as confirm2, input as input4 } from "@inquirer/prompts";
+import { Command as Command5, Option as Option3 } from "clipanion";
+import pc7 from "picocolors";
+
+// src/core/executor.ts
+import { spawn } from "child_process";
+function executeCommand(command) {
+  return new Promise((resolve) => {
+    const shell = process.platform === "win32" ? "cmd" : "/bin/sh";
+    const shellArg = process.platform === "win32" ? "/c" : "-c";
+    const child = spawn(shell, [shellArg, command], {
+      stdio: "inherit",
+      cwd: process.cwd(),
+      env: process.env
+    });
+    child.on("close", (code) => {
+      resolve({
+        exitCode: code ?? 1,
+        stdout: "",
+        stderr: ""
+      });
+    });
+    child.on("error", (err) => {
+      resolve({
+        exitCode: 1,
+        stdout: "",
+        stderr: err.message
+      });
+    });
+  });
+}
+
+// src/utils/clipboard.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+async function copyToClipboard(text) {
+  try {
+    const platform = process.platform;
+    if (platform === "darwin") {
+      await execAsync(`echo ${JSON.stringify(text)} | pbcopy`);
+    } else if (platform === "linux") {
+      try {
+        await execAsync(
+          `echo ${JSON.stringify(text)} | xclip -selection clipboard`
+        );
+      } catch {
+        await execAsync(
+          `echo ${JSON.stringify(text)} | xsel --clipboard --input`
+        );
+      }
+    } else if (platform === "win32") {
+      await execAsync(`echo ${text} | clip`);
+    } else {
+      return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/danger.ts
+var DANGEROUS_PATTERNS = [
+  {
+    pattern: /\b(?:rm|rmdir)\b[^\n]*(?:-rf|-fr|--recursive|--force|-r\b)/i,
+    reason: "Recursively removes files or directories"
+  },
+  {
+    pattern: /\b(?:mkfs|mkfs\.[a-z0-9]+|format|diskpart|diskutil|fdisk|parted)\b/i,
+    reason: "Formats or repartitions disks/filesystems"
+  },
+  {
+    pattern: /\bdd\b/i,
+    reason: "Writes raw data to disks or devices"
+  },
+  {
+    pattern: /\b(?:shutdown|reboot|poweroff|halt)\b/i,
+    reason: "Shuts down or reboots the system"
+  },
+  {
+    pattern: /\b(?:userdel|deluser|groupdel|dscl\b[^\n]*-delete|net\s+user\b[^\n]*\/delete)\b/i,
+    reason: "Deletes system users or groups"
+  },
+  {
+    pattern: /:\s*\(\s*\)\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;\s*:/,
+    reason: "Fork bomb pattern"
+  },
+  {
+    pattern: /\b(?:chmod|chown)\b[^\n]*\s-?R\b/i,
+    reason: "Recursively changes permissions or ownership"
+  },
+  {
+    pattern: /\b(?:git\s+reset\s+--hard|git\s+clean\s+-fd)\b/i,
+    reason: "Discards uncommitted changes"
+  },
+  {
+    pattern: /\b(?:rd|rmdir)\b[^\n]*\s\/s\b/i,
+    reason: "Recursively removes directories (Windows)"
+  },
+  {
+    pattern: /\bdel\b[^\n]*\s\/f\b/i,
+    reason: "Force deletes files (Windows)"
+  }
+];
+var detectDangerousShellCommand = (command) => {
+  const trimmed = command.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const reasons = [];
+  for (const entry of DANGEROUS_PATTERNS) {
+    if (entry.pattern.test(trimmed)) {
+      reasons.push(entry.reason);
+    }
+  }
+  if (reasons.length === 0) {
+    return null;
+  }
+  return { reasons };
+};
+
+// src/cli/commands/DefaultCommand.ts
+var DefaultCommand = class extends Command5 {
+  static paths = [Command5.Default];
+  static usage = Command5.Usage({
+    description: "Convert natural language to shell commands",
+    examples: [
+      ["Find large files", "$0 find files larger than 100mb"],
+      ["Kill a port", "$0 kill whatever is running on port 3000"],
+      ["Use a shortcut", "$0 killport 3000"]
+    ]
+  });
+  query = Option3.Rest({ required: 0 });
+  async execute() {
+    if (this.query.length === 0) {
+      this.showHelp();
+      return 0;
+    }
+    const config = loadConfig();
+    const historyEnabled = config?.settings?.historyEnabled !== false;
+    const shortcut = await tryResolveShortcut(this.query);
+    if (shortcut) {
+      let historyId2 = null;
+      if (historyEnabled) {
+        historyId2 = recordCommand({
+          query: this.query.join(" "),
+          command: shortcut.command,
+          source: "shortcut"
+        });
+      }
+      const context = {
+        queryText: this.query.join(" "),
+        historyId: historyId2,
+        historyEnabled,
+        shortcutName: shortcut.name
+      };
+      if (config?.settings?.autoConfirmShortcuts) {
+        return this.executeShortcutAutoConfirm(shortcut.command, context);
+      }
+      return this.executeWithConfirmation(
+        shortcut.command,
+        "shortcut",
+        context
+      );
+    }
+    if (!configExists()) {
+      logger.warn("Bashio is not configured yet.");
+      console.log(pc7.gray("Run 'b --auth' to set up your AI provider.\n"));
+      return 1;
+    }
+    if (!config) {
+      logger.error("Failed to load configuration.");
+      console.log(pc7.gray("Run 'b --auth' to reconfigure.\n"));
+      return 1;
+    }
+    const queryText = this.query.join(" ").trim();
+    const provider = createProvider(config);
+    const spinner = createSpinner("Generating command...").start();
+    let generatedCommand;
+    try {
+      generatedCommand = await provider.generateCommand(queryText);
+      spinner.stop();
+    } catch (err) {
+      spinner.fail("Failed to generate command");
+      logger.error(err instanceof Error ? err.message : "Unknown error");
+      return 1;
+    }
+    generatedCommand = this.cleanCommand(generatedCommand);
+    let historyId = null;
+    if (historyEnabled) {
+      historyId = recordCommand({
+        query: queryText,
+        command: generatedCommand,
+        source: "ai"
+      });
+    }
+    return this.executeWithConfirmation(generatedCommand, "ai", {
+      queryText,
+      historyId,
+      historyEnabled
+    });
+  }
+  showHelp() {
+    console.log(pc7.bold("\n  Bashio - Natural language to shell commands\n"));
+    console.log("  Usage:");
+    console.log(pc7.cyan("    b <natural language query>"));
+    console.log(pc7.cyan("    b <shortcut> [arguments]"));
+    console.log();
+    console.log("  Examples:");
+    console.log(pc7.gray("    b find all files larger than 100mb"));
+    console.log(pc7.gray("    b kill whatever is running on port 3000"));
+    console.log(pc7.gray("    b killport 3000") + pc7.cyan("  (shortcut)"));
+    console.log();
+    console.log("  Commands:");
+    console.log(pc7.gray("    b --auth              Configure AI provider"));
+    console.log(
+      pc7.gray("    b --config            View current configuration")
+    );
+    console.log(pc7.gray("    b --model             Change AI model"));
+    console.log(pc7.gray("    b --shortcuts         List all shortcuts"));
+    console.log(pc7.gray("    b --add-shortcut      Add a new shortcut"));
+    console.log(pc7.gray("    b --remove-shortcut   Remove a shortcut"));
+    console.log(pc7.gray("    b --edit-shortcuts    Edit shortcuts in editor"));
+    console.log();
+    console.log("  History & Stats:");
+    console.log(pc7.gray("    b --history           View command history"));
+    console.log(pc7.gray("    b --stats             View usage statistics"));
+    console.log(pc7.gray("    b --clear-history     Clear command history"));
+    console.log(pc7.gray("    b --suggest-shortcuts Suggest new shortcuts"));
+    console.log();
+    console.log(pc7.gray("    b --help              Show help"));
+    console.log();
+  }
+  async executeWithConfirmation(command, source, context) {
+    let currentCommand = command;
+    console.log();
+    if (source === "shortcut" && context.shortcutName) {
+      console.log(pc7.gray(`  [shortcut: ${context.shortcutName}]`));
+    }
+    logger.command(currentCommand);
+    console.log();
+    let action = await this.promptConfirmation();
+    while (action !== "yes" && action !== "no" && action !== "copy") {
+      if (action === "explain") {
+        if (source === "shortcut") {
+          console.log(
+            pc7.gray("\n  This command comes from a shortcut, not AI.\n")
+          );
+        } else {
+          const explainConfig = loadConfig();
+          if (explainConfig) {
+            const provider = createProvider(explainConfig);
+            const explainSpinner = createSpinner(
+              "Getting explanation..."
+            ).start();
+            try {
+              const explanation = await provider.explainCommand(currentCommand);
+              explainSpinner.stop();
+              console.log();
+              console.log(pc7.bold("  Explanation:"));
+              console.log(pc7.gray(`  ${explanation.split("\n").join("\n  ")}`));
+              console.log();
+            } catch {
+              explainSpinner.fail("Failed to get explanation");
+            }
+          }
+        }
+      } else if (action === "edit") {
+        try {
+          const edited = await this.editCommandInline(currentCommand);
+          currentCommand = edited.trim();
+          console.log();
+          logger.command(currentCommand);
+          console.log();
+        } catch {
+          logger.error("Edit cancelled");
+        }
+      }
+      action = await this.promptConfirmation();
+    }
+    if (action === "copy") {
+      const success = await copyToClipboard(currentCommand);
+      if (success) {
+        logger.success("Copied to clipboard!");
+      } else {
+        logger.error("Failed to copy to clipboard");
+      }
+      console.log();
+      return 0;
+    }
+    if (action === "no") {
+      logger.info("Cancelled.");
+      return 0;
+    }
+    const danger = detectDangerousShellCommand(currentCommand);
+    if (danger) {
+      const confirmed = await this.promptDangerConfirmation(
+        currentCommand,
+        danger.reasons
+      );
+      if (!confirmed) {
+        logger.info("Cancelled.");
+        return 0;
+      }
+    }
+    console.log();
+    const result = await executeCommand(currentCommand);
+    if (result.exitCode !== 0) {
+      console.log();
+      logger.exitCode(result.exitCode);
+    }
+    console.log();
+    if (context.historyEnabled && context.historyId !== null) {
+      markExecuted(context.historyId, result.exitCode);
+    }
+    return result.exitCode;
+  }
+  async executeShortcutAutoConfirm(command, context) {
+    const danger = detectDangerousShellCommand(command);
+    if (danger) {
+      console.log();
+      if (context.shortcutName) {
+        console.log(pc7.gray(`  [shortcut: ${context.shortcutName}]`));
+      }
+      logger.command(command);
+      console.log();
+      const confirmed = await this.promptDangerConfirmation(
+        command,
+        danger.reasons
+      );
+      if (!confirmed) {
+        logger.info("Cancelled.");
+        return 0;
+      }
+    }
+    console.log();
+    const result = await executeCommand(command);
+    if (result.exitCode !== 0) {
+      console.log();
+      logger.exitCode(result.exitCode);
+    }
+    console.log();
+    if (context.historyEnabled && context.historyId !== null) {
+      markExecuted(context.historyId, result.exitCode);
+    }
+    return result.exitCode;
+  }
+  cleanCommand(command) {
+    let cleaned = command.trim();
+    if (cleaned.startsWith("```")) {
+      const lines = cleaned.split("\n");
+      const startIdx = lines[0].startsWith("```") ? 1 : 0;
+      const endIdx = lines[lines.length - 1] === "```" ? lines.length - 1 : lines.length;
+      cleaned = lines.slice(startIdx, endIdx).join("\n");
+    }
+    cleaned = cleaned.replace(/^`|`$/g, "");
+    return cleaned.trim();
+  }
+  async promptConfirmation() {
+    const answer = await input4({
+      message: "Execute? (y/n/e/c/edit)",
+      default: "y"
+    });
+    const normalized = answer.toLowerCase().trim();
+    if (["y", "yes", ""].includes(normalized)) {
+      return "yes";
+    }
+    if (["e", "explain"].includes(normalized)) {
+      return "explain";
+    }
+    if (["c", "copy"].includes(normalized)) {
+      return "copy";
+    }
+    if (["edit"].includes(normalized)) {
+      return "edit";
+    }
+    return "no";
+  }
+  async promptDangerConfirmation(command, reasons) {
+    for (const line of renderDangerBanner(
+      "This command may cause irreversible changes."
+    )) {
+      console.log(line);
+    }
+    console.log();
+    console.log(pc7.yellow("  Reasons:"));
+    for (const reason of reasons) {
+      console.log(pc7.yellow(`  - ${reason}`));
+    }
+    console.log();
+    console.log(pc7.gray("  Command:"));
+    console.log(pc7.cyan(`  ${command}`));
+    console.log();
+    return confirm2({
+      message: "Proceed with this command?",
+      default: false
+    });
+  }
+  editCommandInline(currentCommand) {
+    return new Promise((resolve, reject) => {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      process.stdout.write(`${pc7.green("?")} ${pc7.bold("Edit command:")} `);
+      rl.write(currentCommand);
+      rl.on("line", (answer) => {
+        rl.close();
+        resolve(answer || currentCommand);
+      });
+      rl.on("close", () => {
+        resolve(currentCommand);
+      });
+      rl.on("SIGINT", () => {
+        rl.close();
+        reject(new Error("Edit cancelled"));
+      });
+    });
+  }
+};
+
+// src/cli/commands/EditShortcutsCommand.ts
+import { spawn as spawn2 } from "child_process";
+import { Command as Command6 } from "clipanion";
+import pc8 from "picocolors";
+var EditShortcutsCommand = class extends Command6 {
+  static paths = [["edit-shortcuts"], ["--edit-shortcuts"]];
+  static usage = Command6.Usage({
+    description: "Open shortcuts file in your default editor",
+    examples: [["Edit shortcuts", "$0 --edit-shortcuts"]]
+  });
+  async execute() {
+    const filePath = getShortcutsFilePath();
+    if (!shortcutsFileExists()) {
+      saveShortcuts({ version: 1, shortcuts: {} });
+      logger.info("Created new shortcuts file.");
+    }
+    const editor = process.env.EDITOR || process.env.VISUAL || this.getDefaultEditor();
+    if (!editor) {
+      logger.error("No editor found. Set $EDITOR environment variable.");
+      console.log(pc8.gray(`
+  Example: export EDITOR=vim`));
+      console.log(pc8.gray(`  Or: export EDITOR="code --wait"`));
+      console.log(pc8.gray(`
+  File location: ${filePath}
+`));
+      return 1;
+    }
+    console.log(pc8.gray(`
+  Opening ${filePath} in ${editor}...
+`));
+    return new Promise((resolve) => {
+      const parts = editor.split(" ");
+      const editorCmd = parts[0];
+      const editorArgs = [...parts.slice(1), filePath];
+      const child = spawn2(editorCmd, editorArgs, {
+        stdio: "inherit",
+        shell: true
+      });
+      child.on("close", (code) => {
+        if (code === 0) {
+          logger.success("Shortcuts file saved.");
+        } else {
+          logger.warn("Editor closed with non-zero exit code.");
+        }
+        console.log();
+        resolve(code ?? 0);
+      });
+      child.on("error", (err) => {
+        logger.error(`Failed to open editor: ${err.message}`);
+        console.log(pc8.gray(`
+  File location: ${filePath}
+`));
+        resolve(1);
+      });
+    });
+  }
+  getDefaultEditor() {
+    const platform = process.platform;
+    if (platform === "darwin") {
+      return "nano";
+    }
+    if (platform === "win32") {
+      return "notepad";
+    }
+    return "nano";
+  }
+};
+
+// src/cli/commands/HistoryCommand.ts
+import { Command as Command7, Option as Option4 } from "clipanion";
+import pc10 from "picocolors";
+
+// src/utils/table.ts
+import pc9 from "picocolors";
+var BOX = {
+  topLeft: "\u250C",
+  topRight: "\u2510",
+  bottomLeft: "\u2514",
+  bottomRight: "\u2518",
+  horizontal: "\u2500",
+  vertical: "\u2502",
+  topMid: "\u252C",
+  bottomMid: "\u2534",
+  leftMid: "\u251C",
+  rightMid: "\u2524",
+  midMid: "\u253C"
+};
+function padString(str, width, align = "left") {
+  const strippedLength = stripAnsi(str).length;
+  const padding = Math.max(0, width - strippedLength);
+  if (align === "right") {
+    return " ".repeat(padding) + str;
+  }
+  if (align === "center") {
+    const leftPad = Math.floor(padding / 2);
+    const rightPad = padding - leftPad;
+    return " ".repeat(leftPad) + str + " ".repeat(rightPad);
+  }
+  return str + " ".repeat(padding);
+}
+function stripAnsi(str) {
+  return str.replace(/\x1B\[[0-9;]*m/g, "");
+}
+function wrapText(text, maxWidth) {
+  const words = text.split(" ");
+  const lines = [];
+  let currentLine = "";
+  for (const word of words) {
+    const testLine = currentLine ? `${currentLine} ${word}` : word;
+    if (stripAnsi(testLine).length <= maxWidth) {
+      currentLine = testLine;
+    } else {
+      if (currentLine) {
+        lines.push(currentLine);
+      }
+      if (stripAnsi(word).length > maxWidth) {
+        currentLine = `${word.slice(0, maxWidth - 3)}...`;
+      } else {
+        currentLine = word;
+      }
+    }
+  }
+  if (currentLine) {
+    lines.push(currentLine);
+  }
+  return lines.length > 0 ? lines : [""];
+}
+function renderTable(options) {
+  const { columns, data, title } = options;
+  if (title) {
+    console.log(pc9.bold(`
+  ${title}
+`));
+  }
+  let topBorder = `  ${BOX.topLeft}`;
+  for (let i = 0; i < columns.length; i++) {
+    topBorder += BOX.horizontal.repeat(columns[i].width + 2);
+    topBorder += i < columns.length - 1 ? BOX.topMid : BOX.topRight;
+  }
+  console.log(pc9.dim(topBorder));
+  let headerRow = `  ${BOX.vertical}`;
+  for (const col of columns) {
+    headerRow += ` ${pc9.bold(padString(col.header, col.width, col.align))} ${BOX.vertical}`;
+  }
+  console.log(
+    pc9.dim(headerRow.slice(0, 2)) + headerRow.slice(2, -1) + pc9.dim(BOX.vertical)
+  );
+  let headerSep = `  ${BOX.leftMid}`;
+  for (let i = 0; i < columns.length; i++) {
+    headerSep += BOX.horizontal.repeat(columns[i].width + 2);
+    headerSep += i < columns.length - 1 ? BOX.midMid : BOX.rightMid;
+  }
+  console.log(pc9.dim(headerSep));
+  for (const row of data) {
+    const wrappedColumns = columns.map((col) => {
+      const value = row[col.key] || "";
+      return wrapText(value, col.width);
+    });
+    const maxLines = Math.max(...wrappedColumns.map((lines) => lines.length));
+    for (let lineIdx = 0; lineIdx < maxLines; lineIdx++) {
+      let dataRow = `  ${BOX.vertical}`;
+      for (let colIdx = 0; colIdx < columns.length; colIdx++) {
+        const col = columns[colIdx];
+        const lines = wrappedColumns[colIdx];
+        const lineValue = lines[lineIdx] || "";
+        let cellValue = padString(lineValue, col.width, col.align);
+        if (col.color && lineValue) {
+          cellValue = col.color(cellValue);
+        }
+        dataRow += ` ${cellValue} ${BOX.vertical}`;
+      }
+      console.log(
+        pc9.dim(dataRow.slice(0, 2)) + dataRow.slice(2, -1) + pc9.dim(BOX.vertical)
+      );
+    }
+  }
+  let bottomBorder = `  ${BOX.bottomLeft}`;
+  for (let i = 0; i < columns.length; i++) {
+    bottomBorder += BOX.horizontal.repeat(columns[i].width + 2);
+    bottomBorder += i < columns.length - 1 ? BOX.bottomMid : BOX.bottomRight;
+  }
+  console.log(pc9.dim(bottomBorder));
+}
+
+// src/cli/commands/HistoryCommand.ts
+var HistoryCommand = class extends Command7 {
+  static paths = [["--history"]];
+  static usage = Command7.Usage({
+    description: "View command history",
+    examples: [
+      ["View recent history", "$0 --history"],
+      ["Limit results", "$0 --history --limit 10"],
+      ["Search history", "$0 --history --search git"]
+    ]
+  });
+  limit = Option4.String("--limit,-l", "20", {
+    description: "Number of entries to show"
+  });
+  search = Option4.String("--search,-s", {
+    description: "Search term to filter history"
+  });
+  async execute() {
+    const limitNum = Number.parseInt(this.limit, 10) || 20;
+    let entries;
+    let title;
+    if (this.search) {
+      entries = searchHistory(this.search, limitNum);
+      title = `Command History (search: "${this.search}")`;
+    } else {
+      entries = getRecentHistory(limitNum);
+      title = "Recent Command History";
+    }
+    if (entries.length === 0) {
+      console.log(pc10.bold(`
+  ${title}
+`));
+      console.log(pc10.gray("  No history entries found.\n"));
+      return 0;
+    }
+    const data = entries.map((entry, index) => ({
+      num: (index + 1).toString(),
+      command: entry.command,
+      query: entry.source === "ai" ? entry.query : "-",
+      source: entry.source,
+      status: this.getStatusDisplay(entry),
+      time: this.getTimeAgo(entry.createdAt)
+    }));
+    renderTable({
+      title,
+      columns: [
+        { header: "#", key: "num", width: 3, align: "right" },
+        { header: "Command", key: "command", width: 35, color: pc10.yellow },
+        { header: "Query", key: "query", width: 25, color: pc10.gray },
+        {
+          header: "Source",
+          key: "source",
+          width: 8,
+          color: (v) => v.trim() === "ai" ? pc10.blue(v) : pc10.cyan(v)
+        },
+        { header: "Status", key: "status", width: 10 },
+        { header: "Time", key: "time", width: 10 }
+      ],
+      data
+    });
+    console.log(pc10.dim(`
+  Showing ${entries.length} entries
+`));
+    return 0;
+  }
+  getStatusDisplay(entry) {
+    if (entry.executed === 0) {
+      return `${pc10.gray("\u25CB")} skipped`;
+    }
+    if (entry.exitCode === 0) {
+      return `${pc10.green("\u2713")} success`;
+    }
+    return `${pc10.red("\u2717")} exit:${entry.exitCode}`;
+  }
+  getTimeAgo(isoString) {
+    const date = new Date(isoString);
+    const now = /* @__PURE__ */ new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const minutes = Math.floor(diffMs / (1e3 * 60));
+    const hours = Math.floor(diffMs / (1e3 * 60 * 60));
+    const days = Math.floor(diffMs / (1e3 * 60 * 60 * 24));
+    if (minutes < 1) return "just now";
+    if (minutes < 60) return `${minutes}m ago`;
+    if (hours < 24) return `${hours}h ago`;
+    if (days < 7) return `${days}d ago`;
+    return date.toLocaleDateString();
+  }
+};
+
+// src/cli/commands/ModelCommand.ts
+import * as readline2 from "readline";
+import { select as select2 } from "@inquirer/prompts";
+import { Command as Command8 } from "clipanion";
+import pc11 from "picocolors";
+var selectWithEsc = async (config) => {
+  const controller = new AbortController();
+  const input6 = process.stdin;
+  const previousRawMode = input6.isTTY && typeof input6.isRaw === "boolean" ? input6.isRaw : null;
+  const onKeypress = (_input, key) => {
+    if (key.name === "escape") {
+      controller.abort();
+    }
+  };
+  readline2.emitKeypressEvents(input6);
+  if (input6.isTTY && typeof input6.setRawMode === "function") {
+    input6.setRawMode(true);
+  }
+  input6.on("keypress", onKeypress);
+  try {
+    return await select2(config, { signal: controller.signal });
+  } finally {
+    input6.off("keypress", onKeypress);
+    if (input6.isTTY && typeof input6.setRawMode === "function" && previousRawMode !== null) {
+      input6.setRawMode(previousRawMode);
+    }
+  }
+};
+var isPromptExit = (error) => {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return error.name === "ExitPromptError" || error.name === "AbortPromptError" || error.name === "CancelPromptError";
+};
+var ModelCommand = class extends Command8 {
+  static paths = [["model"], ["--model"]];
+  static usage = Command8.Usage({
+    description: "Change the AI model for current provider",
+    examples: [["Change model", "$0 --model"]]
+  });
+  async execute() {
+    if (!configExists()) {
+      logger.warn("Bashio is not configured yet.");
+      console.log(
+        pc11.gray("Run 'b --auth' to set up your AI provider first.\n")
+      );
+      return 1;
+    }
+    const config = loadConfig();
+    if (!config) {
+      logger.error("Failed to load configuration.");
+      return 1;
+    }
+    console.log(pc11.bold("\n  Change AI Model\n"));
+    console.log(pc11.gray(`  Current provider: ${config.provider}`));
+    console.log(pc11.gray(`  Current model: ${config.model}`));
+    console.log(pc11.dim("  Press Esc to cancel\n"));
+    let newModel;
+    try {
+      switch (config.provider) {
+        case "claude": {
+          newModel = await selectWithEsc({
+            message: "Select new model:",
+            choices: CLAUDE_MODELS.map((m) => ({
+              value: m.value,
+              name: m.label
+            })),
+            default: config.model
+          });
+          break;
+        }
+        case "openai": {
+          newModel = await selectWithEsc({
+            message: "Select new model:",
+            choices: OPENAI_MODELS.map((m) => ({
+              value: m.value,
+              name: m.label
+            })),
+            default: config.model
+          });
+          break;
+        }
+        case "ollama": {
+          const host = config.credentials.type === "local" ? config.credentials.host : "http://localhost:11434";
+          const spinner = createSpinner("Fetching available models...").start();
+          const availableModels = await OllamaProvider.getAvailableModels(host);
+          spinner.stop();
+          if (availableModels.length === 0) {
+            logger.warn("No models found. Make sure Ollama is running.");
+            console.log(pc11.gray("\n  Install a model: ollama pull llama3.2\n"));
+            return 1;
+          }
+          newModel = await selectWithEsc({
+            message: "Select new model:",
+            choices: availableModels.map((m) => ({
+              value: m,
+              name: m
+            })),
+            default: config.model
+          });
+          break;
+        }
+        case "openrouter": {
+          newModel = await selectWithEsc({
+            message: "Select new model:",
+            choices: OPENROUTER_MODELS.map((m) => ({
+              value: m.value,
+              name: m.label
+            })),
+            default: config.model
+          });
+          break;
+        }
+        default:
+          logger.error(`Unknown provider: ${config.provider}`);
+          return 1;
+      }
+    } catch (error) {
+      if (isPromptExit(error)) {
+        console.log(pc11.dim("\n  Cancelled.\n"));
+        return 0;
+      }
+      throw error;
+    }
+    if (newModel === config.model) {
+      logger.info("Model unchanged.");
+      return 0;
+    }
+    config.model = newModel;
+    saveConfig(config);
+    console.log();
+    logger.success(`Model changed to: ${newModel}`);
+    console.log();
+    return 0;
+  }
+};
+
+// src/cli/commands/RemoveShortcutCommand.ts
+import { confirm as confirm3 } from "@inquirer/prompts";
+import { Command as Command9, Option as Option5 } from "clipanion";
+import pc12 from "picocolors";
+var RemoveShortcutCommand = class extends Command9 {
+  static paths = [["remove-shortcut"], ["--remove-shortcut"]];
+  static usage = Command9.Usage({
+    description: "Remove a shortcut",
+    examples: [["Remove shortcut", "$0 --remove-shortcut killport"]]
+  });
+  name = Option5.String({ required: true });
+  async execute() {
+    const shortcut = getShortcut(this.name);
+    if (!shortcut) {
+      logger.error(`Shortcut "${this.name}" not found.`);
+      return 1;
+    }
+    console.log();
+    console.log(pc12.gray(`  Template: ${shortcut.template}`));
+    if (shortcut.description) {
+      console.log(pc12.gray(`  Description: ${shortcut.description}`));
+    }
+    console.log();
+    for (const line of renderDangerBanner(
+      `This will permanently remove shortcut "${this.name}".`
+    )) {
+      console.log(line);
+    }
+    console.log();
+    const confirmed = await confirm3({
+      message: `Proceed with removing "${this.name}"?`,
+      default: false
+    });
+    if (!confirmed) {
+      logger.info("Cancelled.");
+      return 0;
+    }
+    removeShortcut(this.name);
+    logger.success(`Shortcut "${this.name}" removed.`);
+    console.log();
+    return 0;
+  }
+};
+
+// src/cli/commands/ShortcutsCommand.ts
+import { Command as Command10 } from "clipanion";
+import pc13 from "picocolors";
+var ShortcutsCommand = class extends Command10 {
+  static paths = [["shortcuts"], ["--shortcuts"]];
+  static usage = Command10.Usage({
+    description: "List all configured shortcuts",
+    examples: [["List shortcuts", "$0 --shortcuts"]]
+  });
+  async execute() {
+    const shortcuts = listShortcuts();
+    const names = Object.keys(shortcuts);
+    if (names.length === 0) {
+      console.log(pc13.yellow("\n  No shortcuts configured yet.\n"));
+      console.log(pc13.gray("  Add one with: s --add-shortcut\n"));
+      return 0;
+    }
+    const data = names.map((name) => {
+      const shortcut = shortcuts[name];
+      return {
+        name,
+        template: shortcut.template,
+        args: shortcut.args?.length ? shortcut.args.join(", ") : "-"
+      };
+    });
+    renderTable({
+      title: "Your Shortcuts",
+      columns: [
+        { header: "Name", key: "name", width: 15, color: pc13.cyan },
+        {
+          header: "Command Template",
+          key: "template",
+          width: 45,
+          color: pc13.white
+        },
+        { header: "Arguments", key: "args", width: 15, color: pc13.gray }
+      ],
+      data
+    });
+    console.log(
+      pc13.dim(
+        `
+  Total: ${names.length} shortcut${names.length === 1 ? "" : "s"}
+`
+      )
+    );
+    return 0;
+  }
+};
+
+// src/cli/commands/StatsCommand.ts
+import { Command as Command11 } from "clipanion";
+import pc14 from "picocolors";
+var StatsCommand = class extends Command11 {
+  static paths = [["--stats"]];
+  static usage = Command11.Usage({
+    description: "View usage statistics",
+    examples: [["View stats", "$0 --stats"]]
+  });
+  async execute() {
+    const stats = getStats();
+    console.log(pc14.bold("\n  Bashio Usage Statistics\n"));
+    renderTable({
+      title: "Overview",
+      columns: [
+        { header: "Metric", key: "metric", width: 20 },
+        { header: "Value", key: "value", width: 15, align: "right" }
+      ],
+      data: [
+        { metric: "Commands Generated", value: stats.totalCommands.toString() },
+        {
+          metric: "Executed",
+          value: `${stats.totalExecuted} (${stats.executionRate}%)`
+        },
+        { metric: "Today", value: stats.todayCommands.toString() },
+        { metric: "This Week", value: stats.thisWeekCommands.toString() }
+      ]
+    });
+    console.log();
+    const total = stats.aiCount + stats.shortcutCount;
+    const aiPercent = total > 0 ? Math.round(stats.aiCount / total * 100) : 0;
+    const shortcutPercent = total > 0 ? Math.round(stats.shortcutCount / total * 100) : 0;
+    renderTable({
+      title: "Source Breakdown",
+      columns: [
+        { header: "Source", key: "source", width: 15 },
+        { header: "Count", key: "count", width: 10, align: "right" },
+        { header: "Percentage", key: "percent", width: 12, align: "right" }
+      ],
+      data: [
+        {
+          source: "AI Generated",
+          count: stats.aiCount.toString(),
+          percent: `${aiPercent}%`
+        },
+        {
+          source: "Shortcuts",
+          count: stats.shortcutCount.toString(),
+          percent: `${shortcutPercent}%`
+        }
+      ]
+    });
+    if (stats.topQueries.length > 0) {
+      console.log();
+      renderTable({
+        title: "Most Used Commands",
+        columns: [
+          { header: "#", key: "rank", width: 3, align: "right" },
+          { header: "Command", key: "command", width: 45, color: pc14.cyan },
+          { header: "Uses", key: "uses", width: 8, align: "right" },
+          {
+            header: "Source",
+            key: "source",
+            width: 10,
+            color: (v) => v.trim() === "ai" ? pc14.blue(v) : pc14.cyan(v)
+          }
+        ],
+        data: stats.topQueries.map((q, i) => ({
+          rank: (i + 1).toString(),
+          command: q.query.length > 42 ? `${q.query.slice(0, 39)}...` : q.query,
+          uses: q.useCount.toString(),
+          source: q.source
+        }))
+      });
+    }
+    console.log();
+    return 0;
+  }
+};
+
+// src/cli/commands/SuggestShortcutsCommand.ts
+import { confirm as confirm4, input as input5 } from "@inquirer/prompts";
+import { Command as Command12, Option as Option6 } from "clipanion";
+import pc15 from "picocolors";
+
+// src/core/learning.ts
+function suggestShortcutNameFromCommand(command) {
+  const parts = command.split(/[\s\-&|;()]+/).filter((p) => p.length > 0 && !p.match(/^[.+]/));
+  if (parts.length === 0) {
+    return "cmd";
+  }
+  const mainCmd = parts[0];
+  if (parts.length > 1) {
+    const keyArg = parts[1];
+    if (keyArg && keyArg.length > 0) {
+      const combined = `${mainCmd}${keyArg}`.slice(0, 12);
+      return combined;
+    }
+  }
+  return mainCmd.slice(0, 12);
+}
+function getShortcutSuggestions(threshold = 3) {
+  const db2 = getDatabase();
+  const rows = db2.prepare(
+    `SELECT id, command, source, use_count, success_count, suggested
+       FROM query_stats 
+       WHERE source = 'ai' 
+         AND use_count >= ?
+         AND suggested = 0
+       ORDER BY use_count DESC
+       LIMIT 10`
+  ).all(threshold);
+  const existingShortcuts = listShortcuts();
+  const existingNames = new Set(Object.keys(existingShortcuts));
+  const suggestions = [];
+  for (const row of rows) {
+    let suggestedName = suggestShortcutNameFromCommand(row.command);
+    let counter = 1;
+    const baseName = suggestedName;
+    while (existingNames.has(suggestedName)) {
+      suggestedName = `${baseName}${counter}`;
+      counter++;
+    }
+    suggestions.push({
+      query: row.command,
+      // Store command as "query" for now (for interface compatibility)
+      command: row.command,
+      useCount: row.use_count,
+      suggestedName
+    });
+  }
+  return suggestions;
+}
+function markPatternAsSuggested(command) {
+  const db2 = getDatabase();
+  db2.prepare("UPDATE query_stats SET suggested = 1 WHERE command = ?").run(
+    command
+  );
+}
+
+// src/cli/commands/SuggestShortcutsCommand.ts
+var SuggestShortcutsCommand = class extends Command12 {
+  static paths = [["--suggest-shortcuts"]];
+  static usage = Command12.Usage({
+    description: "Suggest shortcuts based on frequently used commands",
+    examples: [
+      ["Get suggestions", "$0 --suggest-shortcuts"],
+      ["Set minimum use count", "$0 --suggest-shortcuts --threshold 5"]
+    ]
+  });
+  threshold = Option6.String("--threshold,-t", "3", {
+    description: "Minimum use count to suggest (default: 3)"
+  });
+  async execute() {
+    const thresholdNum = Number.parseInt(this.threshold, 10) || 3;
+    const suggestions = getShortcutSuggestions(thresholdNum);
+    console.log(pc15.bold("\n  Shortcut Suggestions\n"));
+    if (suggestions.length === 0) {
+      console.log(
+        pc15.gray(
+          "  No suggestions yet. Use Bashio more to get personalized suggestions."
+        )
+      );
+      console.log(
+        pc15.dim(`  (Commands need to be used ${thresholdNum}+ times)
+`)
+      );
+      return 0;
+    }
+    console.log(
+      pc15.dim(
+        `  Found ${suggestions.length} frequently used commands that could be shortcuts:
+`
+      )
+    );
+    for (const suggestion of suggestions) {
+      console.log(pc15.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+      console.log(`  ${pc15.yellow("Command:")} ${pc15.cyan(suggestion.command)}`);
+      console.log(
+        `  ${pc15.yellow("Used:")} ${pc15.white(suggestion.useCount.toString())} times`
+      );
+      console.log();
+      const action = await this.promptCreateShortcut();
+      if (action === "exit") {
+        console.log(pc15.dim("\n  Exiting suggestions.\n"));
+        return 0;
+      }
+      if (action === "yes") {
+        const finalName = await this.getUniqueShortcutName(
+          suggestion.suggestedName
+        );
+        if (!finalName) {
+          markPatternAsSuggested(suggestion.command);
+          console.log();
+          continue;
+        }
+        const hasNumbers = /\d+/.test(suggestion.command);
+        let template = suggestion.command;
+        const args2 = [];
+        if (hasNumbers) {
+          const parameterize = await confirm4({
+            message: "Make numbers into parameters?",
+            default: true
+          });
+          if (parameterize) {
+            const numbers = suggestion.command.match(/\d+/g) || [];
+            const uniqueNumbers = [...new Set(numbers)];
+            for (let i = 0; i < uniqueNumbers.length; i++) {
+              const argName = `arg${i + 1}`;
+              args2.push(argName);
+              template = template.replace(
+                new RegExp(uniqueNumbers[i], "g"),
+                `{{${argName}}}`
+              );
+            }
+          }
+        }
+        addShortcut(finalName, {
+          template,
+          args: args2,
+          description: `Auto-suggested shortcut for: ${suggestion.command}`
+        });
+        markPatternAsSuggested(suggestion.command);
+        logger.success(`\u2713 Created shortcut: ${finalName}`);
+        console.log(
+          pc15.dim(
+            `  Usage: s ${finalName}${args2.length > 0 ? ` ${args2.map((a) => `<${a}>`).join(" ")}` : ""}`
+          )
+        );
+        console.log();
+      } else {
+        markPatternAsSuggested(suggestion.command);
+        console.log();
+      }
+    }
+    console.log(pc15.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n"));
+    return 0;
+  }
+  async promptCreateShortcut() {
+    const answer = await input5({
+      message: "Create shortcut? (y/n/e)",
+      default: "y"
+    });
+    const normalized = answer.toLowerCase().trim();
+    if (["y", "yes", ""].includes(normalized)) {
+      return "yes";
+    }
+    if (["e", "exit"].includes(normalized)) {
+      return "exit";
+    }
+    return "no";
+  }
+  async getUniqueShortcutName(defaultName) {
+    let attempts = 0;
+    const maxAttempts = 5;
+    while (attempts < maxAttempts) {
+      const enteredName = await input5({
+        message: "Shortcut name:",
+        default: defaultName
+      });
+      const finalName = enteredName.trim();
+      if (!finalName) {
+        logger.error("Shortcut name cannot be empty.");
+        attempts++;
+        continue;
+      }
+      const existingShortcut = getShortcut(finalName);
+      if (existingShortcut) {
+        this.showExistingShortcutTable(finalName, existingShortcut);
+        attempts++;
+        continue;
+      }
+      return finalName;
+    }
+    logger.error("Too many invalid attempts. Skipping this suggestion.");
+    return null;
+  }
+  showExistingShortcutTable(name, shortcut) {
+    const boxWidth = 50;
+    const line = "\u2500".repeat(boxWidth);
+    console.log();
+    console.log(pc15.red(`  \u250C${line}\u2510`));
+    console.log(
+      pc15.red("  \u2502") + pc15.bold(pc15.red(" \u274C Shortcut Already Exists")) + " ".repeat(boxWidth - 27) + pc15.red("\u2502")
+    );
+    console.log(pc15.red(`  \u251C${line}\u2524`));
+    const nameLabel = "  Name:     ";
+    const nameValue = name;
+    const namePadding = boxWidth - nameLabel.length - nameValue.length + 2;
+    console.log(
+      pc15.red("  \u2502") + pc15.gray(nameLabel) + pc15.white(nameValue) + " ".repeat(Math.max(0, namePadding)) + pc15.red("\u2502")
+    );
+    const cmdLabel = "  Command:  ";
+    const cmdValue = shortcut.template.length > 35 ? `${shortcut.template.slice(0, 32)}...` : shortcut.template;
+    const cmdPadding = boxWidth - cmdLabel.length - cmdValue.length + 2;
+    console.log(
+      pc15.red("  \u2502") + pc15.gray(cmdLabel) + pc15.cyan(cmdValue) + " ".repeat(Math.max(0, cmdPadding)) + pc15.red("\u2502")
+    );
+    if (shortcut.args && shortcut.args.length > 0) {
+      const argsLabel = "  Args:     ";
+      const argsValue = shortcut.args.join(", ");
+      const argsPadding = boxWidth - argsLabel.length - argsValue.length + 2;
+      console.log(
+        pc15.red("  \u2502") + pc15.gray(argsLabel) + pc15.yellow(argsValue) + " ".repeat(Math.max(0, argsPadding)) + pc15.red("\u2502")
+      );
+    }
+    console.log(pc15.red(`  \u2514${line}\u2518`));
+    console.log();
+    console.log(pc15.yellow("  Please enter a different name:\n"));
+  }
+};
+
+// src/cli/index.ts
+initDatabase();
+if (shouldRunCleanup()) {
+  const config = loadConfig();
+  const retentionDays = config?.settings?.historyRetentionDays ?? 30;
+  const maxEntries = config?.settings?.historyMaxEntries ?? 2e3;
+  cleanupHistory({ retentionDays, maxEntries });
+}
+var cli = new Cli({
+  binaryLabel: "Bashio",
+  binaryName: "b",
+  binaryVersion: "0.4.0"
+});
+cli.register(DefaultCommand);
+cli.register(AuthCommand);
+cli.register(ConfigCommand);
+cli.register(ModelCommand);
+cli.register(ShortcutsCommand);
+cli.register(AddShortcutCommand);
+cli.register(RemoveShortcutCommand);
+cli.register(EditShortcutsCommand);
+cli.register(HistoryCommand);
+cli.register(StatsCommand);
+cli.register(ClearHistoryCommand);
+cli.register(SuggestShortcutsCommand);
+cli.register(Builtins.HelpCommand);
+cli.register(Builtins.VersionCommand);
+
+// src/index.ts
+var args = process.argv.slice(2);
+cli.runExit(args);
+//# sourceMappingURL=index.js.map