autohand-cli 0.8.2 → 0.9.0

package/dist/chunk-JJ4KA7HK.cjs

@@ -0,0 +1,2219 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkWTB7AFL6cjs = require('./chunk-WTB7AFL6.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkWRTXCQ3Vcjs = require('./chunk-WRTXCQ3V.cjs');
+
+
+var _chunkQ2IL4DDIcjs = require('./chunk-Q2IL4DDI.cjs');
+
+
+var _chunkIKUMVBCWcjs = require('./chunk-IKUMVBCW.cjs');
+
+
+
+
+
+var _chunkCH2J4PVEcjs = require('./chunk-CH2J4PVE.cjs');
+
+
+var _chunk46C73ZKKcjs = require('./chunk-46C73ZKK.cjs');
+
+
+var _chunkYWTIXHU6cjs = require('./chunk-YWTIXHU6.cjs');
+
+
+var _chunkE26KKI46cjs = require('./chunk-E26KKI46.cjs');
+
+
+
+var _chunkWGNMOVMTcjs = require('./chunk-WGNMOVMT.cjs');
+
+
+
+
+
+
+var _chunkCHI52KFRcjs = require('./chunk-CHI52KFR.cjs');
+
+// src/onboarding/projectAnalyzer.ts
+var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
+var _path = require('path');
+var ProjectAnalyzer = class {
+  constructor(workspaceRoot) {
+    this.workspaceRoot = workspaceRoot;
+  }
+  
+  /**
+   * Analyze the workspace and return project information
+   */
+  async analyze() {
+    const info = {};
+    await this.analyzeNodeProject(info);
+    await this.analyzeRustProject(info);
+    await this.analyzeGoProject(info);
+    await this.analyzePythonProject(info);
+    return info;
+  }
+  /**
+   * Analyze Node.js/JavaScript/TypeScript project
+   */
+  async analyzeNodeProject(info) {
+    const pkgPath = _path.join.call(void 0, this.workspaceRoot, "package.json");
+    if (!await _fsextra2.default.pathExists(pkgPath)) {
+      return;
+    }
+    try {
+      const pkg = await _fsextra2.default.readJson(pkgPath);
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (deps.typescript || _optionalChain([pkg, 'access', _ => _.devDependencies, 'optionalAccess', _2 => _2.typescript])) {
+        info.language = "TypeScript";
+      } else {
+        info.language = "JavaScript";
+      }
+      info.framework = this.detectNodeFramework(deps);
+      info.packageManager = await this.detectNodePackageManager();
+      info.testFramework = this.detectNodeTestFramework(deps);
+      info.linter = this.detectNodeLinter(deps);
+      info.formatter = this.detectNodeFormatter(deps);
+      info.buildTool = this.detectNodeBuildTool(deps);
+    } catch (e2) {
+    }
+  }
+  /**
+   * Detect Node.js framework from dependencies
+   */
+  detectNodeFramework(deps) {
+    if (deps.next) return "Next.js";
+    if (deps.nuxt) return "Nuxt";
+    if (deps["@remix-run/node"] || deps["@remix-run/react"]) return "Remix";
+    if (deps["@angular/core"]) return "Angular";
+    if (deps.svelte) return "Svelte";
+    if (deps.vue) return "Vue";
+    if (deps.react) return "React";
+    if (deps.solid) return "Solid";
+    if (deps["@nestjs/core"]) return "NestJS";
+    if (deps.fastify) return "Fastify";
+    if (deps.hono) return "Hono";
+    if (deps.koa) return "Koa";
+    if (deps.express) return "Express";
+    return void 0;
+  }
+  /**
+   * Detect Node.js package manager from lockfiles
+   */
+  async detectNodePackageManager() {
+    if (await _fsextra2.default.pathExists(_path.join.call(void 0, this.workspaceRoot, "bun.lockb")) || await _fsextra2.default.pathExists(_path.join.call(void 0, this.workspaceRoot, "bun.lock"))) {
+      return "bun";
+    }
+    if (await _fsextra2.default.pathExists(_path.join.call(void 0, this.workspaceRoot, "pnpm-lock.yaml"))) {
+      return "pnpm";
+    }
+    if (await _fsextra2.default.pathExists(_path.join.call(void 0, this.workspaceRoot, "yarn.lock"))) {
+      return "yarn";
+    }
+    if (await _fsextra2.default.pathExists(_path.join.call(void 0, this.workspaceRoot, "package-lock.json"))) {
+      return "npm";
+    }
+    return "npm";
+  }
+  /**
+   * Detect Node.js test framework
+   */
+  detectNodeTestFramework(deps) {
+    if (deps.vitest) return "Vitest";
+    if (deps.jest) return "Jest";
+    if (deps.mocha) return "Mocha";
+    if (deps.ava) return "AVA";
+    if (deps["@playwright/test"]) return "Playwright";
+    if (deps.cypress) return "Cypress";
+    if (deps.puppeteer) return "Puppeteer";
+    return void 0;
+  }
+  /**
+   * Detect Node.js linter
+   */
+  detectNodeLinter(deps) {
+    if (deps["@biomejs/biome"]) return "Biome";
+    if (deps.eslint) return "ESLint";
+    if (deps.oxlint) return "Oxlint";
+    return void 0;
+  }
+  /**
+   * Detect Node.js formatter
+   */
+  detectNodeFormatter(deps) {
+    if (deps.prettier) return "Prettier";
+    if (deps["@biomejs/biome"]) return "Biome";
+    if (deps.dprint) return "dprint";
+    return void 0;
+  }
+  /**
+   * Detect Node.js build tool
+   */
+  detectNodeBuildTool(deps) {
+    if (deps.vite) return "Vite";
+    if (deps.tsup) return "tsup";
+    if (deps.esbuild) return "esbuild";
+    if (deps.rollup) return "Rollup";
+    if (deps.webpack) return "Webpack";
+    if (deps.parcel) return "Parcel";
+    if (deps.turbopack || deps.turbo) return "Turbopack";
+    return void 0;
+  }
+  /**
+   * Analyze Rust project
+   */
+  async analyzeRustProject(info) {
+    const cargoPath = _path.join.call(void 0, this.workspaceRoot, "Cargo.toml");
+    if (!await _fsextra2.default.pathExists(cargoPath)) {
+      return;
+    }
+    info.language = "Rust";
+    info.packageManager = "cargo";
+    try {
+      const cargoContent = await _fsextra2.default.readFile(cargoPath, "utf-8");
+      if (cargoContent.includes("actix-web")) {
+        info.framework = "Actix";
+      } else if (cargoContent.includes("axum")) {
+        info.framework = "Axum";
+      } else if (cargoContent.includes("rocket")) {
+        info.framework = "Rocket";
+      } else if (cargoContent.includes("warp")) {
+        info.framework = "Warp";
+      } else if (cargoContent.includes("tauri")) {
+        info.framework = "Tauri";
+      }
+    } catch (e3) {
+    }
+  }
+  /**
+   * Analyze Go project
+   */
+  async analyzeGoProject(info) {
+    const goModPath = _path.join.call(void 0, this.workspaceRoot, "go.mod");
+    if (!await _fsextra2.default.pathExists(goModPath)) {
+      return;
+    }
+    info.language = "Go";
+    info.packageManager = "go";
+    try {
+      const goModContent = await _fsextra2.default.readFile(goModPath, "utf-8");
+      if (goModContent.includes("github.com/gin-gonic/gin")) {
+        info.framework = "Gin";
+      } else if (goModContent.includes("github.com/gofiber/fiber")) {
+        info.framework = "Fiber";
+      } else if (goModContent.includes("github.com/labstack/echo")) {
+        info.framework = "Echo";
+      } else if (goModContent.includes("github.com/gorilla/mux")) {
+        info.framework = "Gorilla";
+      }
+    } catch (e4) {
+    }
+  }
+  /**
+   * Analyze Python project
+   */
+  async analyzePythonProject(info) {
+    const pyprojectPath = _path.join.call(void 0, this.workspaceRoot, "pyproject.toml");
+    const requirementsPath = _path.join.call(void 0, this.workspaceRoot, "requirements.txt");
+    const poetryLockPath = _path.join.call(void 0, this.workspaceRoot, "poetry.lock");
+    const pipfilePath = _path.join.call(void 0, this.workspaceRoot, "Pipfile");
+    const hasPyproject = await _fsextra2.default.pathExists(pyprojectPath);
+    const hasRequirements = await _fsextra2.default.pathExists(requirementsPath);
+    if (!hasPyproject && !hasRequirements) {
+      return;
+    }
+    info.language = "Python";
+    if (await _fsextra2.default.pathExists(poetryLockPath)) {
+      info.packageManager = "poetry";
+    } else if (await _fsextra2.default.pathExists(pipfilePath)) {
+      info.packageManager = "pipenv";
+    } else if (hasPyproject) {
+      info.packageManager = "pip";
+    } else {
+      info.packageManager = "pip";
+    }
+    let depsContent = "";
+    try {
+      if (hasRequirements) {
+        depsContent = await _fsextra2.default.readFile(requirementsPath, "utf-8");
+      } else if (hasPyproject) {
+        depsContent = await _fsextra2.default.readFile(pyprojectPath, "utf-8");
+      }
+      if (depsContent.includes("django")) {
+        info.framework = "Django";
+      } else if (depsContent.includes("fastapi")) {
+        info.framework = "FastAPI";
+      } else if (depsContent.includes("flask")) {
+        info.framework = "Flask";
+      } else if (depsContent.includes("starlette")) {
+        info.framework = "Starlette";
+      } else if (depsContent.includes("tornado")) {
+        info.framework = "Tornado";
+      }
+      if (depsContent.includes("pytest")) {
+        info.testFramework = "pytest";
+      } else if (depsContent.includes("unittest")) {
+        info.testFramework = "unittest";
+      } else if (depsContent.includes("nose")) {
+        info.testFramework = "nose";
+      }
+      if (depsContent.includes("ruff")) {
+        info.linter = "Ruff";
+      } else if (depsContent.includes("flake8")) {
+        info.linter = "Flake8";
+      } else if (depsContent.includes("pylint")) {
+        info.linter = "Pylint";
+      }
+      if (depsContent.includes("black")) {
+        info.formatter = "Black";
+      } else if (depsContent.includes("ruff")) {
+        info.formatter = "Ruff";
+      } else if (depsContent.includes("autopep8")) {
+        info.formatter = "autopep8";
+      }
+    } catch (e5) {
+    }
+  }
+};
+
+// src/onboarding/agentsGenerator.ts
+var AgentsGenerator = class {
+  /**
+   * Generate AGENTS.md content
+   */
+  generateContent(info, options) {
+    const sections = [];
+    sections.push("# AGENTS.md");
+    sections.push("");
+    sections.push("This file helps Autohand understand how to work with this project.");
+    sections.push("");
+    sections.push(this.generateProjectOverview(info));
+    if (info.packageManager) {
+      sections.push(this.generateCommandsSection(info));
+    }
+    if (info.testFramework) {
+      sections.push(this.generateTestingSection(info));
+    }
+    if (info.framework) {
+      const frameworkSection = this.generateFrameworkSection(info);
+      if (frameworkSection) {
+        sections.push(frameworkSection);
+      }
+    }
+    sections.push(this.generateCodeStyleSection(info));
+    sections.push(this.generateConstraintsSection());
+    if (_optionalChain([options, 'optionalAccess', _3 => _3.customSections])) {
+      for (const section of options.customSections) {
+        sections.push(`## ${section.title}`);
+        sections.push("");
+        sections.push(section.content);
+        sections.push("");
+      }
+    }
+    return sections.join("\n");
+  }
+  /**
+   * Generate project overview section
+   */
+  generateProjectOverview(info) {
+    const lines = [];
+    lines.push("## Project Overview");
+    lines.push("");
+    if (info.language) {
+      lines.push(`- **Language**: ${info.language}`);
+    }
+    if (info.framework) {
+      lines.push(`- **Framework**: ${info.framework}`);
+    }
+    if (info.packageManager) {
+      lines.push(`- **Package Manager**: ${info.packageManager}`);
+    }
+    if (info.testFramework) {
+      lines.push(`- **Test Framework**: ${info.testFramework}`);
+    }
+    if (info.buildTool) {
+      lines.push(`- **Build Tool**: ${info.buildTool}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate commands section based on package manager
+   */
+  generateCommandsSection(info) {
+    const lines = [];
+    lines.push("## Commands");
+    lines.push("");
+    const pm = info.packageManager;
+    if (info.language === "Rust") {
+      lines.push("- **Build**: `cargo build`");
+      lines.push("- **Build (release)**: `cargo build --release`");
+      lines.push("- **Run**: `cargo run`");
+      lines.push("- **Test**: `cargo test`");
+      lines.push("- **Check**: `cargo check`");
+      lines.push("- **Format**: `cargo fmt`");
+      lines.push("- **Lint**: `cargo clippy`");
+    } else if (info.language === "Go") {
+      lines.push("- **Build**: `go build`");
+      lines.push("- **Run**: `go run .`");
+      lines.push("- **Test**: `go test ./...`");
+      lines.push("- **Format**: `go fmt ./...`");
+      lines.push("- **Vet**: `go vet ./...`");
+    } else if (info.language === "Python") {
+      if (pm === "poetry") {
+        lines.push("- **Install**: `poetry install`");
+        lines.push("- **Run**: `poetry run python main.py`");
+        lines.push("- **Add dependency**: `poetry add <package>`");
+        if (info.testFramework) {
+          lines.push(`- **Test**: \`poetry run pytest\``);
+        }
+      } else if (pm === "pipenv") {
+        lines.push("- **Install**: `pipenv install`");
+        lines.push("- **Run**: `pipenv run python main.py`");
+        if (info.testFramework) {
+          lines.push(`- **Test**: \`pipenv run pytest\``);
+        }
+      } else {
+        lines.push("- **Install**: `pip install -r requirements.txt`");
+        lines.push("- **Run**: `python main.py`");
+        if (info.testFramework) {
+          lines.push(`- **Test**: \`pytest\``);
+        }
+      }
+    } else {
+      const run = pm === "npm" ? "npm run" : pm;
+      const install = pm === "npm" ? "npm install" : `${pm} install`;
+      lines.push(`- **Install**: \`${install}\``);
+      lines.push(`- **Dev**: \`${run} dev\``);
+      lines.push(`- **Build**: \`${run} build\``);
+      if (info.testFramework) {
+        lines.push(`- **Test**: \`${run} test\``);
+      }
+      if (info.linter) {
+        lines.push(`- **Lint**: \`${run} lint\``);
+      }
+      if (info.formatter) {
+        lines.push(`- **Format**: \`${run} format\``);
+      }
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate testing section
+   */
+  generateTestingSection(info) {
+    const lines = [];
+    lines.push("## Testing");
+    lines.push("");
+    lines.push(`This project uses **${info.testFramework}** for testing.`);
+    lines.push("");
+    lines.push("- Write tests for new features before implementation");
+    lines.push("- Run tests before committing changes");
+    lines.push("- Aim for good test coverage on critical paths");
+    if (info.testFramework === "Vitest" || info.testFramework === "Jest") {
+      lines.push("- Use `describe` and `it` blocks to organize tests");
+      lines.push("- Mock external dependencies when appropriate");
+    } else if (info.testFramework === "pytest") {
+      lines.push("- Use fixtures for shared test setup");
+      lines.push("- Use `pytest.mark` for test categorization");
+    } else if (info.testFramework === "Playwright" || info.testFramework === "Cypress") {
+      lines.push("- Write E2E tests for critical user flows");
+      lines.push("- Keep selectors stable and meaningful");
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate framework-specific section
+   */
+  generateFrameworkSection(info) {
+    const lines = [];
+    switch (info.framework) {
+      case "Next.js":
+        lines.push("## Next.js Guidelines");
+        lines.push("");
+        lines.push("- Use the App Router for new pages (`app/` directory)");
+        lines.push("- Prefer Server Components by default");
+        lines.push('- Use `"use client"` only when needed for interactivity');
+        lines.push("- Keep API routes in `app/api/`");
+        lines.push("- Use `next/image` for optimized images");
+        lines.push("- Use `next/link` for client-side navigation");
+        break;
+      case "React":
+        lines.push("## React Guidelines");
+        lines.push("");
+        lines.push("- Use functional components with hooks");
+        lines.push("- Keep components small and focused");
+        lines.push("- Use custom hooks to share logic");
+        lines.push("- Prefer composition over inheritance");
+        lines.push("- Use TypeScript interfaces for props");
+        break;
+      case "Vue":
+        lines.push("## Vue Guidelines");
+        lines.push("");
+        lines.push("- Use Composition API for new components");
+        lines.push("- Keep components in single-file format (.vue)");
+        lines.push("- Use composables to share logic");
+        break;
+      case "Express":
+        lines.push("## Express Guidelines");
+        lines.push("");
+        lines.push("- Use middleware for cross-cutting concerns");
+        lines.push("- Keep route handlers thin, delegate to services");
+        lines.push("- Use async/await with proper error handling");
+        lines.push("- Validate request input before processing");
+        break;
+      case "FastAPI":
+        lines.push("## FastAPI Guidelines");
+        lines.push("");
+        lines.push("- Use Pydantic models for request/response validation");
+        lines.push("- Use dependency injection for shared resources");
+        lines.push("- Keep endpoints in organized routers");
+        lines.push("- Use async functions for I/O operations");
+        break;
+      case "Django":
+        lines.push("## Django Guidelines");
+        lines.push("");
+        lines.push("- Follow Django project structure conventions");
+        lines.push("- Use class-based views where appropriate");
+        lines.push("- Keep business logic in models or services");
+        lines.push("- Use Django ORM for database operations");
+        break;
+      case "Flask":
+        lines.push("## Flask Guidelines");
+        lines.push("");
+        lines.push("- Use blueprints to organize routes");
+        lines.push("- Keep route handlers focused");
+        lines.push("- Use Flask extensions for common functionality");
+        break;
+      case "NestJS":
+        lines.push("## NestJS Guidelines");
+        lines.push("");
+        lines.push("- Follow module-based architecture");
+        lines.push("- Use dependency injection");
+        lines.push("- Use decorators for metadata");
+        lines.push("- Keep controllers thin, services fat");
+        break;
+      default:
+        return null;
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate code style section
+   */
+  generateCodeStyleSection(info) {
+    const lines = [];
+    lines.push("## Code Style");
+    lines.push("");
+    if (info.language === "TypeScript") {
+      lines.push("- Use strict TypeScript settings");
+      lines.push("- Define types/interfaces for data structures");
+      lines.push("- Avoid `any` type - use `unknown` if type is truly unknown");
+      lines.push("- Use type inference where obvious");
+    } else if (info.language === "Python") {
+      lines.push("- Follow PEP 8 style guidelines");
+      lines.push("- Use type hints for function signatures");
+      lines.push("- Use docstrings for public functions");
+    } else if (info.language === "Rust") {
+      lines.push("- Follow Rust naming conventions (snake_case for functions)");
+      lines.push("- Use descriptive error types");
+      lines.push("- Prefer `Result` over panicking");
+    } else if (info.language === "Go") {
+      lines.push("- Follow Go idioms and conventions");
+      lines.push("- Use short variable names in small scopes");
+      lines.push("- Handle errors explicitly");
+    }
+    lines.push("- Follow existing patterns in the codebase");
+    lines.push("- Use meaningful variable and function names");
+    lines.push("- Add comments for complex logic");
+    lines.push("- Keep functions focused and small");
+    if (info.linter) {
+      lines.push(`- Run **${info.linter}** before committing`);
+    }
+    if (info.formatter) {
+      lines.push(`- Format code with **${info.formatter}**`);
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate constraints section
+   */
+  generateConstraintsSection() {
+    const lines = [];
+    lines.push("## Constraints");
+    lines.push("");
+    lines.push("- Do not modify files outside the project directory");
+    lines.push("- Ask before making breaking changes");
+    lines.push("- Prefer editing existing files over creating new ones");
+    lines.push("- Do not delete files without confirmation");
+    lines.push("- Keep dependencies minimal - avoid adding new ones without good reason");
+    lines.push("- Do not commit sensitive data (API keys, secrets, credentials)");
+    lines.push("");
+    return lines.join("\n");
+  }
+};
+
+// src/onboarding/setupWizard.ts
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+
+
+
+// src/providers/llamaCppSetup.ts
+function looksLikeLlamaCppProcess(commandLine, name = "") {
+  const haystack = `${name} ${commandLine}`.toLowerCase();
+  return haystack.includes("llama-server") || haystack.includes("llama.cpp");
+}
+function extractLlamaCppPort(commandLine) {
+  const match = commandLine.match(/(?:--port(?:=|\s+)|-p\s*)(\d{2,5})\b/i);
+  if (!match) return void 0;
+  const port = Number.parseInt(match[1], 10);
+  return Number.isFinite(port) ? port : void 0;
+}
+async function commandExists(command, cwd) {
+  const lookup = process.platform === "win32" ? { command: "where", args: [command] } : { command: "which", args: [command] };
+  try {
+    const result = await _chunkWTB7AFL6cjs.runCommand.call(void 0, lookup.command, lookup.args, cwd, { timeout: 5e3 });
+    return result.code === 0;
+  } catch (e6) {
+    try {
+      const fallback = await _chunkWTB7AFL6cjs.runCommand.call(void 0, command, ["--version"], cwd, { timeout: 5e3 });
+      return fallback.code === 0;
+    } catch (e7) {
+      return false;
+    }
+  }
+}
+function parseUnixProcesses(stdout) {
+  return stdout.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => {
+    const match = line.match(/^\d+\s+(.*)$/);
+    const commandLine = _nullishCoalesce(_optionalChain([match, 'optionalAccess', _4 => _4[1]]), () => ( line));
+    const name = _nullishCoalesce(commandLine.split(/\s+/)[0], () => ( ""));
+    return { name, commandLine };
+  });
+}
+function parseWindowsProcesses(stdout) {
+  const trimmed = stdout.trim();
+  if (!trimmed) return [];
+  try {
+    const parsed = JSON.parse(trimmed);
+    const items = Array.isArray(parsed) ? parsed : [parsed];
+    return items.map((item) => ({
+      name: _nullishCoalesce(item.Name, () => ( "")),
+      commandLine: _nullishCoalesce(item.CommandLine, () => ( ""))
+    }));
+  } catch (e8) {
+    return [];
+  }
+}
+async function listProcesses(cwd) {
+  if (process.platform === "win32") {
+    try {
+      const result = await _chunkWTB7AFL6cjs.runCommand.call(void 0, 
+        "powershell",
+        [
+          "-NoProfile",
+          "-Command",
+          "Get-CimInstance Win32_Process | Select-Object Name,CommandLine | ConvertTo-Json -Compress"
+        ],
+        cwd,
+        { timeout: 8e3 }
+      );
+      return result.code === 0 ? parseWindowsProcesses(result.stdout) : [];
+    } catch (e9) {
+      return [];
+    }
+  }
+  try {
+    const result = await _chunkWTB7AFL6cjs.runCommand.call(void 0, "ps", ["-ax", "-o", "pid=,command="], cwd, { timeout: 5e3 });
+    return result.code === 0 ? parseUnixProcesses(result.stdout) : [];
+  } catch (e10) {
+    return [];
+  }
+}
+async function detectInstallPlan(cwd) {
+  if (process.platform === "win32") {
+    if (await commandExists("winget", cwd)) {
+      return { command: "winget", args: ["install", "llama.cpp"], label: "winget install llama.cpp" };
+    }
+    return void 0;
+  }
+  if (await commandExists("brew", cwd)) {
+    return { command: "brew", args: ["install", "llama.cpp"], label: "brew install llama.cpp" };
+  }
+  if (await commandExists("nix", cwd)) {
+    return { command: "nix", args: ["profile", "install", "nixpkgs#llama-cpp"], label: "nix profile install nixpkgs#llama-cpp" };
+  }
+  return void 0;
+}
+async function probeLlamaCppPorts(candidatePorts) {
+  for (const port of candidatePorts) {
+    try {
+      const response = await fetch(`http://127.0.0.1:${port}/health`, { signal: AbortSignal.timeout(3e3) });
+      if (response.ok) {
+        return {
+          port,
+          baseUrl: `http://127.0.0.1:${port}`
+        };
+      }
+    } catch (e11) {
+    }
+  }
+  return {};
+}
+async function probeLlamaCppEnvironment(cwd) {
+  const processes = await listProcesses(cwd);
+  const llamaProcess = processes.find((proc) => looksLikeLlamaCppProcess(proc.commandLine, proc.name));
+  const installed = await commandExists("llama-server", cwd) || Boolean(llamaProcess);
+  const installPlan = installed ? void 0 : await detectInstallPlan(cwd);
+  const detectedPort = llamaProcess ? extractLlamaCppPort(llamaProcess.commandLine) : void 0;
+  const candidatePorts = [...new Set([detectedPort, 80, 8080].filter((port) => typeof port === "number"))];
+  const probe = await probeLlamaCppPorts(candidatePorts);
+  return {
+    installed,
+    running: Boolean(probe.baseUrl),
+    port: _nullishCoalesce(probe.port, () => ( detectedPort)),
+    baseUrl: probe.baseUrl,
+    installPlan
+  };
+}
+async function installLlamaCpp(plan, cwd) {
+  try {
+    const result = await _chunkWTB7AFL6cjs.runCommand.call(void 0, plan.command, plan.args, cwd, { timeout: 10 * 60 * 1e3 });
+    const output = [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
+    return {
+      ok: result.code === 0,
+      output
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      output: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+// src/onboarding/setupWizard.ts
+var SetupWizard = class {
+  
+  
+  
+  constructor(workspaceRoot, existingConfig) {
+    this.workspaceRoot = workspaceRoot;
+    this.existingConfig = _nullishCoalesce(existingConfig, () => ( null));
+    this.state = {
+      currentStep: "welcome",
+      skipped: [],
+      completed: false
+    };
+  }
+  /**
+   * Run the full onboarding wizard
+   */
+  async run(options) {
+    if (!_optionalChain([options, 'optionalAccess', _5 => _5.force]) && this.isAlreadyConfigured()) {
+      return {
+        success: true,
+        config: {},
+        skippedSteps: ["welcome", "language", "workspaceSafety", "provider", "apiKey", "model", "permissions", "telemetry", "preferences", "advanced", "agentsFile", "registration", "reviewSummary"],
+        cancelled: false
+      };
+    }
+    try {
+      if (!_optionalChain([options, 'optionalAccess', _6 => _6.skipWelcome])) {
+        await this.showWelcome();
+      }
+      await this.promptLanguage();
+      const safeWorkspace = await this.checkWorkspaceStep();
+      if (!safeWorkspace) return this.cancelled();
+      const provider = await this.promptProvider();
+      if (!provider) return this.cancelled();
+      if (provider === "azure") {
+        const azureResult = await this.promptAzureConfig();
+        if (!azureResult) return this.cancelled();
+      } else if (provider === "vertexai") {
+        const vertexaiResult = await this.promptVertexAIConfig();
+        if (!vertexaiResult) return this.cancelled();
+      } else {
+        if (provider === "llamacpp") {
+          const ready = await this.prepareLlamaCpp();
+          if (!ready) return this.cancelled();
+        }
+        if (provider === "openai") {
+          const authMode = await this.promptOpenAIAuthMode();
+          if (!authMode) return this.cancelled();
+          this.state.openAIAuthMode = authMode;
+          if (authMode === "chatgpt") {
+            const chatgptAuth = await this.promptOpenAIChatGPTAuth();
+            if (!chatgptAuth) return this.cancelled();
+            this.state.openAIChatGPTAuth = chatgptAuth;
+          } else {
+            const apiKey = await this.promptApiKey(provider);
+            if (apiKey === null) return this.cancelled();
+            await this.validateApiKeyDuringSetup();
+          }
+        } else if (this.requiresApiKey(provider)) {
+          const apiKey = await this.promptApiKey(provider);
+          if (apiKey === null) return this.cancelled();
+          await this.validateApiKeyDuringSetup();
+        }
+        const model = await this.promptModel(provider);
+        if (!model) return this.cancelled();
+        if (provider === "openai") {
+          await this.promptReasoningEffort();
+        }
+      }
+      if (this.isLocalProvider(provider)) {
+        const connected = await this.testLocalProviderConnection();
+        if (!connected) return this.cancelled();
+      }
+      await this.promptPermissions();
+      await this.promptTelemetry();
+      await this.promptAutoReport();
+      if (!_optionalChain([options, 'optionalAccess', _7 => _7.quickSetup])) {
+        await this.promptPreferences();
+      } else {
+        this.state.skipped.push("preferences");
+      }
+      if (!_optionalChain([options, 'optionalAccess', _8 => _8.quickSetup])) {
+        const wantsAdvanced = await _chunkCH2J4PVEcjs.showConfirm.call(void 0, {
+          title: _chunkCHI52KFRcjs.t.call(void 0, "setup.advanced.prompt"),
+          defaultValue: false
+        });
+        if (wantsAdvanced) {
+          await this.promptNotifications();
+          await this.promptNetwork();
+          await this.promptSearch();
+          await this.promptMcp();
+          await this.promptAgentBehavior();
+          await this.promptCommunitySkills();
+        } else {
+          this.state.skipped.push("advanced", "notifications", "network", "search", "mcp", "agentBehavior", "communitySkills");
+        }
+      } else {
+        this.state.skipped.push("advanced", "notifications", "network", "search", "mcp", "agentBehavior", "communitySkills");
+      }
+      await this.promptAgentsFile();
+      if (!_optionalChain([options, 'optionalAccess', _9 => _9.quickSetup])) {
+        await this.promptRegistration();
+      } else {
+        this.state.skipped.push("registration");
+      }
+      if (!_optionalChain([options, 'optionalAccess', _10 => _10.quickSetup])) {
+        const confirmed = await this.promptReviewConfirm();
+        if (!confirmed) {
+          this.state = { currentStep: "welcome", skipped: [], completed: false };
+          return this.run({ ...options, force: true });
+        }
+      }
+      return this.complete();
+    } catch (error) {
+      if (this.isCancellation(error)) {
+        return this.cancelled();
+      }
+      throw error;
+    }
+  }
+  /**
+   * Check if configuration is already complete
+   * Requires both a provider and a valid API key (for providers that need one)
+   */
+  isAlreadyConfigured() {
+    if (!this.existingConfig) return false;
+    const provider = this.existingConfig.provider;
+    if (!provider) return false;
+    const providerConfig = _chunk46C73ZKKcjs.getProviderConfig.call(void 0, this.existingConfig, provider);
+    if (!providerConfig) return false;
+    if (provider === "openai") {
+      return this.isOpenAIConfigured(providerConfig);
+    }
+    if (provider === "vertexai") {
+      const vertexaiConfig = providerConfig;
+      return !!(vertexaiConfig.authToken && vertexaiConfig.authToken.length >= 10);
+    }
+    if (this.requiresApiKey(provider)) {
+      const apiKey = providerConfig.apiKey;
+      if (!apiKey || apiKey === "replace-me" || apiKey.length < 10) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Show welcome screen
+   */
+  async showWelcome() {
+    console.clear();
+    console.log(_chalk2.default.gray(_chunkIKUMVBCWcjs.ASCII_FRIEND));
+    console.log();
+    console.log(_chalk2.default.cyan.bold("  Welcome to Autohand!"));
+    console.log(_chalk2.default.gray("  Your super fast self evolving coding agent"));
+    console.log();
+    console.log(_chalk2.default.white("  Let's get you set up in just a few steps."));
+    console.log();
+    await this.pressEnter();
+  }
+  /**
+   * Prompt for provider selection
+   */
+  async promptProvider() {
+    this.state.currentStep = "provider";
+    const providers = _chunkWRTXCQ3Vcjs.ProviderFactory.getProviderNames();
+    const options = providers.map((p) => ({
+      label: this.getProviderDisplayName(p),
+      value: p,
+      description: this.getProviderHint(p)
+    }));
+    const hasValidExistingProvider = _optionalChain([this, 'access', _11 => _11.existingConfig, 'optionalAccess', _12 => _12.provider]) && this.isProviderConfigured(this.existingConfig.provider);
+    let initialIndex = 0;
+    if (hasValidExistingProvider) {
+      initialIndex = providers.indexOf(this.existingConfig.provider);
+    }
+    const result = await _chunkCH2J4PVEcjs.showModal.call(void 0, {
+      title: _chunkCHI52KFRcjs.t.call(void 0, "providers.config.chooseProvider"),
+      options,
+      initialIndex: initialIndex >= 0 ? initialIndex : 0
+    });
+    if (!result) {
+      return null;
+    }
+    this.state.provider = result.value;
+    return result.value;
+  }
+  /**
+   * Check if a specific provider is fully configured (has API key if required)
+   */
+  isProviderConfigured(provider) {
+    if (!this.existingConfig) return false;
+    const providerConfig = _chunk46C73ZKKcjs.getProviderConfig.call(void 0, this.existingConfig, provider);
+    if (!providerConfig) return false;
+    if (provider === "openai") {
+      return this.isOpenAIConfigured(providerConfig);
+    }
+    if (provider === "vertexai") {
+      const vertexaiConfig = providerConfig;
+      return !!(vertexaiConfig.authToken && vertexaiConfig.authToken.length >= 10);
+    }
+    if (this.requiresApiKey(provider)) {
+      const apiKey = providerConfig.apiKey;
+      return apiKey && apiKey !== "replace-me" && apiKey.length >= 10;
+    }
+    return true;
+  }
+  /**
+   * Prompt for API key (cloud providers)
+   */
+  async promptApiKey(provider) {
+    this.state.currentStep = "apiKey";
+    const existingKey = this.getExistingApiKey(provider);
+    if (existingKey && existingKey !== "replace-me") {
+      const useExisting = await _chunkCH2J4PVEcjs.showConfirm.call(void 0, {
+        title: `Use existing ${this.getProviderDisplayName(provider)} API key? (ends with ...${existingKey.slice(-4)})`,
+        defaultValue: true
+      });
+      if (useExisting) {
+        this.state.apiKey = existingKey;
+        return existingKey;
+      }
+    }
+    console.log(_chalk2.default.gray("\n  " + _chunkCHI52KFRcjs.t.call(void 0, "providers.config.apiKeyUrl", { url: this.getApiKeyUrl(provider) }) + "\n"));
+    const apiKey = await _chunkCH2J4PVEcjs.showPassword.call(void 0, {
+      title: _chunkCHI52KFRcjs.t.call(void 0, "providers.config.enterApiKey", { provider: this.getProviderDisplayName(provider) }),
+      placeholder: _chunkCHI52KFRcjs.t.call(void 0, "ui.apiKeyPlaceholder"),
+      validate: (val) => {
+        if (!_optionalChain([val, 'optionalAccess', _13 => _13.trim, 'call', _14 => _14()])) return _chunkCHI52KFRcjs.t.call(void 0, "providers.config.apiKeyRequired");
+        if (val.length < 10) return _chunkCHI52KFRcjs.t.call(void 0, "providers.config.apiKeyTooShort");
+        return true;
+      }
+    });
+    if (!apiKey) {
+      return null;
+    }
+    this.state.apiKey = apiKey.trim();
+    return this.state.apiKey;
+  }
+  async promptOpenAIAuthMode() {
+    const result = await _chunkCH2J4PVEcjs.showModal.call(void 0, {
+      title: _chunkCHI52KFRcjs.t.call(void 0, "providers.openaiAuth.chooseTitle"),
+      options: [
+        {
+          label: _chunkCHI52KFRcjs.t.call(void 0, "providers.openaiAuth.apiKeyLabel"),
+          value: "api-key",
+          description: _chunkCHI52KFRcjs.t.call(void 0, "providers.openaiAuth.apiKeyDescription")
+        },
+        {
+          label: _chunkCHI52KFRcjs.t.call(void 0, "providers.openaiAuth.chatgptLabel"),
+          value: "chatgpt",
+          description: _chunkCHI52KFRcjs.t.call(void 0, "providers.openaiAuth.chatgptDescription")
+        }
+      ],
+      initialIndex: this.getExistingOpenAIAuthMode() === "chatgpt" ? 1 : 0
+    });
+    return _nullishCoalesce(_optionalChain([result, 'optionalAccess', _15 => _15.value]), () => ( null));
+  }
+  async promptOpenAIChatGPTAuth() {
+    const existing = this.getExistingOpenAIChatGPTAuth();
+    if (existing && !_chunkWRTXCQ3Vcjs.isChatGPTAuthExpired.call(void 0, existing)) {
+      this.state.openAIChatGPTAuth = existing;
+      return existing;
+    }
+    try {
+      console.log(_chalk2.default.gray(`
+  ${_chunkCHI52KFRcjs.t.call(void 0, "providers.openaiAuth.starting")}`));
+      const auth = await _chunkWRTXCQ3Vcjs.authenticateOpenAIChatGPT.call(void 0, {
+        onPrompt: ({ authorizationUrl, browserOpened }) => {
+          console.log(_chalk2.default.gray(`
+  ${_chunkCHI52KFRcjs.t.call(void 0, "providers.openaiAuth.browserPrompt")}`));
+          console.log(_chalk2.default.white(`  ${authorizationUrl}`));
+          console.log(_chalk2.default.gray(`  ${browserOpened ? _chunkCHI52KFRcjs.t.call(void 0, "providers.openaiAuth.browserOpened") : _chunkCHI52KFRcjs.t.call(void 0, "providers.openaiAuth.openManually")}`));
+          console.log(_chalk2.default.gray(`  ${_chunkCHI52KFRcjs.t.call(void 0, "providers.openaiAuth.waiting")}
+`));
+        }
+      });
+      this.state.openAIChatGPTAuth = auth;
+      return auth;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(_chalk2.default.red(`
+  ${_chunkCHI52KFRcjs.t.call(void 0, "providers.openaiAuth.failed", { message })}`));
+      throw error;
+    }
+  }
+  /**
+   * Prompt for model selection
+   */
+  async promptModel(provider) {
+    this.state.currentStep = "model";
+    const defaultModel = this.getDefaultModel(provider);
+    if (provider === "llamacpp") {
+      this.state.model = defaultModel;
+      return this.state.model;
+    }
+    if (provider === "zai") {
+      const options = _chunkWRTXCQ3Vcjs.ZAI_MODELS.map((modelName) => ({
+        label: modelName,
+        value: modelName
+      }));
+      const defaultIndex = Math.max(0, _chunkWRTXCQ3Vcjs.ZAI_MODELS.indexOf(defaultModel));
+      const result = await _chunkCH2J4PVEcjs.showModal.call(void 0, {
+        title: _chunkCHI52KFRcjs.t.call(void 0, "providers.config.selectModel"),
+        options,
+        initialIndex: defaultIndex >= 0 ? defaultIndex : 0
+      });
+      if (!result) {
+        return null;
+      }
+      this.state.model = result.value;
+      return this.state.model;
+    }
+    if (provider === "cerebras") {
+      const options = _chunkWRTXCQ3Vcjs.CEREBRAS_MODELS.map((modelName) => ({
+        label: modelName,
+        value: modelName
+      }));
+      const defaultIndex = Math.max(0, _chunkWRTXCQ3Vcjs.CEREBRAS_MODELS.indexOf(defaultModel));
+      const result = await _chunkCH2J4PVEcjs.showModal.call(void 0, {
+        title: _chunkCHI52KFRcjs.t.call(void 0, "providers.config.selectModel"),
+        options,
+        initialIndex: defaultIndex >= 0 ? defaultIndex : 0
+      });
+      if (!result) {
+        return null;
+      }
+      this.state.model = result.value;
+      return this.state.model;
+    }
+    if (provider === "deepseek") {
+      const options = _chunkWRTXCQ3Vcjs.DEEPSEEK_MODELS.map((modelName) => ({
+        label: modelName,
+        value: modelName
+      }));
+      const defaultIndex = Math.max(0, _chunkWRTXCQ3Vcjs.DEEPSEEK_MODELS.indexOf(defaultModel));
+      const result = await _chunkCH2J4PVEcjs.showModal.call(void 0, {
+        title: _chunkCHI52KFRcjs.t.call(void 0, "providers.config.selectModel"),
+        options,
+        initialIndex: defaultIndex >= 0 ? defaultIndex : 0
+      });
+      if (!result) {
+        return null;
+      }
+      this.state.model = result.value;
+      return this.state.model;
+    }
+    if (provider === "nvidia") {
+      const { NVIDIA_MODELS } = await Promise.resolve().then(() => _interopRequireWildcard(require("./NVIDIAProvider-MVTL62PR.cjs")));
+      const options = [...NVIDIA_MODELS].map((modelName) => ({
+        label: modelName,
+        value: modelName
+      }));
+      const defaultIndex = Math.max(0, [...NVIDIA_MODELS].indexOf(defaultModel));
+      const result = await _chunkCH2J4PVEcjs.showModal.call(void 0, {
+        title: _chunkCHI52KFRcjs.t.call(void 0, "providers.config.selectModel"),
+        options,
+        initialIndex: defaultIndex >= 0 ? defaultIndex : 0
+      });
+      if (!result) {
+        return null;
+      }
+      this.state.model = result.value;
+      return this.state.model;
+    }
+    const model = await _chunkCH2J4PVEcjs.showInput.call(void 0, {
+      title: _chunkCHI52KFRcjs.t.call(void 0, "providers.config.enterModelId"),
+      defaultValue: defaultModel,
+      validate: (val) => {
+        return _optionalChain([val, 'optionalAccess', _16 => _16.trim, 'call', _17 => _17()]) ? true : "Model is required";
+      }
+    });
+    if (!model) {
+      return null;
+    }
+    this.state.model = model.trim();
+    return this.state.model;
+  }
+  /**
+   * Prompt for reasoning effort level (OpenAI only)
+   */
+  async promptReasoningEffort() {
+    const options = [
+      { label: "none", value: "none", description: "No extended reasoning" },
+      { label: "low", value: "low", description: "Faster responses, minimal reasoning" },
+      { label: "medium", value: "medium", description: "Balanced speed and reasoning" },
+      { label: "high", value: "high", description: "Thorough reasoning (recommended)" },
+      { label: "xhigh", value: "xhigh", description: "Maximum reasoning depth" }
+    ];
+    const result = await _chunkCH2J4PVEcjs.showModal.call(void 0, {
+      title: _chunkCHI52KFRcjs.t.call(void 0, "providers.config.selectReasoningEffort"),
+      options,
+      initialIndex: 3
+      // default to 'high'
+    });
+    if (result) {
+      this.state.reasoningEffort = result.value;
+    }
+  }
+  /**
+   * Prompt for telemetry preference
+   */
+  async promptTelemetry() {
+    this.state.currentStep = "telemetry";
+    console.log();
+    console.log(_chalk2.default.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(_chalk2.default.white.bold("  Help us improve Autohand"));
+    console.log(_chalk2.default.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log();
+    console.log(_chalk2.default.gray("  We collect anonymous usage data to understand how"));
+    console.log(_chalk2.default.gray("  Autohand is used and where we can make it better."));
+    console.log();
+    console.log(_chalk2.default.gray("  What we collect:"));
+    console.log(_chalk2.default.gray("  - Command usage (which features are popular)"));
+    console.log(_chalk2.default.gray("  - Error rates (to fix bugs faster)"));
+    console.log(_chalk2.default.gray("  - Performance metrics (to speed things up)"));
+    console.log();
+    console.log(_chalk2.default.gray("  What we never collect:"));
+    console.log(_chalk2.default.gray("  - Your code or file contents"));
+    console.log(_chalk2.default.gray("  - API keys or credentials"));
+    console.log(_chalk2.default.gray("  - Personal information"));
+    console.log();
+    const telemetryEnabled = await _chunkCH2J4PVEcjs.showConfirm.call(void 0, {
+      title: "Share anonymous usage data to help improve Autohand?",
+      defaultValue: true
+    });
+    this.state.telemetryEnabled = telemetryEnabled;
+    if (telemetryEnabled) {
+      console.log(_chalk2.default.green("  Thanks for helping us improve Autohand!"));
+    } else {
+      console.log(_chalk2.default.gray("  No problem! You can change this anytime in config."));
+    }
+  }
+  /**
+   * Prompt for auto report issues preference
+   */
+  async promptAutoReport() {
+    this.state.currentStep = "autoReport";
+    console.log();
+    console.log(_chalk2.default.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(_chalk2.default.white.bold("  Auto Report Issues"));
+    console.log(_chalk2.default.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log();
+    console.log(_chalk2.default.gray("  When errors occur, Autohand can automatically report"));
+    console.log(_chalk2.default.gray("  them as GitHub issues to help us fix bugs faster."));
+    console.log();
+    console.log(_chalk2.default.gray("  What gets reported:"));
+    console.log(_chalk2.default.gray("  - Error type, message, and sanitized stack trace"));
+    console.log(_chalk2.default.gray("  - CLI version, platform, and model info"));
+    console.log();
+    console.log(_chalk2.default.gray("  What we never report:"));
+    console.log(_chalk2.default.gray("  - Your code or file contents"));
+    console.log(_chalk2.default.gray("  - API keys or credentials"));
+    console.log(_chalk2.default.gray("  - Personal information"));
+    console.log();
+    const autoReportEnabled = await _chunkCH2J4PVEcjs.showConfirm.call(void 0, {
+      title: "Automatically report errors to help us fix bugs faster?",
+      defaultValue: true
+    });
+    this.state.autoReportEnabled = autoReportEnabled;
+    if (autoReportEnabled) {
+      console.log(_chalk2.default.green("  Thanks! This helps us catch and fix issues quickly."));
+    } else {
+      console.log(_chalk2.default.gray("  No problem! You can enable this anytime in config."));
+    }
+  }
+  /**
+   * Prompt for additional preferences
+   */
+  async promptPreferences() {
+    this.state.currentStep = "preferences";
+    const configurePrefs = await _chunkCH2J4PVEcjs.showConfirm.call(void 0, {
+      title: "Would you like to configure additional preferences? (theme, auto-confirm)",
+      defaultValue: false
+    });
+    if (!configurePrefs) {
+      this.state.skipped.push("preferences");
+      return;
+    }
+    const themes = _chunkYWTIXHU6cjs.getBuiltInThemeNames.call(void 0, );
+    const themeDescriptions = {
+      dark: "Default dark theme",
+      light: "Light theme for light backgrounds",
+      dracula: "Popular Dracula color scheme",
+      sandy: "Warm, earthy desert tones",
+      tui: "New Zealand inspired colors",
+      "github-dark": "GitHub Dark terminal palette",
+      cappadocia: "Cappadocia-inspired rose valleys, dawn sky, and balloon colors",
+      rio: "Rio-inspired blue macaw, rainforest, and beach-light palette",
+      australia: "Australian coast, wattle, and eucalyptus palette"
+    };
+    const themeOptions = themes.map((themeName) => ({
+      label: themeName,
+      value: themeName,
+      description: themeDescriptions[themeName]
+    }));
+    const themeResult = await _chunkCH2J4PVEcjs.showModal.call(void 0, {
+      title: "Select a theme",
+      options: themeOptions
+    });
+    const theme = _optionalChain([themeResult, 'optionalAccess', _18 => _18.value]) || "dark";
+    const autoConfirm = await _chunkCH2J4PVEcjs.showConfirm.call(void 0, {
+      title: "Auto-confirm non-destructive actions?",
+      defaultValue: false
+    });
+    const checkForUpdates = await _chunkCH2J4PVEcjs.showConfirm.call(void 0, {
+      title: "Check for updates on startup?",
+      defaultValue: true
+    });
+    this.state.preferences = { theme, autoConfirm, checkForUpdates };
+  }
+  /**
+   * Prompt for AGENTS.md creation
+   */
+  async promptAgentsFile() {
+    this.state.currentStep = "agentsFile";
+    const agentsPath = _path.join.call(void 0, this.workspaceRoot, "AGENTS.md");
+    const exists = await _fsextra2.default.pathExists(agentsPath);
+    if (exists) {
+      const overwrite = await _chunkCH2J4PVEcjs.showConfirm.call(void 0, {
+        title: "AGENTS.md already exists. Would you like to regenerate it?",
+        defaultValue: false
+      });
+      if (!overwrite) {
+        this.state.skipped.push("agentsFile");
+        console.log(_chalk2.default.gray("  Keeping existing AGENTS.md"));
+        return;
+      }
+    } else {
+      console.log();
+      console.log(_chalk2.default.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+      console.log(_chalk2.default.white.bold("  Project Configuration"));
+      console.log(_chalk2.default.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+      console.log();
+      console.log(_chalk2.default.gray("  AGENTS.md helps Autohand understand your project better."));
+      console.log(_chalk2.default.gray("  It contains instructions specific to your codebase."));
+      console.log();
+      const createAgents = await _chunkCH2J4PVEcjs.showConfirm.call(void 0, {
+        title: "Generate AGENTS.md based on your project?",
+        defaultValue: true
+      });
+      if (!createAgents) {
+        this.state.skipped.push("agentsFile");
+        console.log(_chalk2.default.gray("  You can create it later with /init"));
+        return;
+      }
+    }
+    console.log();
+    console.log(_chalk2.default.gray("  Analyzing your project..."));
+    const analyzer = new ProjectAnalyzer(this.workspaceRoot);
+    const projectInfo = await analyzer.analyze();
+    if (Object.keys(projectInfo).length > 0) {
+      console.log();
+      console.log(_chalk2.default.gray("  Detected:"));
+      if (projectInfo.language) {
+        console.log(_chalk2.default.white(`  - Language: ${projectInfo.language}`));
+      }
+      if (projectInfo.framework) {
+        console.log(_chalk2.default.white(`  - Framework: ${projectInfo.framework}`));
+      }
+      if (projectInfo.packageManager) {
+        console.log(_chalk2.default.white(`  - Package manager: ${projectInfo.packageManager}`));
+      }
+      if (projectInfo.testFramework) {
+        console.log(_chalk2.default.white(`  - Test framework: ${projectInfo.testFramework}`));
+      }
+    }
+    const generator = new AgentsGenerator();
+    const content = generator.generateContent(projectInfo);
+    await _fsextra2.default.writeFile(agentsPath, content);
+    this.state.agentsFileCreated = true;
+    console.log();
+    console.log(_chalk2.default.green("  Created AGENTS.md"));
+    console.log(_chalk2.default.gray("  You can customize it anytime to improve Autohand's understanding."));
+  }
+  /**
+   * Prompt user to create an Autohand account using device-flow auth.
+   * Account creation is now mandatory to use Autohand.
+   * Reuses the same flow as /login command.
+   */
+  async promptRegistration() {
+    this.state.currentStep = "registration";
+    console.log();
+    console.log(_chalk2.default.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(_chalk2.default.white.bold("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.registration.title")));
+    console.log(_chalk2.default.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log();
+    console.log(_chalk2.default.gray("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.registration.descriptionMandatory")));
+    console.log();
+    const authClient = _chunkQ2IL4DDIcjs.getAuthClient.call(void 0, );
+    console.log(_chalk2.default.gray("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.registration.initiating")));
+    const initResult = await authClient.initiateDeviceAuth();
+    if (!initResult.success || !initResult.deviceCode || !initResult.userCode) {
+      console.log(_chalk2.default.yellow("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.registration.failed", { error: initResult.error || "Unknown error" })));
+      const retry2 = await _chunkCH2J4PVEcjs.showConfirm.call(void 0, {
+        title: _chunkCHI52KFRcjs.t.call(void 0, "setup.registration.retryPrompt"),
+        defaultValue: true
+      });
+      if (retry2) {
+        return this.promptRegistration();
+      }
+      this.state.skipped.push("registration");
+      console.log(_chalk2.default.gray("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.registration.tryLater")));
+      return;
+    }
+    const authUrl = initResult.verificationUriComplete || `${_chunkE26KKI46cjs.AUTH_CONFIG.authorizationUrl}?code=${initResult.userCode}`;
+    console.log();
+    console.log(_chalk2.default.white("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.registration.visit")));
+    console.log(_chalk2.default.cyan("  " + authUrl));
+    console.log();
+    console.log(_chalk2.default.gray("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.registration.code")));
+    console.log(_chalk2.default.bold.yellow(`  ${initResult.userCode}`));
+    console.log();
+    try {
+      const open = await Promise.resolve().then(() => _interopRequireWildcard(require("open"))).then((m) => m.default).catch(() => null);
+      if (open) {
+        await open(authUrl);
+        console.log(_chalk2.default.gray("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.registration.browserOpened")));
+      } else {
+        console.log(_chalk2.default.yellow("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.registration.openManually")));
+      }
+    } catch (e12) {
+      console.log(_chalk2.default.yellow("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.registration.openManually")));
+    }
+    console.log();
+    console.log(_chalk2.default.gray("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.registration.waiting")));
+    const startTime = Date.now();
+    const timeout = 3 * 60 * 1e3;
+    const pollInterval = initResult.interval ? initResult.interval * 1e3 : _chunkE26KKI46cjs.AUTH_CONFIG.pollInterval;
+    let dots = 0;
+    const maxDots = 3;
+    while (Date.now() - startTime < timeout) {
+      process.stdout.write(`\r  ${_chalk2.default.gray("Waiting" + ".".repeat(dots + 1) + " ".repeat(maxDots - dots))}`);
+      dots = (dots + 1) % (maxDots + 1);
+      await this.sleep(pollInterval);
+      const pollResult = await authClient.pollDeviceAuth(initResult.deviceCode);
+      if (pollResult.status === "authorized" && pollResult.token && pollResult.user) {
+        process.stdout.write("\r" + " ".repeat(20) + "\r");
+        this.state.authToken = pollResult.token;
+        this.state.authUser = pollResult.user;
+        console.log();
+        console.log(_chalk2.default.green("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.registration.success", { name: pollResult.user.name || pollResult.user.email })));
+        return;
+      }
+      if (pollResult.status === "expired") {
+        process.stdout.write("\r" + " ".repeat(20) + "\r");
+        console.log(_chalk2.default.yellow("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.registration.expired")));
+        const retry2 = await _chunkCH2J4PVEcjs.showConfirm.call(void 0, {
+          title: _chunkCHI52KFRcjs.t.call(void 0, "setup.registration.retryPrompt"),
+          defaultValue: true
+        });
+        if (retry2) {
+          return this.promptRegistration();
+        }
+        this.state.skipped.push("registration");
+        console.log(_chalk2.default.gray("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.registration.tryLater")));
+        return;
+      }
+    }
+    process.stdout.write("\r" + " ".repeat(20) + "\r");
+    console.log(_chalk2.default.yellow("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.registration.timeout")));
+    const retry = await _chunkCH2J4PVEcjs.showConfirm.call(void 0, {
+      title: _chunkCHI52KFRcjs.t.call(void 0, "setup.registration.retryPrompt"),
+      defaultValue: true
+    });
+    if (retry) {
+      return this.promptRegistration();
+    }
+    this.state.skipped.push("registration");
+    console.log(_chalk2.default.gray("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.registration.tryLater")));
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Build final config and return success
+   */
+  complete() {
+    this.state.currentStep = "complete";
+    this.state.completed = true;
+    const config = {
+      provider: this.state.provider
+    };
+    if (this.state.provider) {
+      if (this.state.provider === "azure" && this.state.azureConfig) {
+        config.azure = this.state.azureConfig;
+      } else if (this.state.provider === "openai" && this.state.openAIAuthMode === "chatgpt") {
+        config.openai = {
+          authMode: "chatgpt",
+          chatgptAuth: this.state.openAIChatGPTAuth,
+          model: _nullishCoalesce(this.state.model, () => ( this.getDefaultModel("openai"))),
+          baseUrl: "https://chatgpt.com/backend-api/codex",
+          ...this.state.reasoningEffort !== void 0 && { reasoningEffort: this.state.reasoningEffort }
+        };
+      } else if (this.state.provider === "openai") {
+        config.openai = {
+          authMode: "api-key",
+          apiKey: this.state.apiKey,
+          model: _nullishCoalesce(this.state.model, () => ( this.getDefaultModel("openai"))),
+          baseUrl: this.getDefaultBaseUrl("openai"),
+          ...this.state.reasoningEffort !== void 0 && { reasoningEffort: this.state.reasoningEffort }
+        };
+      } else if (this.state.provider === "vertexai" && this.state.vertexaiConfig) {
+        config.vertexai = this.state.vertexaiConfig;
+      } else if (this.requiresApiKey(this.state.provider)) {
+        config[this.state.provider] = {
+          apiKey: this.state.apiKey,
+          model: this.state.model,
+          baseUrl: this.getDefaultBaseUrl(this.state.provider),
+          ...this.state.reasoningEffort !== void 0 && { reasoningEffort: this.state.reasoningEffort }
+        };
+      } else {
+        config[this.state.provider] = {
+          model: this.state.model,
+          baseUrl: _nullishCoalesce(this.state.providerBaseUrl, () => ( this.getDefaultBaseUrl(this.state.provider)))
+        };
+      }
+    }
+    config.telemetry = {
+      enabled: _nullishCoalesce(this.state.telemetryEnabled, () => ( true))
+    };
+    config.autoReport = {
+      enabled: _nullishCoalesce(this.state.autoReportEnabled, () => ( true))
+    };
+    const uiConfig = {};
+    if (this.state.locale) {
+      uiConfig.locale = this.state.locale;
+    }
+    if (this.state.preferences) {
+      uiConfig.theme = this.state.preferences.theme;
+      uiConfig.autoConfirm = this.state.preferences.autoConfirm;
+      uiConfig.checkForUpdates = this.state.preferences.checkForUpdates;
+    }
+    if (this.state.notifications) {
+      uiConfig.notifications = this.state.notifications;
+    }
+    if (Object.keys(uiConfig).length > 0) {
+      config.ui = uiConfig;
+    }
+    if (this.state.permissionMode) {
+      config.permissions = {
+        mode: this.state.permissionMode,
+        rememberSession: _nullishCoalesce(this.state.rememberSession, () => ( true))
+      };
+    }
+    if (this.state.network) {
+      config.network = this.state.network;
+    }
+    if (this.state.search) {
+      config.search = this.state.search;
+    }
+    if (this.state.mcpEnabled !== void 0) {
+      config.mcp = { enabled: this.state.mcpEnabled };
+    }
+    if (this.state.agentSettings) {
+      config.agent = this.state.agentSettings;
+    }
+    if (this.state.communitySkillsEnabled !== void 0) {
+      config.communitySkills = { enabled: this.state.communitySkillsEnabled };
+    }
+    if (this.state.authToken && this.state.authUser) {
+      config.auth = {
+        token: this.state.authToken,
+        user: this.state.authUser
+      };
+    }
+    this.showCompletionMessage();
+    return {
+      success: true,
+      config,
+      skippedSteps: this.state.skipped,
+      cancelled: false,
+      agentsFileCreated: this.state.agentsFileCreated
+    };
+  }
+  /**
+   * Show setup complete message
+   */
+  showCompletionMessage() {
+    console.log();
+    console.log();
+    console.log(_chalk2.default.green("  Setup complete!"));
+    console.log();
+    console.log(_chalk2.default.gray("  What was created:"));
+    console.log(_chalk2.default.white("  - ~/.autohand/config.toml/yaml/json (your settings)"));
+    if (this.state.agentsFileCreated) {
+      console.log(_chalk2.default.white("  - AGENTS.md (project instructions for Autohand)"));
+    }
+    console.log();
+    console.log(_chalk2.default.gray("  Quick tips:"));
+    console.log(_chalk2.default.white("  - Type your request and press Enter to start"));
+    console.log(_chalk2.default.white("  - Use @filename to mention files"));
+    console.log(_chalk2.default.white("  - Type /help for all commands"));
+    console.log(_chalk2.default.white("  - Press Ctrl+C twice to exit"));
+    console.log();
+  }
+  /**
+   * Return cancelled result
+   */
+  cancelled() {
+    return {
+      success: false,
+      config: {},
+      skippedSteps: [],
+      cancelled: true
+    };
+  }
+  /**
+   * Full Azure OpenAI configuration flow
+   * Shows prerequisites, collects auth method, endpoint, deployment, and API version
+   */
+  async promptAzureConfig() {
+    this.state.currentStep = "apiKey";
+    console.log(_chalk2.default.cyan("\n" + _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.title")));
+    console.log(_chalk2.default.gray(_chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.getStarted") + "\n"));
+    console.log(_chalk2.default.yellow(_chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.setupSteps.title")));
+    console.log(_chalk2.default.gray("  " + _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.setupSteps.step1")));
+    console.log(_chalk2.default.gray("  " + _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.setupSteps.step2")));
+    console.log(_chalk2.default.gray("  " + _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.setupSteps.step3")));
+    console.log(_chalk2.default.gray("  " + _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.setupSteps.step4")));
+    console.log();
+    const authChoices = [
+      { label: _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.authApiKey"), value: "api-key" },
+      { label: _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.authEntraId"), value: "entra-id" },
+      { label: _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.authManagedIdentity"), value: "managed-identity" }
+    ];
+    const authResult = await _chunkCH2J4PVEcjs.showModal.call(void 0, {
+      title: _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.selectAuthMethod"),
+      options: authChoices
+    });
+    if (!authResult) return false;
+    const authMethod = authResult.value;
+    let apiKey;
+    let tenantId;
+    let clientId;
+    let clientSecret;
+    if (authMethod === "api-key") {
+      console.log(_chalk2.default.gray("\n" + _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.apiKeyLocation") + "\n"));
+      apiKey = await _asyncNullishCoalesce(await _chunkCH2J4PVEcjs.showPassword.call(void 0, { title: _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.enterAzureApiKey"), placeholder: _chunkCHI52KFRcjs.t.call(void 0, "ui.apiKeyPlaceholder") }), async () => ( void 0));
+      if (!apiKey) return false;
+    } else if (authMethod === "entra-id") {
+      console.log(_chalk2.default.gray("\n" + _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.entraIdDescription")));
+      console.log(_chalk2.default.gray(_chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.entraIdDocs") + "\n"));
+      tenantId = await _asyncNullishCoalesce(await _chunkCH2J4PVEcjs.showInput.call(void 0, { title: _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.enterTenantId") }), async () => ( void 0));
+      if (!tenantId) return false;
+      clientId = await _asyncNullishCoalesce(await _chunkCH2J4PVEcjs.showInput.call(void 0, { title: _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.enterClientId") }), async () => ( void 0));
+      if (!clientId) return false;
+      clientSecret = await _asyncNullishCoalesce(await _chunkCH2J4PVEcjs.showPassword.call(void 0, { title: _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.enterClientSecret") }), async () => ( void 0));
+      if (!clientSecret) return false;
+    } else {
+      console.log(_chalk2.default.gray("\n" + _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.managedIdentityDescription")));
+      console.log(_chalk2.default.gray(_chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.managedIdentityDocs") + "\n"));
+    }
+    const endpointChoice = await _chunkCH2J4PVEcjs.showModal.call(void 0, {
+      title: _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.endpointChoice"),
+      options: [
+        { label: _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.endpointStructured"), value: "structured" },
+        { label: _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.endpointUrl"), value: "url" }
+      ]
+    });
+    if (!endpointChoice) return false;
+    let resourceName;
+    let deploymentName;
+    let baseUrl;
+    if (endpointChoice.value === "structured") {
+      console.log(_chalk2.default.gray(_chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.endpointUrlHint")));
+      console.log(_chalk2.default.gray(_chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.endpointUrlExample") + "\n"));
+      resourceName = await _asyncNullishCoalesce(await _chunkCH2J4PVEcjs.showInput.call(void 0, { title: _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.enterEndpointOrResource") }), async () => ( void 0));
+      if (!resourceName) return false;
+      console.log(_chalk2.default.gray("\n" + _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.deploymentHint")));
+      console.log(_chalk2.default.gray(_chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.deploymentNotUrl") + "\n"));
+      deploymentName = await _asyncNullishCoalesce(await _chunkCH2J4PVEcjs.showInput.call(void 0, { title: _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.enterDeploymentName"), defaultValue: "gpt-5.3-codex" }), async () => ( void 0));
+      if (!deploymentName) return false;
+      if (deploymentName.startsWith("http://") || deploymentName.startsWith("https://")) {
+        console.log(_chalk2.default.red("\n\u2717 " + _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.deploymentUrlError")));
+        console.log(_chalk2.default.gray("  " + _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.deploymentUrlErrorHint")));
+        console.log(_chalk2.default.gray("  " + _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.deploymentUrlErrorLocation") + "\n"));
+        return false;
+      }
+    } else {
+      baseUrl = await _asyncNullishCoalesce(await _chunkCH2J4PVEcjs.showInput.call(void 0, {
+        title: _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.enterFullEndpointUrl"),
+        defaultValue: "https://your-resource.openai.azure.com/openai/deployments/gpt-5.3-codex"
+      }), async () => ( void 0));
+      if (!baseUrl) return false;
+    }
+    const apiVersion = await _asyncNullishCoalesce(await _chunkCH2J4PVEcjs.showInput.call(void 0, { title: _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.apiVersion"), defaultValue: "2024-10-21" }), async () => ( void 0));
+    if (!apiVersion) return false;
+    const model = _nullishCoalesce(deploymentName, () => ( "gpt-5.3-codex"));
+    const azureConfig = {
+      model,
+      authMethod,
+      apiVersion,
+      ...apiKey && { apiKey },
+      ...tenantId && { tenantId },
+      ...clientId && { clientId },
+      ...clientSecret && { clientSecret },
+      ...resourceName && { resourceName },
+      ...deploymentName && { deploymentName },
+      ...baseUrl && { baseUrl }
+    };
+    this.state.azureConfig = azureConfig;
+    this.state.model = model;
+    console.log(_chalk2.default.green("\n\u2713 " + _chunkCHI52KFRcjs.t.call(void 0, "providers.config.configuredSuccessfully", { provider: _chunkCHI52KFRcjs.t.call(void 0, "providers.azure") })));
+    console.log(_chalk2.default.gray("  " + _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.azure.authLabel", { method: authMethod })));
+    console.log(_chalk2.default.gray("  " + _chunkCHI52KFRcjs.t.call(void 0, "providers.config.modelLabel", { model })));
+    console.log();
+    return true;
+  }
+  /**
+   * Full Google Cloud Vertex AI configuration flow
+   * Shows prerequisites, collects endpoint, region, project ID, auth token, and model
+   * Auto-detects gcloud CLI and uses it for automatic token management
+   */
+  async promptVertexAIConfig() {
+    this.state.currentStep = "apiKey";
+    console.log(_chalk2.default.cyan("\n" + _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.vertexai.title")));
+    console.log(_chalk2.default.gray(_chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.vertexai.getStarted") + "\n"));
+    const gcloudInstalled = await _chunkWRTXCQ3Vcjs.isGcloudInstalled.call(void 0, );
+    const gcloudAccount = gcloudInstalled ? await _chunkWRTXCQ3Vcjs.getGcloudAccount.call(void 0, ) : null;
+    const gcloudProject = gcloudInstalled ? await _chunkWRTXCQ3Vcjs.getGcloudProject.call(void 0, ) : null;
+    const existingConfig = _optionalChain([this, 'access', _19 => _19.existingConfig, 'optionalAccess', _20 => _20.vertexai]);
+    const existingProjectId = _optionalChain([existingConfig, 'optionalAccess', _21 => _21.projectId]);
+    const existingEndpoint = _optionalChain([existingConfig, 'optionalAccess', _22 => _22.endpoint]);
+    const existingRegion = _optionalChain([existingConfig, 'optionalAccess', _23 => _23.region]);
+    if (gcloudInstalled) {
+      console.log(_chalk2.default.green("  \u2713 gcloud CLI detected"));
+      if (gcloudAccount) {
+        console.log(_chalk2.default.gray(`    Account: ${gcloudAccount}`));
+      }
+      if (gcloudProject) {
+        console.log(_chalk2.default.gray(`    Project: ${gcloudProject}`));
+      }
+      console.log();
+    } else {
+      console.log(_chalk2.default.yellow("  \u26A0 gcloud CLI not detected"));
+      console.log(_chalk2.default.gray("  Install it for automatic token management:"));
+      console.log(_chalk2.default.gray("  https://cloud.google.com/sdk/docs/install"));
+      console.log();
+    }
+    const endpoint = await _chunkCH2J4PVEcjs.showInput.call(void 0, {
+      title: _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.vertexai.enterEndpoint"),
+      defaultValue: existingEndpoint || "aiplatform.googleapis.com"
+    });
+    if (!endpoint) return false;
+    const region = await _chunkCH2J4PVEcjs.showInput.call(void 0, {
+      title: _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.vertexai.enterRegion"),
+      defaultValue: existingRegion || "global"
+    });
+    if (!region) return false;
+    const defaultProjectId = existingProjectId || gcloudProject || "";
+    const projectId = await _chunkCH2J4PVEcjs.showInput.call(void 0, {
+      title: _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.vertexai.enterProjectId"),
+      defaultValue: defaultProjectId,
+      placeholder: "YOUR_PROJECT_ID"
+    });
+    if (!projectId) return false;
+    let authToken;
+    if (gcloudInstalled) {
+      console.log(_chalk2.default.gray("\n  Fetching access token from gcloud..."));
+      const tokenResult = await _chunkWRTXCQ3Vcjs.getGcloudAccessToken.call(void 0, );
+      if (tokenResult.token) {
+        console.log(_chalk2.default.green("  \u2713 Access token obtained (valid for ~25 minutes)"));
+        console.log(_chalk2.default.gray("  Tokens are automatically refreshed when using gcloud."));
+        authToken = tokenResult.token;
+      } else {
+        console.log(_chalk2.default.yellow(`  \u26A0 ${tokenResult.error}`));
+        console.log(_chalk2.default.gray("  Please enter token manually or run: gcloud auth login"));
+        console.log();
+        const manualToken = await _chunkCH2J4PVEcjs.showPassword.call(void 0, {
+          title: _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.vertexai.enterAuthToken"),
+          placeholder: _chunkCHI52KFRcjs.t.call(void 0, "ui.apiKeyPlaceholder")
+        });
+        if (!manualToken) return false;
+        authToken = manualToken;
+      }
+    } else {
+      console.log(_chalk2.default.gray("\n" + _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.vertexai.authTokenHint")));
+      console.log(_chalk2.default.gray("  " + _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.vertexai.authTokenCommand")));
+      console.log();
+      const manualToken = await _chunkCH2J4PVEcjs.showPassword.call(void 0, {
+        title: _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.vertexai.enterAuthToken"),
+        placeholder: _chunkCHI52KFRcjs.t.call(void 0, "ui.apiKeyPlaceholder")
+      });
+      if (!manualToken) return false;
+      authToken = manualToken;
+    }
+    const modelOptions = _chunkWRTXCQ3Vcjs.VERTEX_AI_CODING_MODELS.map((name) => ({
+      label: name,
+      value: name
+    }));
+    const modelResult = await _chunkCH2J4PVEcjs.showModal.call(void 0, {
+      title: _chunkCHI52KFRcjs.t.call(void 0, "providers.config.selectModel"),
+      options: modelOptions,
+      allowCustomInput: true
+    });
+    if (!modelResult) return false;
+    const model = modelResult.value;
+    this.state.provider = "vertexai";
+    this.state.apiKey = authToken;
+    this.state.model = model;
+    this.state.providerBaseUrl = `https://${endpoint}/v1/projects/${projectId}/locations/${region}/endpoints/openapi`;
+    this.state.vertexaiConfig = {
+      authToken,
+      endpoint,
+      region,
+      projectId,
+      model
+    };
+    console.log(_chalk2.default.green("\n\u2713 " + _chunkCHI52KFRcjs.t.call(void 0, "providers.config.configuredSuccessfully", { provider: _chunkCHI52KFRcjs.t.call(void 0, "providers.vertexai") })));
+    console.log(_chalk2.default.gray("  " + _chunkCHI52KFRcjs.t.call(void 0, "providers.config.modelLabel", { model })));
+    if (gcloudInstalled) {
+      console.log(_chalk2.default.gray("  Token auto-refresh enabled via gcloud CLI"));
+    }
+    console.log();
+    return true;
+  }
+  /**
+   * Prompt for language selection
+   */
+  async promptLanguage() {
+    this.state.currentStep = "language";
+    const detected = _chunkCHI52KFRcjs.detectLocale.call(void 0, );
+    console.log(_chalk2.default.gray("\n  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.language.detected", { language: _chunkCHI52KFRcjs.LANGUAGE_DISPLAY_NAMES[detected.locale] })));
+    const options = _chunkCHI52KFRcjs.SUPPORTED_LOCALES.map((locale) => ({
+      label: _chunkCHI52KFRcjs.LANGUAGE_DISPLAY_NAMES[locale],
+      value: locale
+    }));
+    const initialIndex = _chunkCHI52KFRcjs.SUPPORTED_LOCALES.indexOf(detected.locale);
+    const result = await _chunkCH2J4PVEcjs.showModal.call(void 0, {
+      title: _chunkCHI52KFRcjs.t.call(void 0, "setup.language.prompt"),
+      options,
+      initialIndex: initialIndex >= 0 ? initialIndex : 0
+    });
+    if (!result) {
+      this.state.locale = detected.locale;
+      return;
+    }
+    const selectedLocale = result.value;
+    this.state.locale = selectedLocale;
+    if (selectedLocale !== detected.locale) {
+      await _chunkCHI52KFRcjs.changeLanguage.call(void 0, selectedLocale);
+      console.log(_chalk2.default.green("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.language.changed", { language: _chunkCHI52KFRcjs.LANGUAGE_DISPLAY_NAMES[selectedLocale] })));
+    }
+  }
+  /**
+   * Validate API key during setup by hitting GET /models
+   */
+  async validateApiKeyDuringSetup() {
+    if (!this.state.provider || !this.state.apiKey) return;
+    if (!this.requiresApiKey(this.state.provider)) return;
+    const baseUrl = this.getDefaultBaseUrl(this.state.provider);
+    console.log(_chalk2.default.gray("\n  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.apiKeyValidation.validating")));
+    try {
+      const response = await fetch(`${baseUrl}/models`, {
+        headers: { Authorization: `Bearer ${this.state.apiKey}` },
+        signal: AbortSignal.timeout(1e4)
+      });
+      if (response.ok) {
+        console.log(_chalk2.default.green("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.apiKeyValidation.success")));
+      } else {
+        console.log(_chalk2.default.yellow("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.apiKeyValidation.failed", { error: `HTTP ${response.status}` })));
+        console.log(_chalk2.default.gray("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.apiKeyValidation.hint")));
+      }
+    } catch (e13) {
+      console.log(_chalk2.default.yellow("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.apiKeyValidation.skipped")));
+    }
+  }
+  /**
+   * Test local provider connection (Ollama, llama.cpp, MLX)
+   */
+  async testLocalProviderConnection() {
+    if (!this.state.provider || !this.isLocalProvider(this.state.provider)) return true;
+    this.state.currentStep = "connectionTest";
+    const provider = this.state.provider;
+    const baseUrl = _nullishCoalesce(this.state.providerBaseUrl, () => ( this.getDefaultBaseUrl(provider)));
+    const endpoints = {
+      ollama: `${baseUrl}/api/tags`,
+      llamacpp: `${baseUrl}/health`,
+      mlx: `${baseUrl}/v1/models`
+    };
+    const endpoint = endpoints[provider];
+    if (!endpoint) return true;
+    console.log(_chalk2.default.gray("\n  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.connectionTest.testing", { provider: this.getProviderDisplayName(provider) })));
+    try {
+      const response = await fetch(endpoint, { signal: AbortSignal.timeout(5e3) });
+      if (response.ok) {
+        console.log(_chalk2.default.green("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.connectionTest.success", { provider: this.getProviderDisplayName(provider) })));
+        return true;
+      }
+      throw new Error(`HTTP ${response.status}`);
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : "Unknown error";
+      console.log(_chalk2.default.yellow("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.connectionTest.failed", { provider: this.getProviderDisplayName(provider), error: errorMsg })));
+      const hintKey = `setup.connectionTest.hint${provider.charAt(0).toUpperCase() + provider.slice(1)}`;
+      const hint = _chunkCHI52KFRcjs.t.call(void 0, hintKey);
+      if (hint !== hintKey) {
+        console.log(_chalk2.default.gray("  " + hint));
+      }
+      const continueAnyway = await _chunkCH2J4PVEcjs.showConfirm.call(void 0, {
+        title: _chunkCHI52KFRcjs.t.call(void 0, "setup.connectionTest.continueAnyway"),
+        defaultValue: true
+      });
+      return continueAnyway;
+    }
+  }
+  async prepareLlamaCpp() {
+    const probe = await probeLlamaCppEnvironment(this.workspaceRoot);
+    let detectedPort = probe.port;
+    if (probe.baseUrl) {
+      this.state.providerBaseUrl = probe.baseUrl;
+      console.log(_chalk2.default.green(`  Detected llama.cpp server at ${probe.baseUrl}`));
+    } else if (probe.installed) {
+      console.log(_chalk2.default.gray("  llama.cpp is installed but no running server was detected."));
+    } else if (!probe.installPlan) {
+      console.log(_chalk2.default.yellow("  llama.cpp is not installed and no supported package manager was detected."));
+    } else {
+      console.log(_chalk2.default.yellow(`  llama.cpp is not installed. Autohand can install it with: ${probe.installPlan.label}`));
+      const shouldInstall = await _chunkCH2J4PVEcjs.showConfirm.call(void 0, {
+        title: "Install llama.cpp now?",
+        defaultValue: true
+      });
+      if (shouldInstall) {
+        console.log(_chalk2.default.gray(`  Installing llama.cpp with ${probe.installPlan.label}...`));
+        const install = await installLlamaCpp(probe.installPlan, this.workspaceRoot);
+        if (!install.ok) {
+          console.log(_chalk2.default.red("  llama.cpp installation failed."));
+          if (install.output) {
+            console.log(_chalk2.default.gray(`  ${install.output}`));
+          }
+          return false;
+        }
+        console.log(_chalk2.default.green("  llama.cpp installation completed."));
+        const refreshed = await probeLlamaCppEnvironment(this.workspaceRoot);
+        detectedPort = refreshed.port;
+        if (refreshed.baseUrl) {
+          this.state.providerBaseUrl = refreshed.baseUrl;
+          console.log(_chalk2.default.green(`  Detected llama.cpp server at ${refreshed.baseUrl}`));
+        } else {
+          console.log(_chalk2.default.gray("  Start llama-server with your model, then Autohand will connect on the detected port."));
+        }
+      }
+    }
+    const port = await _chunkCH2J4PVEcjs.showInput.call(void 0, {
+      title: _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.llamacpp.serverPort"),
+      defaultValue: String(_nullishCoalesce(detectedPort, () => ( 80)))
+    });
+    if (!port) {
+      return false;
+    }
+    this.state.providerBaseUrl = `http://localhost:${port}`;
+    return true;
+  }
+  /**
+   * Prompt for permission mode selection
+   */
+  async promptPermissions() {
+    this.state.currentStep = "permissions";
+    console.log();
+    console.log(_chalk2.default.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(_chalk2.default.white.bold("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.permissions.title")));
+    console.log(_chalk2.default.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log();
+    console.log(_chalk2.default.gray("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.permissions.description")));
+    console.log();
+    const options = [
+      { label: _chunkCHI52KFRcjs.t.call(void 0, "setup.permissions.interactive"), value: "interactive" },
+      { label: _chunkCHI52KFRcjs.t.call(void 0, "setup.permissions.unrestricted"), value: "unrestricted" },
+      { label: _chunkCHI52KFRcjs.t.call(void 0, "setup.permissions.restricted"), value: "restricted" }
+    ];
+    const result = await _chunkCH2J4PVEcjs.showModal.call(void 0, {
+      title: _chunkCHI52KFRcjs.t.call(void 0, "setup.permissions.title"),
+      options
+    });
+    const mode = _nullishCoalesce(_optionalChain([result, 'optionalAccess', _24 => _24.value]), () => ( "interactive"));
+    this.state.permissionMode = mode;
+    if (mode === "unrestricted") {
+      console.log(_chalk2.default.yellow("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.permissions.warning")));
+    }
+    console.log(_chalk2.default.green("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.permissions.set", { mode })));
+    const rememberSession = await _chunkCH2J4PVEcjs.showConfirm.call(void 0, {
+      title: _chunkCHI52KFRcjs.t.call(void 0, "setup.permissions.rememberPrompt"),
+      defaultValue: true
+    });
+    this.state.rememberSession = rememberSession;
+  }
+  /**
+   * Check workspace safety
+   */
+  async checkWorkspaceStep() {
+    this.state.currentStep = "workspaceSafety";
+    console.log(_chalk2.default.gray("\n  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.workspaceSafety.checking")));
+    const result = _chunkWGNMOVMTcjs.checkWorkspaceSafety.call(void 0, this.workspaceRoot);
+    if (result.safe) {
+      console.log(_chalk2.default.green("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.workspaceSafety.safe")));
+      return true;
+    }
+    _chunkWGNMOVMTcjs.printDangerousWorkspaceWarning.call(void 0, this.workspaceRoot, result);
+    console.log(_chalk2.default.yellow("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.workspaceSafety.unsafe", { reason: result.reason || "" })));
+    const continueUnsafe = await _chunkCH2J4PVEcjs.showConfirm.call(void 0, {
+      title: _chunkCHI52KFRcjs.t.call(void 0, "setup.workspaceSafety.continueUnsafe"),
+      defaultValue: false
+    });
+    return continueUnsafe;
+  }
+  /**
+   * Prompt for notification preferences
+   */
+  async promptNotifications() {
+    this.state.currentStep = "notifications";
+    console.log();
+    console.log(_chalk2.default.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(_chalk2.default.white.bold("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.notifications.title")));
+    console.log(_chalk2.default.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log();
+    console.log(_chalk2.default.gray("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.notifications.description")));
+    console.log();
+    const enabled = await _chunkCH2J4PVEcjs.showConfirm.call(void 0, {
+      title: _chunkCHI52KFRcjs.t.call(void 0, "setup.notifications.enablePrompt"),
+      defaultValue: true
+    });
+    let sound = true;
+    if (enabled) {
+      sound = await _chunkCH2J4PVEcjs.showConfirm.call(void 0, {
+        title: _chunkCHI52KFRcjs.t.call(void 0, "setup.notifications.soundPrompt"),
+        defaultValue: true
+      });
+    }
+    this.state.notifications = { enabled, sound };
+  }
+  /**
+   * Prompt for network settings
+   */
+  async promptNetwork() {
+    this.state.currentStep = "network";
+    const needCustom = await _chunkCH2J4PVEcjs.showConfirm.call(void 0, {
+      title: _chunkCHI52KFRcjs.t.call(void 0, "setup.network.needCustom"),
+      defaultValue: false
+    });
+    if (!needCustom) {
+      this.state.skipped.push("network");
+      return;
+    }
+    const maxRetriesStr = await _chunkCH2J4PVEcjs.showInput.call(void 0, {
+      title: _chunkCHI52KFRcjs.t.call(void 0, "setup.network.maxRetries"),
+      defaultValue: "3",
+      validate: (val) => {
+        const n = parseInt(val, 10);
+        if (isNaN(n) || n < 1 || n > 5) return "Enter a number between 1 and 5";
+        return true;
+      }
+    });
+    const timeoutStr = await _chunkCH2J4PVEcjs.showInput.call(void 0, {
+      title: _chunkCHI52KFRcjs.t.call(void 0, "setup.network.timeout"),
+      defaultValue: "30000",
+      validate: (val) => {
+        const n = parseInt(val, 10);
+        if (isNaN(n) || n < 5e3 || n > 12e4) return "Enter a number between 5000 and 120000";
+        return true;
+      }
+    });
+    this.state.network = {
+      maxRetries: parseInt(maxRetriesStr || "3", 10),
+      timeout: parseInt(timeoutStr || "30000", 10)
+    };
+  }
+  /**
+   * Prompt for web search provider
+   */
+  async promptSearch() {
+    this.state.currentStep = "search";
+    const options = [
+      { label: "Google", value: "google", description: "Default web search" },
+      { label: "Brave Search", value: "brave", description: "Privacy-focused search (requires API key)" },
+      { label: "DuckDuckGo", value: "duckduckgo", description: "Privacy-focused, no API key needed" },
+      { label: "Parallel.ai", value: "parallel", description: "AI-optimized search (requires API key)" }
+    ];
+    const result = await _chunkCH2J4PVEcjs.showModal.call(void 0, {
+      title: _chunkCHI52KFRcjs.t.call(void 0, "setup.search.prompt"),
+      options
+    });
+    const provider = _nullishCoalesce(_optionalChain([result, 'optionalAccess', _25 => _25.value]), () => ( "google"));
+    const searchState = { provider };
+    if (provider === "brave") {
+      const key = await _chunkCH2J4PVEcjs.showPassword.call(void 0, { title: _chunkCHI52KFRcjs.t.call(void 0, "setup.search.braveKeyPrompt"), placeholder: _chunkCHI52KFRcjs.t.call(void 0, "ui.apiKeyPlaceholder") });
+      if (key) searchState.braveApiKey = key;
+    } else if (provider === "parallel") {
+      const key = await _chunkCH2J4PVEcjs.showPassword.call(void 0, { title: _chunkCHI52KFRcjs.t.call(void 0, "setup.search.parallelKeyPrompt"), placeholder: _chunkCHI52KFRcjs.t.call(void 0, "ui.apiKeyPlaceholder") });
+      if (key) searchState.parallelApiKey = key;
+    }
+    this.state.search = searchState;
+  }
+  /**
+   * Prompt for MCP support
+   */
+  async promptMcp() {
+    this.state.currentStep = "mcp";
+    console.log();
+    console.log(_chalk2.default.gray("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.mcp.description")));
+    console.log();
+    const enabled = await _chunkCH2J4PVEcjs.showConfirm.call(void 0, {
+      title: _chunkCHI52KFRcjs.t.call(void 0, "setup.mcp.enablePrompt"),
+      defaultValue: true
+    });
+    this.state.mcpEnabled = enabled;
+    if (enabled) {
+      console.log(_chalk2.default.green("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.mcp.enabled")));
+    }
+  }
+  /**
+   * Prompt for agent behavior settings
+   */
+  async promptAgentBehavior() {
+    this.state.currentStep = "agentBehavior";
+    const maxIterStr = await _chunkCH2J4PVEcjs.showInput.call(void 0, {
+      title: _chunkCHI52KFRcjs.t.call(void 0, "setup.agent.maxIterationsPrompt"),
+      defaultValue: "100",
+      validate: (val) => {
+        const n = parseInt(val, 10);
+        if (isNaN(n) || n < 10 || n > 500) return "Enter a number between 10 and 500";
+        return true;
+      }
+    });
+    const debug = await _chunkCH2J4PVEcjs.showConfirm.call(void 0, {
+      title: _chunkCHI52KFRcjs.t.call(void 0, "setup.agent.debugPrompt"),
+      defaultValue: false
+    });
+    this.state.agentSettings = {
+      maxIterations: parseInt(maxIterStr || "100", 10),
+      debug
+    };
+    console.log(_chalk2.default.green("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.agent.set")));
+  }
+  /**
+   * Prompt for community skills
+   */
+  async promptCommunitySkills() {
+    this.state.currentStep = "communitySkills";
+    console.log();
+    console.log(_chalk2.default.gray("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.communitySkills.description")));
+    console.log();
+    const enabled = await _chunkCH2J4PVEcjs.showConfirm.call(void 0, {
+      title: _chunkCHI52KFRcjs.t.call(void 0, "setup.communitySkills.enablePrompt"),
+      defaultValue: true
+    });
+    this.state.communitySkillsEnabled = enabled;
+  }
+  /**
+   * Show review summary and confirm settings
+   */
+  async promptReviewConfirm() {
+    this.state.currentStep = "reviewSummary";
+    console.log();
+    console.log(_chalk2.default.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(_chalk2.default.white.bold("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.review.title")));
+    console.log(_chalk2.default.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log();
+    if (this.state.locale) {
+      console.log(_chalk2.default.white(`  Language: ${_chunkCHI52KFRcjs.LANGUAGE_DISPLAY_NAMES[this.state.locale]}`));
+    }
+    if (this.state.provider) {
+      console.log(_chalk2.default.white("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.review.provider", { provider: this.getProviderDisplayName(this.state.provider) })));
+    }
+    if (this.state.model) {
+      console.log(_chalk2.default.white("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.review.model", { model: this.state.model })));
+    }
+    if (this.state.reasoningEffort) {
+      console.log(_chalk2.default.white("  " + _chunkCHI52KFRcjs.t.call(void 0, "providers.config.reasoningEffortLabel", { level: this.state.reasoningEffort })));
+    }
+    if (this.state.permissionMode) {
+      console.log(_chalk2.default.white(`  Permissions: ${this.state.permissionMode}`));
+    }
+    console.log(_chalk2.default.white(`  Telemetry: ${this.state.telemetryEnabled ? "enabled" : "disabled"}`));
+    console.log(_chalk2.default.white(`  Auto-report: ${this.state.autoReportEnabled ? "enabled" : "disabled"}`));
+    if (this.state.notifications) {
+      console.log(_chalk2.default.white(`  Notifications: ${this.state.notifications.enabled ? "enabled" : "disabled"}`));
+    }
+    if (_optionalChain([this, 'access', _26 => _26.state, 'access', _27 => _27.search, 'optionalAccess', _28 => _28.provider])) {
+      console.log(_chalk2.default.white(`  Search: ${this.state.search.provider}`));
+    }
+    if (this.state.mcpEnabled !== void 0) {
+      console.log(_chalk2.default.white(`  MCP: ${this.state.mcpEnabled ? "enabled" : "disabled"}`));
+    }
+    if (this.state.authUser) {
+      console.log(_chalk2.default.white(`  Account: ${this.state.authUser.email}`));
+    }
+    console.log();
+    const confirmed = await _chunkCH2J4PVEcjs.showConfirm.call(void 0, {
+      title: _chunkCHI52KFRcjs.t.call(void 0, "setup.review.confirm"),
+      defaultValue: true
+    });
+    if (!confirmed) {
+      console.log(_chalk2.default.gray("  " + _chunkCHI52KFRcjs.t.call(void 0, "setup.review.goBack")));
+    }
+    return confirmed;
+  }
+  /**
+   * Check if a provider is local (no API key, has server to test)
+   */
+  isLocalProvider(provider) {
+    return provider === "ollama" || provider === "llamacpp" || provider === "mlx";
+  }
+  // Helper methods
+  requiresApiKey(provider) {
+    return provider === "openrouter" || provider === "llmgateway" || provider === "zai" || provider === "vertexai" || provider === "xai" || provider === "cerebras" || provider === "nvidia" || provider === "deepseek";
+  }
+  getProviderDisplayName(provider) {
+    return _chunkCHI52KFRcjs.t.call(void 0, `providers.${provider}`);
+  }
+  getProviderHint(provider) {
+    return _chunkCHI52KFRcjs.t.call(void 0, `providers.hints.${provider}`);
+  }
+  getApiKeyUrl(provider) {
+    const urls = {
+      openrouter: _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.openrouter.apiKeyUrl"),
+      openai: _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.openai.apiKeyUrl"),
+      llmgateway: _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.llmgateway.apiKeyUrl"),
+      zai: _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.zai.apiKeyUrl"),
+      nvidia: _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.nvidia.apiKeyUrl"),
+      deepseek: _chunkCHI52KFRcjs.t.call(void 0, "providers.wizard.deepseek.apiKeyUrl")
+    };
+    return urls[provider] || "";
+  }
+  getDefaultModel(provider) {
+    const defaults = {
+      openrouter: "nvidia/nemotron-3-super-120b-a12b:free",
+      openai: "gpt-5.4",
+      ollama: "llama3.2:latest",
+      llamacpp: "local",
+      mlx: "mlx-community/Llama-3.2-3B-Instruct-4bit",
+      llmgateway: "gpt-4o",
+      azure: "gpt-5.3-codex",
+      zai: "glm-4.5",
+      vertexai: "zai-org/glm-5-maas",
+      xai: "grok-4.20-reasoning",
+      cerebras: "zai-glm-4.7",
+      nvidia: "mistralai/mixtral-8x7b-instruct-v0.1",
+      deepseek: "deepseek-v4-flash"
+    };
+    return defaults[provider] || "";
+  }
+  getDefaultBaseUrl(provider) {
+    const urls = {
+      openrouter: "https://openrouter.ai/api/v1",
+      openai: "https://api.openai.com/v1",
+      ollama: "http://localhost:11434",
+      llamacpp: "http://localhost:8080",
+      mlx: "http://localhost:8080",
+      llmgateway: "https://api.llmgateway.io/v1",
+      azure: "https://{resourceName}.openai.azure.com",
+      zai: _chunkWRTXCQ3Vcjs.ZAI_DEFAULT_BASE_URL,
+      vertexai: "https://aiplatform.googleapis.com",
+      xai: "https://api.x.ai/v1",
+      cerebras: _chunkWRTXCQ3Vcjs.CEREBRAS_DEFAULT_BASE_URL,
+      nvidia: "https://integrate.api.nvidia.com/v1",
+      deepseek: _chunkWRTXCQ3Vcjs.DEEPSEEK_DEFAULT_BASE_URL
+    };
+    return urls[provider] || "";
+  }
+  getExistingApiKey(provider) {
+    if (!this.existingConfig) return null;
+    const config = this.existingConfig[provider];
+    return _optionalChain([config, 'optionalAccess', _29 => _29.apiKey]) || null;
+  }
+  getExistingOpenAIAuthMode() {
+    const config = _optionalChain([this, 'access', _30 => _30.existingConfig, 'optionalAccess', _31 => _31.openai]);
+    return _optionalChain([config, 'optionalAccess', _32 => _32.authMode]) === "chatgpt" ? "chatgpt" : "api-key";
+  }
+  getExistingOpenAIChatGPTAuth() {
+    const auth = _optionalChain([this, 'access', _33 => _33.existingConfig, 'optionalAccess', _34 => _34.openai, 'optionalAccess', _35 => _35.chatgptAuth]);
+    return auth && auth.accessToken && auth.accountId ? auth : null;
+  }
+  isOpenAIConfigured(config) {
+    if (config.authMode === "chatgpt") {
+      return !!_optionalChain([config, 'access', _36 => _36.chatgptAuth, 'optionalAccess', _37 => _37.accessToken]) && !!_optionalChain([config, 'access', _38 => _38.chatgptAuth, 'optionalAccess', _39 => _39.accountId]);
+    }
+    return !!config.apiKey && config.apiKey !== "replace-me" && config.apiKey.length >= 10;
+  }
+  isCancellation(error) {
+    if (error && typeof error === "object") {
+      const e = error;
+      return e.code === "ERR_USE_AFTER_CLOSE" || _optionalChain([e, 'access', _40 => _40.message, 'optionalAccess', _41 => _41.includes, 'call', _42 => _42("cancelled")]) || _optionalChain([e, 'access', _43 => _43.message, 'optionalAccess', _44 => _44.includes, 'call', _45 => _45("canceled")]);
+    }
+    return false;
+  }
+  async pressEnter() {
+    console.log(_chalk2.default.gray("  Press Enter to continue..."));
+    await new Promise((resolve) => {
+      process.stdin.once("data", () => resolve());
+    });
+  }
+};
+
+
+
+
+
+
+
+exports.ProjectAnalyzer = ProjectAnalyzer; exports.AgentsGenerator = AgentsGenerator; exports.probeLlamaCppEnvironment = probeLlamaCppEnvironment; exports.installLlamaCpp = installLlamaCpp; exports.SetupWizard = SetupWizard;
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */