eser 4.0.0 → 4.0.3

package/eser.js

@@ -1,4 +1,10 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
 // deno:https://jsr.io/@std/cli/1.0.25/parse_args.ts
 var FLAG_REGEXP = /^(?:-(?:(?<doubleDash>-)(?<negated>no-)?)?)(?<key>.+?)(?:=(?<value>.+?))?$/s;
 var LETTER_REGEXP = /[A-Za-z]/;
@@ -257,6 +263,44 @@ function parseArgs(args, options) {
   return argv;
 }
 
+// pkg/@eser/standards/runtime/mod.ts
+var mod_exports2 = {};
+__export(mod_exports2, {
+  AlreadyExistsError: () => AlreadyExistsError,
+  BROWSER_CAPABILITIES: () => BROWSER_CAPABILITIES,
+  BUN_CAPABILITIES: () => BUN_CAPABILITIES,
+  DENO_CAPABILITIES: () => DENO_CAPABILITIES,
+  FULL_CAPABILITIES: () => FULL_CAPABILITIES,
+  NODE_CAPABILITIES: () => NODE_CAPABILITIES,
+  NotFoundError: () => NotFoundError,
+  ProcessError: () => ProcessError,
+  RuntimeCapabilityError: () => RuntimeCapabilityError,
+  UNKNOWN_CAPABILITIES: () => UNKNOWN_CAPABILITIES,
+  WORKERD_CAPABILITIES: () => WORKERD_CAPABILITIES,
+  clearWorkerdEnv: () => clearEnv,
+  createRuntime: () => createRuntime,
+  detectRuntime: () => detectRuntime,
+  getArch: () => getArch,
+  getCapabilities: () => getCapabilities,
+  getHomedir: () => getHomedir,
+  getPlatform: () => getPlatform,
+  getPlatformInfo: () => getPlatformInfo,
+  getRuntimeVersion: () => getRuntimeVersion,
+  getTmpdir: () => getTmpdir,
+  hasCapability: () => hasCapability,
+  isBrowser: () => isBrowser,
+  isBun: () => isBun,
+  isDeno: () => isDeno,
+  isEdge: () => isEdge,
+  isNode: () => isNode,
+  isServer: () => isServer,
+  isWorkerd: () => isWorkerd,
+  populateEnvFromContext: () => populateEnvFromContext,
+  posixPath: () => posixPath,
+  runtime: () => runtime,
+  searchFileHierarchy: () => searchFileHierarchy
+});
+
 // pkg/@eser/standards/runtime/types.ts
 var RuntimeCapabilityError = class extends Error {
   capability;
@@ -276,6 +320,14 @@ var NotFoundError = class extends Error {
     this.path = path;
   }
 };
+var AlreadyExistsError = class extends Error {
+  path;
+  constructor(path) {
+    super(`File or directory already exists: ${path}`);
+    this.name = "AlreadyExistsError";
+    this.path = path;
+  }
+};
 var ProcessError = class extends Error {
   cmd;
   code;
@@ -312,8 +364,152 @@ var detectRuntime = () => {
   }
   return "unknown";
 };
+var getRuntimeVersion = () => {
+  const runtime2 = detectRuntime();
+  switch (runtime2) {
+    case "deno": {
+      return globalThis.Deno?.version?.deno ?? "unknown";
+    }
+    case "bun": {
+      return globalThis.Bun?.version ?? "unknown";
+    }
+    case "node": {
+      return globalThis.process?.versions?.node ?? "unknown";
+    }
+    case "workerd": {
+      return "unknown";
+    }
+    case "browser": {
+      return globalThis.navigator?.userAgent ?? "unknown";
+    }
+    default: {
+      return "unknown";
+    }
+  }
+};
+var isDeno = () => detectRuntime() === "deno";
+var isNode = () => detectRuntime() === "node";
+var isBun = () => detectRuntime() === "bun";
+var isWorkerd = () => detectRuntime() === "workerd";
+var isBrowser = () => detectRuntime() === "browser";
+var isServer = () => {
+  const rt = detectRuntime();
+  return rt === "deno" || rt === "node" || rt === "bun";
+};
+var isEdge = () => {
+  const rt = detectRuntime();
+  return rt === "workerd";
+};
+
+// pkg/@eser/standards/runtime/platform.ts
+var getPlatform = () => {
+  if (typeof Deno !== "undefined" && Deno.build?.os) {
+    const os = Deno.build.os;
+    if (os === "darwin") return "darwin";
+    if (os === "linux") return "linux";
+    if (os === "windows") return "windows";
+  }
+  const proc = globalThis.process;
+  if (proc?.platform) {
+    const platform = proc.platform;
+    if (platform === "darwin") return "darwin";
+    if (platform === "linux") return "linux";
+    if (platform === "win32") return "windows";
+  }
+  const nav = globalThis.navigator;
+  if (nav?.userAgent) {
+    const ua = nav.userAgent.toLowerCase();
+    if (ua.includes("mac")) return "darwin";
+    if (ua.includes("win")) return "windows";
+    if (ua.includes("linux")) return "linux";
+  }
+  return "linux";
+};
+var getArch = () => {
+  if (typeof Deno !== "undefined" && Deno.build?.arch) {
+    const arch = Deno.build.arch;
+    if (arch === "x86_64") return "amd64";
+    if (arch === "aarch64") return "arm64";
+  }
+  const proc = globalThis.process;
+  if (proc?.arch) {
+    const arch = proc.arch;
+    if (arch === "x64") return "amd64";
+    if (arch === "arm64") return "arm64";
+  }
+  const nav = globalThis.navigator;
+  if (nav?.userAgent) {
+    const ua = nav.userAgent.toLowerCase();
+    if (ua.includes("arm64") || ua.includes("aarch64")) return "arm64";
+  }
+  return "amd64";
+};
+var getHomedir = () => {
+  if (typeof Deno !== "undefined" && Deno.env?.get) {
+    const home = Deno.env.get("HOME") ?? Deno.env.get("USERPROFILE");
+    if (home) return home;
+  }
+  const proc = globalThis.process;
+  if (proc?.env) {
+    const home = proc.env.HOME ?? proc.env.USERPROFILE;
+    if (home) return home;
+  }
+  try {
+    const os = globalThis.require?.("os");
+    if (os?.homedir) {
+      return os.homedir();
+    }
+  } catch {
+  }
+  const platform = getPlatform();
+  if (platform === "windows") {
+    return "C:\\Users\\Default";
+  }
+  return "/home";
+};
+var getTmpdir = () => {
+  if (typeof Deno !== "undefined" && Deno.env?.get) {
+    const tmp = Deno.env.get("TMPDIR") ?? Deno.env.get("TMP") ?? Deno.env.get("TEMP");
+    if (tmp) return tmp;
+  }
+  const proc = globalThis.process;
+  if (proc?.env) {
+    const tmp = proc.env.TMPDIR ?? proc.env.TMP ?? proc.env.TEMP;
+    if (tmp) return tmp;
+  }
+  try {
+    const os = globalThis.require?.("os");
+    if (os?.tmpdir) {
+      return os.tmpdir();
+    }
+  } catch {
+  }
+  const platform = getPlatform();
+  if (platform === "windows") {
+    return "C:\\Windows\\Temp";
+  }
+  return "/tmp";
+};
+var getPlatformInfo = () => {
+  return {
+    platform: getPlatform(),
+    arch: getArch(),
+    homedir: getHomedir(),
+    tmpdir: getTmpdir()
+  };
+};
 
 // pkg/@eser/standards/runtime/capabilities.ts
+var FULL_CAPABILITIES = {
+  fs: true,
+  fsSync: true,
+  exec: true,
+  process: true,
+  env: true,
+  stdin: true,
+  stdout: true,
+  kv: false
+};
 var DENO_CAPABILITIES = {
   fs: true,
   fsSync: true,
@@ -390,6 +586,9 @@ var getCapabilities = (runtime2) => {
       return UNKNOWN_CAPABILITIES;
   }
 };
+var hasCapability = (runtime2, capability) => {
+  return getCapabilities(runtime2)[capability];
+};
 
 // pkg/@eser/standards/runtime/polyfills/path.ts
 var POSIX_SEP = "/";
@@ -568,6 +767,33 @@ var posixPath = {
   delimiter: POSIX_DELIMITER
 };
 
+// pkg/@eser/standards/runtime/file-search.ts
+var searchFileHierarchy = async (startDir, filenames, options = {}) => {
+  const { searchParents = false } = options;
+  let dir = startDir;
+  while (true) {
+    for (const name of filenames) {
+      const filepath = runtime.path.join(dir, name);
+      const exists = await runtime.fs.exists(filepath);
+      if (exists) {
+        const stat3 = await runtime.fs.stat(filepath);
+        if (stat3.isFile) {
+          return filepath;
+        }
+      }
+    }
+    if (!searchParents) {
+      break;
+    }
+    const parent = runtime.path.dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  return void 0;
+};
+
 // pkg/@eser/standards/runtime/adapters/workerd.ts
 var createWorkerdFs = () => {
   const throwNotAvailable = () => {
@@ -625,6 +851,16 @@ var createWorkerdEnv = () => {
     }
   };
 };
+var populateEnvFromContext = (env) => {
+  for (const [key, value2] of Object.entries(env)) {
+    if (typeof value2 === "string") {
+      envStorage.set(key, value2);
+    }
+  }
+};
+var clearEnv = () => {
+  envStorage.clear();
+};
 var createWorkerdProcess = () => {
   const throwNotAvailable = () => {
     throw new RuntimeCapabilityError("process", "workerd");
@@ -655,7 +891,7 @@ var createWorkerdProcess = () => {
 var createWorkerdRuntime = () => {
   const fs = createWorkerdFs();
   const path = createWorkerdPath();
-  const exec = createWorkerdExec();
+  const exec2 = createWorkerdExec();
   const env = createWorkerdEnv();
   const process = createWorkerdProcess();
   return {
@@ -664,7 +900,7 @@ var createWorkerdRuntime = () => {
     capabilities: WORKERD_CAPABILITIES,
     fs,
     path,
-    exec,
+    exec: exec2,
     env,
     process
   };
@@ -2265,21 +2501,23 @@ var createDenoPath = () => {
 var createDenoExec = () => {
   return {
     async spawn(cmd, args = [], options) {
+      const stdoutMode = options?.stdout ?? "piped";
+      const stderrMode = options?.stderr ?? "piped";
       const command = new Deno.Command(cmd, {
         args,
         cwd: options?.cwd,
         env: options?.env,
         stdin: options?.stdin ?? "null",
-        stdout: options?.stdout ?? "piped",
-        stderr: options?.stderr ?? "piped",
+        stdout: stdoutMode,
+        stderr: stderrMode,
         signal: options?.signal
       });
       const result = await command.output();
       return {
         success: result.success,
         code: result.code,
-        stdout: result.stdout,
-        stderr: result.stderr
+        stdout: stdoutMode === "piped" ? result.stdout : new Uint8Array(),
+        stderr: stderrMode === "piped" ? result.stderr : new Uint8Array()
       };
     },
     async exec(cmd, args = [], options) {
@@ -2385,7 +2623,7 @@ var createDenoProcess = () => {
 var createDenoRuntime = () => {
   const fs = createDenoFs();
   const path = createDenoPath();
-  const exec = createDenoExec();
+  const exec2 = createDenoExec();
   const env = createDenoEnv();
   const process = createDenoProcess();
   return {
@@ -2394,7 +2632,7 @@ var createDenoRuntime = () => {
     capabilities: DENO_CAPABILITIES,
     fs,
     path,
-    exec,
+    exec: exec2,
     env,
     process
   };
@@ -2406,7 +2644,7 @@ import * as nodePath from "node:path";
 import * as nodeOs from "node:os";
 import * as nodeChildProcess from "node:child_process";
 import nodeProcess from "node:process";
-import { Buffer } from "node:buffer";
+import { Buffer as Buffer2 } from "node:buffer";
 import { Readable, Writable } from "node:stream";
 var createNodeFs = () => {
   const mapStats = (stats) => ({
@@ -2582,8 +2820,8 @@ var createNodeExec = () => {
         });
         proc.on("error", reject);
         proc.on("close", (code2) => {
-          const stdout = new Uint8Array(Buffer.concat(stdoutChunks));
-          const stderr = new Uint8Array(Buffer.concat(stderrChunks));
+          const stdout = new Uint8Array(Buffer2.concat(stdoutChunks));
+          const stderr = new Uint8Array(Buffer2.concat(stderrChunks));
           resolve7({
             success: code2 === 0,
             code: code2 ?? 1,
@@ -2657,8 +2895,8 @@ var createNodeExec = () => {
           return {
             success: status.success,
             code: status.code,
-            stdout: new Uint8Array(Buffer.concat(stdoutChunks)),
-            stderr: new Uint8Array(Buffer.concat(stderrChunks))
+            stdout: new Uint8Array(Buffer2.concat(stdoutChunks)),
+            stderr: new Uint8Array(Buffer2.concat(stderrChunks))
           };
         },
         kill: (signal) => {
@@ -2720,7 +2958,7 @@ var createNodeProcess = () => {
 var createNodeRuntime = () => {
   const fs = createNodeFs();
   const path = createNodePath();
-  const exec = createNodeExec();
+  const exec2 = createNodeExec();
   const env = createNodeEnv();
   const process = createNodeProcess();
   return {
@@ -2729,7 +2967,7 @@ var createNodeRuntime = () => {
     capabilities: NODE_CAPABILITIES,
     fs,
     path,
-    exec,
+    exec: exec2,
     env,
     process
   };
@@ -3041,7 +3279,7 @@ var createBunProcess = () => {
 var createBunRuntime = () => {
   const fs = createBunFs();
   const path = createBunPath();
-  const exec = createBunExec();
+  const exec2 = createBunExec();
   const env = createBunEnv();
   const process = createBunProcess();
   return {
@@ -3050,7 +3288,7 @@ var createBunRuntime = () => {
     capabilities: BUN_CAPABILITIES,
     fs,
     path,
-    exec,
+    exec: exec2,
     env,
     process
   };
@@ -3181,6 +3419,11 @@ function code(open, close) {
 function run(str2, code2) {
   return enabled ? `${code2.open}${str2.replace(code2.regexp, code2.open)}${code2.close}` : str2;
 }
+function dim(str2) {
+  return run(str2, code([
+    2
+  ], 22));
+}
 function red(str2) {
   return run(str2, code([
     31
@@ -8311,10 +8554,1413 @@ var codebaseCommand = async (rawArgs, _parentFlags) => {
   await def.handler(parsed._.slice(1), parsed);
 };
 
+// pkg/@eser/shell/args/flags.ts
+var buildParseOptions = (flags) => {
+  const boolean2 = [];
+  const string = [];
+  const alias = {};
+  const defaultValues = {};
+  for (const flag of flags) {
+    if (flag.type === "boolean") {
+      boolean2.push(flag.name);
+    } else {
+      string.push(flag.name);
+    }
+    if (flag.short !== void 0) {
+      alias[flag.short] = flag.name;
+    }
+    if (flag.default !== void 0) {
+      defaultValues[flag.name] = flag.default;
+    }
+  }
+  return {
+    boolean: boolean2,
+    string,
+    alias,
+    default: defaultValues
+  };
+};
+var coerceValue = (value2, type) => {
+  if (value2 === void 0) {
+    return void 0;
+  }
+  switch (type) {
+    case "boolean":
+      return Boolean(value2);
+    case "number":
+      return typeof value2 === "string" ? Number(value2) : value2;
+    case "string":
+      return String(value2);
+    case "string[]":
+      if (Array.isArray(value2)) {
+        return value2.map(String);
+      }
+      return value2 !== void 0 ? [
+        String(value2)
+      ] : [];
+    default:
+      return value2;
+  }
+};
+var extractFlags = (parsed, flags) => {
+  const result = {};
+  for (const flag of flags) {
+    const value2 = parsed[flag.name];
+    result[flag.name] = coerceValue(value2, flag.type);
+  }
+  return result;
+};
+var validateRequiredFlags = (flags, definitions) => {
+  const errors = [];
+  for (const def of definitions) {
+    if (def.required === true) {
+      const value2 = flags[def.name];
+      if (value2 === void 0 || value2 === "" || value2 === false) {
+        errors.push(`Required flag --${def.name} is missing`);
+      }
+    }
+  }
+  return errors;
+};
+
+// pkg/@eser/shell/args/help.ts
+var padRight = (str2, len) => {
+  return str2 + " ".repeat(Math.max(0, len - str2.length));
+};
+var formatFlag = (flag) => {
+  let name = `--${flag.name}`;
+  if (flag.short !== void 0) {
+    name = `-${flag.short}, ${name}`;
+  }
+  if (flag.type !== "boolean") {
+    name += ` <${flag.type}>`;
+  }
+  return name;
+};
+var generateHelp = (meta, commandPath) => {
+  const lines = [];
+  const fullName = commandPath.join(" ");
+  if (meta.description !== void 0) {
+    lines.push(`${fullName} - ${meta.description}`);
+  } else {
+    lines.push(fullName);
+  }
+  lines.push("");
+  if (meta.usage !== void 0) {
+    lines.push("Usage:");
+    lines.push(`  ${meta.usage}`);
+  } else {
+    let usage = fullName;
+    if (meta.children.length > 0) {
+      usage += " <command>";
+    }
+    if (meta.flags.length > 0) {
+      usage += " [options]";
+    }
+    lines.push("Usage:");
+    lines.push(`  ${usage}`);
+  }
+  lines.push("");
+  if (meta.children.length > 0) {
+    lines.push("Commands:");
+    const maxLen = Math.max(...meta.children.map((c) => c.name.length));
+    for (const child of meta.children) {
+      const desc = child.description ?? "";
+      lines.push(`  ${padRight(child.name, maxLen + 2)}${desc}`);
+    }
+    lines.push("");
+  }
+  if (meta.flags.length > 0) {
+    lines.push("Options:");
+    const formatted = meta.flags.map((f) => ({
+      flag: formatFlag(f),
+      desc: f.description
+    }));
+    const maxLen = Math.max(...formatted.map((f) => f.flag.length));
+    for (const { flag, desc } of formatted) {
+      lines.push(`  ${padRight(flag, maxLen + 2)}${desc}`);
+    }
+    lines.push("");
+  }
+  if (meta.examples !== void 0 && meta.examples.length > 0) {
+    lines.push("Examples:");
+    for (const example of meta.examples) {
+      lines.push(`  ${example}`);
+    }
+    lines.push("");
+  }
+  if (meta.children.length > 0) {
+    lines.push(`Run '${fullName} <command> --help' for more information on a command.`);
+  }
+  return lines.join("\n");
+};
+
+// pkg/@eser/shell/completions/generators/bash.ts
+var generateFlagCompletions = (flags) => {
+  const parts = [];
+  for (const flag of flags) {
+    parts.push(`--${flag.name}`);
+    if (flag.short !== void 0) {
+      parts.push(`-${flag.short}`);
+    }
+  }
+  return parts.join(" ");
+};
+var generateSubcommandCase = (node, prefix) => {
+  if (node.children === void 0 || node.children.length === 0) {
+    return "";
+  }
+  const subcommandNames = node.children.map((c) => c.name).join(" ");
+  const flagCompletions = node.flags !== void 0 ? generateFlagCompletions(node.flags) : "";
+  const completions = [
+    subcommandNames,
+    flagCompletions
+  ].filter((s) => s.length > 0).join(" ");
+  let output = `        ${prefix})
+`;
+  output += `            COMPREPLY=( $(compgen -W "${completions}" -- "\${cur}") )
+`;
+  output += `            return 0
+`;
+  output += `            ;;
+`;
+  for (const child of node.children) {
+    if (child.children !== void 0 && child.children.length > 0) {
+      output += generateSubcommandCase(child, `${prefix} ${child.name}`);
+    }
+  }
+  return output;
+};
+var generate = (appName, tree) => {
+  const topLevelCommands = tree.children?.map((c) => c.name).join(" ") ?? "";
+  const topLevelFlags = tree.flags !== void 0 ? generateFlagCompletions(tree.flags) : "";
+  const topLevel = [
+    topLevelCommands,
+    topLevelFlags
+  ].filter((s) => s.length > 0).join(" ");
+  let caseClauses = "";
+  if (tree.children !== void 0) {
+    for (const child of tree.children) {
+      caseClauses += generateSubcommandCase(child, child.name);
+    }
+  }
+  return `# ${appName} bash completion
+# Generated by @eser/shell/completions
+
+_${appName}_completions() {
+    local cur prev words cword
+    _init_completion || return
+
+    COMPREPLY=()
+    cur="\${COMP_WORDS[COMP_CWORD]}"
+    prev="\${COMP_WORDS[COMP_CWORD-1]}"
+
+    # Build the command path from words
+    local cmd_path=""
+    local i
+    for ((i=1; i<COMP_CWORD; i++)); do
+        case "\${COMP_WORDS[i]}" in
+            -*)
+                # Skip flags
+                ;;
+            *)
+                if [[ -n "$cmd_path" ]]; then
+                    cmd_path="$cmd_path \${COMP_WORDS[i]}"
+                else
+                    cmd_path="\${COMP_WORDS[i]}"
+                fi
+                ;;
+        esac
+    done
+
+    case "$cmd_path" in
+${caseClauses}        "")
+            COMPREPLY=( $(compgen -W "${topLevel}" -- "\${cur}") )
+            return 0
+            ;;
+    esac
+}
+
+complete -F _${appName}_completions ${appName}
+`;
+};
+
+// pkg/@eser/shell/completions/generators/zsh.ts
+var escapeZsh = (str2) => {
+  return str2.replace(/'/g, "'\\''");
+};
+var generateFlagSpecs = (flags) => {
+  const specs = [];
+  for (const flag of flags) {
+    const desc = escapeZsh(flag.description ?? `${flag.name} flag`);
+    if (flag.takesValue === true) {
+      specs.push(`'--${flag.name}=[${desc}]'`);
+      if (flag.short !== void 0) {
+        specs.push(`'-${flag.short}=[${desc}]'`);
+      }
+    } else {
+      specs.push(`'--${flag.name}[${desc}]'`);
+      if (flag.short !== void 0) {
+        specs.push(`'-${flag.short}[${desc}]'`);
+      }
+    }
+  }
+  return specs;
+};
+var generateSubcommandSpecs = (children) => {
+  const specs = children.map((c) => {
+    const desc = escapeZsh(c.description ?? c.name);
+    return `'${c.name}:${desc}'`;
+  });
+  return specs.join("\n            ");
+};
+var generateCommandFunction = (appName, node, path) => {
+  const funcName = path.length === 0 ? `_${appName}` : `_${appName}_${path.join("_")}`;
+  let output = `${funcName}() {
+`;
+  output += `    local -a commands
+`;
+  output += `    local -a flags
+
+`;
+  if (node.flags !== void 0 && node.flags.length > 0) {
+    const flagSpecs = generateFlagSpecs(node.flags);
+    output += `    flags=(
+        ${flagSpecs.join("\n        ")}
+    )
+
+`;
+  }
+  if (node.children !== void 0 && node.children.length > 0) {
+    output += `    commands=(
+`;
+    output += `            ${generateSubcommandSpecs(node.children)}
+`;
+    output += `    )
+
+`;
+    output += `    _arguments -C \\
+`;
+    if (node.flags !== void 0 && node.flags.length > 0) {
+      output += `        "\${flags[@]}" \\
+`;
+    }
+    output += `        '1: :->command' \\
+`;
+    output += `        '*::arg:->args'
+
+`;
+    output += `    case "$state" in
+`;
+    output += `        command)
+`;
+    output += `            _describe -t commands 'command' commands
+`;
+    output += `            ;;
+`;
+    output += `        args)
+`;
+    output += `            case "\${words[1]}" in
+`;
+    for (const child of node.children) {
+      const childPath = [
+        ...path,
+        child.name
+      ];
+      const childFunc = `_${appName}_${childPath.join("_")}`;
+      output += `                ${child.name})
+`;
+      output += `                    ${childFunc}
+`;
+      output += `                    ;;
+`;
+    }
+    output += `            esac
+`;
+    output += `            ;;
+`;
+    output += `    esac
+`;
+  } else if (node.flags !== void 0 && node.flags.length > 0) {
+    output += `    _arguments "\${flags[@]}"
+`;
+  }
+  output += `}
+
+`;
+  if (node.children !== void 0) {
+    for (const child of node.children) {
+      output += generateCommandFunction(appName, child, [
+        ...path,
+        child.name
+      ]);
+    }
+  }
+  return output;
+};
+var generate2 = (appName, tree) => {
+  let output = `#compdef ${appName}
+`;
+  output += `# ${appName} zsh completion
+`;
+  output += `# Generated by @eser/shell/completions
+
+`;
+  output += generateCommandFunction(appName, tree, []);
+  output += `_${appName} "$@"
+`;
+  return output;
+};
+
+// pkg/@eser/shell/completions/generators/fish.ts
+var escapeFish = (str2) => {
+  return str2.replace(/'/g, "\\'");
+};
+var generateFlagCompletions2 = (appName, flags, condition) => {
+  let output = "";
+  for (const flag of flags) {
+    const desc = escapeFish(flag.description ?? `${flag.name} flag`);
+    let cmd = `complete -c ${appName} ${condition}`;
+    cmd += ` -l ${flag.name}`;
+    if (flag.short !== void 0) {
+      cmd += ` -s ${flag.short}`;
+    }
+    if (flag.takesValue === true) {
+      cmd += " -r";
+    }
+    cmd += ` -d '${desc}'`;
+    output += cmd + "\n";
+  }
+  return output;
+};
+var generateCommandCompletions = (appName, node, path) => {
+  let output = "";
+  let condition;
+  if (path.length === 0) {
+    condition = "-n __fish_use_subcommand";
+  } else {
+    const pathConditions = path.map((p) => `__fish_seen_subcommand_from ${p}`).join("; and ");
+    condition = `-n "${pathConditions}"`;
+  }
+  if (node.children !== void 0 && node.children.length > 0) {
+    for (const child of node.children) {
+      const desc = escapeFish(child.description ?? child.name);
+      if (path.length === 0) {
+        output += `complete -c ${appName} -f ${condition} `;
+        output += `-a "${child.name}" -d '${desc}'
+`;
+      } else {
+        const parentCondition = `-n "__fish_seen_subcommand_from ${path[path.length - 1]}"`;
+        output += `complete -c ${appName} -f ${parentCondition} `;
+        output += `-a "${child.name}" -d '${desc}'
+`;
+      }
+    }
+    for (const child of node.children) {
+      output += generateCommandCompletions(appName, child, [
+        ...path,
+        child.name
+      ]);
+    }
+  }
+  if (node.flags !== void 0 && node.flags.length > 0) {
+    output += generateFlagCompletions2(appName, node.flags, condition);
+  }
+  return output;
+};
+var generate3 = (appName, tree) => {
+  let output = `# ${appName} fish completion
+`;
+  output += `# Generated by @eser/shell/completions
+
+`;
+  output += `complete -c ${appName} -f
+
+`;
+  output += generateCommandCompletions(appName, tree, []);
+  return output;
+};
+
+// pkg/@eser/shell/completions/mod.ts
+var generate4 = (shell, appName, tree) => {
+  switch (shell) {
+    case "bash":
+      return generate(appName, tree);
+    case "zsh":
+      return generate2(appName, tree);
+    case "fish":
+      return generate3(appName, tree);
+  }
+};
+
+// pkg/@eser/shell/args/command.ts
+var Command = class {
+  #name;
+  #description;
+  #usage;
+  #examples = [];
+  #aliases = [];
+  #flags = [];
+  #persistentFlags = [];
+  #children = [];
+  #handler;
+  #argsConfig = {
+    validation: "none"
+  };
+  #version;
+  #parent;
+  constructor(name) {
+    this.#name = name;
+  }
+  /** Get the command name */
+  get name() {
+    return this.#name;
+  }
+  /** Set command description */
+  description(text) {
+    this.#description = text;
+    return this;
+  }
+  /** Set custom usage string */
+  usage(text) {
+    this.#usage = text;
+    return this;
+  }
+  /** Add usage example */
+  example(text) {
+    this.#examples.push(text);
+    return this;
+  }
+  /** Set command aliases */
+  aliases(...names) {
+    this.#aliases = names;
+    return this;
+  }
+  /** Set version (for root command) */
+  version(v) {
+    this.#version = v;
+    return this;
+  }
+  /** Add a local flag (only available to this command) */
+  flag(def) {
+    this.#flags.push(def);
+    return this;
+  }
+  /** Add a persistent flag (available to this command and all subcommands) */
+  persistentFlag(def) {
+    this.#persistentFlags.push({
+      ...def,
+      persistent: true
+    });
+    return this;
+  }
+  /** Configure argument validation */
+  args(validation, count) {
+    if (validation === "exact" && typeof count === "number") {
+      this.#argsConfig = {
+        validation,
+        count
+      };
+    } else if (validation === "min" && typeof count === "number") {
+      this.#argsConfig = {
+        validation,
+        min: count
+      };
+    } else if (validation === "max" && typeof count === "number") {
+      this.#argsConfig = {
+        validation,
+        max: count
+      };
+    } else if (validation === "range" && Array.isArray(count)) {
+      this.#argsConfig = {
+        validation,
+        min: count[0],
+        max: count[1]
+      };
+    } else {
+      this.#argsConfig = {
+        validation
+      };
+    }
+    return this;
+  }
+  /** Add a single subcommand */
+  command(child) {
+    child.#parent = this;
+    this.#children.push(child);
+    return this;
+  }
+  /** Add multiple subcommands */
+  commands(...children) {
+    for (const child of children) {
+      this.command(child);
+    }
+    return this;
+  }
+  /** Set the command handler */
+  run(handler) {
+    this.#handler = handler;
+    return this;
+  }
+  /** Get all flags including inherited persistent flags */
+  #getAllFlags() {
+    const inherited = [];
+    let current = this.#parent;
+    while (current !== void 0) {
+      inherited.push(...current.#persistentFlags);
+      current = current.#parent;
+    }
+    return [
+      ...inherited,
+      ...this.#persistentFlags,
+      ...this.#flags
+    ];
+  }
+  /** Get the root command */
+  #getRoot() {
+    if (this.#parent === void 0) {
+      return this;
+    }
+    return this.#parent.#getRoot();
+  }
+  /** Get the command path from root */
+  #getPath() {
+    if (this.#parent === void 0) {
+      return [
+        this.#name
+      ];
+    }
+    return [
+      ...this.#parent.#getPath(),
+      this.#name
+    ];
+  }
+  /** Find a child command by name or alias */
+  #findChild(name) {
+    return this.#children.find((c) => c.#name === name || c.#aliases.includes(name));
+  }
+  /** Validate argument count */
+  #validateArgs(args) {
+    const { validation, count, min, max } = this.#argsConfig;
+    const len = args.length;
+    switch (validation) {
+      case "no-args":
+        if (len > 0) return `This command takes no arguments`;
+        break;
+      case "exact":
+        if (len !== count) {
+          return `Expected exactly ${count} argument(s), got ${len}`;
+        }
+        break;
+      case "min":
+        if (len < (min ?? 0)) {
+          return `Expected at least ${min} argument(s), got ${len}`;
+        }
+        break;
+      case "max":
+        if (len > (max ?? Infinity)) {
+          return `Expected at most ${max} argument(s), got ${len}`;
+        }
+        break;
+      case "range":
+        if (len < (min ?? 0) || len > (max ?? Infinity)) {
+          return `Expected ${min}-${max} arguments, got ${len}`;
+        }
+        break;
+    }
+    return void 0;
+  }
+  /** Parse and execute the command */
+  async parse(argv) {
+    const inputArgs = argv ?? runtime.process.args;
+    await this.#execute(inputArgs, []);
+  }
+  async #execute(argv, parentPath) {
+    const allFlags = this.#getAllFlags();
+    const parseOptions = buildParseOptions(allFlags);
+    const parsed = parseArgs(argv, {
+      ...parseOptions,
+      stopEarly: this.#children.length > 0
+    });
+    const flags = extractFlags(parsed, allFlags);
+    const positional = parsed._;
+    if (this.#version !== void 0 && flags["version"] === true) {
+      console.log(`${this.#name} ${this.#version}`);
+      return;
+    }
+    if (flags["help"] === true) {
+      console.log(this.help());
+      return;
+    }
+    const firstArg = positional[0];
+    if (firstArg !== void 0 && this.#children.length > 0) {
+      const child = this.#findChild(firstArg);
+      if (child !== void 0) {
+        await child.#execute(positional.slice(1), [
+          ...parentPath,
+          this.#name
+        ]);
+        return;
+      }
+    }
+    if (this.#handler === void 0) {
+      console.log(this.help());
+      return;
+    }
+    const flagErrors = validateRequiredFlags(flags, allFlags);
+    if (flagErrors.length > 0) {
+      console.error(flagErrors.join("\n"));
+      runtime.process.exit(1);
+    }
+    const argsError = this.#validateArgs(positional);
+    if (argsError !== void 0) {
+      console.error(argsError);
+      runtime.process.exit(1);
+    }
+    const commandPath = [
+      ...parentPath,
+      this.#name
+    ];
+    const ctx = {
+      args: positional,
+      flags,
+      root: this.#getRoot(),
+      commandPath
+    };
+    await this.#handler(ctx);
+  }
+  /** Generate help text */
+  help() {
+    const meta = {
+      name: this.#name,
+      description: this.#description,
+      usage: this.#usage,
+      examples: this.#examples,
+      flags: this.#getAllFlags(),
+      children: this.#children.map((c) => ({
+        name: c.#name,
+        description: c.#description,
+        usage: c.#usage,
+        examples: c.#examples,
+        flags: c.#getAllFlags(),
+        children: []
+      }))
+    };
+    return generateHelp(meta, this.#getPath());
+  }
+  /** Build completion tree from command structure */
+  #buildCompletionTree() {
+    const flagsToCompletionFlags = (flags) => {
+      return flags.map((f) => ({
+        name: f.name,
+        short: f.short,
+        description: f.description,
+        takesValue: f.type !== "boolean"
+      }));
+    };
+    const buildNode = (cmd) => ({
+      name: cmd.#name,
+      description: cmd.#description,
+      children: cmd.#children.map(buildNode),
+      flags: flagsToCompletionFlags(cmd.#getAllFlags())
+    });
+    return buildNode(this);
+  }
+  /** Generate shell completion script */
+  completions(shell) {
+    const tree = this.#buildCompletionTree();
+    return generate4(shell, this.#name, tree);
+  }
+};
+
+// pkg/@eser/shell/exec/types.ts
+var CommandError = class extends Error {
+  command;
+  code;
+  stderr;
+  constructor(message, command, code2, stderr) {
+    super(message), this.command = command, this.code = code2, this.stderr = stderr;
+    this.name = "CommandError";
+  }
+};
+
+// pkg/@eser/shell/exec/command.ts
+var decoder = new TextDecoder();
+var CommandBuilder = class _CommandBuilder {
+  #cmd;
+  #args;
+  #options;
+  constructor(cmd, args = [], options = {}) {
+    this.#cmd = cmd;
+    this.#args = args;
+    this.#options = {
+      throwOnError: true,
+      stdout: "piped",
+      stderr: "piped",
+      ...options
+    };
+  }
+  /** Set working directory */
+  cwd(path) {
+    return new _CommandBuilder(this.#cmd, this.#args, {
+      ...this.#options,
+      cwd: path
+    });
+  }
+  /** Set environment variable(s) */
+  env(keyOrVars, value2) {
+    const currentEnv = this.#options.env ?? {};
+    let newEnv;
+    if (typeof keyOrVars === "string" && value2 !== void 0) {
+      newEnv = {
+        ...currentEnv,
+        [keyOrVars]: value2
+      };
+    } else if (typeof keyOrVars === "object") {
+      newEnv = {
+        ...currentEnv,
+        ...keyOrVars
+      };
+    } else {
+      newEnv = currentEnv;
+    }
+    return new _CommandBuilder(this.#cmd, this.#args, {
+      ...this.#options,
+      env: newEnv
+    });
+  }
+  /** Set stdin handling */
+  stdin(option) {
+    return new _CommandBuilder(this.#cmd, this.#args, {
+      ...this.#options,
+      stdin: option
+    });
+  }
+  /** Set stdout handling */
+  stdout(option) {
+    return new _CommandBuilder(this.#cmd, this.#args, {
+      ...this.#options,
+      stdout: option
+    });
+  }
+  /** Set stderr handling */
+  stderr(option) {
+    return new _CommandBuilder(this.#cmd, this.#args, {
+      ...this.#options,
+      stderr: option
+    });
+  }
+  /** Set timeout in milliseconds */
+  timeout(ms) {
+    return new _CommandBuilder(this.#cmd, this.#args, {
+      ...this.#options,
+      timeout: ms
+    });
+  }
+  /** Disable throwing on non-zero exit code */
+  noThrow() {
+    return new _CommandBuilder(this.#cmd, this.#args, {
+      ...this.#options,
+      throwOnError: false
+    });
+  }
+  /** Suppress all output (null stdout and stderr) */
+  quiet() {
+    return new _CommandBuilder(this.#cmd, this.#args, {
+      ...this.#options,
+      stdout: "null",
+      stderr: "null"
+    });
+  }
+  /** Print command before execution */
+  printCommand() {
+    const fullCmd = [
+      this.#cmd,
+      ...this.#args
+    ].join(" ");
+    console.log(`$ ${fullCmd}`);
+    return this;
+  }
+  /** Execute command and return result */
+  async spawn() {
+    const { runtime: runtime2 } = mod_exports2;
+    const result = await runtime2.exec.spawn(this.#cmd, this.#args, {
+      cwd: this.#options.cwd,
+      env: this.#options.env,
+      stdin: this.#options.stdin,
+      stdout: this.#options.stdout,
+      stderr: this.#options.stderr
+    });
+    if (!result.success && this.#options.throwOnError === true) {
+      const stderrText = decoder.decode(result.stderr);
+      throw new CommandError(`Command failed with exit code ${result.code}: ${this.#cmd}`, this.#cmd, result.code, stderrText);
+    }
+    return result;
+  }
+  /** Execute and return stdout as trimmed text */
+  async text(stream = "stdout") {
+    const result = await this.spawn();
+    switch (stream) {
+      case "stdout":
+        return decoder.decode(result.stdout).trim();
+      case "stderr":
+        return decoder.decode(result.stderr).trim();
+      case "combined":
+        return (decoder.decode(result.stdout) + decoder.decode(result.stderr)).trim();
+    }
+  }
+  /** Execute and parse stdout as JSON */
+  async json() {
+    const text = await this.text();
+    return JSON.parse(text);
+  }
+  /** Execute and return stdout as lines */
+  async lines() {
+    const text = await this.text();
+    if (text === "") return [];
+    return text.split("\n");
+  }
+  /** Execute and return stdout as bytes */
+  async bytes() {
+    const result = await this.spawn();
+    return result.stdout;
+  }
+  /** Execute and return only the exit code (never throws) */
+  async code() {
+    const result = await this.noThrow().spawn();
+    return result.code;
+  }
+  /** Pipe this command's output to another command */
+  pipe(next) {
+    return new PipedCommandBuilder([
+      this,
+      next
+    ]);
+  }
+  /**
+   * Spawn child process with streaming I/O support.
+   * Returns a handle with stdin/stdout/stderr streams for advanced use cases.
+   *
+   * @example
+   * ```ts
+   * const child = exec`deno fmt -`.child();
+   * await input.pipeTo(child.stdin!);
+   * const { stdout } = await child.output();
+   * ```
+   */
+  child() {
+    const { runtime: runtime2 } = mod_exports2;
+    return runtime2.exec.spawnChild(this.#cmd, this.#args, {
+      cwd: this.#options.cwd,
+      env: this.#options.env,
+      stdin: this.#options.stdin ?? "piped",
+      stdout: this.#options.stdout ?? "piped",
+      stderr: this.#options.stderr ?? "piped"
+    });
+  }
+};
+var PipedCommandBuilder = class _PipedCommandBuilder {
+  #commands;
+  constructor(commands2) {
+    this.#commands = commands2;
+  }
+  /** Add another command to the pipeline */
+  pipe(next) {
+    return new _PipedCommandBuilder([
+      ...this.#commands,
+      next
+    ]);
+  }
+  /** Execute the pipeline and return final stdout as text */
+  async text() {
+    let input = "";
+    for (const cmd of this.#commands) {
+      const result = await cmd.spawn();
+      input = decoder.decode(result.stdout);
+    }
+    return input.trim();
+  }
+  /** Execute the pipeline and return final stdout as lines */
+  async lines() {
+    const text = await this.text();
+    if (text === "") return [];
+    return text.split("\n");
+  }
+};
+
+// pkg/@eser/shell/exec/parser.ts
+var parseCommand = (strings, values) => {
+  const parts = [];
+  for (let i = 0; i < strings.length; i++) {
+    const str2 = strings[i];
+    if (str2 !== void 0) {
+      parts.push(str2);
+    }
+    if (i < values.length) {
+      const value2 = values[i];
+      if (Array.isArray(value2)) {
+        parts.push(value2.map((v) => escapeArg(String(v))).join(" "));
+      } else if (value2 !== void 0 && value2 !== null) {
+        parts.push(escapeArg(String(value2)));
+      }
+    }
+  }
+  const fullCommand = parts.join("").trim();
+  return splitCommand(fullCommand);
+};
+var escapeArg = (arg) => {
+  if (/[\s"'\\$`]/.test(arg)) {
+    return `'${arg.replace(/'/g, "'\\''")}'`;
+  }
+  return arg;
+};
+var splitCommand = (input) => {
+  const tokens = [];
+  let current = "";
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let escape = false;
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+    if (escape) {
+      current += char;
+      escape = false;
+      continue;
+    }
+    if (char === "\\") {
+      escape = true;
+      continue;
+    }
+    if (char === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote;
+      continue;
+    }
+    if (char === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+      continue;
+    }
+    if (char === " " && !inSingleQuote && !inDoubleQuote) {
+      if (current.length > 0) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (current.length > 0) {
+    tokens.push(current);
+  }
+  const firstToken = tokens[0];
+  if (firstToken === void 0) {
+    return [
+      "",
+      []
+    ];
+  }
+  return [
+    firstToken,
+    tokens.slice(1)
+  ];
+};
+
+// pkg/@eser/shell/exec/exec.ts
+var exec = (strings, ...values) => {
+  const [cmd, args] = parseCommand(strings, values);
+  return new CommandBuilder(cmd, args);
+};
+
+// pkg/@eser/shell/env/detector.ts
+var getHomeDir = () => {
+  const { runtime: runtime2 } = mod_exports2;
+  return runtime2.env.get("HOME") ?? "";
+};
+var detectShell = () => {
+  const { runtime: runtime2 } = mod_exports2;
+  const shellPath = runtime2.env.get("SHELL") ?? "";
+  if (shellPath.includes("zsh")) {
+    return "zsh";
+  }
+  if (shellPath.includes("fish")) {
+    return "fish";
+  }
+  return "bash";
+};
+var getRcFilePath = (shell) => {
+  const home = getHomeDir();
+  switch (shell) {
+    case "zsh":
+      return join4(home, ".zshrc");
+    case "bash":
+      return join4(home, ".bashrc");
+    case "fish":
+      return join4(home, ".config", "fish", "config.fish");
+  }
+};
+var getCompletionsFilePath = (shell, appName) => {
+  const home = getHomeDir();
+  switch (shell) {
+    case "zsh":
+      return join4(home, ".zshrc");
+    case "bash":
+      return join4(home, ".bashrc");
+    case "fish":
+      return join4(home, ".config", "fish", "completions", `${appName}.fish`);
+  }
+};
+var getCompletionEvalLine = (shell, appName) => {
+  return `eval "$(${appName} system completions --shell ${shell})"`;
+};
+var getCompletionType = (shell) => {
+  return shell === "fish" ? "file" : "eval";
+};
+var getShellConfig = (shell, appName = "eser") => {
+  const detectedShell = shell ?? detectShell();
+  const completionType = getCompletionType(detectedShell);
+  return {
+    shell: detectedShell,
+    rcFile: getRcFilePath(detectedShell),
+    completionType,
+    completionsFile: completionType === "file" ? getCompletionsFilePath(detectedShell, appName) : void 0
+  };
+};
+
+// pkg/@eser/cli/commands/handlers/completions-setup.ts
+var COMPLETION_MARKER = "# eser CLI completions";
+var APP_NAME = "eser";
+var readFileOrEmpty = async (path) => {
+  const { runtime: runtime2 } = mod_exports2;
+  try {
+    return await runtime2.fs.readTextFile(path);
+  } catch {
+    return "";
+  }
+};
+var fileExists = async (path) => {
+  const { runtime: runtime2 } = mod_exports2;
+  try {
+    await runtime2.fs.stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var hasCompletions = async (shell) => {
+  const config = getShellConfig(shell, APP_NAME);
+  if (config.completionType === "file") {
+    return await fileExists(config.completionsFile);
+  }
+  const content = await readFileOrEmpty(config.rcFile);
+  const line = getCompletionEvalLine(shell, APP_NAME);
+  return content.includes(line);
+};
+var addCompletions = async (shell) => {
+  const { runtime: runtime2 } = mod_exports2;
+  const config = getShellConfig(shell, APP_NAME);
+  try {
+    if (config.completionType === "file") {
+      const fishPath = config.completionsFile;
+      const dir = dirname4(fishPath);
+      try {
+        await runtime2.fs.mkdir(dir, {
+          recursive: true
+        });
+      } catch {
+      }
+      const fishScript = `# eser CLI completions
+# This file is auto-generated. Run 'eser system completions --shell fish' to regenerate.
+complete -c eser -f
+complete -c eser -n "__fish_use_subcommand" -a "codebase" -d "Codebase validation and management tools"
+complete -c eser -n "__fish_use_subcommand" -a "system" -d "System management and setup tools"
+complete -c eser -n "__fish_use_subcommand" -a "install" -d "Install eser CLI globally"
+complete -c eser -n "__fish_use_subcommand" -a "update" -d "Update eser CLI to latest version"
+complete -c eser -n "__fish_seen_subcommand_from system" -a "install" -d "Install eser CLI globally"
+complete -c eser -n "__fish_seen_subcommand_from system" -a "uninstall" -d "Uninstall eser CLI globally"
+complete -c eser -n "__fish_seen_subcommand_from system" -a "update" -d "Update eser CLI to latest version"
+complete -c eser -n "__fish_seen_subcommand_from system" -a "completions" -d "Generate shell completion scripts"
+`;
+      await runtime2.fs.writeTextFile(fishPath, fishScript);
+      console.log(`  ${dim("Created")} ${cyan(fishPath)}`);
+    } else {
+      const content = await readFileOrEmpty(config.rcFile);
+      const line = getCompletionEvalLine(shell, APP_NAME);
+      if (!content.includes(line)) {
+        const addition = `
+${COMPLETION_MARKER}
+${line}
+`;
+        await runtime2.fs.writeTextFile(config.rcFile, content + addition);
+        console.log(`  ${dim("Added completions to")} ${cyan(config.rcFile)}`);
+      }
+    }
+  } catch (error) {
+    console.log(yellow(`  Warning: Could not add shell completions: ${error instanceof Error ? error.message : String(error)}`));
+  }
+};
+var removeCompletions = async (shell) => {
+  const { runtime: runtime2 } = mod_exports2;
+  const config = getShellConfig(shell, APP_NAME);
+  try {
+    if (config.completionType === "file") {
+      const fishPath = config.completionsFile;
+      if (await fileExists(fishPath)) {
+        await runtime2.fs.remove(fishPath);
+        console.log(`  ${dim("Removed")} ${cyan(fishPath)}`);
+      }
+    } else {
+      const content = await readFileOrEmpty(config.rcFile);
+      if (content === "") {
+        return;
+      }
+      const line = getCompletionEvalLine(shell, APP_NAME);
+      if (!content.includes(line)) {
+        return;
+      }
+      const filtered = content.split("\n").filter((l) => !l.includes("eser system completions")).filter((l) => l !== COMPLETION_MARKER).join("\n").replace(/\n{3,}/g, "\n\n");
+      await runtime2.fs.writeTextFile(config.rcFile, filtered);
+      console.log(`  ${dim("Removed completions from")} ${cyan(config.rcFile)}`);
+    }
+  } catch (error) {
+    console.log(yellow(`  Warning: Could not remove shell completions: ${error instanceof Error ? error.message : String(error)}`));
+  }
+};
+
+// pkg/@eser/cli/commands/handlers/install.ts
+var INSTALL_CONFIGS = {
+  deno: {
+    cmd: "deno",
+    args: [
+      "install",
+      "-g",
+      "-A",
+      "--name",
+      "eser",
+      "jsr:@eser/cli"
+    ]
+  },
+  node: {
+    cmd: "npm",
+    args: [
+      "install",
+      "-g",
+      "eser"
+    ]
+  },
+  bun: {
+    cmd: "bun",
+    args: [
+      "install",
+      "-g",
+      "eser"
+    ]
+  }
+};
+var installHandler = async (_ctx) => {
+  const { runtime: runtime2 } = mod_exports2;
+  const runtimeName = detectRuntime();
+  console.log(`Detected runtime: ${cyan(runtimeName)}`);
+  const config = INSTALL_CONFIGS[runtimeName];
+  if (config === void 0) {
+    console.error(red(`
+Unsupported runtime: ${runtimeName}`));
+    console.error("Global installation is only supported for Deno, Node.js, and Bun.");
+    runtime2.process.exit(1);
+    return;
+  }
+  const { cmd, args } = config;
+  console.log(dim(`Running: ${cmd} ${args.join(" ")}`));
+  console.log("");
+  const result = await exec`${cmd} ${args}`.stdout("inherit").stderr("inherit").noThrow().spawn();
+  if (result.success) {
+    console.log(green("\nInstallation complete!"));
+    console.log(`You can now use ${cyan("eser")} from anywhere in your terminal.`);
+    const shell = detectShell();
+    const alreadyHasCompletions = await hasCompletions(shell);
+    if (!alreadyHasCompletions) {
+      console.log(`
+Setting up ${cyan(shell)} completions...`);
+      await addCompletions(shell);
+      const shellConfig = getShellConfig(shell);
+      if (shellConfig.completionType === "eval") {
+        console.log(dim(`  Restart your shell or run 'source ${shellConfig.rcFile}' to enable completions.`));
+      }
+    }
+  } else {
+    console.error(red("\nInstallation failed."));
+  }
+  runtime2.process.exit(result.code);
+};
+
+// pkg/@eser/cli/commands/handlers/uninstall.ts
+var UNINSTALL_CONFIGS = {
+  deno: {
+    cmd: "deno",
+    args: [
+      "uninstall",
+      "-g",
+      "eser"
+    ]
+  },
+  node: {
+    cmd: "npm",
+    args: [
+      "uninstall",
+      "-g",
+      "eser"
+    ]
+  },
+  bun: {
+    cmd: "bun",
+    args: [
+      "remove",
+      "-g",
+      "eser"
+    ]
+  }
+};
+var uninstallHandler = async (_ctx) => {
+  const { runtime: runtime2 } = mod_exports2;
+  const runtimeName = detectRuntime();
+  console.log(`Detected runtime: ${cyan(runtimeName)}`);
+  const config = UNINSTALL_CONFIGS[runtimeName];
+  if (config === void 0) {
+    console.error(red(`
+Unsupported runtime: ${runtimeName}`));
+    console.error("Global uninstallation is only supported for Deno, Node.js, and Bun.");
+    runtime2.process.exit(1);
+    return;
+  }
+  const { cmd, args } = config;
+  const shell = detectShell();
+  console.log(`
+Removing ${cyan(shell)} completions...`);
+  await removeCompletions(shell);
+  console.log(dim(`
+Running: ${cmd} ${args.join(" ")}`));
+  console.log("");
+  const result = await exec`${cmd} ${args}`.stdout("inherit").stderr("inherit").noThrow().spawn();
+  if (result.success) {
+    console.log(green("\nUninstallation complete!"));
+    console.log(`The ${cyan("eser")} command has been removed from your system.`);
+  } else {
+    console.error(red("\nUninstallation failed."));
+  }
+  runtime2.process.exit(result.code);
+};
+
+// pkg/@eser/cli/commands/handlers/update.ts
+var UPDATE_CONFIGS = {
+  deno: {
+    cmd: "deno",
+    // Deno doesn't have an update command, so we reinstall with -f (force)
+    args: [
+      "install",
+      "-g",
+      "-A",
+      "-f",
+      "--name",
+      "eser",
+      "jsr:@eser/cli"
+    ]
+  },
+  node: {
+    cmd: "npm",
+    args: [
+      "update",
+      "-g",
+      "eser"
+    ]
+  },
+  bun: {
+    cmd: "bun",
+    args: [
+      "update",
+      "-g",
+      "eser"
+    ]
+  }
+};
+var updateHandler = async (_ctx) => {
+  const { runtime: runtime2 } = mod_exports2;
+  const runtimeName = detectRuntime();
+  console.log(`Detected runtime: ${cyan(runtimeName)}`);
+  const config = UPDATE_CONFIGS[runtimeName];
+  if (config === void 0) {
+    console.error(red(`
+Unsupported runtime: ${runtimeName}`));
+    console.error("Global update is only supported for Deno, Node.js, and Bun.");
+    runtime2.process.exit(1);
+    return;
+  }
+  const { cmd, args } = config;
+  console.log(dim(`Running: ${cmd} ${args.join(" ")}`));
+  console.log("");
+  const result = await exec`${cmd} ${args}`.stdout("inherit").stderr("inherit").noThrow().spawn();
+  if (result.success) {
+    console.log(green("\nUpdate complete!"));
+    console.log(`The ${cyan("eser")} command has been updated to the latest version.`);
+  } else {
+    console.error(red("\nUpdate failed."));
+  }
+  runtime2.process.exit(result.code);
+};
+
+// pkg/@eser/cli/commands/handlers/completions.ts
+var getInstallInstructions = (shell) => {
+  const config = getShellConfig(shell, "eser");
+  if (config.completionType === "file") {
+    return `
+To install, run:
+
+  ${dim(`eser system completions --shell fish > ${config.completionsFile}`)}
+`;
+  }
+  const evalLine = getCompletionEvalLine(shell, "eser");
+  return `
+To install, add the following to your ${cyan(config.rcFile)}:
+
+  ${dim(evalLine)}
+`;
+};
+var completionsHandler = (ctx) => {
+  const { runtime: runtime2 } = mod_exports2;
+  const shellFlag = ctx.flags["shell"];
+  let shell;
+  if (shellFlag !== void 0) {
+    if (![
+      "bash",
+      "zsh",
+      "fish"
+    ].includes(shellFlag)) {
+      console.error(red(`Invalid shell: ${shellFlag}`));
+      console.error("Supported shells: bash, zsh, fish");
+      runtime2.process.exit(1);
+    }
+    shell = shellFlag;
+  } else {
+    shell = detectShell();
+  }
+  const rootCommand = ctx.root;
+  const script = rootCommand.completions(shell);
+  if (shellFlag === void 0) {
+    console.log(`Generating ${cyan(shell)} completions...`);
+    console.log(getInstallInstructions(shell));
+    console.log(dim("--- Completion script ---\n"));
+  }
+  console.log(script);
+};
+
+// pkg/@eser/cli/commands/system.ts
+var systemCommand = new Command("system").description("System management and setup tools").command(new Command("install").description("Install eser CLI globally").run(installHandler)).command(new Command("uninstall").description("Uninstall eser CLI globally").run(uninstallHandler)).command(new Command("update").description("Update eser CLI to the latest version").run(updateHandler)).command(new Command("completions").description("Generate shell completion scripts").flag({
+  name: "shell",
+  type: "string",
+  description: "Shell type: bash, zsh, or fish"
+}).run(completionsHandler));
+
 // pkg/@eser/cli/package.json
 var package_default = {
   name: "@eser/cli",
-  version: "4.0.0",
+  version: "4.0.3",
   type: "module",
   exports: "./main.ts",
   bin: {
@@ -8330,14 +9976,43 @@ var package_default = {
 };
 
 // pkg/@eser/cli/main.ts
+var wrapCommand = (cmd) => {
+  return async (args, _flags) => {
+    await cmd.parse(args);
+  };
+};
+var wrapHandler = (handler, commandName) => {
+  return async (_args, flags) => {
+    const mockRoot = {
+      name: "eser",
+      completions: () => "",
+      help: () => ""
+    };
+    await handler({
+      args: [],
+      flags,
+      root: mockRoot,
+      commandPath: [
+        "eser",
+        commandName
+      ]
+    });
+  };
+};
 var commands = {
-  codebase: codebaseCommand
+  codebase: codebaseCommand,
+  system: wrapCommand(systemCommand),
+  install: wrapHandler(installHandler, "install"),
+  update: wrapHandler(updateHandler, "update")
 };
 var showHelp2 = () => {
   console.log("eser - Eser Ozvataf's command-line tooling to access things\n");
   console.log("Usage: eser <command> [subcommand] [options]\n");
   console.log("Commands:");
   console.log("  codebase    Codebase validation and management tools");
+  console.log("  system      System management and setup tools");
+  console.log("  install     Install eser CLI globally (alias for system install)");
+  console.log("  update      Update eser CLI to latest version (alias for system update)");
   console.log("\nOptions:");
   console.log("  -h, --help     Show this help message");
   console.log("  -v, --version  Show version number");