@ideascol/agents-generator-sdk 0.7.3 → 0.7.4

package/dist/bin/cli.js

@@ -91,7 +91,12 @@ var require_colors = __commonJS((exports2) => {
     BgBlue: "\x1B[44m",
     BgMagenta: "\x1B[45m",
     BgCyan: "\x1B[46m",
-    BgWhite: "\x1B[47m"
+    BgWhite: "\x1B[47m",
+    Success: "\x1B[32m",
+    Error: "\x1B[31m",
+    Warning: "\x1B[33m",
+    Info: "\x1B[36m",
+    SpinnerFrames: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
   };
 });
 
@@ -110,9 +115,1140 @@ var require_interfaces = __commonJS((exports2) => {
     ParamType2["Phone"] = "phone";
     ParamType2["Url"] = "url";
     ParamType2["Package"] = "Package";
+    ParamType2["Password"] = "password";
   })(ParamType || (exports2.ParamType = ParamType = {}));
 });
 
+// node_modules/@ideascol/cli-maker/dist/common.js
+var require_common = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", { value: true });
+  exports2.ProgressBar = exports2.ProgressIndicator = undefined;
+  exports2.stripAnsiCodes = stripAnsiCodes;
+  exports2.showSuccess = showSuccess;
+  exports2.showError = showError;
+  exports2.showWarning = showWarning;
+  exports2.showInfo = showInfo;
+  exports2.createTable = createTable;
+  exports2.formatParameterTable = formatParameterTable;
+  var colors_1 = require_colors();
+  function stripAnsiCodes(str) {
+    return str.replace(/\u001b\[[0-9;]*[mG]/g, "");
+  }
+
+  class ProgressIndicator {
+    constructor() {
+      this.interval = null;
+      this.frameIndex = 0;
+    }
+    start(message = "Processing...") {
+      process.stdout.write(`${colors_1.Colors.Info}${colors_1.Colors.SpinnerFrames[0]} ${message}${colors_1.Colors.Reset}`);
+      this.interval = setInterval(() => {
+        this.frameIndex = (this.frameIndex + 1) % colors_1.Colors.SpinnerFrames.length;
+        process.stdout.write(`\r${colors_1.Colors.Info}${colors_1.Colors.SpinnerFrames[this.frameIndex]} ${message}${colors_1.Colors.Reset}`);
+      }, 100);
+    }
+    update(message) {
+      if (this.interval) {
+        process.stdout.write(`\r${colors_1.Colors.Info}${colors_1.Colors.SpinnerFrames[this.frameIndex]} ${message}${colors_1.Colors.Reset}`);
+      }
+    }
+    stop(success = true, finalMessage) {
+      if (this.interval) {
+        clearInterval(this.interval);
+        this.interval = null;
+        const icon = success ? "✅" : "❌";
+        const color = success ? colors_1.Colors.Success : colors_1.Colors.Error;
+        const message = finalMessage || (success ? "Done!" : "Failed!");
+        process.stdout.write("\r\x1B[K");
+        process.stdout.write(`${color}${icon} ${message}${colors_1.Colors.Reset}
+`);
+      }
+    }
+    success(message = "Completed successfully!") {
+      this.stop(true, message);
+    }
+    error(message = "Operation failed!") {
+      this.stop(false, message);
+    }
+  }
+  exports2.ProgressIndicator = ProgressIndicator;
+
+  class ProgressBar {
+    constructor(total, barLength = 40) {
+      this.current = 0;
+      this.barLength = 40;
+      this.message = "";
+      this.total = total;
+      this.barLength = barLength;
+    }
+    render() {
+      const percentage = Math.floor(this.current / this.total * 100);
+      const filledLength = Math.floor(this.current / this.total * this.barLength);
+      const emptyLength = this.barLength - filledLength;
+      const filledBar = "█".repeat(filledLength);
+      const emptyBar = "░".repeat(emptyLength);
+      const bar = `${colors_1.Colors.FgCyan}${filledBar}${colors_1.Colors.FgGray}${emptyBar}${colors_1.Colors.Reset}`;
+      const percentageText = `${colors_1.Colors.Bright}${percentage}%${colors_1.Colors.Reset}`;
+      const messageText = this.message ? ` ${colors_1.Colors.FgGray}${this.message}${colors_1.Colors.Reset}` : "";
+      process.stdout.write(`\r\x1B[K[${bar}] ${percentageText}${messageText}`);
+    }
+    start(message = "") {
+      this.message = message;
+      this.current = 0;
+      this.render();
+    }
+    update(current, message) {
+      this.current = Math.min(current, this.total);
+      if (message !== undefined) {
+        this.message = message;
+      }
+      this.render();
+    }
+    increment(step = 1, message) {
+      this.update(this.current + step, message);
+    }
+    complete(message = "Completed!") {
+      this.current = this.total;
+      this.render();
+      process.stdout.write(`
+${colors_1.Colors.Success}✅ ${message}${colors_1.Colors.Reset}
+`);
+    }
+    error(message = "Failed!") {
+      process.stdout.write(`
+${colors_1.Colors.Error}❌ ${message}${colors_1.Colors.Reset}
+`);
+    }
+  }
+  exports2.ProgressBar = ProgressBar;
+  function showSuccess(message) {
+    console.log(`${colors_1.Colors.Success}✅ ${message}${colors_1.Colors.Reset}`);
+  }
+  function showError(message) {
+    console.log(`${colors_1.Colors.Error}❌ ${message}${colors_1.Colors.Reset}`);
+  }
+  function showWarning(message) {
+    console.log(`${colors_1.Colors.Warning}⚠️  ${message}${colors_1.Colors.Reset}`);
+  }
+  function showInfo(message) {
+    console.log(`${colors_1.Colors.Info}ℹ️  ${message}${colors_1.Colors.Reset}`);
+  }
+  function createTable(headers, rows) {
+    if (rows.length === 0)
+      return "";
+    const allRows = [headers, ...rows];
+    const colWidths = headers.map((_, i) => Math.max(...allRows.map((row) => stripAnsiCodes(row[i] || "").length)));
+    const createRow = (row) => {
+      return row.map((cell, i) => {
+        const cleanCell = stripAnsiCodes(cell);
+        return cell.padEnd(colWidths[i] + (cell.length - cleanCell.length));
+      }).join(" │ ");
+    };
+    const separator = colWidths.map((width) => "─".repeat(width)).join("─┼─");
+    let table = createRow(headers) + `
+`;
+    table += separator + `
+`;
+    table += rows.map(createRow).join(`
+`);
+    return table;
+  }
+  function formatParameterTable(params) {
+    const headers = ["Parameter", "Type", "Required", "Description"];
+    const rows = params.map((param) => [
+      colors_1.Colors.FgGreen + param.name + colors_1.Colors.Reset,
+      colors_1.Colors.FgBlue + (param.type || "text") + colors_1.Colors.Reset,
+      param.required ? colors_1.Colors.FgRed + "Yes" + colors_1.Colors.Reset : colors_1.Colors.FgGray + "No" + colors_1.Colors.Reset,
+      param.description + (param.options ? `
+${colors_1.Colors.FgGray}Options: ${param.options.join(", ")}${colors_1.Colors.Reset}` : "")
+    ]);
+    return createTable(headers, rows);
+  }
+});
+
+// node_modules/@ideascol/cli-maker/dist/session/markdown.js
+var require_markdown = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", { value: true });
+  exports2.renderMarkdown = renderMarkdown;
+  var colors_1 = require_colors();
+  function renderMarkdown(md) {
+    const lines = md.split(`
+`);
+    const output = [];
+    let inCodeBlock = false;
+    let codeBlockLang = "";
+    let codeLines = [];
+    for (let i = 0;i < lines.length; i++) {
+      const line = lines[i];
+      if (line.trimStart().startsWith("```")) {
+        if (!inCodeBlock) {
+          inCodeBlock = true;
+          codeBlockLang = line.trimStart().slice(3).trim();
+          codeLines = [];
+          continue;
+        } else {
+          const header = codeBlockLang ? `${colors_1.Colors.FgGray}┌─ ${codeBlockLang} ${"─".repeat(Math.max(0, 40 - codeBlockLang.length))}┐${colors_1.Colors.Reset}` : `${colors_1.Colors.FgGray}┌${"─".repeat(44)}┐${colors_1.Colors.Reset}`;
+          output.push(header);
+          for (const cl of codeLines) {
+            output.push(`${colors_1.Colors.FgGray}│${colors_1.Colors.Reset} ${colors_1.Colors.FgCyan}${cl}${colors_1.Colors.Reset}`);
+          }
+          const footer = `${colors_1.Colors.FgGray}└${"─".repeat(44)}┘${colors_1.Colors.Reset}`;
+          output.push(footer);
+          inCodeBlock = false;
+          codeBlockLang = "";
+          codeLines = [];
+          continue;
+        }
+      }
+      if (inCodeBlock) {
+        codeLines.push(line);
+        continue;
+      }
+      if (/^(\s*[-*_]\s*){3,}$/.test(line)) {
+        output.push(`${colors_1.Colors.FgGray}${"─".repeat(46)}${colors_1.Colors.Reset}`);
+        continue;
+      }
+      const headerMatch = line.match(/^(#{1,6})\s+(.*)$/);
+      if (headerMatch) {
+        const level = headerMatch[1].length;
+        const text = formatInline(headerMatch[2]);
+        if (level === 1) {
+          output.push(`
+${colors_1.Colors.Bright}${colors_1.Colors.FgCyan}${text}${colors_1.Colors.Reset}`);
+          output.push(`${colors_1.Colors.FgGray}${"═".repeat(stripAnsi(text).length)}${colors_1.Colors.Reset}`);
+        } else if (level === 2) {
+          output.push(`
+${colors_1.Colors.Bright}${colors_1.Colors.FgGreen}${text}${colors_1.Colors.Reset}`);
+          output.push(`${colors_1.Colors.FgGray}${"─".repeat(stripAnsi(text).length)}${colors_1.Colors.Reset}`);
+        } else {
+          output.push(`
+${colors_1.Colors.Bright}${colors_1.Colors.FgYellow}${text}${colors_1.Colors.Reset}`);
+        }
+        continue;
+      }
+      const ulMatch = line.match(/^(\s*)([-*+])\s+(.*)$/);
+      if (ulMatch) {
+        const indent = ulMatch[1];
+        const text = formatInline(ulMatch[3]);
+        output.push(`${indent}${colors_1.Colors.FgCyan}•${colors_1.Colors.Reset} ${text}`);
+        continue;
+      }
+      const olMatch = line.match(/^(\s*)(\d+)\.\s+(.*)$/);
+      if (olMatch) {
+        const indent = olMatch[1];
+        const num = olMatch[2];
+        const text = formatInline(olMatch[3]);
+        output.push(`${indent}${colors_1.Colors.FgCyan}${num}.${colors_1.Colors.Reset} ${text}`);
+        continue;
+      }
+      const bqMatch = line.match(/^>\s?(.*)$/);
+      if (bqMatch) {
+        const text = formatInline(bqMatch[1]);
+        output.push(`${colors_1.Colors.FgGray}│${colors_1.Colors.Reset} ${colors_1.Colors.Dim}${text}${colors_1.Colors.Reset}`);
+        continue;
+      }
+      output.push(formatInline(line));
+    }
+    if (inCodeBlock && codeLines.length > 0) {
+      const header = codeBlockLang ? `${colors_1.Colors.FgGray}┌─ ${codeBlockLang} ${"─".repeat(Math.max(0, 40 - codeBlockLang.length))}┐${colors_1.Colors.Reset}` : `${colors_1.Colors.FgGray}┌${"─".repeat(44)}┐${colors_1.Colors.Reset}`;
+      output.push(header);
+      for (const cl of codeLines) {
+        output.push(`${colors_1.Colors.FgGray}│${colors_1.Colors.Reset} ${colors_1.Colors.FgCyan}${cl}${colors_1.Colors.Reset}`);
+      }
+      const footer = `${colors_1.Colors.FgGray}└${"─".repeat(44)}┘${colors_1.Colors.Reset}`;
+      output.push(footer);
+    }
+    return output.join(`
+`);
+  }
+  function formatInline(text) {
+    text = text.replace(/`([^`]+)`/g, `${colors_1.Colors.FgCyan}$1${colors_1.Colors.Reset}`);
+    text = text.replace(/\*\*\*(.+?)\*\*\*/g, `${colors_1.Colors.Bright}${colors_1.Colors.Dim}$1${colors_1.Colors.Reset}`);
+    text = text.replace(/\*\*(.+?)\*\*/g, `${colors_1.Colors.Bright}$1${colors_1.Colors.Reset}`);
+    text = text.replace(/__(.+?)__/g, `${colors_1.Colors.Bright}$1${colors_1.Colors.Reset}`);
+    text = text.replace(/\*(.+?)\*/g, `${colors_1.Colors.Dim}$1${colors_1.Colors.Reset}`);
+    text = text.replace(/_(.+?)_/g, `${colors_1.Colors.Dim}$1${colors_1.Colors.Reset}`);
+    text = text.replace(/~~(.+?)~~/g, `${colors_1.Colors.FgGray}$1${colors_1.Colors.Reset}`);
+    text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, `${colors_1.Colors.FgBlue}${colors_1.Colors.Underscore}$1${colors_1.Colors.Reset} ${colors_1.Colors.FgGray}($2)${colors_1.Colors.Reset}`);
+    return text;
+  }
+  function stripAnsi(str) {
+    return str.replace(/\u001b\[[0-9;]*[mG]/g, "");
+  }
+});
+
+// node_modules/@ideascol/cli-maker/dist/session/slash-commands.js
+var require_slash_commands = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", { value: true });
+  exports2.getBuiltInSlashCommands = getBuiltInSlashCommands;
+  var colors_1 = require_colors();
+  function getBuiltInSlashCommands() {
+    return [
+      {
+        name: "help",
+        description: "Show available slash commands",
+        action: (_args, ctx) => {
+          const allCommands = getAllSlashCommands(ctx);
+          console.log(`
+${colors_1.Colors.Bright}${colors_1.Colors.FgCyan}Available Commands${colors_1.Colors.Reset}`);
+          console.log(`${colors_1.Colors.FgGray}${"─".repeat(40)}${colors_1.Colors.Reset}`);
+          for (const cmd of allCommands) {
+            console.log(`  ${colors_1.Colors.FgGreen}/${cmd.name}${colors_1.Colors.Reset}  ${colors_1.Colors.FgGray}${cmd.description}${colors_1.Colors.Reset}`);
+          }
+          console.log("");
+        }
+      },
+      {
+        name: "clear",
+        description: "Clear the screen",
+        action: (_args, _ctx) => {
+          process.stdout.write("\x1B[2J\x1B[0;0H");
+        }
+      },
+      {
+        name: "history",
+        description: "Show conversation history",
+        action: (_args, ctx) => {
+          if (ctx.history.length === 0) {
+            console.log(`
+${colors_1.Colors.FgGray}No messages in history yet.${colors_1.Colors.Reset}
+`);
+            return;
+          }
+          console.log(`
+${colors_1.Colors.Bright}${colors_1.Colors.FgCyan}Conversation History${colors_1.Colors.Reset} ${colors_1.Colors.FgGray}(${ctx.history.length} messages)${colors_1.Colors.Reset}`);
+          console.log(`${colors_1.Colors.FgGray}${"─".repeat(40)}${colors_1.Colors.Reset}`);
+          for (const msg of ctx.history) {
+            const roleColor = msg.role === "user" ? colors_1.Colors.FgGreen : msg.role === "assistant" ? colors_1.Colors.FgCyan : colors_1.Colors.FgYellow;
+            const roleLabel = msg.role === "tool" && msg.toolName ? `tool:${msg.toolName}` : msg.role;
+            const preview = msg.content.length > 80 ? msg.content.slice(0, 80) + "..." : msg.content;
+            console.log(`  ${roleColor}[${roleLabel}]${colors_1.Colors.Reset} ${preview}`);
+          }
+          console.log("");
+        }
+      },
+      {
+        name: "tools",
+        description: "List registered tools",
+        action: (_args, ctx) => {
+          if (ctx.tools.length === 0) {
+            console.log(`
+${colors_1.Colors.FgGray}No tools registered.${colors_1.Colors.Reset}
+`);
+            return;
+          }
+          console.log(`
+${colors_1.Colors.Bright}${colors_1.Colors.FgCyan}Registered Tools${colors_1.Colors.Reset} ${colors_1.Colors.FgGray}(${ctx.tools.length})${colors_1.Colors.Reset}`);
+          console.log(`${colors_1.Colors.FgGray}${"─".repeat(40)}${colors_1.Colors.Reset}`);
+          for (const tool of ctx.tools) {
+            console.log(`  ${colors_1.Colors.FgYellow}⚡${colors_1.Colors.Reset} ${colors_1.Colors.Bright}${tool.name}${colors_1.Colors.Reset}  ${colors_1.Colors.FgGray}${tool.description}${colors_1.Colors.Reset}`);
+            if (tool.parameters && tool.parameters.length > 0) {
+              for (const p of tool.parameters) {
+                const req = p.required ? `${colors_1.Colors.FgRed}*${colors_1.Colors.Reset}` : "";
+                console.log(`      ${colors_1.Colors.FgGray}${p.name}${req} (${p.type}) — ${p.description}${colors_1.Colors.Reset}`);
+              }
+            }
+          }
+          console.log("");
+        }
+      },
+      {
+        name: "compact",
+        description: "Trim conversation history to the last N messages (default: 10)",
+        action: (args, ctx) => {
+          const keep = parseInt(args.trim(), 10) || 10;
+          const removed = Math.max(0, ctx.history.length - keep);
+          if (removed > 0) {
+            ctx.history.splice(0, removed);
+          }
+          console.log(`
+${colors_1.Colors.FgGreen}✓${colors_1.Colors.Reset} History compacted: kept ${ctx.history.length} messages, removed ${removed}.
+`);
+        }
+      },
+      {
+        name: "exit",
+        description: "End the interactive session",
+        action: (_args, _ctx) => {}
+      }
+    ];
+  }
+  function getAllSlashCommands(ctx) {
+    const builtIn = getBuiltInSlashCommands();
+    return builtIn;
+  }
+});
+
+// node_modules/@ideascol/cli-maker/dist/session/ui.js
+var require_ui = __commonJS((exports2) => {
+  Object.defineProperty(exports2, "__esModule", { value: true });
+  exports2.drawBox = drawBox;
+  exports2.drawTwoColumnBox = drawTwoColumnBox;
+  exports2.infoBar = infoBar;
+  exports2.separator = separator;
+  exports2.toolCallHeader = toolCallHeader;
+  exports2.toolCallArgs = toolCallArgs;
+  exports2.toolResultBox = toolResultBox;
+  exports2.sectionHeader = sectionHeader;
+  exports2.alignedList = alignedList;
+  var colors_1 = require_colors();
+  var common_1 = require_common();
+  var BORDERS = {
+    single: { tl: "┌", tr: "┐", bl: "└", br: "┘", h: "─", v: "│" },
+    double: { tl: "╔", tr: "╗", bl: "╚", br: "╝", h: "═", v: "║" },
+    dashed: { tl: "┌", tr: "┐", bl: "└", br: "┘", h: "╌", v: "╎" },
+    rounded: { tl: "╭", tr: "╮", bl: "╰", br: "╯", h: "─", v: "│" }
+  };
+  function drawBox(contentLines, opts = {}) {
+    const border = BORDERS[opts.borderStyle ?? "rounded"];
+    const bColor = opts.borderColor ?? colors_1.Colors.FgGray;
+    const pad = opts.padding ?? 1;
+    const termWidth = process.stdout.columns || 80;
+    const maxW = opts.maxWidth ?? termWidth - 4;
+    const contentWidths = contentLines.map((l) => (0, common_1.stripAnsiCodes)(l).length);
+    let innerWidth = Math.max(...contentWidths, 10);
+    if (opts.title) {
+      innerWidth = Math.max(innerWidth, (0, common_1.stripAnsiCodes)(opts.title).length + 4);
+    }
+    innerWidth = Math.min(innerWidth, maxW - pad * 2 - 2);
+    const totalInner = innerWidth + pad * 2;
+    const padStr = " ".repeat(pad);
+    const output = [];
+    if (opts.title) {
+      const tColor = opts.titleColor ?? colors_1.Colors.Bright;
+      const titleClean = (0, common_1.stripAnsiCodes)(opts.title);
+      const remaining = Math.max(0, totalInner - titleClean.length - 3);
+      output.push(`${bColor}${border.tl}${border.h} ${colors_1.Colors.Reset}${tColor}${opts.title}${colors_1.Colors.Reset}${bColor} ${border.h.repeat(remaining)}${border.tr}${colors_1.Colors.Reset}`);
+    } else {
+      output.push(`${bColor}${border.tl}${border.h.repeat(totalInner)}${border.tr}${colors_1.Colors.Reset}`);
+    }
+    for (const line of contentLines) {
+      const cleanLen = (0, common_1.stripAnsiCodes)(line).length;
+      const rightPad = Math.max(0, innerWidth - cleanLen);
+      output.push(`${bColor}${border.v}${colors_1.Colors.Reset}${padStr}${line}${" ".repeat(rightPad)}${padStr}${bColor}${border.v}${colors_1.Colors.Reset}`);
+    }
+    output.push(`${bColor}${border.bl}${border.h.repeat(totalInner)}${border.br}${colors_1.Colors.Reset}`);
+    return output.join(`
+`);
+  }
+  function drawTwoColumnBox(leftLines, rightLines, opts = {}) {
+    const border = BORDERS[opts.borderStyle ?? "rounded"];
+    const bColor = opts.borderColor ?? colors_1.Colors.FgGray;
+    const pad = opts.padding ?? 1;
+    const termWidth = process.stdout.columns || 80;
+    const maxW = opts.maxWidth ?? termWidth;
+    const totalInner = maxW - 2;
+    const ratio = opts.leftRatio ?? 0.45;
+    const divider = opts.dividerChar ?? border.v;
+    const overhead = pad * 4 + 1;
+    const usable = totalInner - overhead;
+    const leftW = Math.max(10, Math.floor(usable * ratio));
+    const rightW = Math.max(10, usable - leftW);
+    const maxRows = Math.max(leftLines.length, rightLines.length);
+    const padStr = " ".repeat(pad);
+    const truncate = (s, maxLen) => {
+      const clean = (0, common_1.stripAnsiCodes)(s);
+      if (clean.length <= maxLen)
+        return s;
+      let visible = 0;
+      let i = 0;
+      let inEsc = false;
+      let result = "";
+      while (i < s.length && visible < maxLen - 1) {
+        if (s[i] === "\x1B") {
+          inEsc = true;
+          result += s[i];
+        } else if (inEsc) {
+          result += s[i];
+          if (/[a-zA-Z]/.test(s[i]))
+            inEsc = false;
+        } else {
+          result += s[i];
+          visible++;
+        }
+        i++;
+      }
+      return result + "…" + colors_1.Colors.Reset;
+    };
+    const output = [];
+    if (opts.title) {
+      const tColor = opts.titleColor ?? colors_1.Colors.Bright;
+      const titleClean = (0, common_1.stripAnsiCodes)(opts.title);
+      const remaining = Math.max(0, totalInner - titleClean.length - 4);
+      output.push(`${bColor}${border.tl}${border.h}${border.h}${border.h} ${colors_1.Colors.Reset}${tColor}${opts.title}${colors_1.Colors.Reset}${bColor} ${border.h.repeat(remaining)}${border.tr}${colors_1.Colors.Reset}`);
+    } else {
+      output.push(`${bColor}${border.tl}${border.h.repeat(totalInner)}${border.tr}${colors_1.Colors.Reset}`);
+    }
+    for (let i = 0;i < maxRows; i++) {
+      const rawLeft = leftLines[i] ?? "";
+      const rawRight = rightLines[i] ?? "";
+      const left = truncate(rawLeft, leftW);
+      const right = truncate(rawRight, rightW);
+      const leftClean = (0, common_1.stripAnsiCodes)(left).length;
+      const rightClean = (0, common_1.stripAnsiCodes)(right).length;
+      const leftPadR = Math.max(0, leftW - leftClean);
+      const rightPadR = Math.max(0, rightW - rightClean);
+      output.push(`${bColor}${border.v}${colors_1.Colors.Reset}${padStr}${left}${" ".repeat(leftPadR)}${padStr}${bColor}${divider}${colors_1.Colors.Reset}${padStr}${right}${" ".repeat(rightPadR)}${padStr}${bColor}${border.v}${colors_1.Colors.Reset}`);
+    }
+    output.push(`${bColor}${border.bl}${border.h.repeat(totalInner)}${border.br}${colors_1.Colors.Reset}`);
+    return output.join(`
+`);
+  }
+  function infoBar(text) {
+    return `${colors_1.Colors.FgGray}${text}${colors_1.Colors.Reset}`;
+  }
+  function separator(char = "─", width) {
+    const w = width ?? (process.stdout.columns || 80) - 2;
+    return `${colors_1.Colors.FgGray}${char.repeat(w)}${colors_1.Colors.Reset}`;
+  }
+  function toolCallHeader(toolName, description) {
+    return `  ${colors_1.Colors.FgYellow}⏺${colors_1.Colors.Reset}  ${colors_1.Colors.Bright}${toolName}${colors_1.Colors.Reset}`;
+  }
+  function toolCallArgs(args) {
+    const lines = [];
+    for (const [key, val] of Object.entries(args)) {
+      const display = typeof val === "string" ? val : JSON.stringify(val);
+      lines.push(`     ${colors_1.Colors.FgGray}${key}:${colors_1.Colors.Reset} ${display}`);
+    }
+    return lines.join(`
+`);
+  }
+  function toolResultBox(result) {
+    const lines = result.split(`
+`);
+    const output = [];
+    for (const line of lines) {
+      output.push(`     ${colors_1.Colors.FgGray}│${colors_1.Colors.Reset} ${line}`);
+    }
+    return output.join(`
+`);
+  }
+  function sectionHeader(title) {
+    return `
+  ${colors_1.Colors.Bright}${colors_1.Colors.FgCyan}${title}${colors_1.Colors.Reset}`;
+  }
+  function alignedList(items, indent = 4) {
+    const indentStr = " ".repeat(indent);
+    const maxKeyLen = Math.max(...items.map((i) => (0, common_1.stripAnsiCodes)(i.prefix ?? "").length + (0, common_1.stripAnsiCodes)(i.key).length));
+    const gap = 3;
+    const lines = [];
+    for (const item of items) {
+      const prefix = item.prefix ?? "";
+      const prefixClean = (0, common_1.stripAnsiCodes)(prefix).length;
+      const keyClean = (0, common_1.stripAnsiCodes)(item.key).length;
+      const keyColor = item.keyColor ?? colors_1.Colors.FgGreen;
+      const padding = " ".repeat(Math.max(1, maxKeyLen - prefixClean - keyClean + gap));
+      lines.push(`${indentStr}${prefix}${keyColor}${item.key}${colors_1.Colors.Reset}${padding}${colors_1.Colors.FgGray}${item.value}${colors_1.Colors.Reset}`);
+    }
+    return lines.join(`
+`);
+  }
+});
+
+// node_modules/@ideascol/cli-maker/dist/session/session.js
+var require_session = __commonJS((exports2) => {
+  var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+  Object.defineProperty(exports2, "__esModule", { value: true });
+  exports2.InteractiveSession = undefined;
+  var readline_1 = __importDefault(require("readline"));
+  var child_process_1 = require("child_process");
+  var colors_1 = require_colors();
+  var common_1 = require_common();
+  var markdown_1 = require_markdown();
+  var slash_commands_1 = require_slash_commands();
+  var ui_1 = require_ui();
+
+  class InteractiveSession {
+    constructor(options) {
+      this.history = [];
+      this.rl = null;
+      this.inputHistory = [];
+      this.running = false;
+      this.options = {
+        prompt: options.prompt ?? "> ",
+        historySize: options.historySize ?? 100,
+        multiLineEnabled: options.multiLineEnabled ?? true,
+        ...options
+      };
+      this.tools = options.tools ?? [];
+      this.slashCommands = this.mergeSlashCommands(options.slashCommands ?? []);
+      this.theme = {
+        borderColor: options.theme?.borderColor ?? colors_1.Colors.FgGreen,
+        borderStyle: options.theme?.borderStyle ?? "dashed",
+        promptColor: options.theme?.promptColor ?? colors_1.Colors.FgGreen,
+        accentColor: options.theme?.accentColor ?? colors_1.Colors.FgCyan
+      };
+    }
+    async start() {
+      this.running = true;
+      const ctx = this.buildContext();
+      this.renderWelcomeScreen();
+      if (this.options.onStart) {
+        await this.options.onStart(ctx);
+      }
+      const termW = process.stdout.columns || 80;
+      console.log(`  ${colors_1.Colors.FgGray}${"─".repeat(Math.max(10, termW - 4))}${colors_1.Colors.Reset}
+`);
+      while (this.running) {
+        let input;
+        try {
+          input = await this.readInput();
+        } catch {
+          break;
+        }
+        const trimmed = input.trim();
+        if (trimmed.length === 0)
+          continue;
+        if (trimmed.startsWith("!")) {
+          const shellCmd = trimmed.slice(1).trim();
+          if (shellCmd.length === 0) {
+            console.log(`  ${colors_1.Colors.FgGray}Usage: ! <command>  (e.g. ! ls, ! pwd, ! git status)${colors_1.Colors.Reset}
+`);
+          } else {
+            console.log(`  ${colors_1.Colors.FgGray}$ ${shellCmd}${colors_1.Colors.Reset}`);
+            try {
+              const output = (0, child_process_1.execSync)(shellCmd, {
+                encoding: "utf-8",
+                stdio: ["pipe", "pipe", "pipe"],
+                timeout: 30000,
+                cwd: process.cwd()
+              });
+              if (output.trim().length > 0) {
+                const indented = output.trimEnd().split(`
+`).map((l) => `  ${l}`).join(`
+`);
+                console.log(indented);
+              }
+            } catch (err) {
+              if (err.stderr) {
+                const indented = err.stderr.toString().trimEnd().split(`
+`).map((l) => `  ${l}`).join(`
+`);
+                console.log(`${colors_1.Colors.FgRed}${indented}${colors_1.Colors.Reset}`);
+              }
+              if (err.status != null) {
+                console.log(`  ${colors_1.Colors.FgGray}exit code: ${err.status}${colors_1.Colors.Reset}`);
+              }
+            }
+            console.log("");
+          }
+          continue;
+        }
+        if (trimmed.startsWith("/")) {
+          const spaceIdx = trimmed.indexOf(" ");
+          const cmdName = spaceIdx === -1 ? trimmed.slice(1) : trimmed.slice(1, spaceIdx);
+          const cmdArgs = spaceIdx === -1 ? "" : trimmed.slice(spaceIdx + 1);
+          if (cmdName === "exit" || cmdName === "quit") {
+            break;
+          }
+          if (cmdName === "clear") {
+            process.stdout.write("\x1B[2J\x1B[0;0H");
+            this.renderWelcomeScreen();
+            const termW2 = process.stdout.columns || 80;
+            console.log(`  ${colors_1.Colors.FgGray}${"─".repeat(Math.max(10, termW2 - 4))}${colors_1.Colors.Reset}
+`);
+            continue;
+          }
+          const cmd = this.slashCommands.find((c) => c.name === cmdName);
+          if (cmd) {
+            await cmd.action(cmdArgs, this.buildContext());
+          } else {
+            console.log(`  ${colors_1.Colors.FgRed}✗${colors_1.Colors.Reset} Unknown command: ${colors_1.Colors.Bright}/${cmdName}${colors_1.Colors.Reset}`);
+            console.log(`  ${colors_1.Colors.FgGray}Type ${colors_1.Colors.FgGreen}/help${colors_1.Colors.FgGray} for a list of commands.${colors_1.Colors.Reset}
+`);
+          }
+          continue;
+        }
+        this.addToHistory({ role: "user", content: trimmed });
+        try {
+          await this.options.onMessage(trimmed, this.buildContext());
+        } catch (err) {
+          console.log(`
+  ${colors_1.Colors.FgRed}✗ Error:${colors_1.Colors.Reset} ${err?.message ?? err}
+`);
+        }
+      }
+      if (this.options.onEnd) {
+        await this.options.onEnd(this.buildContext());
+      }
+      console.log(`
+  ${colors_1.Colors.FgGray}Session ended. Goodbye!${colors_1.Colors.Reset}
+`);
+      this.cleanup();
+    }
+    stop() {
+      this.running = false;
+    }
+    getHistory() {
+      return [...this.history];
+    }
+    renderWelcomeScreen() {
+      console.log("");
+      const hasTips = this.options.tips && this.options.tips.length > 0;
+      const hasWelcome = !!this.options.welcomeMessage;
+      if (hasWelcome && hasTips) {
+        const leftLines = this.options.welcomeMessage.split(`
+`).map((l) => {
+          return l.replace(/\*\*(.+?)\*\*/g, `${colors_1.Colors.Bright}$1${colors_1.Colors.Reset}`).replace(/`([^`]+)`/g, `${colors_1.Colors.FgCyan}$1${colors_1.Colors.Reset}`);
+        });
+        const rightLines = [];
+        for (const tip of this.options.tips) {
+          rightLines.push(`${colors_1.Colors.FgYellow}${colors_1.Colors.Bright}${tip.title}${colors_1.Colors.Reset}`);
+          for (const line of tip.lines) {
+            rightLines.push(`${line}`);
+          }
+          rightLines.push("");
+        }
+        if (rightLines.length > 0 && rightLines[rightLines.length - 1] === "") {
+          rightLines.pop();
+        }
+        console.log((0, ui_1.drawTwoColumnBox)(leftLines, rightLines, {
+          borderColor: this.theme.borderColor,
+          borderStyle: this.theme.borderStyle
+        }));
+      } else if (hasWelcome) {
+        const lines = this.options.welcomeMessage.split(`
+`).map((l) => {
+          return l.replace(/\*\*(.+?)\*\*/g, `${colors_1.Colors.Bright}$1${colors_1.Colors.Reset}`).replace(/`([^`]+)`/g, `${colors_1.Colors.FgCyan}$1${colors_1.Colors.Reset}`);
+        });
+        console.log((0, ui_1.drawBox)(lines, {
+          borderColor: this.theme.borderColor,
+          borderStyle: this.theme.borderStyle
+        }));
+      }
+      if (this.options.infoLines && this.options.infoLines.length > 0) {
+        for (const line of this.options.infoLines) {
+          console.log(`  ${colors_1.Colors.FgGray}${line}${colors_1.Colors.Reset}`);
+        }
+      }
+    }
+    readInput() {
+      const isTTY = process.stdin.isTTY ?? false;
+      if (!isTTY) {
+        return new Promise((resolve, reject) => {
+          this.rl = readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            terminal: false
+          });
+          this.rl.question("> ", (answer) => {
+            this.rl.close();
+            this.rl = null;
+            resolve(answer);
+          });
+          this.rl.on("close", () => reject(new Error("EOF")));
+        });
+      }
+      return new Promise((resolve, reject) => {
+        let line = "";
+        let cursor = 0;
+        let historyIdx = -1;
+        let savedLine = "";
+        let menuItems = [];
+        let menuSelected = 0;
+        let menuLineCount = 0;
+        const promptStr = `${this.theme.promptColor}>${colors_1.Colors.Reset} `;
+        const promptVisualLen = 2;
+        const eraseBelow = () => {
+          if (menuLineCount > 0) {
+            process.stdout.write("\x1B[J");
+            menuLineCount = 0;
+          }
+        };
+        const renderPromptLine = () => {
+          process.stdout.write("\r\x1B[2K");
+          process.stdout.write(promptStr + line);
+          const cursorPos = promptVisualLen + cursor;
+          process.stdout.write(`\r\x1B[${cursorPos + 1}G`);
+        };
+        const renderMenu = () => {
+          if (menuItems.length === 0)
+            return;
+          const maxNameLen = Math.max(...menuItems.map((c) => c.name.length));
+          const gap = 4;
+          const rows = [];
+          for (let i = 0;i < menuItems.length; i++) {
+            const cmd = menuItems[i];
+            const nameStr = `/${cmd.name}`.padEnd(maxNameLen + 1 + gap);
+            if (i === menuSelected) {
+              rows.push(`  ${colors_1.Colors.Dim}${colors_1.Colors.Reverse} ${nameStr}${cmd.description} ${colors_1.Colors.Reset}`);
+            } else {
+              rows.push(`  ${colors_1.Colors.FgWhite}/${cmd.name}${colors_1.Colors.Reset}${" ".repeat(maxNameLen - cmd.name.length + gap)}${colors_1.Colors.FgGray}${cmd.description}${colors_1.Colors.Reset}`);
+            }
+          }
+          for (const row of rows) {
+            process.stdout.write(`
+\x1B[2K` + row);
+          }
+          menuLineCount = rows.length;
+          if (menuLineCount > 0) {
+            process.stdout.write(`\x1B[${menuLineCount}A`);
+          }
+          const cursorPos = promptVisualLen + cursor;
+          process.stdout.write(`\r\x1B[${cursorPos + 1}G`);
+        };
+        const redraw = () => {
+          eraseBelow();
+          renderPromptLine();
+          const isSlashPrefix = line.startsWith("/") && !line.includes(" ");
+          if (isSlashPrefix) {
+            const partial = line.slice(1).toLowerCase();
+            menuItems = this.slashCommands.filter((c) => c.name.toLowerCase().startsWith(partial));
+            menuSelected = Math.min(menuSelected, Math.max(0, menuItems.length - 1));
+            if (menuItems.length > 0) {
+              renderMenu();
+            }
+          } else {
+            menuItems = [];
+            menuSelected = 0;
+          }
+        };
+        const finish = (result) => {
+          eraseBelow();
+          process.stdin.removeListener("data", onData);
+          if (process.stdin.setRawMode) {
+            process.stdin.setRawMode(false);
+          }
+          process.stdout.write(`
+`);
+          const trimmed = result.trim();
+          if (trimmed.length > 0) {
+            this.inputHistory.unshift(trimmed);
+            if (this.inputHistory.length > 50)
+              this.inputHistory.pop();
+          }
+          resolve(result);
+        };
+        const onData = (data) => {
+          const s = data.toString();
+          if (s === "\x03") {
+            eraseBelow();
+            process.stdin.removeListener("data", onData);
+            if (process.stdin.setRawMode) {
+              process.stdin.setRawMode(false);
+            }
+            process.stdout.write(`
+`);
+            reject(new Error("EOF"));
+            return;
+          }
+          if (s === "\x04") {
+            if (line.length === 0) {
+              eraseBelow();
+              process.stdin.removeListener("data", onData);
+              if (process.stdin.setRawMode) {
+                process.stdin.setRawMode(false);
+              }
+              process.stdout.write(`
+`);
+              reject(new Error("EOF"));
+              return;
+            }
+            return;
+          }
+          if (s === "\r" || s === `
+`) {
+            if (menuItems.length > 0 && menuSelected < menuItems.length) {
+              const selected = menuItems[menuSelected];
+              line = `/${selected.name}`;
+              cursor = line.length;
+            }
+            finish(line);
+            return;
+          }
+          if (s === "\t") {
+            if (menuItems.length > 0 && menuSelected < menuItems.length) {
+              const selected = menuItems[menuSelected];
+              line = `/${selected.name}`;
+              cursor = line.length;
+              menuItems = [];
+              menuSelected = 0;
+              redraw();
+            }
+            return;
+          }
+          if (s === "" || s === "\b") {
+            if (cursor > 0) {
+              line = line.slice(0, cursor - 1) + line.slice(cursor);
+              cursor--;
+              menuSelected = 0;
+              redraw();
+            }
+            return;
+          }
+          if (s === "\x1B") {
+            if (menuItems.length > 0) {
+              menuItems = [];
+              menuSelected = 0;
+              redraw();
+            }
+            return;
+          }
+          if (s === "\x1B[A" || s === "\x1BOA") {
+            if (menuItems.length > 0) {
+              menuSelected = (menuSelected - 1 + menuItems.length) % menuItems.length;
+              eraseBelow();
+              renderPromptLine();
+              renderMenu();
+            } else {
+              if (historyIdx === -1)
+                savedLine = line;
+              if (historyIdx < this.inputHistory.length - 1) {
+                historyIdx++;
+                line = this.inputHistory[historyIdx];
+                cursor = line.length;
+                redraw();
+              }
+            }
+            return;
+          }
+          if (s === "\x1B[B" || s === "\x1BOB") {
+            if (menuItems.length > 0) {
+              menuSelected = (menuSelected + 1) % menuItems.length;
+              eraseBelow();
+              renderPromptLine();
+              renderMenu();
+            } else {
+              if (historyIdx > 0) {
+                historyIdx--;
+                line = this.inputHistory[historyIdx];
+                cursor = line.length;
+                redraw();
+              } else if (historyIdx === 0) {
+                historyIdx = -1;
+                line = savedLine;
+                cursor = line.length;
+                redraw();
+              }
+            }
+            return;
+          }
+          if (s === "\x1B[D" || s === "\x1BOD") {
+            if (cursor > 0) {
+              cursor--;
+              process.stdout.write("\x1B[1D");
+            }
+            return;
+          }
+          if (s === "\x1B[C" || s === "\x1BOC") {
+            if (cursor < line.length) {
+              cursor++;
+              process.stdout.write("\x1B[1C");
+            }
+            return;
+          }
+          if (s === "\x1B[H" || s === "\x01") {
+            cursor = 0;
+            process.stdout.write(`\r\x1B[${promptVisualLen + 1}G`);
+            return;
+          }
+          if (s === "\x1B[F" || s === "\x05") {
+            cursor = line.length;
+            process.stdout.write(`\r\x1B[${promptVisualLen + cursor + 1}G`);
+            return;
+          }
+          if (s === "\x1B[3~") {
+            if (cursor < line.length) {
+              line = line.slice(0, cursor) + line.slice(cursor + 1);
+              menuSelected = 0;
+              redraw();
+            }
+            return;
+          }
+          if (s.startsWith("\x1B")) {
+            return;
+          }
+          if (s.length === 1 && s.charCodeAt(0) >= 32) {
+            line = line.slice(0, cursor) + s + line.slice(cursor);
+            cursor++;
+            historyIdx = -1;
+            menuSelected = 0;
+            redraw();
+            return;
+          }
+        };
+        if (process.stdin.setRawMode) {
+          process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        renderPromptLine();
+        process.stdin.on("data", onData);
+      });
+    }
+    buildContext() {
+      const self = this;
+      return {
+        history: this.history,
+        tools: this.tools,
+        callTool: (name, args) => self.executeTool(name, args),
+        print: (text) => self.print(text),
+        printStream: (stream) => self.printStream(stream),
+        printMarkdown: (md) => self.printMarkdown(md),
+        spinner: new common_1.ProgressIndicator,
+        session: self
+      };
+    }
+    async executeTool(name, args) {
+      const tool = this.tools.find((t) => t.name === name);
+      if (!tool) {
+        throw new Error(`Tool not found: ${name}`);
+      }
+      if (tool.parameters) {
+        for (const param of tool.parameters) {
+          if (param.required && (args[param.name] === undefined || args[param.name] === null)) {
+            throw new Error(`Missing required parameter '${param.name}' for tool '${name}'`);
+          }
+        }
+      }
+      console.log("");
+      console.log((0, ui_1.toolCallHeader)(tool.name, tool.description));
+      if (Object.keys(args).length > 0) {
+        console.log((0, ui_1.toolCallArgs)(args));
+      }
+      const spinner = new common_1.ProgressIndicator;
+      spinner.start("  Running...");
+      let result;
+      try {
+        result = await tool.execute(args, this.buildContext());
+        spinner.success("Done");
+      } catch (err) {
+        spinner.error(err?.message ?? "Tool execution failed");
+        throw err;
+      }
+      const resultStr = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+      console.log((0, ui_1.toolResultBox)(resultStr));
+      console.log("");
+      this.addToHistory({ role: "tool", content: resultStr, toolName: name });
+      return result;
+    }
+    print(text) {
+      console.log(`  ${text}`);
+      this.addToHistory({ role: "assistant", content: text });
+    }
+    async printStream(stream) {
+      let full = "";
+      process.stdout.write("  ");
+      for await (const chunk of stream) {
+        process.stdout.write(chunk);
+        full += chunk;
+      }
+      process.stdout.write(`
+
+`);
+      this.addToHistory({ role: "assistant", content: full });
+    }
+    printMarkdown(md) {
+      const rendered = (0, markdown_1.renderMarkdown)(md);
+      const indented = rendered.split(`
+`).map((l) => `  ${l}`).join(`
+`);
+      console.log(indented);
+      this.addToHistory({ role: "assistant", content: md });
+    }
+    addToHistory(message) {
+      this.history.push(message);
+      while (this.history.length > this.options.historySize) {
+        this.history.shift();
+      }
+    }
+    mergeSlashCommands(custom) {
+      const builtIn = (0, slash_commands_1.getBuiltInSlashCommands)();
+      const customNames = new Set(custom.map((c) => c.name));
+      const merged = builtIn.filter((b) => !customNames.has(b.name));
+      merged.push(...custom);
+      const helpIdx = merged.findIndex((c) => c.name === "help");
+      if (helpIdx !== -1) {
+        merged[helpIdx] = {
+          name: "help",
+          description: "Show available slash commands",
+          action: (_args, _ctx) => {
+            console.log((0, ui_1.sectionHeader)("Commands"));
+            console.log("");
+            const items = merged.map((cmd) => ({
+              key: `/${cmd.name}`,
+              value: cmd.description,
+              keyColor: colors_1.Colors.FgGreen
+            }));
+            console.log((0, ui_1.alignedList)(items));
+            console.log("");
+          }
+        };
+      }
+      const toolsIdx = merged.findIndex((c) => c.name === "tools");
+      if (toolsIdx !== -1) {
+        const self = this;
+        merged[toolsIdx] = {
+          name: "tools",
+          description: "List registered tools",
+          action: (_args, _ctx) => {
+            if (self.tools.length === 0) {
+              console.log(`
+  ${colors_1.Colors.FgGray}No tools registered.${colors_1.Colors.Reset}
+`);
+              return;
+            }
+            console.log((0, ui_1.sectionHeader)(`Tools ${colors_1.Colors.FgGray}(${self.tools.length})${colors_1.Colors.Reset}`));
+            console.log("");
+            for (const tool of self.tools) {
+              console.log(`    ${colors_1.Colors.FgYellow}⚡${colors_1.Colors.Reset} ${colors_1.Colors.Bright}${tool.name}${colors_1.Colors.Reset}  ${colors_1.Colors.FgGray}${tool.description}${colors_1.Colors.Reset}`);
+              if (tool.parameters && tool.parameters.length > 0) {
+                for (const p of tool.parameters) {
+                  const req = p.required ? `${colors_1.Colors.FgRed}*${colors_1.Colors.Reset}` : "";
+                  console.log(`       ${colors_1.Colors.FgGray}${p.name}${req} ${colors_1.Colors.Dim}(${p.type})${colors_1.Colors.Reset} ${colors_1.Colors.FgGray}${p.description}${colors_1.Colors.Reset}`);
+                }
+              }
+            }
+            console.log("");
+          }
+        };
+      }
+      const historyIdx = merged.findIndex((c) => c.name === "history");
+      if (historyIdx !== -1) {
+        const self = this;
+        merged[historyIdx] = {
+          name: "history",
+          description: "Show conversation history",
+          action: (_args, _ctx) => {
+            if (self.history.length === 0) {
+              console.log(`
+  ${colors_1.Colors.FgGray}No messages yet.${colors_1.Colors.Reset}
+`);
+              return;
+            }
+            console.log((0, ui_1.sectionHeader)(`History ${colors_1.Colors.FgGray}(${self.history.length} messages)${colors_1.Colors.Reset}`));
+            console.log("");
+            for (const msg of self.history) {
+              const roleColor = msg.role === "user" ? colors_1.Colors.FgGreen : msg.role === "assistant" ? colors_1.Colors.FgCyan : colors_1.Colors.FgYellow;
+              const roleLabel = msg.role === "tool" && msg.toolName ? `tool:${msg.toolName}` : msg.role;
+              const icon = msg.role === "user" ? "▸" : msg.role === "assistant" ? "◂" : "⚡";
+              const preview = msg.content.length > 80 ? msg.content.slice(0, 80) + "…" : msg.content;
+              console.log(`    ${roleColor}${icon} ${roleLabel}${colors_1.Colors.Reset}  ${colors_1.Colors.FgGray}${preview}${colors_1.Colors.Reset}`);
+            }
+            console.log("");
+          }
+        };
+      }
+      return merged;
+    }
+    cleanup() {
+      if (this.rl) {
+        this.rl.close();
+        this.rl = null;
+      }
+      if (process.stdin.setRawMode) {
+        try {
+          process.stdin.setRawMode(false);
+        } catch {}
+      }
+      process.stdin.pause();
+      process.stdin.unref();
+    }
+  }
+  exports2.InteractiveSession = InteractiveSession;
+});
+
 // node_modules/@ideascol/cli-maker/dist/command/validator.js
 var require_validator = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", { value: true });
@@ -123,68 +1259,785 @@ var require_validator = __commonJS((exports2) => {
   class Validator {
     validateParam(value, type, isRequired, options, paramName) {
       if (this.checkEmpty(value) && isRequired) {
-        return { error: `${colors_1.Colors.FgRed}Missing required parameter${paramName ? `: ${paramName}` : ""}${colors_1.Colors.Reset}` };
+        return {
+          error: `
+${colors_1.Colors.BgRed}${colors_1.Colors.FgWhite} ERROR ${colors_1.Colors.Reset} ${colors_1.Colors.FgRed}Missing required parameter${paramName ? `: ${colors_1.Colors.Bright}${paramName}${colors_1.Colors.Reset}${colors_1.Colors.FgRed}` : ""}${colors_1.Colors.Reset}
+`
+        };
       } else if (this.checkEmpty(value) && !isRequired) {
         return { value: undefined, error: "" };
       }
-      if (value === undefined) {
-        return { value };
+      if (value === undefined) {
+        return { value };
+      }
+      switch (type) {
+        case interfaces_1.ParamType.Number:
+          if (!/^[0-9]+$/.test(value)) {
+            return {
+              error: `
+${colors_1.Colors.BgRed}${colors_1.Colors.FgWhite} ERROR ${colors_1.Colors.Reset} ${colors_1.Colors.FgRed}Invalid number format: '${colors_1.Colors.Bright}${value}${colors_1.Colors.Reset}${colors_1.Colors.FgRed}'${colors_1.Colors.Reset}
+${colors_1.Colors.FgGray}       Expected: whole numbers only (e.g., 42)${colors_1.Colors.Reset}
+`
+            };
+          }
+          return { value: Number(value) };
+        case interfaces_1.ParamType.Custom:
+          try {
+            const customValue = JSON.parse(value);
+            if (Array.isArray(customValue) || typeof customValue === "object") {
+              return { value: customValue };
+            } else {
+              return {
+                error: `
+${colors_1.Colors.BgRed}${colors_1.Colors.FgWhite} ERROR ${colors_1.Colors.Reset} ${colors_1.Colors.FgRed}Invalid custom value: '${colors_1.Colors.Bright}${value}${colors_1.Colors.Reset}${colors_1.Colors.FgRed}'${colors_1.Colors.Reset}
+${colors_1.Colors.FgGray}       Expected: JSON array or object (e.g., ["item1", "item2"] or {"key": "value"})${colors_1.Colors.Reset}
+`
+              };
+            }
+          } catch {
+            return {
+              error: `
+${colors_1.Colors.BgRed}${colors_1.Colors.FgWhite} ERROR ${colors_1.Colors.Reset} ${colors_1.Colors.FgRed}Invalid JSON format: '${colors_1.Colors.Bright}${value}${colors_1.Colors.Reset}${colors_1.Colors.FgRed}'${colors_1.Colors.Reset}
+${colors_1.Colors.FgGray}       Expected: Valid JSON array or object${colors_1.Colors.Reset}
+`
+            };
+          }
+        case interfaces_1.ParamType.List: {
+          if (options === undefined || options?.length === 0) {
+            return {
+              error: `
+${colors_1.Colors.BgRed}${colors_1.Colors.FgWhite} ERROR ${colors_1.Colors.Reset} ${colors_1.Colors.FgRed}List parameter has no options configured${colors_1.Colors.Reset}
+`,
+              value: undefined
+            };
+          }
+          const foundValue = options?.filter((x) => x === value);
+          if (foundValue?.length === 0) {
+            return {
+              error: `
+${colors_1.Colors.BgRed}${colors_1.Colors.FgWhite} ERROR ${colors_1.Colors.Reset} ${colors_1.Colors.FgRed}Invalid option: '${colors_1.Colors.Bright}${value}${colors_1.Colors.Reset}${colors_1.Colors.FgRed}'${colors_1.Colors.Reset}
+${colors_1.Colors.FgGray}       Available options: ${options?.join(", ")}${colors_1.Colors.Reset}
+`,
+              value: undefined
+            };
+          }
+          return { value };
+        }
+        case interfaces_1.ParamType.Boolean:
+          if (value.toLowerCase() !== "true" && value.toLowerCase() !== "false") {
+            return {
+              error: `
+${colors_1.Colors.BgRed}${colors_1.Colors.FgWhite} ERROR ${colors_1.Colors.Reset} ${colors_1.Colors.FgRed}Invalid boolean: '${colors_1.Colors.Bright}${value}${colors_1.Colors.Reset}${colors_1.Colors.FgRed}'${colors_1.Colors.Reset}
+${colors_1.Colors.FgGray}       Expected: 'true' or 'false'${colors_1.Colors.Reset}
+`
+            };
+          }
+          return { value: value.toLowerCase() === "true" };
+        case interfaces_1.ParamType.Email:
+          if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) {
+            return {
+              error: `
+${colors_1.Colors.BgRed}${colors_1.Colors.FgWhite} ERROR ${colors_1.Colors.Reset} ${colors_1.Colors.FgRed}Invalid email format: '${colors_1.Colors.Bright}${value}${colors_1.Colors.Reset}${colors_1.Colors.FgRed}'${colors_1.Colors.Reset}
+${colors_1.Colors.FgGray}       Expected: user@domain.com${colors_1.Colors.Reset}
+`
+            };
+          }
+          return { value };
+        case interfaces_1.ParamType.Url:
+          if (!/^https?:\/\/.+$/.test(value)) {
+            return {
+              error: `
+${colors_1.Colors.BgRed}${colors_1.Colors.FgWhite} ERROR ${colors_1.Colors.Reset} ${colors_1.Colors.FgRed}Invalid URL format: '${colors_1.Colors.Bright}${value}${colors_1.Colors.Reset}${colors_1.Colors.FgRed}'${colors_1.Colors.Reset}
+${colors_1.Colors.FgGray}       Expected: https://example.com or http://example.com${colors_1.Colors.Reset}
+`
+            };
+          }
+          return { value };
+        case interfaces_1.ParamType.Package:
+          if (!/^@[a-zA-Z0-9-]+\/[a-zA-Z0-9-]+$/.test(value)) {
+            return {
+              error: `
+${colors_1.Colors.BgRed}${colors_1.Colors.FgWhite} ERROR ${colors_1.Colors.Reset} ${colors_1.Colors.FgRed}Invalid package format: '${colors_1.Colors.Bright}${value}${colors_1.Colors.Reset}${colors_1.Colors.FgRed}'${colors_1.Colors.Reset}
+${colors_1.Colors.FgGray}       Expected: @company/package-name${colors_1.Colors.Reset}
+`
+            };
+          }
+          return { value };
+        case interfaces_1.ParamType.Password:
+          if (this.checkEmpty(value) && isRequired) {
+            return {
+              error: `
+${colors_1.Colors.BgRed}${colors_1.Colors.FgWhite} ERROR ${colors_1.Colors.Reset} ${colors_1.Colors.FgRed}Password cannot be empty${colors_1.Colors.Reset}
+`
+            };
+          }
+          return { value };
+        default:
+          return { value };
+      }
+    }
+    checkEmpty(value) {
+      return value === undefined || value === "" || value === null;
+    }
+  }
+  exports2.Validator = Validator;
+});
+
+// node_modules/@ideascol/cli-maker/dist/setup.js
+var require_setup = __commonJS((exports2) => {
+  var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+  Object.defineProperty(exports2, "__esModule", { value: true });
+  exports2.createSetupCommand = createSetupCommand;
+  exports2.loadSetupConfig = loadSetupConfig;
+  exports2.getRawConfig = getRawConfig;
+  exports2.getConfigValue = getConfigValue;
+  exports2.hiddenPrompt = hiddenPrompt;
+  exports2.prompt = prompt;
+  var fs_1 = __importDefault(require("fs"));
+  var path_1 = __importDefault(require("path"));
+  var readline_1 = __importDefault(require("readline"));
+  var crypto_1 = __importDefault(require("crypto"));
+  var os_1 = __importDefault(require("os"));
+  var colors_1 = require_colors();
+  var interfaces_1 = require_interfaces();
+  var validator_1 = require_validator();
+  function createSetupCommand(cliName, options) {
+    const commandName = options.name || "setup";
+    const description = options.description || "Configure CLI defaults";
+    const validator = new validator_1.Validator;
+    const configFile = buildConfigPath(cliName, options.configFileName);
+    return {
+      name: commandName,
+      description,
+      params: [
+        {
+          name: "interactive",
+          description: "Select a single config option to setup interactively",
+          required: false,
+          type: interfaces_1.ParamType.Boolean
+        }
+      ],
+      action: async (args) => {
+        let passphrase;
+        let existingConfig = {};
+        const hasExistingConfig = fs_1.default.existsSync(configFile);
+        let hasEncryptedFields = false;
+        if (hasExistingConfig) {
+          try {
+            const rawConfig = JSON.parse(fs_1.default.readFileSync(configFile, "utf-8"));
+            hasEncryptedFields = Object.values(rawConfig).some((value) => value && typeof value === "object" && (value.__enc || value.__b64));
+          } catch {}
+        }
+        if (hasEncryptedFields || options.encryption?.enabled) {
+          if (hasEncryptedFields) {
+            let validPassphrase = false;
+            while (!validPassphrase) {
+              passphrase = await askPassphrase(options.encryption?.prompt || "Passphrase to decrypt existing config");
+              if (!passphrase) {
+                console.log(`${colors_1.Colors.Error}❌ Passphrase is required to modify encrypted configuration.${colors_1.Colors.Reset}
+`);
+                return;
+              }
+              const testConfig = loadConfig(configFile, options.steps, passphrase);
+              const rawConfig = JSON.parse(fs_1.default.readFileSync(configFile, "utf-8"));
+              const encryptedKeys = Object.keys(rawConfig).filter((key) => {
+                const value = rawConfig[key];
+                return value && typeof value === "object" && (value.__enc || value.__b64);
+              });
+              if (encryptedKeys.length > 0) {
+                const successfullyDecrypted = encryptedKeys.some((key) => testConfig[key] !== undefined && typeof testConfig[key] === "string");
+                if (successfullyDecrypted) {
+                  validPassphrase = true;
+                  existingConfig = testConfig;
+                } else {
+                  console.log(`${colors_1.Colors.Error}❌ Invalid passphrase. Please try again.${colors_1.Colors.Reset}
+`);
+                }
+              } else {
+                validPassphrase = true;
+                existingConfig = testConfig;
+              }
+            }
+          } else {
+            passphrase = await askPassphrase(options.encryption?.prompt || "Passphrase for encryption (not stored)");
+            if (!passphrase) {
+              console.log(`${colors_1.Colors.Error}❌ Passphrase is required for encrypted configuration.${colors_1.Colors.Reset}
+`);
+              return;
+            }
+          }
+        } else {
+          existingConfig = loadConfig(configFile, options.steps, passphrase);
+        }
+        const answers = { ...existingConfig };
+        if (args?.interactive === true) {
+          console.log(`
+${colors_1.Colors.BgBlue}${colors_1.Colors.FgWhite} SETUP ${colors_1.Colors.Reset} ${colors_1.Colors.FgBlue}Select a configuration to setup${colors_1.Colors.Reset}
+`);
+          const selectedStep = await selectSingleConfigStep(options.steps, existingConfig);
+          if (selectedStep) {
+            const value = await askForStep(selectedStep, answers[selectedStep.name], validator);
+            if (value !== undefined) {
+              answers[selectedStep.name] = value;
+            }
+            ensureDir(path_1.default.dirname(configFile));
+            const encoded = encodePasswords(options.steps, answers, passphrase);
+            fs_1.default.writeFileSync(configFile, JSON.stringify(encoded, null, 2), "utf-8");
+            console.log(`
+${colors_1.Colors.Success}✅ Config '${selectedStep.name}' updated in ${configFile}${colors_1.Colors.Reset}
+`);
+          } else {
+            console.log(`
+${colors_1.Colors.Warning}Setup cancelled.${colors_1.Colors.Reset}
+`);
+          }
+        } else {
+          console.log(`
+${colors_1.Colors.BgBlue}${colors_1.Colors.FgWhite} SETUP ${colors_1.Colors.Reset} ${colors_1.Colors.FgBlue}Configure your CLI step by step${colors_1.Colors.Reset}
+`);
+          for (const step of options.steps) {
+            const value = await askForStep(step, answers[step.name], validator);
+            if (value !== undefined) {
+              answers[step.name] = value;
+            }
+          }
+          ensureDir(path_1.default.dirname(configFile));
+          const encoded = encodePasswords(options.steps, answers, passphrase);
+          fs_1.default.writeFileSync(configFile, JSON.stringify(encoded, null, 2), "utf-8");
+          console.log(`
+${colors_1.Colors.Success}✅ Config stored in ${configFile}${colors_1.Colors.Reset}
+`);
+        }
+        if (options.onComplete) {
+          options.onComplete(answers);
+        }
+      }
+    };
+  }
+  function loadSetupConfig(cliName, steps, options) {
+    const configFile = buildConfigPath(cliName, options?.configFileName);
+    return loadConfig(configFile, steps, options?.passphrase);
+  }
+  function getRawConfig(cliName, options) {
+    const configFile = buildConfigPath(cliName, options?.configFileName);
+    try {
+      if (fs_1.default.existsSync(configFile)) {
+        return JSON.parse(fs_1.default.readFileSync(configFile, "utf-8"));
       }
-      switch (type) {
-        case interfaces_1.ParamType.Number:
-          if (!/^[0-9]+$/.test(value)) {
-            return { error: `${colors_1.Colors.FgRed}Invalid number:${colors_1.Colors.Reset} ${value}` };
-          }
-          return { value: Number(value) };
-        case interfaces_1.ParamType.Custom:
-          try {
-            const customValue = JSON.parse(value);
-            if (Array.isArray(customValue) || typeof customValue === "object") {
-              return { value: customValue };
+    } catch {}
+    return {};
+  }
+  function getConfigValue(cliName, key, options) {
+    const config = getRawConfig(cliName, options);
+    return config[key];
+  }
+  function buildConfigPath(cliName, customName) {
+    const safeName = (customName || `${cliName}-config.json`).replace(/[^a-z0-9._-]/gi, "-");
+    const home = os_1.default.homedir();
+    return path_1.default.join(home, ".cli-maker", safeName);
+  }
+  function loadConfig(file, steps, passphrase) {
+    try {
+      if (fs_1.default.existsSync(file)) {
+        const raw = JSON.parse(fs_1.default.readFileSync(file, "utf-8"));
+        return decodePasswords(steps, raw, passphrase);
+      }
+    } catch {}
+    return {};
+  }
+  function ensureDir(dir) {
+    fs_1.default.mkdirSync(dir, { recursive: true });
+  }
+  async function askForStep(step, existing, validator) {
+    let rl = readline_1.default.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
+    const label = `${colors_1.Colors.Bright}${step.name}${colors_1.Colors.Reset} ${colors_1.Colors.FgGray}(${step.description})${colors_1.Colors.Reset}`;
+    console.log(label);
+    if (step.options && step.options.length > 0) {
+      console.log(`${colors_1.Colors.FgGray}Opciones: ${step.options.join(", ")}${colors_1.Colors.Reset}`);
+    }
+    if (existing !== undefined) {
+      const display = step.type === interfaces_1.ParamType.Password ? "********" : existing;
+      console.log(`${colors_1.Colors.FgYellow}Actual value:${colors_1.Colors.Reset} ${display}`);
+    } else if (step.defaultValue !== undefined) {
+      const displayDefault = step.type === interfaces_1.ParamType.Password ? "********" : step.defaultValue;
+      console.log(`${colors_1.Colors.FgYellow}Default value:${colors_1.Colors.Reset} ${displayDefault}`);
+    }
+    let finalValue;
+    let done = false;
+    while (!done) {
+      if (step.type === interfaces_1.ParamType.List && step.options && step.options.length > 0) {
+        const chosen = await askListOption(step, rl);
+        finalValue = step.options[chosen];
+        done = true;
+      } else {
+        const prompt2 = `${colors_1.Colors.FgGreen}>${colors_1.Colors.Reset} `;
+        let input;
+        if (step.type === interfaces_1.ParamType.Password) {
+          rl.close();
+          input = await readHiddenInput(prompt2);
+          rl = readline_1.default.createInterface({ input: process.stdin, output: process.stdout });
+        } else {
+          input = await ask(prompt2);
+        }
+        const candidateRaw = input === "" ? existing ?? step.defaultValue ?? "" : input;
+        const candidate = typeof candidateRaw === "boolean" ? String(candidateRaw) : candidateRaw;
+        const validation = validator.validateParam(candidate, step.type, step.required, step.options, step.name);
+        if (validation.error) {
+          console.log(validation.error);
+        } else {
+          finalValue = validation.value;
+          done = true;
+        }
+      }
+    }
+    rl.close();
+    return finalValue;
+  }
+  async function selectSingleConfigStep(steps, existingConfig) {
+    console.log(`${colors_1.Colors.FgYellow}Available configuration options:${colors_1.Colors.Reset}
+`);
+    console.log(`${colors_1.Colors.FgGray}Use ↑/↓ arrows to navigate, Enter to select, or 'q' to cancel${colors_1.Colors.Reset}
+`);
+    const options = [...steps, { name: "Cancel", description: "Exit setup", type: interfaces_1.ParamType.Text }];
+    let selectedIndex = 0;
+    const renderMenu = () => {
+      process.stdout.write("\x1B[2J\x1B[H");
+      console.log(`${colors_1.Colors.FgYellow}Available configuration options:${colors_1.Colors.Reset}
+`);
+      console.log(`${colors_1.Colors.FgGray}Use ↑/↓ arrows to navigate, Enter to select, or 'q' to cancel${colors_1.Colors.Reset}
+`);
+      options.forEach((option, idx) => {
+        const isSelected = idx === selectedIndex;
+        const prefix = isSelected ? `${colors_1.Colors.BgBlue}${colors_1.Colors.FgWhite} ▶ ${colors_1.Colors.Reset}` : "   ";
+        if (idx < steps.length) {
+          const step = steps[idx];
+          const hasValue = existingConfig[step.name] !== undefined;
+          const statusIcon = hasValue ? `${colors_1.Colors.FgGreen}✓${colors_1.Colors.Reset}` : `${colors_1.Colors.FgGray}○${colors_1.Colors.Reset}`;
+          const valueDisplay = hasValue ? step.type === interfaces_1.ParamType.Password ? " (configured)" : ` (${existingConfig[step.name]})` : " (not set)";
+          const highlight = isSelected ? `${colors_1.Colors.BgBlue}${colors_1.Colors.FgWhite}` : "";
+          const resetColor = isSelected ? `${colors_1.Colors.Reset}` : "";
+          console.log(`${prefix}${highlight}${statusIcon} ${colors_1.Colors.Bright}${step.name}${colors_1.Colors.Reset}${highlight} - ${step.description}${colors_1.Colors.FgGray}${valueDisplay}${resetColor}${colors_1.Colors.Reset}`);
+        } else {
+          const highlight = isSelected ? `${colors_1.Colors.BgRed}${colors_1.Colors.FgWhite}` : `${colors_1.Colors.FgRed}`;
+          const resetColor = isSelected ? `${colors_1.Colors.Reset}` : `${colors_1.Colors.Reset}`;
+          console.log(`${prefix}${highlight}Cancel${resetColor}`);
+        }
+      });
+      console.log(`
+${colors_1.Colors.FgGray}Selected: ${options[selectedIndex].name}${colors_1.Colors.Reset}`);
+    };
+    return new Promise((resolve) => {
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+      process.stdin.setEncoding("utf8");
+      renderMenu();
+      const onKeyPress = (key) => {
+        switch (key) {
+          case "\x1B[A":
+            selectedIndex = selectedIndex > 0 ? selectedIndex - 1 : options.length - 1;
+            renderMenu();
+            break;
+          case "\x1B[B":
+            selectedIndex = selectedIndex < options.length - 1 ? selectedIndex + 1 : 0;
+            renderMenu();
+            break;
+          case "\r":
+            process.stdin.setRawMode(false);
+            process.stdin.removeListener("data", onKeyPress);
+            process.stdin.pause();
+            if (selectedIndex === steps.length) {
+              resolve(null);
             } else {
-              return { error: `${colors_1.Colors.FgRed}Invalid custom value:${colors_1.Colors.Reset} ${value}` };
+              resolve(steps[selectedIndex]);
             }
+            break;
+          case "q":
+          case "Q":
+          case "\x03":
+            process.stdin.setRawMode(false);
+            process.stdin.removeListener("data", onKeyPress);
+            process.stdin.pause();
+            resolve(null);
+            break;
+          default:
+            break;
+        }
+      };
+      process.stdin.on("data", onKeyPress);
+    });
+  }
+  async function askListOption(step, rl) {
+    const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
+    step.options = step.options || [];
+    step.options.forEach((opt, idx) => {
+      console.log(`  ${colors_1.Colors.FgCyan}${idx + 1}.${colors_1.Colors.Reset} ${opt}`);
+    });
+    let selected = -1;
+    while (selected < 0 || selected >= step.options.length) {
+      const answer = await ask(`${colors_1.Colors.FgGreen}Select option (1-${step.options.length}):${colors_1.Colors.Reset} `);
+      const num = parseInt(answer, 10);
+      if (!isNaN(num) && num >= 1 && num <= step.options.length) {
+        selected = num - 1;
+      } else {
+        console.log(`${colors_1.Colors.Warning}Invalid option.${colors_1.Colors.Reset}`);
+      }
+    }
+    return selected;
+  }
+  function encodePasswords(steps, data, passphrase) {
+    const result = { ...data };
+    steps.forEach((step) => {
+      if (step.type === interfaces_1.ParamType.Password && result[step.name] !== undefined) {
+        const str = String(result[step.name]);
+        if (passphrase) {
+          result[step.name] = encryptWithPassphrase(str, passphrase);
+        } else {
+          result[step.name] = { __b64: true, value: Buffer.from(str, "utf-8").toString("base64") };
+        }
+      }
+    });
+    return result;
+  }
+  function decodePasswords(steps, data, passphrase) {
+    const result = { ...data };
+    steps.forEach((step) => {
+      const value = result[step.name];
+      if (step.type === interfaces_1.ParamType.Password && value && typeof value === "object") {
+        if (value.__enc && value.data && passphrase) {
+          const decrypted = decryptWithPassphrase(value, passphrase);
+          result[step.name] = decrypted;
+        } else if (value.__b64 && value.value) {
+          try {
+            result[step.name] = Buffer.from(value.value, "base64").toString("utf-8");
           } catch {
-            return { error: `${colors_1.Colors.FgRed}Invalid custom value:${colors_1.Colors.Reset} ${value}` };
+            result[step.name] = undefined;
           }
-        case interfaces_1.ParamType.List:
-          if (options === undefined || options?.length === 0) {
-            return { error: `${colors_1.Colors.FgRed}Invalid List:${colors_1.Colors.Reset} empty options`, value: undefined };
+        }
+      }
+    });
+    return result;
+  }
+  async function hiddenPrompt(prompt2) {
+    return readHiddenInput(prompt2);
+  }
+  async function prompt(question) {
+    return new Promise((resolve) => {
+      const rl = readline_1.default.createInterface({ input: process.stdin, output: process.stdout });
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve(answer);
+      });
+    });
+  }
+  async function readHiddenInput(prompt2) {
+    return new Promise((resolve) => {
+      const stdin = process.stdin;
+      const stdout = process.stdout;
+      stdout.write(prompt2);
+      const onData = (char) => {
+        const key = char.toString();
+        if (key === `
+` || key === "\r" || key === "\x04") {
+          stdout.write(`
+`);
+          stdin.removeListener("data", onData);
+          if (stdin.isTTY)
+            stdin.setRawMode(false);
+          stdin.pause();
+          resolve(buffer);
+        } else if (key === "\x03") {
+          stdin.removeListener("data", onData);
+          if (stdin.isTTY)
+            stdin.setRawMode(false);
+          stdin.pause();
+          process.exit(0);
+        } else if (key === "" || key === "\b") {
+          if (buffer.length > 0) {
+            buffer = buffer.slice(0, -1);
+            stdout.write("\b \b");
           }
-          const foundValue = options?.filter((x) => x === value);
-          if (foundValue?.length === 0) {
-            return { error: `${colors_1.Colors.FgRed}Invalid List:${colors_1.Colors.Reset} ${value} doesn't exists`, value: undefined };
+        } else {
+          const printableChars = key.split("").filter((c) => c >= " " && c <= "~").join("");
+          if (printableChars.length > 0) {
+            buffer += printableChars;
+            stdout.write("*".repeat(printableChars.length));
           }
-          return { value };
-        case interfaces_1.ParamType.Boolean:
-          if (value.toLowerCase() !== "true" && value.toLowerCase() !== "false") {
-            return { error: `${colors_1.Colors.FgRed}Invalid boolean:${colors_1.Colors.Reset} ${value}` };
+        }
+      };
+      let buffer = "";
+      stdin.resume();
+      if (stdin.isTTY) {
+        stdin.setRawMode(true);
+      }
+      stdin.on("data", onData);
+    });
+  }
+  function encryptWithPassphrase(plain, passphrase) {
+    const salt = crypto_1.default.randomBytes(16);
+    const iv = crypto_1.default.randomBytes(12);
+    const key = crypto_1.default.pbkdf2Sync(passphrase, salt, 120000, 32, "sha256");
+    const cipher = crypto_1.default.createCipheriv("aes-256-gcm", key, iv);
+    const encrypted = Buffer.concat([cipher.update(plain, "utf8"), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return {
+      __enc: true,
+      alg: "aes-256-gcm",
+      iv: iv.toString("base64"),
+      salt: salt.toString("base64"),
+      tag: tag.toString("base64"),
+      data: encrypted.toString("base64")
+    };
+  }
+  function decryptWithPassphrase(payload, passphrase) {
+    try {
+      const salt = Buffer.from(payload.salt, "base64");
+      const iv = Buffer.from(payload.iv, "base64");
+      const tag = Buffer.from(payload.tag, "base64");
+      const data = Buffer.from(payload.data, "base64");
+      const key = crypto_1.default.pbkdf2Sync(passphrase, salt, 120000, 32, "sha256");
+      const decipher = crypto_1.default.createDecipheriv("aes-256-gcm", key, iv);
+      decipher.setAuthTag(tag);
+      const decrypted = Buffer.concat([decipher.update(data), decipher.final()]);
+      return decrypted.toString("utf8");
+    } catch {
+      return;
+    }
+  }
+  async function askPassphrase(promptText) {
+    const pass = await readHiddenInput(`${colors_1.Colors.FgCyan}${promptText}:${colors_1.Colors.Reset} `);
+    return pass || undefined;
+  }
+});
+
+// node_modules/@ideascol/cli-maker/dist/rotate-passphrase.js
+var require_rotate_passphrase = __commonJS((exports2) => {
+  var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+  Object.defineProperty(exports2, "__esModule", { value: true });
+  exports2.createRotatePassphraseCommand = createRotatePassphraseCommand;
+  var interfaces_1 = require_interfaces();
+  var colors_1 = require_colors();
+  var setup_1 = require_setup();
+  var fs_1 = __importDefault(require("fs"));
+  var path_1 = __importDefault(require("path"));
+  var os_1 = __importDefault(require("os"));
+  var crypto_1 = __importDefault(require("crypto"));
+  function createRotatePassphraseCommand(cliName) {
+    return {
+      name: "rotate-passphrase",
+      description: "Rotate the passphrase used to encrypt configuration values",
+      params: [
+        {
+          name: "config-file",
+          description: "Specific config file to rotate passphrase for (optional)",
+          required: false,
+          type: interfaces_1.ParamType.Text
+        },
+        {
+          name: "create-backup",
+          description: "Create backup file before rotation (less secure but allows recovery)",
+          required: false,
+          type: interfaces_1.ParamType.Boolean
+        },
+        {
+          name: "secure-delete-backup",
+          description: "Securely delete backup after successful rotation (only works with --create-backup)",
+          required: false,
+          type: interfaces_1.ParamType.Boolean
+        }
+      ],
+      action: async (args) => {
+        const configFileName = args["config-file"];
+        console.log(`
+${colors_1.Colors.BgYellow}${colors_1.Colors.FgBlack} ROTATE PASSPHRASE ${colors_1.Colors.Reset} ${colors_1.Colors.FgYellow}Updating encryption passphrase${colors_1.Colors.Reset}
+`);
+        const configFile = buildConfigPath(cliName, configFileName);
+        if (!fs_1.default.existsSync(configFile)) {
+          console.log(`${colors_1.Colors.Error}❌ Config file not found: ${configFile}${colors_1.Colors.Reset}
+`);
+          console.log(`${colors_1.Colors.FgGray}Run the setup command first to create a configuration.${colors_1.Colors.Reset}
+`);
+          return;
+        }
+        const rawConfig = JSON.parse(fs_1.default.readFileSync(configFile, "utf-8"));
+        const hasEncryptedFields = Object.values(rawConfig).some((value) => value && typeof value === "object" && (value.__enc || value.__b64));
+        if (!hasEncryptedFields) {
+          console.log(`${colors_1.Colors.Warning}⚠️  No encrypted fields found in config file.${colors_1.Colors.Reset}
+`);
+          console.log(`${colors_1.Colors.FgGray}The configuration doesn't contain any password fields that require encryption.${colors_1.Colors.Reset}
+`);
+          return;
+        }
+        try {
+          console.log(`${colors_1.Colors.FgCyan}Enter current passphrase to decrypt existing configuration:${colors_1.Colors.Reset}`);
+          const currentPassphrase = await (0, setup_1.hiddenPrompt)("Current passphrase: ");
+          if (!currentPassphrase) {
+            console.log(`${colors_1.Colors.Error}❌ Current passphrase is required.${colors_1.Colors.Reset}
+`);
+            return;
           }
-          return { value: value.toLowerCase() === "true" };
-        case interfaces_1.ParamType.Email:
-          if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) {
-            return { error: `${colors_1.Colors.FgRed}Invalid email:${colors_1.Colors.Reset} ${value}` };
+          const decryptedConfig = await tryDecryptConfig(rawConfig, currentPassphrase);
+          if (!decryptedConfig) {
+            console.log(`${colors_1.Colors.Error}❌ Invalid current passphrase. Unable to decrypt configuration.${colors_1.Colors.Reset}
+`);
+            return;
           }
-          return { value };
-        case interfaces_1.ParamType.Url:
-          if (!/^https?:\/\/.+$/.test(value)) {
-            return { error: `${colors_1.Colors.FgRed}Invalid URL:${colors_1.Colors.Reset} ${value}` };
+          console.log(`
+${colors_1.Colors.FgCyan}Enter new passphrase for encryption:${colors_1.Colors.Reset}`);
+          const newPassphrase = await (0, setup_1.hiddenPrompt)("New passphrase: ");
+          if (!newPassphrase) {
+            console.log(`${colors_1.Colors.Error}❌ New passphrase is required.${colors_1.Colors.Reset}
+`);
+            return;
           }
-          return { value };
-        case interfaces_1.ParamType.Package:
-          if (!/^@[a-zA-Z0-9-]+\/[a-zA-Z0-9-]+$/.test(value)) {
-            return { error: `${colors_1.Colors.FgRed}the format of the package is not correct, @company/package-name${colors_1.Colors.Reset}` };
+          if (newPassphrase === currentPassphrase) {
+            console.log(`${colors_1.Colors.Warning}⚠️  New passphrase is the same as current passphrase.${colors_1.Colors.Reset}
+`);
+            return;
           }
-          return { value };
-        default:
-          return { value };
+          console.log(`${colors_1.Colors.FgCyan}Confirm new passphrase:${colors_1.Colors.Reset}`);
+          const confirmPassphrase = await (0, setup_1.hiddenPrompt)("Confirm new passphrase: ");
+          if (newPassphrase !== confirmPassphrase) {
+            console.log(`${colors_1.Colors.Error}❌ Passphrases do not match.${colors_1.Colors.Reset}
+`);
+            return;
+          }
+          const reencryptedConfig = reencryptConfig(rawConfig, decryptedConfig, newPassphrase);
+          let backupFile = null;
+          if (args["create-backup"]) {
+            backupFile = `${configFile}.backup.${Date.now()}`;
+            fs_1.default.copyFileSync(configFile, backupFile);
+            console.log(`${colors_1.Colors.FgGray}\uD83D\uDCC1 Backup created: ${backupFile}${colors_1.Colors.Reset}`);
+            if (args["secure-delete-backup"]) {
+              console.log(`${colors_1.Colors.FgYellow}⚠️  Backup will be securely deleted after successful rotation.${colors_1.Colors.Reset}`);
+            }
+          } else {
+            console.log(`${colors_1.Colors.FgGreen}\uD83D\uDD12 No backup created (secure by default).${colors_1.Colors.Reset}`);
+            if (args["secure-delete-backup"]) {
+              console.log(`${colors_1.Colors.FgYellow}⚠️  --secure-delete-backup ignored (no backup created).${colors_1.Colors.Reset}`);
+            }
+          }
+          fs_1.default.writeFileSync(configFile, JSON.stringify(reencryptedConfig, null, 2), "utf-8");
+          if (backupFile && args["secure-delete-backup"]) {
+            try {
+              secureDeleteFile(backupFile);
+              console.log(`${colors_1.Colors.FgGray}\uD83D\uDDD1️  Backup securely deleted.${colors_1.Colors.Reset}`);
+            } catch (error) {
+              console.log(`${colors_1.Colors.Warning}⚠️  Warning: Could not securely delete backup file: ${backupFile}${colors_1.Colors.Reset}`);
+              console.log(`${colors_1.Colors.FgGray}Please manually delete it: rm "${backupFile}"${colors_1.Colors.Reset}`);
+            }
+          }
+          console.log(`
+${colors_1.Colors.Success}✅ Passphrase rotated successfully!${colors_1.Colors.Reset}`);
+          console.log(`${colors_1.Colors.FgGray}Configuration file: ${configFile}${colors_1.Colors.Reset}`);
+          console.log(`${colors_1.Colors.FgGray}All encrypted fields have been re-encrypted with the new passphrase.${colors_1.Colors.Reset}`);
+          if (backupFile && !args["secure-delete-backup"]) {
+            console.log(`${colors_1.Colors.FgYellow}⚠️  Security reminder: Backup file contains old passphrase encryption.${colors_1.Colors.Reset}`);
+            console.log(`${colors_1.Colors.FgGray}Consider deleting it manually: rm "${backupFile}"${colors_1.Colors.Reset}`);
+          }
+          console.log("");
+        } catch (error) {
+          console.log(`${colors_1.Colors.Error}❌ Error rotating passphrase: ${error instanceof Error ? error.message : "Unknown error"}${colors_1.Colors.Reset}
+`);
+        }
+      }
+    };
+  }
+  function buildConfigPath(cliName, customName) {
+    const safeName = (customName || `${cliName}-config.json`).replace(/[^a-z0-9._-]/gi, "-");
+    const home = os_1.default.homedir();
+    return path_1.default.join(home, ".cli-maker", safeName);
+  }
+  async function tryDecryptConfig(rawConfig, passphrase) {
+    try {
+      const decrypted = { ...rawConfig };
+      for (const [key, value] of Object.entries(rawConfig)) {
+        if (value && typeof value === "object") {
+          if (value.__enc && value.data) {
+            const decryptedValue = decryptWithPassphrase(value, passphrase);
+            if (decryptedValue === undefined) {
+              return null;
+            }
+            decrypted[key] = decryptedValue;
+          } else if (value.__b64 && value.value) {
+            try {
+              decrypted[key] = Buffer.from(value.value, "base64").toString("utf-8");
+            } catch {
+              decrypted[key] = undefined;
+            }
+          }
+        }
       }
+      return decrypted;
+    } catch {
+      return null;
     }
-    checkEmpty(value) {
-      return value === undefined || value === "" || value === null;
+  }
+  function reencryptConfig(rawConfig, decryptedConfig, newPassphrase) {
+    const reencrypted = { ...rawConfig };
+    for (const [key, value] of Object.entries(rawConfig)) {
+      if (value && typeof value === "object" && (value.__enc || value.__b64)) {
+        const decryptedValue = decryptedConfig[key];
+        if (typeof decryptedValue === "string") {
+          reencrypted[key] = encryptWithPassphrase(decryptedValue, newPassphrase);
+        }
+      }
+    }
+    return reencrypted;
+  }
+  function encryptWithPassphrase(plain, passphrase) {
+    const salt = crypto_1.default.randomBytes(16);
+    const iv = crypto_1.default.randomBytes(12);
+    const key = crypto_1.default.pbkdf2Sync(passphrase, salt, 120000, 32, "sha256");
+    const cipher = crypto_1.default.createCipheriv("aes-256-gcm", key, iv);
+    const encrypted = Buffer.concat([cipher.update(plain, "utf8"), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return {
+      __enc: true,
+      alg: "aes-256-gcm",
+      iv: iv.toString("base64"),
+      salt: salt.toString("base64"),
+      tag: tag.toString("base64"),
+      data: encrypted.toString("base64")
+    };
+  }
+  function decryptWithPassphrase(payload, passphrase) {
+    try {
+      const salt = Buffer.from(payload.salt, "base64");
+      const iv = Buffer.from(payload.iv, "base64");
+      const tag = Buffer.from(payload.tag, "base64");
+      const data = Buffer.from(payload.data, "base64");
+      const key = crypto_1.default.pbkdf2Sync(passphrase, salt, 120000, 32, "sha256");
+      const decipher = crypto_1.default.createDecipheriv("aes-256-gcm", key, iv);
+      decipher.setAuthTag(tag);
+      const decrypted = Buffer.concat([decipher.update(data), decipher.final()]);
+      return decrypted.toString("utf8");
+    } catch {
+      return;
+    }
+  }
+  function secureDeleteFile(filePath) {
+    try {
+      const stats = fs_1.default.statSync(filePath);
+      const fileSize = stats.size;
+      const passes = 3;
+      for (let i = 0;i < passes; i++) {
+        const randomData = crypto_1.default.randomBytes(fileSize);
+        fs_1.default.writeFileSync(filePath, randomData);
+        fs_1.default.fsyncSync(fs_1.default.openSync(filePath, "r+"));
+      }
+      const zeroData = Buffer.alloc(fileSize, 0);
+      fs_1.default.writeFileSync(filePath, zeroData);
+      fs_1.default.fsyncSync(fs_1.default.openSync(filePath, "r+"));
+      fs_1.default.unlinkSync(filePath);
+    } catch (error) {
+      throw new Error(`Failed to securely delete file: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
   }
-  exports2.Validator = Validator;
 });
 
 // node_modules/@ideascol/cli-maker/dist/command/command.js
@@ -195,9 +2048,152 @@ var require_command = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", { value: true });
   exports2.CLI = undefined;
   var readline_1 = __importDefault(require("readline"));
+  var fs_1 = __importDefault(require("fs"));
+  var path_1 = __importDefault(require("path"));
+  var os_1 = __importDefault(require("os"));
   var colors_1 = require_colors();
   var interfaces_1 = require_interfaces();
+  var session_1 = require_session();
   var validator_1 = require_validator();
+  var common_1 = require_common();
+  var setup_1 = require_setup();
+  var rotate_passphrase_1 = require_rotate_passphrase();
+  function generatePixelAsciiArt(text) {
+    const font = {
+      A: ["███", "█ █", "███", "█ █", "█ █"],
+      B: ["██ ", "█ █", "██ ", "█ █", "██ "],
+      C: ["███", "█  ", "█  ", "█  ", "███"],
+      D: ["██ ", "█ █", "█ █", "█ █", "██ "],
+      E: ["███", "█  ", "██ ", "█  ", "███"],
+      F: ["███", "█  ", "██ ", "█  ", "█  "],
+      G: ["███", "█  ", "█ █", "█ █", "███"],
+      H: ["█ █", "█ █", "███", "█ █", "█ █"],
+      I: ["███", " █ ", " █ ", " █ ", "███"],
+      J: ["███", "  █", "  █", "█ █", "███"],
+      K: ["█ █", "██ ", "█  ", "██ ", "█ █"],
+      L: ["█  ", "█  ", "█  ", "█  ", "███"],
+      M: ["█ █", "███", "███", "█ █", "█ █"],
+      N: ["█ █", "███", "███", "███", "█ █"],
+      O: ["███", "█ █", "█ █", "█ █", "███"],
+      P: ["██ ", "█ █", "██ ", "█  ", "█  "],
+      Q: ["███", "█ █", "█ █", "███", "  █"],
+      R: ["██ ", "█ █", "██ ", "█ █", "█ █"],
+      S: ["███", "█  ", "███", "  █", "███"],
+      T: ["███", " █ ", " █ ", " █ ", " █ "],
+      U: ["█ █", "█ █", "█ █", "█ █", "███"],
+      V: ["█ █", "█ █", "█ █", "█ █", " █ "],
+      W: ["█ █", "█ █", "███", "███", "█ █"],
+      X: ["█ █", "█ █", " █ ", "█ █", "█ █"],
+      Y: ["█ █", "█ █", " █ ", " █ ", " █ "],
+      Z: ["███", "  █", " █ ", "█  ", "███"],
+      "-": ["   ", "   ", "███", "   ", "   "],
+      " ": ["   ", "   ", "   ", "   ", "   "],
+      "0": ["███", "█ █", "█ █", "█ █", "███"],
+      "1": [" █ ", "██ ", " █ ", " █ ", "███"],
+      "2": ["██ ", "  █", "███", "█  ", "███"],
+      "3": ["██ ", "  █", "██ ", "  █", "██ "],
+      "4": ["█ █", "█ █", "███", "  █", "  █"],
+      "5": ["███", "█  ", "██ ", "  █", "██ "],
+      "6": ["███", "█  ", "███", "█ █", "███"],
+      "7": ["███", "  █", " █ ", " █ ", " █ "],
+      "8": ["███", "█ █", "███", "█ █", "███"],
+      "9": ["███", "█ █", "███", "  █", "███"]
+    };
+    const upperText = text.toUpperCase();
+    const lines = ["", "", "", "", ""];
+    for (let i = 0;i < upperText.length; i++) {
+      const char = upperText[i];
+      const charLines = font[char] || font[" "];
+      for (let row = 0;row < 5; row++) {
+        lines[row] += charLines[row] + " ";
+      }
+    }
+    return lines.map((line) => line.trimEnd());
+  }
+  var INTRO_PRESETS = {
+    hacker: {
+      frames: ["▌", " ", "▌", " "],
+      padding: 1,
+      speedMs: 120,
+      loops: 2,
+      lines: ["Initializing secure channel..."]
+    },
+    vaporwave: {
+      frames: ["✦", "✺", "✹", "✸"],
+      padding: 2,
+      speedMs: 85,
+      loops: 2,
+      lines: ["Ride the gradient."]
+    },
+    radar: {
+      frames: ["◜", "◠", "◝", "◡"],
+      padding: 2,
+      speedMs: 75,
+      loops: 3,
+      lines: ["Scanning environment..."]
+    },
+    pixel: {
+      frames: ["░", "▒", "▓", "█"],
+      padding: 1,
+      speedMs: 70,
+      loops: 2,
+      lines: ["Booting 8-bit systems..."]
+    },
+    steampunk: {
+      frames: ["⚙︎", "⚙", "⚙︎", "⚙"],
+      padding: 2,
+      speedMs: 90,
+      loops: 2,
+      lines: ["Warming valves..."],
+      asciiArt: [
+        "    ___ ",
+        " __/ o \\__",
+        "|  ⚙   ⚙  |",
+        "‾‾‾‾‾‾‾‾‾‾‾"
+      ]
+    },
+    sonar: {
+      frames: ["◉", "◎", "◉", "◎"],
+      padding: 2,
+      speedMs: 95,
+      loops: 3,
+      lines: ["Ping..."]
+    },
+    "retro-space": {
+      frames: ["=≡>", "⇝◎", "⇢✸", "⇝◎"],
+      padding: 2,
+      speedMs: 90,
+      loops: 3,
+      lines: ["Scanning for lifeforms..."],
+      asciiArt: [
+        "    /\\",
+        "   /::\\",
+        "  /::::\\",
+        "  |/::\\|",
+        "  ‾‾‾‾‾‾"
+      ]
+    },
+    rainbow: {
+      frames: [
+        `${colors_1.Colors.FgRed}◐${colors_1.Colors.Reset}`,
+        `${colors_1.Colors.FgYellow}◐${colors_1.Colors.Reset}`,
+        `${colors_1.Colors.FgGreen}◐${colors_1.Colors.Reset}`,
+        `${colors_1.Colors.FgCyan}◐${colors_1.Colors.Reset}`,
+        `${colors_1.Colors.FgBlue}◐${colors_1.Colors.Reset}`,
+        `${colors_1.Colors.FgMagenta}◐${colors_1.Colors.Reset}`
+      ],
+      padding: 2,
+      speedMs: 70,
+      loops: 2,
+      lines: ["Painting the sky..."],
+      asciiArt: [
+        `${colors_1.Colors.FgRed}╭────────────────────╮${colors_1.Colors.Reset}`,
+        `${colors_1.Colors.FgRed}│${colors_1.Colors.Reset}${colors_1.Colors.FgYellow}████${colors_1.Colors.Reset}${colors_1.Colors.FgGreen}████${colors_1.Colors.Reset}${colors_1.Colors.FgCyan}████${colors_1.Colors.Reset}${colors_1.Colors.FgBlue}████${colors_1.Colors.Reset}${colors_1.Colors.FgMagenta}████${colors_1.Colors.Reset}${colors_1.Colors.FgRed}│${colors_1.Colors.Reset}`,
+        `${colors_1.Colors.FgRed}│${colors_1.Colors.Reset}${colors_1.Colors.FgMagenta}████${colors_1.Colors.Reset}${colors_1.Colors.FgBlue}████${colors_1.Colors.Reset}${colors_1.Colors.FgCyan}████${colors_1.Colors.Reset}${colors_1.Colors.FgGreen}████${colors_1.Colors.Reset}${colors_1.Colors.FgYellow}████${colors_1.Colors.Reset}${colors_1.Colors.FgRed}│${colors_1.Colors.Reset}`,
+        `${colors_1.Colors.FgRed}╰────────────────────╯${colors_1.Colors.Reset}`
+      ]
+    }
+  };
 
   class CLI {
     constructor(name, description, options) {
@@ -206,9 +2202,49 @@ var require_command = __commonJS((exports2) => {
       this.options = options;
       this.commands = [];
       if (this.options == null) {
-        this.options = { interactive: true, version: "1.0.0" };
+        this.options = { interactive: true, version: "1.0.0", branding: true, introAnimation: { enabled: false, showOnce: true } };
+      } else {
+        if (this.options.branding === undefined) {
+          this.options.branding = true;
+        }
+        if (this.options.introAnimation == null) {
+          this.options.introAnimation = { enabled: false, showOnce: true };
+        } else {
+          if (this.options.introAnimation.enabled === undefined) {
+            this.options.introAnimation.enabled = true;
+          }
+          if (this.options.introAnimation.showOnce === undefined) {
+            this.options.introAnimation.showOnce = true;
+          }
+          if (this.options.introAnimation.introMode === undefined) {
+            this.options.introAnimation.introMode = undefined;
+          }
+        }
       }
       this.validator = new validator_1.Validator;
+      this.resolvedIntro = this.resolveIntroOptions(this.options?.introAnimation);
+      const binName = this.getBinName();
+      if (binName) {
+        this.executableName = binName;
+      } else {
+        this.executableName = this.name;
+      }
+      this.commands.push((0, rotate_passphrase_1.createRotatePassphraseCommand)(this.name));
+    }
+    getBinName() {
+      try {
+        const scriptDir = path_1.default.dirname(process.argv[1]);
+        const packageJsonPath = path_1.default.join(scriptDir, "package.json");
+        const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, "utf-8"));
+        const bin = packageJson.bin;
+        if (typeof bin === "string") {
+          return bin;
+        } else if (typeof bin === "object" && bin !== null) {
+          const keys = Object.keys(bin);
+          return keys.length > 0 ? keys[0] : null;
+        }
+      } catch (error) {}
+      return null;
     }
     getCommands() {
       return this.commands;
@@ -225,102 +2261,322 @@ var require_command = __commonJS((exports2) => {
     command(command) {
       this.commands.push(command);
     }
+    setupCommand(options) {
+      this.setupSteps = options.steps;
+      this.setupConfigFileName = options.configFileName;
+      const setupCmd = (0, setup_1.createSetupCommand)(this.name, options);
+      this.commands.push(setupCmd);
+      return this;
+    }
+    async getConfigValue(key, passphrase) {
+      if (!this.setupSteps) {
+        const config = (0, setup_1.getRawConfig)(this.name, { configFileName: this.setupConfigFileName });
+        return config[key];
+      }
+      const step = this.setupSteps.find((s) => s.name === key);
+      const isPasswordField = step?.type === interfaces_1.ParamType.Password;
+      if (isPasswordField) {
+        let actualPassphrase = passphrase;
+        if (!actualPassphrase) {
+          actualPassphrase = process.env.CLI_PASSPHRASE;
+          if (!actualPassphrase) {
+            actualPassphrase = await (0, setup_1.hiddenPrompt)("Passphrase to decrypt: ");
+          }
+        }
+        const config = (0, setup_1.loadSetupConfig)(this.name, this.setupSteps, {
+          passphrase: actualPassphrase,
+          configFileName: this.setupConfigFileName
+        });
+        return config[key];
+      } else {
+        const config = (0, setup_1.getRawConfig)(this.name, { configFileName: this.setupConfigFileName });
+        return config[key];
+      }
+    }
+    async loadConfig(passphrase) {
+      if (!this.setupSteps) {
+        return (0, setup_1.getRawConfig)(this.name, { configFileName: this.setupConfigFileName });
+      }
+      const hasPasswordFields = this.setupSteps.some((s) => s.type === interfaces_1.ParamType.Password);
+      if (hasPasswordFields) {
+        let actualPassphrase = passphrase;
+        if (!actualPassphrase) {
+          actualPassphrase = process.env.CLI_PASSPHRASE;
+          if (!actualPassphrase) {
+            actualPassphrase = await (0, setup_1.hiddenPrompt)("Passphrase to decrypt: ");
+          }
+        }
+        return (0, setup_1.loadSetupConfig)(this.name, this.setupSteps, {
+          passphrase: actualPassphrase,
+          configFileName: this.setupConfigFileName
+        });
+      } else {
+        return (0, setup_1.getRawConfig)(this.name, { configFileName: this.setupConfigFileName });
+      }
+    }
+    async startSession(options) {
+      const session = new session_1.InteractiveSession(options);
+      return session.start();
+    }
     setOptions(options) {
-      this.options = options;
+      const merged = { ...this.options, ...options };
+      if (merged.branding === undefined) {
+        merged.branding = true;
+      }
+      if (merged.introAnimation == null) {
+        merged.introAnimation = { enabled: false, showOnce: true };
+      } else {
+        if (merged.introAnimation.enabled === undefined) {
+          merged.introAnimation.enabled = true;
+        }
+        if (merged.introAnimation.showOnce === undefined) {
+          merged.introAnimation.showOnce = true;
+        }
+        if (merged.introAnimation.introMode === undefined) {
+          merged.introAnimation.introMode = undefined;
+        }
+      }
+      this.options = merged;
+      this.resolvedIntro = this.resolveIntroOptions(this.options.introAnimation);
     }
     parse(argv) {
-      const [nodePath, scriptPath, ...args] = argv;
-      const commandName = args[0];
-      if (!commandName || commandName === "--version") {
-        if (commandName === "--version") {
+      const [nodePath, scriptPath, ...rawArgs] = argv;
+      const { introMode, filteredArgs } = this.extractIntroFlags(rawArgs);
+      const args = filteredArgs;
+      this.showIntroIfNeeded(introMode);
+      if (args.length === 0 || args[0] === "--version") {
+        if (args[0] === "--version") {
           console.log(`
-${colors_1.Colors.FgGreen}${this.name} version: ${this.options?.version}${colors_1.Colors.Reset}
+${colors_1.Colors.FgGreen}${this.executableName} version: ${this.options?.version}${colors_1.Colors.Reset}
 `);
         } else {
           this.help();
         }
         return;
       }
-      const command = this.findCommand(commandName);
-      if (!command) {
-        this.showUnknownCommandError(commandName);
+      if (args.length === 1 && args[0] === "--help") {
+        this.help();
+        return;
+      }
+      const commandPath = [];
+      let currentArgs = [...args];
+      let i = 0;
+      while (i < args.length) {
+        const potentialCommand = args[i];
+        if (potentialCommand.startsWith("--"))
+          break;
+        commandPath.push(potentialCommand);
+        currentArgs = args.slice(i + 1);
+        i++;
+        if (commandPath.length === 1) {
+          const rootCommand = this.findCommand(commandPath[0]);
+          if (!rootCommand) {
+            this.showUnknownCommandError(commandPath[0]);
+            return;
+          }
+          if (!rootCommand.subcommands || i >= args.length || args[i].startsWith("--"))
+            break;
+        } else {
+          const result = this.findSubcommand(commandPath);
+          if (!result) {
+            commandPath.pop();
+            currentArgs = args.slice(i);
+            break;
+          }
+          const { command } = result;
+          if (!command.subcommands || i >= args.length || args[i].startsWith("--"))
+            break;
+        }
+      }
+      if (currentArgs.includes("--help")) {
+        if (commandPath.length === 1) {
+          const command = this.findCommand(commandPath[0]);
+          if (command)
+            this.commandHelp(command, commandPath);
+        } else if (commandPath.length > 1) {
+          const result = this.findSubcommand(commandPath);
+          if (result)
+            this.commandHelp(result.command, commandPath);
+        }
         return;
       }
-      if (args.includes("--help")) {
-        this.commandHelp(command);
+      let commandToExecute;
+      if (commandPath.length === 1) {
+        commandToExecute = this.findCommand(commandPath[0]);
+      } else if (commandPath.length > 1) {
+        const result = this.findSubcommand(commandPath);
+        if (result)
+          commandToExecute = result.command;
+      }
+      if (!commandToExecute) {
+        this.showUnknownCommandError(commandPath.join(" "));
         return;
       }
-      const params = this.parseArgs(args.slice(1), command);
+      const params = this.parseArgs(currentArgs, commandToExecute);
       if (params.error) {
         console.log(`
 ${params.error}`);
         process.exit(1);
       }
-      if (Object.keys(params.result).length > 0) {
-        if (this.options.interactive) {
-          this.options.interactive = false;
-        }
+      if (Object.keys(params.result).length > 0 && this.options.interactive) {
+        this.options.interactive = false;
       }
-      const missingParams = this.getMissingParams(command, params.result);
+      const missingParams = this.getMissingParams(commandToExecute, params.result);
       if (missingParams.length > 0 && this.options?.interactive) {
-        this.handleMissingParams(command.params, params.result, command);
+        this.handleMissingParams(commandToExecute.params, params.result, commandToExecute);
       } else {
         if (missingParams.length > 0) {
           console.log(`
-${colors_1.Colors.FgRed}error missing params${colors_1.Colors.Reset}
+${colors_1.Colors.BgRed}${colors_1.Colors.FgWhite} ERROR ${colors_1.Colors.Reset} ${colors_1.Colors.FgRed}Missing required parameters${colors_1.Colors.Reset}
 `);
-          missingParams.map((param) => {
-            console.log(`> ${colors_1.Colors.FgRed}${param.name}${colors_1.Colors.Reset}`);
-            console.log(`  > ${colors_1.Colors.FgGray}Type: ${param.type}${colors_1.Colors.Reset}`);
-            console.log(`  > ${colors_1.Colors.FgGray}Description: ${param.description}${colors_1.Colors.Reset}`);
+          missingParams.forEach((param) => {
+            console.log(`${colors_1.Colors.FgRed}❌ ${colors_1.Colors.Bright}${param.name}${colors_1.Colors.Reset}${colors_1.Colors.FgRed} (${param.type})${colors_1.Colors.Reset}`);
+            console.log(`   ${colors_1.Colors.FgGray}${param.description}${colors_1.Colors.Reset}`);
             if (param.options) {
-              console.log(`  > ${colors_1.Colors.FgGray}Options: ${param.options}${colors_1.Colors.Reset}`);
+              console.log(`   ${colors_1.Colors.FgGray}Options: ${param.options.join(", ")}${colors_1.Colors.Reset}`);
             }
+            console.log("");
           });
-          console.log(`
-${colors_1.Colors.FgYellow}Optional missing params${colors_1.Colors.Reset}
+          const optionalParams = this.getOptionalParams(commandToExecute, params.result);
+          if (optionalParams.length > 0) {
+            console.log(`${colors_1.Colors.FgYellow}⚠️  Optional parameters you can provide:${colors_1.Colors.Reset}
+`);
+            optionalParams.forEach((param) => {
+              console.log(`${colors_1.Colors.FgYellow}○ ${param.name}${colors_1.Colors.Reset}${colors_1.Colors.FgYellow} (${param.type})${colors_1.Colors.Reset}`);
+              console.log(`  ${colors_1.Colors.FgGray}${param.description}${colors_1.Colors.Reset}`);
+              if (param.options) {
+                console.log(`  ${colors_1.Colors.FgGray}Options: ${param.options.join(", ")}${colors_1.Colors.Reset}`);
+              }
+              console.log("");
+            });
+          }
+          console.log(`${colors_1.Colors.FgGray}Try '${colors_1.Colors.Bright}${this.executableName} ${commandToExecute.name} --help${colors_1.Colors.Reset}${colors_1.Colors.FgGray}' for more information.${colors_1.Colors.Reset}
 `);
-          this.getOptionalParams(command, params.result).map((param) => {
-            console.log(`> ${colors_1.Colors.FgYellow}${param.name}${colors_1.Colors.Reset}`);
-            console.log(`  > ${colors_1.Colors.FgGray}Type: ${param.type}${colors_1.Colors.Reset}`);
-            console.log(`  > ${colors_1.Colors.FgGray}Description: ${param.description}${colors_1.Colors.Reset}`);
-            if (param.options) {
-              console.log(`  > ${colors_1.Colors.FgGray}Options: ${param.options}${colors_1.Colors.Reset}`);
-            }
-          });
           process.exit(1);
         }
-        command.action(params.result);
+        const actionResult = commandToExecute.action(params.result);
+        Promise.resolve(actionResult).then(() => this.showBranding()).catch((error) => {
+          console.error(`${colors_1.Colors.Error}❌ Command failed:${colors_1.Colors.Reset}`, error);
+        });
       }
     }
     help() {
-      console.log("");
-      console.log(`${colors_1.Colors.Bright}Welcome to ${colors_1.Colors.FgGreen}${this.name}${colors_1.Colors.Reset}`);
-      console.log("");
-      console.log(`${colors_1.Colors.FgYellow}${this.description}${colors_1.Colors.Reset}`);
-      console.log("");
-      console.log(`${colors_1.Colors.Bright}Available commands:${colors_1.Colors.Reset}`);
+      console.log(`
+${colors_1.Colors.BgGreen}${colors_1.Colors.FgBlack} ${this.name} ${colors_1.Colors.Reset}`);
+      console.log(`${colors_1.Colors.FgGreen}${this.description}${colors_1.Colors.Reset}
+`);
+      console.log(`${colors_1.Colors.Bright}${colors_1.Colors.FgCyan}USAGE${colors_1.Colors.Reset}`);
+      console.log(`  ${colors_1.Colors.FgGray}$ ${this.executableName} <command> [options]${colors_1.Colors.Reset}
+`);
+      console.log(`${colors_1.Colors.Bright}${colors_1.Colors.FgCyan}COMMANDS${colors_1.Colors.Reset}`);
       this.commands.forEach((cmd) => {
-        console.log(`${colors_1.Colors.FgGreen}  ${cmd.name}${colors_1.Colors.Reset}: ${cmd.description}`);
+        console.log(`  ${colors_1.Colors.FgGreen}${cmd.name.padEnd(15)}${colors_1.Colors.Reset}${cmd.description}`);
+        if (cmd.subcommands && cmd.subcommands.length > 0) {
+          cmd.subcommands.forEach((subcmd) => {
+            console.log(`    ${colors_1.Colors.FgGreen}${cmd.name} ${subcmd.name}${colors_1.Colors.Reset}: ${subcmd.description}`);
+          });
+        }
       });
       console.log("");
+      console.log(`${colors_1.Colors.Bright}${colors_1.Colors.FgCyan}OPTIONS${colors_1.Colors.Reset}`);
+      console.log(`  ${colors_1.Colors.FgYellow}--help${colors_1.Colors.Reset}${colors_1.Colors.FgGray.padEnd(12)}Show help for a command${colors_1.Colors.Reset}`);
+      console.log(`  ${colors_1.Colors.FgYellow}--version${colors_1.Colors.Reset}${colors_1.Colors.FgGray.padEnd(10)}Show version information${colors_1.Colors.Reset}
+`);
+      console.log(`${colors_1.Colors.FgGray}Run '${colors_1.Colors.Bright}${this.executableName} <command> --help${colors_1.Colors.Reset}${colors_1.Colors.FgGray}' for detailed help on a specific command.${colors_1.Colors.Reset}
+`);
+    }
+    showBranding() {
+      if (this.options?.branding) {
+        console.log(`
+${colors_1.Colors.FgGray}─────────────────────────────────────────────────────────────────${colors_1.Colors.Reset}`);
+        console.log(`${colors_1.Colors.FgYellow}⭐ ${colors_1.Colors.Bright}Like this CLI? Star us on GitHub!${colors_1.Colors.Reset}`);
+        console.log(`${colors_1.Colors.FgGray}   https://github.com/ideascoldigital/cli-maker${colors_1.Colors.Reset}`);
+        console.log(`${colors_1.Colors.FgGray}─────────────────────────────────────────────────────────────────${colors_1.Colors.Reset}
+`);
+      }
     }
-    commandHelp(command) {
-      console.log(`${colors_1.Colors.Bright}Help for command: ${colors_1.Colors.FgGreen}${command.name}${colors_1.Colors.Reset}`);
-      console.log(`${colors_1.Colors.FgGreen}Description:${colors_1.Colors.Reset} ${command.description}`);
+    commandHelp(command, fullCommandPath) {
+      const fullCommand = fullCommandPath.join(" ");
+      console.log(`
+${colors_1.Colors.BgGreen}${colors_1.Colors.FgBlack} ${this.name} ${fullCommand} ${colors_1.Colors.Reset}`);
+      console.log(`${colors_1.Colors.FgGreen}${command.description}${colors_1.Colors.Reset}
+`);
+      console.log(`${colors_1.Colors.Bright}${colors_1.Colors.FgCyan}USAGE${colors_1.Colors.Reset}`);
+      const paramList = command.params.map((p) => `${p.required ? "<" : "["}${p.name}${p.required ? ">" : "]"} `).join("");
+      console.log(`  ${colors_1.Colors.FgGray}$ ${this.executableName} ${fullCommand} ${paramList}${colors_1.Colors.Reset}
+`);
       if (command.params.length > 0) {
-        console.log(`${colors_1.Colors.FgGreen}Parameters:${colors_1.Colors.Reset}`);
-        command.params.forEach((param) => {
-          console.log(`${colors_1.Colors.FgYellow}(${param.type}) ${colors_1.Colors.Reset}${colors_1.Colors.FgGreen}${param.name}${colors_1.Colors.Reset}: ${param.description} ${param.required ? "(required)" : ""}`);
+        console.log(`${colors_1.Colors.Bright}${colors_1.Colors.FgCyan}PARAMETERS${colors_1.Colors.Reset}
+`);
+        console.log((0, common_1.formatParameterTable)(command.params));
+        console.log("");
+      }
+      if (command.subcommands && command.subcommands.length > 0) {
+        console.log(`${colors_1.Colors.Bright}${colors_1.Colors.FgCyan}SUBCOMMANDS${colors_1.Colors.Reset}`);
+        command.subcommands.forEach((subcmd) => {
+          console.log(`  ${colors_1.Colors.FgGreen}${subcmd.name}${colors_1.Colors.Reset}: ${subcmd.description}`);
         });
+        console.log("");
+      }
+      console.log(`${colors_1.Colors.Bright}${colors_1.Colors.FgCyan}EXAMPLES${colors_1.Colors.Reset}`);
+      console.log(`  ${colors_1.Colors.FgGray}$ ${this.executableName} ${fullCommand} --help${colors_1.Colors.Reset}`);
+      if (command.params.some((p) => p.required)) {
+        const exampleParams = command.params.filter((p) => p.required).slice(0, 2).map((p) => {
+          if (p.type === interfaces_1.ParamType.List && p.options) {
+            return `--${p.name} ${p.options[0]}`;
+          } else if (p.type === interfaces_1.ParamType.Boolean) {
+            return `--${p.name}`;
+          } else {
+            return `--${p.name} value`;
+          }
+        }).join(" ");
+        console.log(`  ${colors_1.Colors.FgGray}$ ${this.executableName} ${fullCommand} ${exampleParams}${colors_1.Colors.Reset}`);
+      }
+      console.log("");
+    }
+    findCommand(commandName, commands = this.commands) {
+      return commands.find((cmd) => cmd.name === commandName);
+    }
+    findSubcommand(commandPath) {
+      if (commandPath.length < 2)
+        return;
+      const rootCommandName = commandPath[0];
+      const rootCommand = this.findCommand(rootCommandName);
+      if (!rootCommand || !rootCommand.subcommands)
+        return;
+      let currentCommand = rootCommand;
+      let currentCommands = rootCommand.subcommands;
+      let i = 1;
+      while (i < commandPath.length - 1) {
+        const subCmd = this.findCommand(commandPath[i], currentCommands);
+        if (!subCmd || !subCmd.subcommands)
+          return;
+        currentCommand = subCmd;
+        currentCommands = subCmd.subcommands;
+        i++;
       }
-    }
-    findCommand(commandName) {
-      return this.commands.find((cmd) => cmd.name === commandName);
+      const finalSubcommand = this.findCommand(commandPath[commandPath.length - 1], currentCommands);
+      if (!finalSubcommand)
+        return;
+      return { parentCommand: currentCommand, command: finalSubcommand };
     }
     showUnknownCommandError(commandName) {
-      console.log(`${colors_1.Colors.FgRed}Unknown command: ${commandName}${colors_1.Colors.Reset}`);
-      this.help();
+      console.log(`
+${colors_1.Colors.BgRed}${colors_1.Colors.FgWhite} ERROR ${colors_1.Colors.Reset} ${colors_1.Colors.FgRed}Unknown command: '${colors_1.Colors.Bright}${commandName}${colors_1.Colors.Reset}${colors_1.Colors.FgRed}'${colors_1.Colors.Reset}
+`);
+      console.log(`${colors_1.Colors.FgYellow}Available commands:${colors_1.Colors.Reset}
+`);
+      this.commands.forEach((cmd) => {
+        console.log(`  ${colors_1.Colors.FgGreen}${cmd.name}${colors_1.Colors.Reset}: ${cmd.description}`);
+        if (cmd.subcommands && cmd.subcommands.length > 0) {
+          cmd.subcommands.forEach((subcmd) => {
+            console.log(`    ${colors_1.Colors.FgGreen}${cmd.name} ${subcmd.name}${colors_1.Colors.Reset}: ${subcmd.description}`);
+          });
+        }
+      });
+      console.log(`
+${colors_1.Colors.FgGray}Try '${colors_1.Colors.Bright}${this.executableName} --help${colors_1.Colors.Reset}${colors_1.Colors.FgGray}' for more information.${colors_1.Colors.Reset}
+`);
     }
     getMissingParams(command, result) {
       const requiredParams = command.params.filter((p) => p.required === true);
@@ -342,9 +2598,22 @@ ${colors_1.Colors.FgYellow}Optional missing params${colors_1.Colors.Reset}
     }
     parseArgs(args, command) {
       const result = {};
-      for (const arg of args) {
-        const [key, value] = arg.split("=");
-        if (key.startsWith("--")) {
+      for (let i = 0;i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith("--")) {
+          let key;
+          let value;
+          if (arg.includes("=")) {
+            [key, value] = arg.split("=");
+          } else {
+            key = arg;
+            value = args[i + 1];
+            if (value && !value.startsWith("--")) {
+              i++;
+            } else {
+              value = undefined;
+            }
+          }
           const paramName = key.slice(2);
           const commandParam = command.params.find((p) => p.name === paramName);
           if (commandParam) {
@@ -354,8 +2623,12 @@ ${colors_1.Colors.FgYellow}Optional missing params${colors_1.Colors.Reset}
             }
             result[paramName] = validation.value;
           } else {
-            return { error: `
-Param ${colors_1.Colors.FgRed}${paramName}${colors_1.Colors.Reset} ${colors_1.Colors.Bright}is not allowed${colors_1.Colors.Reset}` };
+            return {
+              error: `
+${colors_1.Colors.BgRed}${colors_1.Colors.FgWhite} ERROR ${colors_1.Colors.Reset} ${colors_1.Colors.FgRed}Unknown parameter: '${colors_1.Colors.Bright}${paramName}${colors_1.Colors.Reset}${colors_1.Colors.FgRed}'${colors_1.Colors.Reset}
+${colors_1.Colors.FgGray}       Available parameters: ${command.params.map((p) => p.name).join(", ")}${colors_1.Colors.Reset}
+`
+            };
           }
         }
       }
@@ -367,67 +2640,319 @@ Param ${colors_1.Colors.FgRed}${paramName}${colors_1.Colors.Reset} ${colors_1.Co
     findParamType(paramName) {
       return this.commands.flatMap((command) => command.params).find((param) => param.name === paramName);
     }
+    showIntroIfNeeded(overrideMode) {
+      const introOptions = this.resolvedIntro || this.resolveIntroOptions(this.options?.introAnimation);
+      const mode = overrideMode || introOptions?.introMode;
+      if (!introOptions || introOptions.enabled === false) {
+        if (mode === "always") {
+          this.renderIntroAnimation(introOptions || {});
+        }
+        return;
+      }
+      if (mode === "never")
+        return;
+      const markerPath = this.getIntroMarkerPath(introOptions);
+      if (mode !== "always" && introOptions.showOnce !== false && this.hasSeenIntro(markerPath)) {
+        return;
+      }
+      this.renderIntroAnimation(introOptions);
+      if (introOptions.showOnce !== false && mode !== "always") {
+        this.markIntroSeen(markerPath);
+      }
+    }
+    resolveIntroOptions(intro) {
+      if (!intro)
+        return { enabled: false, showOnce: true };
+      const preset = intro.preset ? INTRO_PRESETS[intro.preset] : undefined;
+      const replacePlaceholders = (text) => {
+        if (!text)
+          return text;
+        return text.replace(/\{\{cliName\}\}/g, this.name).replace(/\{\{cliDescription\}\}/g, this.description);
+      };
+      const extractCliNameWithoutCompany = (fullName) => {
+        const parts = fullName.split("/");
+        return parts.length > 1 ? parts[1] : fullName;
+      };
+      const extractCompany = (fullName) => {
+        const parts = fullName.split("/");
+        return parts.length > 1 ? parts[0] : null;
+      };
+      let resolvedTitle = replacePlaceholders(intro.title ?? preset?.title);
+      let resolvedSubtitle = replacePlaceholders(intro.subtitle ?? preset?.subtitle);
+      let resolvedLines = intro.lines ?? preset?.lines;
+      let resolvedAsciiArt = intro.asciiArt ?? preset?.asciiArt;
+      if (intro.preset === "ascii-art") {
+        const cliNameOnly = extractCliNameWithoutCompany(this.name);
+        const company = extractCompany(this.name);
+        resolvedAsciiArt = generatePixelAsciiArt(cliNameOnly).map((line) => `${colors_1.Colors.FgYellow}${line}${colors_1.Colors.Reset}`);
+        resolvedTitle = undefined;
+        resolvedSubtitle = undefined;
+        if (company) {
+          resolvedLines = [`${colors_1.Colors.FgGray}by ${company}${colors_1.Colors.Reset}`];
+        }
+      }
+      return {
+        enabled: intro.enabled ?? preset?.enabled ?? false,
+        showOnce: intro.showOnce ?? preset?.showOnce ?? true,
+        introMode: intro.introMode ?? preset?.introMode,
+        animateText: intro.animateText ?? preset?.animateText ?? true,
+        preset: intro.preset,
+        frames: intro.frames ?? preset?.frames,
+        padding: intro.padding ?? preset?.padding,
+        speedMs: intro.speedMs ?? preset?.speedMs,
+        loops: intro.loops ?? preset?.loops,
+        lines: resolvedLines,
+        asciiArt: resolvedAsciiArt,
+        title: resolvedTitle,
+        subtitle: resolvedSubtitle,
+        storageKey: intro.storageKey ?? preset?.storageKey
+      };
+    }
+    renderIntroAnimation(introOptions) {
+      const frames = introOptions.frames && introOptions.frames.length > 0 ? introOptions.frames : ["◢", "◣", "◤", "◥"];
+      const loops = Math.max(1, introOptions.loops ?? 2);
+      const speed = Math.max(40, introOptions.speedMs ?? 90);
+      const totalFrames = frames.length * loops;
+      const fallbackFrame = frames[0] || "★";
+      let renderedLines = 0;
+      if (!process.stdout.isTTY) {
+        const lines = this.buildIntroLines(fallbackFrame, introOptions, 1);
+        console.log(lines.join(`
+`));
+        console.log("");
+        return;
+      }
+      for (let i = 0;i < totalFrames; i++) {
+        const frameSymbol = frames[i % frames.length] || fallbackFrame;
+        const revealProgress = introOptions.animateText === false ? 1 : Math.min(1, (i + 1) / totalFrames);
+        const lines = this.buildIntroLines(frameSymbol, introOptions, revealProgress);
+        if (renderedLines > 0) {
+          process.stdout.write(`\x1B[${renderedLines}A\r`);
+          process.stdout.write("\x1B[0J");
+        }
+        process.stdout.write(lines.join(`
+`) + `
+`);
+        renderedLines = lines.length;
+        this.blockingSleep(speed);
+      }
+      console.log("");
+    }
+    buildIntroLines(frameSymbol, introOptions, revealProgress) {
+      const paddingSize = Math.max(0, introOptions.padding ?? 2);
+      const padding = " ".repeat(paddingSize);
+      const title = introOptions.title || this.name;
+      const subtitle = introOptions.subtitle ?? this.description;
+      const extraLines = introOptions.lines ?? [];
+      const asciiArt = introOptions.asciiArt ?? [];
+      const rawTitle = `${frameSymbol} ${title}`;
+      const rawLines = [rawTitle];
+      if (subtitle)
+        rawLines.push(subtitle);
+      rawLines.push(...extraLines);
+      rawLines.push(...asciiArt);
+      const contentWidth = Math.max(...rawLines.map((line) => (0, common_1.stripAnsiCodes)(line).length));
+      const terminalWidth = process.stdout.columns || 80;
+      const minWidth = Math.floor(terminalWidth / 2) - paddingSize * 2 - 4;
+      const maxContentWidth = Math.max(contentWidth, minWidth);
+      const horizontal = "─".repeat(maxContentWidth + 2);
+      const topBorder = `${padding}${colors_1.Colors.FgGray}┌${horizontal}┐${colors_1.Colors.Reset}`;
+      const bottomBorder = `${padding}${colors_1.Colors.FgGray}└${horizontal}┘${colors_1.Colors.Reset}`;
+      const formatLine = (text, rawText) => {
+        const displayLength = (0, common_1.stripAnsiCodes)(text).length;
+        const spaces = Math.max(0, maxContentWidth - displayLength);
+        const lineContent = ` ${text}${" ".repeat(spaces)} `;
+        return `${padding}${colors_1.Colors.FgGray}│${colors_1.Colors.Reset}${lineContent}${colors_1.Colors.FgGray}│${colors_1.Colors.Reset}`;
+      };
+      const rainbowMode = introOptions.preset === "rainbow";
+      const visibleTitle = this.revealText(title, revealProgress, introOptions.animateText);
+      const coloredTitle = rainbowMode ? this.colorizeRainbow(visibleTitle) : `${colors_1.Colors.Bright}${colors_1.Colors.FgCyan}${visibleTitle}${colors_1.Colors.Reset}`;
+      const formattedTitle = `${colors_1.Colors.FgYellow}${frameSymbol}${colors_1.Colors.Reset} ${coloredTitle}`;
+      const formattedLines = [formatLine(formattedTitle, rawTitle)];
+      if (subtitle) {
+        const visibleSubtitle = this.revealText(subtitle, revealProgress, introOptions.animateText);
+        const coloredSubtitle = rainbowMode ? this.colorizeRainbow(visibleSubtitle) : `${colors_1.Colors.FgGray}${visibleSubtitle}${colors_1.Colors.Reset}`;
+        formattedLines.push(formatLine(coloredSubtitle, subtitle));
+      }
+      extraLines.forEach((line) => {
+        const visibleLine = this.revealText(line, revealProgress, introOptions.animateText);
+        const coloredLine = rainbowMode ? this.colorizeRainbow(visibleLine) : `${colors_1.Colors.FgGray}${visibleLine}${colors_1.Colors.Reset}`;
+        formattedLines.push(formatLine(coloredLine, line));
+      });
+      asciiArt.forEach((line) => {
+        const shouldAnimateArt = introOptions.animateText !== false && !line.includes("\x1B");
+        const visibleArt = this.revealText(line, shouldAnimateArt ? revealProgress : 1, shouldAnimateArt);
+        formattedLines.push(formatLine(visibleArt, line));
+      });
+      return [topBorder, ...formattedLines, bottomBorder];
+    }
+    getIntroMarkerPath(introOptions) {
+      if (introOptions.showOnce === false)
+        return null;
+      const homeDir = os_1.default.homedir();
+      const safeName = (introOptions.storageKey || `${this.executableName || this.name}-intro`).replace(/[^a-z0-9-_]/gi, "-").toLowerCase();
+      const markerDir = path_1.default.join(homeDir, ".cli-maker");
+      return path_1.default.join(markerDir, `${safeName}.json`);
+    }
+    hasSeenIntro(markerPath) {
+      if (!markerPath)
+        return false;
+      try {
+        return fs_1.default.existsSync(markerPath);
+      } catch {
+        return false;
+      }
+    }
+    markIntroSeen(markerPath) {
+      if (!markerPath)
+        return;
+      try {
+        fs_1.default.mkdirSync(path_1.default.dirname(markerPath), { recursive: true });
+        fs_1.default.writeFileSync(markerPath, JSON.stringify({ seenAt: new Date().toISOString() }), "utf-8");
+      } catch {}
+    }
+    blockingSleep(ms) {
+      if (ms <= 0)
+        return;
+      const sharedBuffer = new SharedArrayBuffer(4);
+      const sharedArray = new Int32Array(sharedBuffer);
+      Atomics.wait(sharedArray, 0, 0, ms);
+    }
+    revealText(text, progress, animate) {
+      if (!text)
+        return "";
+      if (animate === false)
+        return text;
+      const clean = (0, common_1.stripAnsiCodes)(text);
+      const len = clean.length;
+      if (len === 0)
+        return "";
+      const visible = Math.min(len, Math.max(0, Math.round(len * progress)));
+      return text.slice(0, visible);
+    }
+    colorizeRainbow(text) {
+      const palette = [colors_1.Colors.FgRed, colors_1.Colors.FgYellow, colors_1.Colors.FgGreen, colors_1.Colors.FgCyan, colors_1.Colors.FgBlue, colors_1.Colors.FgMagenta];
+      let colored = "";
+      let colorIndex = 0;
+      for (let i = 0;i < text.length; i++) {
+        const char = text[i];
+        if (char.trim().length === 0) {
+          colored += char;
+          continue;
+        }
+        colored += `${palette[colorIndex % palette.length]}${char}${colors_1.Colors.Reset}`;
+        colorIndex++;
+      }
+      return colored;
+    }
+    extractIntroFlags(rawArgs) {
+      let introMode;
+      const filteredArgs = rawArgs.filter((arg) => {
+        if (arg === "--intro-always") {
+          introMode = "always";
+          return false;
+        }
+        if (arg === "--no-intro") {
+          introMode = "never";
+          return false;
+        }
+        return true;
+      });
+      return { introMode, filteredArgs };
+    }
     async promptForMissingParams(missingParams, existingParams) {
-      const rl = readline_1.default.createInterface({
+      let rl = readline_1.default.createInterface({
         input: process.stdin,
         output: process.stdout
       });
       const askQuestion = (question) => {
         return new Promise((resolve) => rl.question(question, resolve));
       };
+      console.log(`
+${colors_1.Colors.BgBlue}${colors_1.Colors.FgWhite} INTERACTIVE MODE ${colors_1.Colors.Reset} ${colors_1.Colors.FgBlue}Please provide the following information:${colors_1.Colors.Reset}
+`);
       const prompts = missingParams.reduce((promise, param) => {
         return promise.then(async (answers) => {
           let answer;
           let validation;
+          const requiredIndicator = param.required ? `${colors_1.Colors.FgRed}*${colors_1.Colors.Reset}` : `${colors_1.Colors.FgGray}○${colors_1.Colors.Reset}`;
+          console.log(`${requiredIndicator} ${colors_1.Colors.Bright}${param.name}${colors_1.Colors.Reset} ${colors_1.Colors.FgGray}(${param.type})${colors_1.Colors.Reset}`);
+          console.log(`  ${colors_1.Colors.FgGray}${param.description}${colors_1.Colors.Reset}`);
+          if (param.options && param.options.length > 0) {
+            console.log(`  ${colors_1.Colors.FgGray}Options: ${param.options.join(", ")}${colors_1.Colors.Reset}`);
+          }
+          console.log("");
           if (param.type === interfaces_1.ParamType.List && param.options) {
-            const isRequired = param.required ? "(required) " : "";
-            console.log(`
-${colors_1.Colors.FgYellow}(${param.type}) ${colors_1.Colors.Reset}${colors_1.Colors.FgGreen}${param.name}${colors_1.Colors.Reset} `);
-            console.log(`${colors_1.Colors.FgYellow}> ${colors_1.Colors.Reset}${colors_1.Colors.FgGray}${isRequired}${param.description}:${colors_1.Colors.Reset}
-`);
+            console.log(`${colors_1.Colors.FgCyan}Use ↑/↓ arrow keys to navigate, Enter to select:${colors_1.Colors.Reset}`);
             answer = await this.promptWithArrows(param);
             validation = { value: param.options[parseInt(answer, 10)] };
+            console.log(`${colors_1.Colors.Success}✓ Selected: ${validation.value}${colors_1.Colors.Reset}
+`);
           } else {
+            let attemptCount = 0;
             do {
-              const isRequired = param.required ? "(required) " : "(Enter to skip) ";
-              const message = `
-${colors_1.Colors.FgYellow}(${param.type}) ${colors_1.Colors.Reset}${colors_1.Colors.FgGreen}${param.name}${colors_1.Colors.Reset}
-${colors_1.Colors.FgYellow}> ${colors_1.Colors.Reset}${colors_1.Colors.FgGray}${isRequired}${param.description}:${colors_1.Colors.Reset}
-`;
-              answer = await askQuestion(message);
+              if (attemptCount > 0) {
+                console.log(`${colors_1.Colors.FgYellow}Please try again:${colors_1.Colors.Reset}`);
+              }
+              const promptText = param.required ? `${colors_1.Colors.FgGreen}Enter value${colors_1.Colors.Reset} ${colors_1.Colors.FgGray}(required)${colors_1.Colors.Reset}: ` : `${colors_1.Colors.FgGreen}Enter value${colors_1.Colors.Reset} ${colors_1.Colors.FgGray}(or press Enter to skip)${colors_1.Colors.Reset}: `;
+              if (param.type === interfaces_1.ParamType.Password) {
+                rl.close();
+                answer = await CLI.askHiddenQuestion(promptText);
+                rl = readline_1.default.createInterface({
+                  input: process.stdin,
+                  output: process.stdout
+                });
+              } else {
+                answer = await askQuestion(promptText);
+              }
               validation = this.validateParam(answer, param.type, param.required, param.options);
               if (validation.error) {
                 console.log(validation.error);
+                attemptCount++;
+              } else if (validation.value !== undefined) {
+                console.log(`${colors_1.Colors.Success}✓ Accepted${colors_1.Colors.Reset}
+`);
+              } else {
+                console.log(`${colors_1.Colors.FgGray}○ Skipped${colors_1.Colors.Reset}
+`);
               }
             } while (validation.error);
           }
           return { ...answers, [param.name]: validation.value };
         });
       }, Promise.resolve(existingParams));
-      return prompts.finally(() => rl.close());
+      return prompts.finally(() => {
+        rl.close();
+        console.log(`${colors_1.Colors.Success}✅ All parameters collected successfully!${colors_1.Colors.Reset}
+`);
+      });
     }
     async promptWithArrows(param) {
       return new Promise((resolve) => {
         let index = 0;
         const options = param.options;
         const renderOptions = () => {
-          options.forEach((option, i) => {
-            process.stdout.write("\x1B[2K\x1B[0G");
-            if (i === index) {
-              process.stdout.write(`${colors_1.Colors.FgGreen}> ${option}${colors_1.Colors.Reset}
-`);
-            } else {
-              process.stdout.write(`  ${option}
+          console.clear();
+          console.log(`${colors_1.Colors.BgBlue}${colors_1.Colors.FgWhite} SELECT OPTION ${colors_1.Colors.Reset} ${colors_1.Colors.FgBlue}for ${param.name}${colors_1.Colors.Reset}
 `);
-            }
+          options.forEach((option, i) => {
+            const prefix = i === index ? `${colors_1.Colors.FgGreen}❯ ${option}${colors_1.Colors.Reset}` : `  ${option}`;
+            const indicator = i === index ? ` ${colors_1.Colors.FgCyan}← Current selection${colors_1.Colors.Reset}` : "";
+            console.log(`${prefix}${indicator}`);
           });
-          process.stdout.write(`\x1B[${options.length}A`);
+          console.log(`
+${colors_1.Colors.FgGray}Use ↑/↓ to navigate, Enter to confirm, Ctrl+C to cancel${colors_1.Colors.Reset}`);
+          console.log(`${colors_1.Colors.FgGray}Selected: ${options[index]}${colors_1.Colors.Reset}`);
+        };
+        const clearScreen = () => {
+          process.stdout.write("\x1B[0J");
+          process.stdout.write("\x1B[0;0H");
         };
-        const clearLines = (numLines) => {
-          for (let i = 0;i < numLines; i++) {
-            process.stdout.write("\x1B[2K\x1B[1A");
+        const cleanup = () => {
+          process.stdin.removeListener("keypress", keypressHandler);
+          if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
           }
-          process.stdout.write("\x1B[2K\x1B[0G");
         };
         const keypressHandler = (str, key) => {
           if (key.name === "up") {
@@ -437,22 +2962,16 @@ ${colors_1.Colors.FgYellow}> ${colors_1.Colors.Reset}${colors_1.Colors.FgGray}${
             index = (index + 1) % options.length;
             renderOptions();
           } else if (key.name === "return") {
-            process.stdin.removeListener("keypress", keypressHandler);
-            clearLines(options.length);
-            options.forEach((option, i) => {
-              if (i === index) {
-                process.stdout.write(`${colors_1.Colors.FgGreen}> ${option}${colors_1.Colors.Reset}
-`);
-              } else {
-                process.stdout.write(`  ${option}
-`);
-              }
-            });
-            process.stdout.write(`
-Selected: ${options[index]}
-`);
+            cleanup();
+            clearScreen();
             resolve(index.toString());
             return;
+          } else if (key.ctrl && key.name === "c") {
+            cleanup();
+            clearScreen();
+            console.log(`${colors_1.Colors.Warning}⚠️  Selection cancelled${colors_1.Colors.Reset}
+`);
+            process.exit(0);
           }
         };
         readline_1.default.emitKeypressEvents(process.stdin);
@@ -463,23 +2982,111 @@ Selected: ${options[index]}
         renderOptions();
       });
     }
+    static async askQuestion(question) {
+      return new Promise((resolve) => {
+        const rl = readline_1.default.createInterface({
+          input: process.stdin,
+          output: process.stdout
+        });
+        rl.question(question, (answer) => {
+          rl.close();
+          resolve(answer);
+        });
+      });
+    }
+    static async askHiddenQuestion(question) {
+      return new Promise((resolve) => {
+        const stdin = process.stdin;
+        const stdout = process.stdout;
+        stdout.write(question);
+        let buffer = "";
+        const onData = (char) => {
+          const key = char.toString();
+          if (key === `
+` || key === "\r" || key === "\x04") {
+            stdout.write(`
+`);
+            stdin.removeListener("data", onData);
+            if (stdin.isTTY)
+              stdin.setRawMode(false);
+            stdin.pause();
+            resolve(buffer);
+          } else if (key === "\x03") {
+            stdin.removeListener("data", onData);
+            if (stdin.isTTY)
+              stdin.setRawMode(false);
+            stdin.pause();
+            process.exit(0);
+          } else if (key === "" || key === "\b") {
+            if (buffer.length > 0) {
+              buffer = buffer.slice(0, -1);
+              stdout.write("\b \b");
+            }
+          } else {
+            const printableChars = key.split("").filter((c) => c >= " " && c <= "~").join("");
+            if (printableChars.length > 0) {
+              buffer += printableChars;
+              stdout.write("*".repeat(printableChars.length));
+            }
+          }
+        };
+        stdin.resume();
+        if (stdin.isTTY)
+          stdin.setRawMode(true);
+        stdin.on("data", onData);
+      });
+    }
   }
   exports2.CLI = CLI;
 });
 
-// node_modules/@ideascol/cli-maker/dist/common.js
-var require_common = __commonJS((exports2) => {
+// node_modules/@ideascol/cli-maker/dist/session/index.js
+var require_session2 = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", { value: true });
-  exports2.stripAnsiCodes = stripAnsiCodes;
-  function stripAnsiCodes(str) {
-    return str.replace(/[\u001b\u009b][[\]()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, "");
-  }
+  exports2.separator = exports2.alignedList = exports2.sectionHeader = exports2.toolResultBox = exports2.toolCallArgs = exports2.toolCallHeader = exports2.drawTwoColumnBox = exports2.drawBox = exports2.getBuiltInSlashCommands = exports2.renderMarkdown = exports2.InteractiveSession = undefined;
+  var session_1 = require_session();
+  Object.defineProperty(exports2, "InteractiveSession", { enumerable: true, get: function() {
+    return session_1.InteractiveSession;
+  } });
+  var markdown_1 = require_markdown();
+  Object.defineProperty(exports2, "renderMarkdown", { enumerable: true, get: function() {
+    return markdown_1.renderMarkdown;
+  } });
+  var slash_commands_1 = require_slash_commands();
+  Object.defineProperty(exports2, "getBuiltInSlashCommands", { enumerable: true, get: function() {
+    return slash_commands_1.getBuiltInSlashCommands;
+  } });
+  var ui_1 = require_ui();
+  Object.defineProperty(exports2, "drawBox", { enumerable: true, get: function() {
+    return ui_1.drawBox;
+  } });
+  Object.defineProperty(exports2, "drawTwoColumnBox", { enumerable: true, get: function() {
+    return ui_1.drawTwoColumnBox;
+  } });
+  Object.defineProperty(exports2, "toolCallHeader", { enumerable: true, get: function() {
+    return ui_1.toolCallHeader;
+  } });
+  Object.defineProperty(exports2, "toolCallArgs", { enumerable: true, get: function() {
+    return ui_1.toolCallArgs;
+  } });
+  Object.defineProperty(exports2, "toolResultBox", { enumerable: true, get: function() {
+    return ui_1.toolResultBox;
+  } });
+  Object.defineProperty(exports2, "sectionHeader", { enumerable: true, get: function() {
+    return ui_1.sectionHeader;
+  } });
+  Object.defineProperty(exports2, "alignedList", { enumerable: true, get: function() {
+    return ui_1.alignedList;
+  } });
+  Object.defineProperty(exports2, "separator", { enumerable: true, get: function() {
+    return ui_1.separator;
+  } });
 });
 
 // node_modules/@ideascol/cli-maker/dist/index.js
 var require_dist = __commonJS((exports2) => {
   Object.defineProperty(exports2, "__esModule", { value: true });
-  exports2.stripAnsiCodes = exports2.ParamType = exports2.CLI = undefined;
+  exports2.getBuiltInSlashCommands = exports2.renderMarkdown = exports2.InteractiveSession = exports2.hiddenPrompt = exports2.getConfigValue = exports2.getRawConfig = exports2.loadSetupConfig = exports2.createSetupCommand = exports2.formatParameterTable = exports2.createTable = exports2.showInfo = exports2.showWarning = exports2.showError = exports2.showSuccess = exports2.ProgressBar = exports2.ProgressIndicator = exports2.stripAnsiCodes = exports2.ParamType = exports2.CLI = undefined;
   var command_1 = require_command();
   Object.defineProperty(exports2, "CLI", { enumerable: true, get: function() {
     return command_1.CLI;
@@ -492,6 +3099,59 @@ var require_dist = __commonJS((exports2) => {
   Object.defineProperty(exports2, "stripAnsiCodes", { enumerable: true, get: function() {
     return common_1.stripAnsiCodes;
   } });
+  Object.defineProperty(exports2, "ProgressIndicator", { enumerable: true, get: function() {
+    return common_1.ProgressIndicator;
+  } });
+  Object.defineProperty(exports2, "ProgressBar", { enumerable: true, get: function() {
+    return common_1.ProgressBar;
+  } });
+  Object.defineProperty(exports2, "showSuccess", { enumerable: true, get: function() {
+    return common_1.showSuccess;
+  } });
+  Object.defineProperty(exports2, "showError", { enumerable: true, get: function() {
+    return common_1.showError;
+  } });
+  Object.defineProperty(exports2, "showWarning", { enumerable: true, get: function() {
+    return common_1.showWarning;
+  } });
+  Object.defineProperty(exports2, "showInfo", { enumerable: true, get: function() {
+    return common_1.showInfo;
+  } });
+  Object.defineProperty(exports2, "createTable", { enumerable: true, get: function() {
+    return common_1.createTable;
+  } });
+  Object.defineProperty(exports2, "formatParameterTable", { enumerable: true, get: function() {
+    return common_1.formatParameterTable;
+  } });
+  var setup_1 = require_setup();
+  Object.defineProperty(exports2, "createSetupCommand", { enumerable: true, get: function() {
+    return setup_1.createSetupCommand;
+  } });
+  Object.defineProperty(exports2, "loadSetupConfig", { enumerable: true, get: function() {
+    return setup_1.loadSetupConfig;
+  } });
+  Object.defineProperty(exports2, "getRawConfig", { enumerable: true, get: function() {
+    return setup_1.getRawConfig;
+  } });
+  Object.defineProperty(exports2, "getConfigValue", { enumerable: true, get: function() {
+    return setup_1.getConfigValue;
+  } });
+  Object.defineProperty(exports2, "prompt", { enumerable: true, get: function() {
+    return setup_1.prompt;
+  } });
+  Object.defineProperty(exports2, "hiddenPrompt", { enumerable: true, get: function() {
+    return setup_1.hiddenPrompt;
+  } });
+  var index_1 = require_session2();
+  Object.defineProperty(exports2, "InteractiveSession", { enumerable: true, get: function() {
+    return index_1.InteractiveSession;
+  } });
+  Object.defineProperty(exports2, "renderMarkdown", { enumerable: true, get: function() {
+    return index_1.renderMarkdown;
+  } });
+  Object.defineProperty(exports2, "getBuiltInSlashCommands", { enumerable: true, get: function() {
+    return index_1.getBuiltInSlashCommands;
+  } });
 });
 
 // src/lib/clients/agents-generator/core/ApiError.ts
@@ -619,7 +3279,7 @@ var OpenAPI;
 var init_OpenAPI = __esm(() => {
   OpenAPI = {
     BASE: "",
-    VERSION: "main-4e98343b9970cdc29452c95593033dcfc9074e11",
+    VERSION: "main-18ea61a3a4dd0d19d2d7aba58dce085c8bf2e17b",
     WITH_CREDENTIALS: false,
     CREDENTIALS: "include",
     TOKEN: undefined,
@@ -2391,6 +5051,20 @@ var init_AgentFoldersService = __esm(() => {
   init_request();
 });
 
+// src/lib/clients/agents-generator/services/AuthService.ts
+class AuthService {
+  static whoami() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/auth/whoami"
+    });
+  }
+}
+var init_AuthService = __esm(() => {
+  init_OpenAPI();
+  init_request();
+});
+
 // src/lib/clients/agents-generator/services/ConversationsService.ts
 class ConversationsService {
   static createConversation(requestBody) {
@@ -3539,6 +6213,7 @@ var init_agents_generator = __esm(() => {
   init_AdminWorkspacesService();
   init_AgentService();
   init_AgentFoldersService();
+  init_AuthService();
   init_ConversationsService();
   init_CredentialsService();
   init_FileLibraryService();
@@ -3556,6 +6231,57 @@ var init_agents_generator = __esm(() => {
   init_WorkspacesService();
 });
 
+// src/lib/config.ts
+function decodeConfigValue(value) {
+  if (!value)
+    return;
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "object" && value !== null) {
+    const obj = value;
+    if (obj.__b64 && obj.value) {
+      try {
+        return Buffer.from(obj.value, "base64").toString("utf-8");
+      } catch {
+        return;
+      }
+    }
+  }
+  return String(value);
+}
+async function getCli() {
+  if (!cliInstance) {
+    const { cli } = await Promise.resolve().then(() => (init_cli(), exports_cli));
+    cliInstance = cli;
+  }
+  return cliInstance;
+}
+async function loadAppConfig() {
+  const cli = await getCli();
+  const cfg = await cli.loadConfig();
+  const apiKey = decodeConfigValue(cfg.api_key);
+  const apiUrl = decodeConfigValue(cfg.api_url);
+  if (!apiKey) {
+    throw new Error("API key not configured. Run `agents-generator-sdk setup` first.");
+  }
+  return {
+    apiKey,
+    apiUrl: apiUrl || DEFAULT_CONFIG.apiUrl
+  };
+}
+function getConfigFilePath() {
+  const os = require("os");
+  const path = require("path");
+  const safeName = `${CLI_NAME}-config.json`.replace(/[^a-z0-9._-]/gi, "-");
+  return path.join(os.homedir(), ".cli-maker", safeName);
+}
+var CLI_NAME = "@ideascol/agents-generator-sdk", DEFAULT_CONFIG, cliInstance = null;
+var init_config = __esm(() => {
+  DEFAULT_CONFIG = {
+    apiUrl: "https://api.agentsgenerator.dev"
+  };
+});
+
 // src/lib/index.ts
 class AgentClient {
   admin;
@@ -3598,7 +6324,8 @@ class AgentClient {
       apiKeys: AdminApiKeysService,
       presence: PresenceService,
       schema: SchemaGeneratorService,
-      tokenUsage: TokenUsageService
+      tokenUsage: TokenUsageService,
+      auth: AuthService
     };
     this.public = {
       agents: PublicAgentsService,
@@ -3667,13 +6394,10 @@ var init_lib = __esm(() => {
         function processStream() {
           reader.read().then(({ done, value }) => {
             if (done) {
-              console.log("Stream completado");
               if (buffer.length > 0) {
-                console.log("Procesando buffer final:", buffer);
                 if (isDirectTextMode) {
                   fullMessage += buffer;
                   if (callbacks.onMessage) {
-                    console.log("Actualizando mensaje final (texto directo):", fullMessage);
                     callbacks.onMessage(fullMessage);
                   }
                 } else {
@@ -3704,7 +6428,6 @@ var init_lib = __esm(() => {
                   if (buffer.length > 0) {
                     fullMessage += buffer;
                     if (callbacks.onMessage) {
-                      console.log("Actualizando mensaje final (buffer restante):", fullMessage);
                       callbacks.onMessage(fullMessage);
                     }
                   }
@@ -3717,18 +6440,15 @@ var init_lib = __esm(() => {
             }
             const chunk = decoder.decode(value, { stream: true });
             buffer += chunk;
-            console.log("Chunk recibido:", chunk);
             let eventEnd = buffer.indexOf(`
 
 `);
             if (buffer.length > 50 && eventEnd === -1 && !isDirectTextMode) {
               isDirectTextMode = true;
-              console.log("Detectado modo texto directo");
             }
             if (isDirectTextMode) {
               fullMessage += chunk;
               if (callbacks.onMessage) {
-                console.log("Actualizando con texto directo:", fullMessage);
                 callbacks.onMessage(fullMessage);
               }
             } else {
@@ -3739,7 +6459,6 @@ var init_lib = __esm(() => {
                   const jsonStr = eventData.substring(6);
                   try {
                     const data = JSON.parse(jsonStr);
-                    console.log("Evento SSE recibido:", data);
                     if (data.type === "message" && data.content && callbacks.onMessage) {
                       fullMessage = data.content;
                       callbacks.onMessage(fullMessage);
@@ -3749,12 +6468,10 @@ var init_lib = __esm(() => {
                       callbacks.onTransfer(data.transfer);
                     }
                   } catch (e) {
-                    console.error("Error al parsear JSON del evento:", e);
                     if (eventData.startsWith("data: ")) {
                       const directContent = eventData.substring(6);
                       fullMessage += directContent;
                       if (callbacks.onMessage) {
-                        console.log("Actualizando con texto SSE simple:", fullMessage);
                         callbacks.onMessage(fullMessage);
                       }
                     } else {
@@ -3766,7 +6483,6 @@ var init_lib = __esm(() => {
                 } else {
                   fullMessage += eventData;
                   if (callbacks.onMessage) {
-                    console.log("Actualizando con evento no reconocido:", fullMessage);
                     callbacks.onMessage(fullMessage);
                   }
                 }
@@ -3778,7 +6494,6 @@ var init_lib = __esm(() => {
                 fullMessage += buffer;
                 buffer = "";
                 if (callbacks.onMessage) {
-                  console.log("Actualizando con buffer residual:", fullMessage);
                   callbacks.onMessage(fullMessage);
                 }
               }
@@ -3850,55 +6565,39 @@ var init_lib = __esm(() => {
 });
 
 // src/commands/agentsCommand.ts
-var import_cli_maker, commandAgents, agentsCommand_default;
+var commandAgents, agentsCommand_default;
 var init_agentsCommand = __esm(() => {
   init_lib();
-  import_cli_maker = __toESM(require_dist(), 1);
+  init_config();
   commandAgents = {
     name: "getAgents",
     description: "Get the list of agents",
-    params: [{
-      name: "URL",
-      description: "The URL of the API",
-      required: true,
-      type: import_cli_maker.ParamType.Url
-    }],
-    action: async (args) => {
-      const client = new lib_default({ apiUrl: args.URL, apiToken: "" });
-      const agents = await client.agent.getAgents(0, 100);
-      const agents2 = await client.admin.agents.getAgents(0, 100);
-      const agent = await client.public.agents.getAgent("some-agent-id");
-      const conversation = await client.public.conversations.sendMessageWithStreaming;
+    params: [],
+    action: async () => {
+      const config = await loadAppConfig();
+      const client = new lib_default({ apiUrl: config.apiUrl, apiToken: config.apiKey });
+      const workspaceId = (await client.admin.auth.whoami()).workspace_id;
+      const agents = await client.admin.agents.getAgents(0, 100, workspaceId);
       console.log(agents);
-      console.log(agents2);
     }
   };
   agentsCommand_default = commandAgents;
 });
 
 // src/commands/rootCommand.ts
-var import_cli_maker2, rootCommand, rootCommand_default;
+var rootCommand, rootCommand_default;
 var init_rootCommand = __esm(() => {
   init_lib();
-  import_cli_maker2 = __toESM(require_dist(), 1);
+  init_config();
   rootCommand = {
     name: "version",
     description: "Get the version of the API",
-    params: [{
-      name: "URL",
-      description: "The URL of the API",
-      required: false,
-      type: import_cli_maker2.ParamType.Url
-    }, {
-      name: "apiToken",
-      description: "The API token",
-      required: false,
-      type: import_cli_maker2.ParamType.Text
-    }],
-    action: async (args) => {
+    params: [],
+    action: async () => {
+      const config = await loadAppConfig();
       const client = new AgentClient({
-        apiUrl: args.URL || "https://api.agentsgenerator.dev/",
-        apiToken: args.apiToken
+        apiUrl: config.apiUrl,
+        apiToken: config.apiKey
       });
       const hello = await client.root.healthCheck();
       console.log(hello);
@@ -3908,42 +6607,323 @@ var init_rootCommand = __esm(() => {
 });
 
 // src/commands/conversationsCommand.ts
-var import_cli_maker3, commandConversations, conversationsCommand_default;
+var import_cli_maker, commandConversations, conversationsCommand_default;
 var init_conversationsCommand = __esm(() => {
   init_agents_generator();
-  import_cli_maker3 = __toESM(require_dist(), 1);
+  init_config();
+  import_cli_maker = __toESM(require_dist(), 1);
   commandConversations = {
     name: "getConversations",
     description: "Get the list of conversations",
     params: [{
-      name: "URL",
-      description: "The URL of the API",
-      required: true,
-      type: import_cli_maker3.ParamType.Url
-    }, {
       name: "conversationId",
       description: "The ID of the conversation",
       required: true,
-      type: import_cli_maker3.ParamType.Text
+      type: import_cli_maker.ParamType.Text
     }, {
       name: "agentId",
       description: "The ID of the agent",
       required: true,
-      type: import_cli_maker3.ParamType.Text
+      type: import_cli_maker.ParamType.Text
     }],
     action: async (args) => {
-      OpenAPI["BASE"] = args.URL;
+      const config = await loadAppConfig();
+      OpenAPI.BASE = config.apiUrl;
+      OpenAPI.TOKEN = config.apiKey;
       const conversationId = args.conversationId;
       const agentId = args.agentId;
       const conversationList = await ConversationsService.getAgentConversations(agentId);
       const conversations = await ConversationsService.getConversation(conversationId);
+      console.log({ conversationList, conversations });
+    }
+  };
+  conversationsCommand_default = commandConversations;
+});
+
+// src/commands/chatCommand.ts
+function formatAgentList(agentList) {
+  if (agentList.length === 0) {
+    return "  No agents found.";
+  }
+  return agentList.map((a, i) => `  ${i + 1}. **${a.name}** (${a.id}) — ${a.status || "unknown"}`).join(`
+`);
+}
+function formatConversationList(conversations) {
+  if (conversations.length === 0) {
+    return "  No conversations found.";
+  }
+  return conversations.map((c, i) => `  ${i + 1}. ${c.title || "Untitled"} (${c.id}) — ${c.created_at}`).join(`
+`);
+}
+async function initClient() {
+  const config = await loadAppConfig();
+  return new AgentClient({
+    apiUrl: config.apiUrl,
+    apiToken: config.apiKey
+  });
+}
+function createMessageStream(agentClient, conversationId, message) {
+  let lastContent = "";
+  const chunks = [];
+  let resolveNext = null;
+  let done = false;
+  let streamError = null;
+  let abortFn = null;
+  function push(chunk) {
+    if (resolveNext) {
+      const r = resolveNext;
+      resolveNext = null;
+      r({ value: chunk, done: false });
+    } else {
+      chunks.push(chunk);
+    }
+  }
+  function finish() {
+    done = true;
+    if (resolveNext) {
+      const r = resolveNext;
+      resolveNext = null;
+      r({ value: "", done: true });
+    }
+  }
+  abortFn = agentClient.sendMessageWithStreaming(conversationId, { content: message }, {
+    onMessage: (content) => {
+      const newChunk = content.slice(lastContent.length);
+      lastContent = content;
+      if (newChunk)
+        push(newChunk);
+    },
+    onTransfer: (transfer) => {
+      push(`
+\uD83D\uDD04 Transfer: ${transfer.from_agent || "?"} → ${transfer.to_agent || "?"} (${transfer.reason || "no reason"})
+`);
+    },
+    onDone: () => {
+      finish();
+    },
+    onError: (err) => {
+      streamError = err;
+      finish();
+    }
+  });
+  return {
+    [Symbol.asyncIterator]() {
       return {
-        conversationList,
-        conversations
+        async next() {
+          if (streamError)
+            throw streamError;
+          if (chunks.length > 0)
+            return { value: chunks.shift(), done: false };
+          if (done)
+            return { value: "", done: true };
+          return new Promise((res) => {
+            resolveNext = res;
+          });
+        },
+        async return() {
+          if (abortFn)
+            abortFn();
+          return { value: "", done: true };
+        }
       };
     }
   };
-  conversationsCommand_default = commandConversations;
+}
+function createChatCommand(cliInstance2) {
+  return {
+    name: "chat",
+    description: "Start an interactive chat session with your agents",
+    params: [],
+    action: async () => {
+      try {
+        client = await initClient();
+      } catch (err) {
+        console.error(`
+  ❌ ${err.message}
+`);
+        return;
+      }
+      try {
+        const workspaceId = (await client.admin.auth.whoami()).workspace_id;
+        agents = await client.admin.agents.getAgents(0, 100, workspaceId);
+      } catch (err) {
+        console.error(`
+  ❌ Failed to fetch agents: ${err.message}
+`);
+        return;
+      }
+      await cliInstance2.startSession({
+        welcomeMessage: [
+          "  Welcome to **Agents Generator** Chat",
+          "",
+          "  Select an agent and start chatting.",
+          "",
+          `  Found **${agents.length}** agent(s):`,
+          "",
+          formatAgentList(agents)
+        ].join(`
+`),
+        tips: [
+          {
+            title: "Getting started",
+            lines: [
+              "Use `/select <number>` to pick an agent",
+              "Then type a message to chat",
+              "Responses stream in real-time"
+            ]
+          },
+          {
+            title: "Commands",
+            lines: [
+              "/agents         Refresh agent list",
+              "/select <n|id>  Select an agent",
+              "/conversations  List conversations",
+              "/new            New conversation",
+              "/help           Show all commands"
+            ]
+          }
+        ],
+        infoLines: [
+          `v${client.OpenAPI.VERSION} · ${client.OpenAPI.BASE}`
+        ],
+        theme: {
+          borderColor: "\x1B[36m",
+          borderStyle: "rounded",
+          promptColor: "\x1B[36m",
+          accentColor: "\x1B[33m"
+        },
+        historySize: 50,
+        tools: [],
+        slashCommands: [
+          {
+            name: "agents",
+            description: "List available agents",
+            action: async (_args, ctx) => {
+              ctx.spinner.start("Fetching agents...");
+              try {
+                const workspaceId = (await client.admin.auth.whoami()).workspace_id;
+                agents = await client.admin.agents.getAgents(0, 100, workspaceId);
+                ctx.spinner.stop();
+                ctx.printMarkdown(`**Agents (${agents.length}):**
+
+${formatAgentList(agents)}`);
+              } catch (err) {
+                ctx.spinner.stop();
+                ctx.print(`❌ Error: ${err.message}`);
+              }
+            }
+          },
+          {
+            name: "select",
+            description: "Select an agent by number or ID",
+            action: async (args, ctx) => {
+              const input = args.trim();
+              if (!input) {
+                ctx.print("Usage: /select <number or agent-id>");
+                return;
+              }
+              const index = parseInt(input, 10);
+              if (!isNaN(index) && index >= 1 && index <= agents.length) {
+                selectedAgent = agents[index - 1];
+              } else {
+                const found = agents.find((a) => a.id === input || a.name.toLowerCase() === input.toLowerCase());
+                if (found) {
+                  selectedAgent = found;
+                } else {
+                  ctx.print(`❌ Agent not found: "${input}". Use /agents to see the list.`);
+                  return;
+                }
+              }
+              ctx.printMarkdown(`✅ Selected agent: **${selectedAgent.name}** (\`${selectedAgent.id}\`)`);
+              ctx.spinner.start("Creating conversation...");
+              try {
+                activeConversation = await client.public.conversations.createConversation({
+                  agent_id: selectedAgent.id,
+                  title: `CLI Chat — ${new Date().toLocaleString()}`
+                });
+                ctx.spinner.stop();
+                ctx.printMarkdown(`\uD83D\uDCAC New conversation: \`${activeConversation.id}\`
+
+Type a message to start chatting.`);
+              } catch (err) {
+                ctx.spinner.stop();
+                ctx.print(`❌ Failed to create conversation: ${err.message}`);
+                activeConversation = null;
+              }
+            }
+          },
+          {
+            name: "conversations",
+            description: "List conversations for the selected agent",
+            action: async (_args, ctx) => {
+              if (!selectedAgent) {
+                ctx.print("No agent selected. Use /select first.");
+                return;
+              }
+              ctx.spinner.start("Fetching conversations...");
+              try {
+                const convos = await client.conversations.getAgentConversations(selectedAgent.id, 0, 20);
+                ctx.spinner.stop();
+                ctx.printMarkdown(`**Conversations for ${selectedAgent.name}:**
+
+${formatConversationList(convos)}`);
+              } catch (err) {
+                ctx.spinner.stop();
+                ctx.print(`❌ Error: ${err.message}`);
+              }
+            }
+          },
+          {
+            name: "new",
+            description: "Create a new conversation for the selected agent",
+            action: async (_args, ctx) => {
+              if (!selectedAgent) {
+                ctx.print("No agent selected. Use /select first.");
+                return;
+              }
+              ctx.spinner.start("Creating conversation...");
+              try {
+                activeConversation = await client.public.conversations.createConversation({
+                  agent_id: selectedAgent.id,
+                  title: `CLI Chat — ${new Date().toLocaleString()}`
+                });
+                ctx.spinner.stop();
+                ctx.printMarkdown(`\uD83D\uDCAC New conversation: \`${activeConversation.id}\`
+
+Type a message to start chatting.`);
+              } catch (err) {
+                ctx.spinner.stop();
+                ctx.print(`❌ Failed to create conversation: ${err.message}`);
+              }
+            }
+          }
+        ],
+        onMessage: async (message, ctx) => {
+          if (!selectedAgent) {
+            ctx.printMarkdown("⚠️ No agent selected. Use `/select <number>` to pick an agent first.\n\n" + formatAgentList(agents));
+            return;
+          }
+          if (!activeConversation) {
+            ctx.print("⚠️ No active conversation. Use /new to create one.");
+            return;
+          }
+          const stream = createMessageStream(client, activeConversation.id, message);
+          await ctx.printStream(stream);
+        },
+        onEnd: async (ctx) => {
+          console.log(`  Total messages: ${ctx.history.length}`);
+          selectedAgent = null;
+          activeConversation = null;
+        }
+      });
+    }
+  };
+}
+var client = null, agents, selectedAgent = null, activeConversation = null;
+var init_chatCommand = __esm(() => {
+  init_lib();
+  init_config();
+  agents = [];
 });
 
 // src/cli.ts
@@ -3951,21 +6931,94 @@ var exports_cli = {};
 __export(exports_cli, {
   cli: () => cli
 });
-var import_cli_maker4, cli;
+function truncateValue(value, showFull = false) {
+  if (!value)
+    return "<not set>";
+  const str = typeof value === "object" ? JSON.stringify(value) : String(value);
+  if (showFull)
+    return str;
+  if (str.length <= 8)
+    return "****";
+  return str.substring(0, 4) + "..." + str.substring(str.length - 4);
+}
+var import_cli_maker2, import_fs, cli, args, isSetupCommand, isHelpCommand, isVersionCommand, isShowConfigCommand, cleanArgv;
 var init_cli = __esm(() => {
   init_agents_generator();
+  init_config();
   init_agentsCommand();
   init_rootCommand();
   init_conversationsCommand();
-  import_cli_maker4 = __toESM(require_dist(), 1);
-  cli = new import_cli_maker4.CLI("@ideascol/agents-generator-sdk", "agents-generator-sdk", {
+  init_chatCommand();
+  import_cli_maker2 = __toESM(require_dist(), 1);
+  import_fs = __toESM(require("fs"));
+  cli = new import_cli_maker2.CLI("@ideascol/agents-generator-sdk", "agents-generator-sdk", {
     interactive: true,
     version: OpenAPI.VERSION
   });
+  cli.setupCommand({
+    name: "setup",
+    description: "Configure API credentials for agents-generator",
+    steps: [
+      { name: "api_key", description: "API token (JWT)", required: true, type: import_cli_maker2.ParamType.Password },
+      { name: "api_url", description: "API base URL", required: true, type: import_cli_maker2.ParamType.Url, defaultValue: "https://api.agentsgenerator.dev" }
+    ],
+    encryption: {
+      enabled: true,
+      prompt: "Passphrase to encrypt your credentials"
+    }
+  });
+  cli.command({
+    name: "show-config",
+    description: "Show your current configuration",
+    params: [],
+    action: async () => {
+      const cfgPath = getConfigFilePath();
+      const showRaw = process.argv.includes("--raw");
+      if (!import_fs.default.existsSync(cfgPath)) {
+        console.log("\n⚠️  No configuration found. Run `agents-generator-sdk setup` first.\n");
+        return;
+      }
+      console.log(`
+\uD83D\uDCC1 Config file: ` + cfgPath);
+      try {
+        const cfg = await cli.loadConfig();
+        const sensitiveKeys = ["api_key"];
+        console.log(`
+✅ Configuration:`);
+        console.log("─".repeat(50));
+        for (const [key, value] of Object.entries(cfg)) {
+          const decoded = decodeConfigValue(value);
+          const display = sensitiveKeys.includes(key) ? truncateValue(decoded, showRaw) : String(decoded || "<not set>");
+          console.log(`  ${key.padEnd(20)} ${display}`);
+        }
+        console.log("─".repeat(50));
+        if (!showRaw) {
+          console.log(`
+\uD83D\uDCA1 Use --raw to show full values`);
+        }
+      } catch (err) {
+        console.error(`
+❌ Error loading config: ${err.message}`);
+      }
+    }
+  });
   cli.command(rootCommand_default);
   cli.command(agentsCommand_default);
   cli.command(conversationsCommand_default);
-  cli.parse(process.argv);
+  cli.command(createChatCommand(cli));
+  args = process.argv.slice(2);
+  isSetupCommand = args[0] === "setup";
+  isHelpCommand = args.includes("--help") || args.includes("-h");
+  isVersionCommand = args[0] === "version" || args.includes("--version") || args.includes("-v");
+  isShowConfigCommand = args[0] === "show-config";
+  if (!import_fs.default.existsSync(getConfigFilePath()) && !isSetupCommand && !isHelpCommand && !isVersionCommand && !isShowConfigCommand) {
+    console.log(`
+⚠️  No configuration found. Running setup wizard...
+`);
+    process.argv = [process.argv[0], process.argv[1], "setup"];
+  }
+  cleanArgv = process.argv.filter((a) => a !== "--raw");
+  cli.parse(cleanArgv);
 });
 
 // src/bin/cli.ts