ketoy-dev 0.1.0

package/dist/ketoy.js

@@ -0,0 +1,3165 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import process2 from "process";
+
+// src/lib/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_DIR = join(homedir(), ".ketoy-cli");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+var PROJECT_STATE_DIR = ".ketoy";
+var PROJECT_STATE_FILE = join(PROJECT_STATE_DIR, "state.json");
+var CLI_VERSION = "0.1.0";
+
+// src/lib/log.ts
+import pc from "picocolors";
+var PREFIX = pc.bold(pc.magenta("ketoy"));
+var log = {
+  info(msg) {
+    process.stdout.write(`${PREFIX} ${msg}
+`);
+  },
+  success(msg) {
+    process.stdout.write(`${PREFIX} ${pc.green("\u2713")} ${msg}
+`);
+  },
+  warn(msg) {
+    process.stderr.write(`${PREFIX} ${pc.yellow("!")} ${msg}
+`);
+  },
+  error(msg) {
+    process.stderr.write(`${PREFIX} ${pc.red("\u2717")} ${msg}
+`);
+  },
+  step(n, total, msg) {
+    process.stdout.write(`${PREFIX} ${pc.dim(`[${n}/${total}]`)} ${msg}
+`);
+  },
+  detail(msg) {
+    process.stdout.write(`       ${pc.dim(msg)}
+`);
+  },
+  raw(msg) {
+    process.stdout.write(msg);
+  }
+};
+
+// src/lib/errors.ts
+var KetoyCliError = class extends Error {
+  exitCode;
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.name = "KetoyCliError";
+    this.exitCode = exitCode;
+  }
+};
+var UserAbortError = class extends KetoyCliError {
+  constructor(message = "Aborted by user") {
+    super(message, 130);
+    this.name = "UserAbortError";
+  }
+};
+var ConfigError = class extends KetoyCliError {
+  constructor(message) {
+    super(message, 2);
+    this.name = "ConfigError";
+  }
+};
+var DetectionError = class extends KetoyCliError {
+  constructor(message) {
+    super(message, 3);
+    this.name = "DetectionError";
+  }
+};
+var NoInternetError = class extends KetoyCliError {
+  constructor(message) {
+    super(message, 4);
+    this.name = "NoInternetError";
+  }
+};
+
+// src/lib/ketoy-version.ts
+var VERSION_URL = process.env["KETOY_VERSION_URL"] ?? "https://ketoy.dev/v1/version";
+var FETCH_TIMEOUT_MS = Number(process.env["KETOY_VERSION_TIMEOUT_MS"] ?? "5000");
+var VERSION_RE = /^[0-9]+\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+var cached = null;
+async function fetchVersion() {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  let response;
+  try {
+    response = await fetch(VERSION_URL, {
+      method: "GET",
+      headers: { accept: "text/plain, application/json;q=0.9" },
+      signal: controller.signal
+    });
+  } catch (e) {
+    const err = e;
+    const offline = err.name === "AbortError" || err.code === "ENOTFOUND" || err.code === "ECONNREFUSED" || err.code === "ECONNRESET" || err.code === "ETIMEDOUT" || /fetch failed|network|getaddrinfo/i.test(err.message);
+    if (offline) {
+      throw new NoInternetError(
+        `No internet \u2014 cannot reach ${VERSION_URL}. The Ketoy version is fetched live and not embedded in the CLI; connect to the network and retry. (${err.message})`
+      );
+    }
+    throw new KetoyCliError(`Failed to fetch Ketoy version from ${VERSION_URL}: ${err.message}`);
+  } finally {
+    clearTimeout(timer);
+  }
+  if (!response.ok) {
+    throw new KetoyCliError(
+      `Ketoy version endpoint returned HTTP ${response.status} ${response.statusText} for ${VERSION_URL}.`
+    );
+  }
+  const body = (await response.text()).trim();
+  if (!VERSION_RE.test(body)) {
+    throw new KetoyCliError(
+      `Ketoy version endpoint returned an unexpected body: ${JSON.stringify(body.slice(0, 80))}. Expected a semver string like "0.3.4-alpha".`
+    );
+  }
+  return body;
+}
+async function getKetoyVersion() {
+  if (cached !== null) return cached;
+  cached = fetchVersion().catch((e) => {
+    cached = null;
+    throw e;
+  });
+  return cached;
+}
+
+// src/config/store.ts
+import { mkdir, readFile, writeFile, chmod, access } from "fs/promises";
+import { dirname } from "path";
+
+// src/config/schema.ts
+import { z } from "zod";
+var ProviderIdSchema = z.enum([
+  "anthropic",
+  "openai",
+  "google",
+  "mistral",
+  "groq",
+  "xai",
+  "openrouter",
+  "ollama"
+]);
+var GlobalConfigSchema = z.object({
+  model: z.string().default("anthropic:claude-sonnet-4-5"),
+  defaultProvider: ProviderIdSchema.default("anthropic"),
+  apiKeys: z.record(ProviderIdSchema, z.string()).default({}),
+  ollama: z.object({
+    baseUrl: z.string().default("http://localhost:11434")
+  }).default({ baseUrl: "http://localhost:11434" }),
+  agent: z.object({
+    maxSteps: z.number().int().min(1).max(200).default(50),
+    autoApproveReads: z.boolean().default(true),
+    autoApproveSafeBash: z.boolean().default(true)
+  }).default({ maxSteps: 50, autoApproveReads: true, autoApproveSafeBash: true })
+});
+var ProjectStateSchema = z.object({
+  ketoyVersion: z.string(),
+  initRanOn: z.string(),
+  hilt: z.boolean(),
+  applicationId: z.string(),
+  namespace: z.string(),
+  packagePath: z.string(),
+  bundlePath: z.string()
+});
+
+// src/config/store.ts
+var cached2 = null;
+async function fileExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadConfig() {
+  if (cached2) return cached2;
+  if (!await fileExists(CONFIG_FILE)) {
+    cached2 = GlobalConfigSchema.parse({});
+    return cached2;
+  }
+  const raw = await readFile(CONFIG_FILE, "utf-8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    throw new ConfigError(`Malformed config at ${CONFIG_FILE}: ${e.message}`);
+  }
+  const result = GlobalConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new ConfigError(`Invalid config at ${CONFIG_FILE}: ${result.error.message}`);
+  }
+  cached2 = result.data;
+  return cached2;
+}
+async function saveConfig(config) {
+  await mkdir(dirname(CONFIG_FILE), { recursive: true, mode: 448 });
+  await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", {
+    encoding: "utf-8",
+    mode: 384
+  });
+  await chmod(CONFIG_FILE, 384).catch(() => void 0);
+  cached2 = config;
+}
+async function setApiKey(provider, key) {
+  const config = await loadConfig();
+  const updated = {
+    ...config,
+    apiKeys: { ...config.apiKeys, [provider]: key }
+  };
+  await saveConfig(updated);
+}
+async function removeApiKey(provider) {
+  const config = await loadConfig();
+  const { [provider]: _removed, ...rest } = config.apiKeys;
+  await saveConfig({ ...config, apiKeys: rest });
+}
+async function getApiKey(provider) {
+  const config = await loadConfig();
+  return config.apiKeys[provider];
+}
+
+// src/commands/version.ts
+async function runVersionCommand() {
+  const config = await loadConfig();
+  log.info(`${pc.bold("ketoy")} ${CLI_VERSION}`);
+  const ketoyVersion = await getKetoyVersion();
+  log.detail(`Ketoy target:   ${ketoyVersion}`);
+  log.detail(`Default model:  ${config.model}`);
+  log.detail(`Node:           ${process.version}`);
+}
+
+// src/commands/auth.ts
+import { password, select, input } from "@inquirer/prompts";
+
+// src/providers/registry.ts
+var PROVIDERS = {
+  anthropic: {
+    id: "anthropic",
+    displayName: "Anthropic",
+    envVar: "ANTHROPIC_API_KEY",
+    apiKeyHelp: "Get a key at https://console.anthropic.com/settings/keys",
+    signupUrl: "https://console.anthropic.com",
+    defaultModel: "claude-sonnet-4-5",
+    sampleModels: [
+      "claude-sonnet-4-5",
+      "claude-opus-4-1",
+      "claude-haiku-4-5"
+    ]
+  },
+  openai: {
+    id: "openai",
+    displayName: "OpenAI",
+    envVar: "OPENAI_API_KEY",
+    apiKeyHelp: "Get a key at https://platform.openai.com/api-keys",
+    signupUrl: "https://platform.openai.com",
+    defaultModel: "gpt-4o",
+    sampleModels: ["gpt-4o", "gpt-4o-mini", "o1", "o1-mini"]
+  },
+  google: {
+    id: "google",
+    displayName: "Google (Gemini)",
+    envVar: "GOOGLE_GENERATIVE_AI_API_KEY",
+    apiKeyHelp: "Get a key at https://aistudio.google.com/apikey",
+    signupUrl: "https://aistudio.google.com",
+    defaultModel: "gemini-2.0-flash-exp",
+    sampleModels: ["gemini-2.0-flash-exp", "gemini-1.5-pro", "gemini-1.5-flash"]
+  },
+  mistral: {
+    id: "mistral",
+    displayName: "Mistral",
+    envVar: "MISTRAL_API_KEY",
+    apiKeyHelp: "Get a key at https://console.mistral.ai/api-keys/",
+    signupUrl: "https://console.mistral.ai",
+    defaultModel: "mistral-large-latest",
+    sampleModels: ["mistral-large-latest", "mistral-small-latest", "codestral-latest"]
+  },
+  groq: {
+    id: "groq",
+    displayName: "Groq",
+    envVar: "GROQ_API_KEY",
+    apiKeyHelp: "Get a key at https://console.groq.com/keys",
+    signupUrl: "https://console.groq.com",
+    defaultModel: "llama-3.3-70b-versatile",
+    sampleModels: ["llama-3.3-70b-versatile", "llama-3.1-70b-versatile", "mixtral-8x7b-32768"]
+  },
+  xai: {
+    id: "xai",
+    displayName: "xAI (Grok)",
+    envVar: "XAI_API_KEY",
+    apiKeyHelp: "Get a key at https://console.x.ai",
+    signupUrl: "https://console.x.ai",
+    defaultModel: "grok-2-latest",
+    sampleModels: ["grok-2-latest", "grok-beta"]
+  },
+  openrouter: {
+    id: "openrouter",
+    displayName: "OpenRouter (any model)",
+    envVar: "OPENROUTER_API_KEY",
+    apiKeyHelp: "Get a key at https://openrouter.ai/keys",
+    signupUrl: "https://openrouter.ai",
+    defaultModel: "anthropic/claude-sonnet-4",
+    sampleModels: [
+      "anthropic/claude-sonnet-4",
+      "openai/gpt-4o",
+      "google/gemini-2.0-flash-exp",
+      "meta-llama/llama-3.1-405b-instruct"
+    ]
+  },
+  ollama: {
+    id: "ollama",
+    displayName: "Ollama (local models)",
+    envVar: "",
+    apiKeyHelp: "No API key required \u2014 Ollama runs locally. Install at https://ollama.com",
+    signupUrl: "https://ollama.com",
+    defaultModel: "llama3.1:70b",
+    sampleModels: ["llama3.1:70b", "qwen2.5:32b", "codellama:34b"],
+    needsBaseUrl: true
+  }
+};
+function parseModelId(modelId) {
+  const idx = modelId.indexOf(":");
+  if (idx === -1) {
+    throw new Error(
+      `Invalid model id "${modelId}". Use the form "<provider>:<name>" \u2014 e.g. "anthropic:claude-sonnet-4-5".`
+    );
+  }
+  const providerRaw = modelId.slice(0, idx);
+  const name = modelId.slice(idx + 1);
+  if (!(providerRaw in PROVIDERS)) {
+    throw new Error(
+      `Unknown provider "${providerRaw}". Known providers: ${Object.keys(PROVIDERS).join(", ")}.`
+    );
+  }
+  if (!name) {
+    throw new Error(`Empty model name in "${modelId}". Use "<provider>:<name>".`);
+  }
+  return { provider: providerRaw, name };
+}
+
+// src/commands/auth.ts
+async function runAuthCommand(args) {
+  const providerKeys = Object.keys(PROVIDERS);
+  let provider;
+  if (args.provider) {
+    if (!providerKeys.includes(args.provider)) {
+      throw new KetoyCliError(
+        `Unknown provider "${args.provider}". Known: ${providerKeys.join(", ")}.`
+      );
+    }
+    provider = args.provider;
+  } else {
+    provider = await select({
+      message: "Choose a provider:",
+      choices: providerKeys.map((p) => ({
+        name: `${PROVIDERS[p].displayName} (${p})`,
+        value: p
+      }))
+    });
+  }
+  const info = PROVIDERS[provider];
+  if (args.remove) {
+    await removeApiKey(provider);
+    log.success(`Removed credentials for ${info.displayName}.`);
+    return;
+  }
+  if (provider === "ollama") {
+    const current = (await loadConfig()).ollama.baseUrl;
+    const base = await input({
+      message: "Ollama base URL:",
+      default: current
+    });
+    const config2 = await loadConfig();
+    await saveConfig({ ...config2, ollama: { baseUrl: base } });
+    log.success(`Ollama base URL saved: ${base}`);
+    return;
+  }
+  log.info(info.apiKeyHelp);
+  const existing = await getApiKey(provider);
+  if (existing) {
+    log.detail(`A key for ${info.displayName} is already saved (ends in \u2026${existing.slice(-4)}).`);
+  }
+  const key = await password({
+    message: `${info.displayName} API key:`,
+    mask: "*",
+    validate: (v) => v.trim().length > 0 ? true : "API key cannot be empty."
+  });
+  await setApiKey(provider, key.trim());
+  const config = await loadConfig();
+  if (config.defaultProvider !== provider) {
+    log.info(
+      `Tip: run ${pc.bold(`ketoy config set model ${provider}:${info.defaultModel}`)} to use this provider by default.`
+    );
+  }
+  log.success(`Saved ${info.displayName} key to ${pc.dim("~/.ketoy-cli/config.json")} (mode 0600).`);
+}
+async function listAuthStatus() {
+  const config = await loadConfig();
+  const providerKeys = Object.keys(PROVIDERS);
+  log.info("Provider credentials:");
+  for (const p of providerKeys) {
+    const info = PROVIDERS[p];
+    const key = config.apiKeys[p];
+    const status = key ? pc.green(`set (\u2026${key.slice(-4)})`) : pc.dim("not set");
+    log.detail(`${info.displayName.padEnd(28)} ${status}`);
+  }
+  log.detail(`Default model: ${config.model}`);
+  try {
+    log.detail(`Will use model on next chat: ${parseModelId(config.model).provider}`);
+  } catch (e) {
+    log.warn(
+      `Default model "${config.model}" is malformed (${e.message}). Run \`ketoy config set model <provider>:<name>\`.`
+    );
+  }
+}
+
+// src/commands/config.ts
+async function runConfigList() {
+  const config = await loadConfig();
+  log.info("Config:");
+  log.detail(`model:            ${config.model}`);
+  log.detail(`defaultProvider:  ${config.defaultProvider}`);
+  log.detail(`ollama.baseUrl:   ${config.ollama.baseUrl}`);
+  log.detail(`agent.maxSteps:   ${config.agent.maxSteps}`);
+  log.detail(`agent.autoApproveReads:    ${config.agent.autoApproveReads}`);
+  log.detail(`agent.autoApproveSafeBash: ${config.agent.autoApproveSafeBash}`);
+  log.detail(`Providers configured: ${Object.keys(config.apiKeys).join(", ") || pc.dim("(none)")}`);
+}
+var REDACTED_KEYS = /* @__PURE__ */ new Set(["apiKeys"]);
+function isRedacted(key) {
+  const top = key.split(".")[0] ?? "";
+  return REDACTED_KEYS.has(top);
+}
+var FORBIDDEN_KEY_PARTS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+function assertSafeKey(key) {
+  for (const part of key.split(".")) {
+    if (FORBIDDEN_KEY_PARTS.has(part)) {
+      throw new KetoyCliError(`Refusing key "${key}" \u2014 reserved property name "${part}".`);
+    }
+  }
+}
+async function runConfigGet(key) {
+  assertSafeKey(key);
+  if (isRedacted(key)) {
+    throw new KetoyCliError(
+      `Refusing to print "${key}" \u2014 contains secrets. Use \`ketoy auth --list\` for a redacted view.`
+    );
+  }
+  const config = await loadConfig();
+  const value = readByDottedKey(config, key);
+  if (value === void 0) {
+    log.warn(`Unknown config key: ${key}`);
+    process.exitCode = 2;
+    return;
+  }
+  log.info(typeof value === "object" ? JSON.stringify(value, null, 2) : String(value));
+}
+async function runConfigSet(key, value) {
+  assertSafeKey(key);
+  if (isRedacted(key)) {
+    throw new KetoyCliError(
+      `Refusing to set "${key}" directly. Use \`ketoy auth <provider>\` to store API keys securely.`
+    );
+  }
+  const config = await loadConfig();
+  const obj = JSON.parse(JSON.stringify(config));
+  const parsedValue = coerceValue(key, value);
+  writeByDottedKey(obj, key, parsedValue);
+  const reparsed = GlobalConfigSchema.parse(obj);
+  await saveConfig(reparsed);
+  log.success(`Updated ${pc.bold(key)} = ${JSON.stringify(parsedValue)}`);
+}
+function coerceValue(key, value) {
+  if (key === "model") {
+    parseModelId(value);
+    return value;
+  }
+  if (key === "defaultProvider") {
+    if (!(value in PROVIDERS)) {
+      throw new KetoyCliError(
+        `Unknown provider "${value}". Known: ${Object.keys(PROVIDERS).join(", ")}.`
+      );
+    }
+    return value;
+  }
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (/^-?\d+$/.test(value)) return Number(value);
+  return value;
+}
+function readByDottedKey(obj, key) {
+  return key.split(".").reduce((acc, part) => {
+    if (acc && typeof acc === "object" && Object.prototype.hasOwnProperty.call(acc, part)) {
+      return acc[part];
+    }
+    return void 0;
+  }, obj);
+}
+function writeByDottedKey(obj, key, value) {
+  const parts = key.split(".");
+  let cursor = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (FORBIDDEN_KEY_PARTS.has(part)) {
+      throw new KetoyCliError(`Refusing key "${key}" \u2014 reserved property name "${part}".`);
+    }
+    const next = cursor[part];
+    if (next === void 0 || typeof next !== "object" || next === null) {
+      cursor[part] = /* @__PURE__ */ Object.create(null);
+    }
+    cursor = cursor[part];
+  }
+  const last = parts[parts.length - 1];
+  if (FORBIDDEN_KEY_PARTS.has(last)) {
+    throw new KetoyCliError(`Refusing key "${key}" \u2014 reserved property name "${last}".`);
+  }
+  cursor[last] = value;
+}
+
+// src/commands/init/index.ts
+import { confirm } from "@inquirer/prompts";
+
+// src/commands/init/detect.ts
+import { readFile as readFile2, access as access2 } from "fs/promises";
+import { join as join2 } from "path";
+import { glob } from "tinyglobby";
+async function fileExists2(p) {
+  try {
+    await access2(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detectProject(projectRoot) {
+  const settingsKts = join2(projectRoot, "settings.gradle.kts");
+  const settingsGradle = join2(projectRoot, "settings.gradle");
+  const rootSettings = await fileExists2(settingsKts) ? settingsKts : await fileExists2(settingsGradle) ? settingsGradle : null;
+  if (!rootSettings) {
+    throw new DetectionError(
+      "No settings.gradle.kts (or settings.gradle) at the project root. Run from an Android project root."
+    );
+  }
+  if (rootSettings.endsWith(".gradle")) {
+    throw new DetectionError(
+      "Groovy settings.gradle detected \u2014 Ketoy requires Kotlin DSL (settings.gradle.kts). Migrate the build files first."
+    );
+  }
+  const appBuildKts = join2(projectRoot, "app", "build.gradle.kts");
+  if (!await fileExists2(appBuildKts)) {
+    throw new DetectionError(
+      `No app/build.gradle.kts found. Expected the Android app module at ${join2(projectRoot, "app")}.`
+    );
+  }
+  const appBuildSource = await readFile2(appBuildKts, "utf-8");
+  const namespace = matchOne(appBuildSource, /namespace\s*=\s*"([\w.]+)"/);
+  const applicationId = matchOne(appBuildSource, /applicationId\s*=\s*"([\w.]+)"/);
+  const minSdkRaw = matchOne(appBuildSource, /minSdk\s*=\s*(\d+)/);
+  if (!namespace) throw new DetectionError(`Could not read android.namespace from ${appBuildKts}.`);
+  if (!applicationId) throw new DetectionError(`Could not read defaultConfig.applicationId from ${appBuildKts}.`);
+  if (!minSdkRaw) throw new DetectionError(`Could not read defaultConfig.minSdk from ${appBuildKts}.`);
+  const minSdk = Number(minSdkRaw);
+  const manifestPath = join2(projectRoot, "app", "src", "main", "AndroidManifest.xml");
+  if (!await fileExists2(manifestPath)) {
+    throw new DetectionError(`Missing AndroidManifest.xml at ${manifestPath}.`);
+  }
+  const packageDotPath = applicationId.replace(/\./g, "/");
+  const kotlinRoot = join2(projectRoot, "app", "src", "main", "kotlin", packageDotPath);
+  const javaRoot = join2(projectRoot, "app", "src", "main", "java", packageDotPath);
+  let packageSrcRoot;
+  let packagePath;
+  if (await fileExists2(kotlinRoot)) {
+    packageSrcRoot = "kotlin";
+    packagePath = kotlinRoot;
+  } else if (await fileExists2(javaRoot)) {
+    packageSrcRoot = "java";
+    packagePath = javaRoot;
+  } else {
+    packageSrcRoot = "kotlin";
+    packagePath = kotlinRoot;
+  }
+  const hasHilt = /dagger\.hilt|hilt\.android|@HiltAndroidApp/.test(appBuildSource) || await searchForHilt(projectRoot);
+  const manifestSource = await readFile2(manifestPath, "utf-8");
+  const appTagMatch = /<application\b([^>]*)>/.exec(manifestSource);
+  const appTagAttrs = appTagMatch ? appTagMatch[1] ?? "" : "";
+  const applicationNameAttr = matchOne(appTagAttrs, /android:name\s*=\s*"([.\w]+)"/);
+  const existingApplicationClassFq = applicationNameAttr ? applicationNameAttr.startsWith(".") ? applicationId + applicationNameAttr : applicationNameAttr : null;
+  const mainActivityCandidates = await glob("app/src/main/{java,kotlin}/**/MainActivity.kt", {
+    cwd: projectRoot,
+    absolute: true,
+    onlyFiles: true
+  });
+  const existingMainActivityPath = mainActivityCandidates[0] ?? null;
+  const rootBuildKts = join2(projectRoot, "build.gradle.kts");
+  const rootBuildGradlePath = await fileExists2(rootBuildKts) ? rootBuildKts : null;
+  const versionCatalog = join2(projectRoot, "gradle", "libs.versions.toml");
+  const versionCatalogPath = await fileExists2(versionCatalog) ? versionCatalog : null;
+  return {
+    projectRoot,
+    appModulePath: join2(projectRoot, "app"),
+    appModuleRelative: "app",
+    buildGradleKtsPath: appBuildKts,
+    manifestPath,
+    namespace,
+    applicationId,
+    minSdk,
+    packagePath,
+    packageSrcRoot,
+    hasHilt,
+    existingApplicationClassFq,
+    existingMainActivityPath,
+    rootSettingsPath: rootSettings,
+    rootBuildGradlePath,
+    versionCatalogPath
+  };
+}
+function matchOne(source, re) {
+  const m = re.exec(source);
+  return m && m[1] !== void 0 ? m[1] : null;
+}
+async function searchForHilt(projectRoot) {
+  const matches = await glob("app/src/main/**/*.kt", {
+    cwd: projectRoot,
+    absolute: true,
+    onlyFiles: true
+  });
+  for (const f of matches) {
+    const content = await readFile2(f, "utf-8").catch(() => "");
+    if (/dagger\.hilt|@HiltAndroidApp/.test(content)) return true;
+  }
+  return false;
+}
+
+// src/commands/init/plan.ts
+import { join as join3, relative } from "path";
+import { access as access3 } from "fs/promises";
+
+// src/alpha-pins.ts
+var ALPHA_PINS = [
+  // ── Compiler/toolchain ─────────────────────────────────────────────
+  {
+    key: "kotlin",
+    required: "2.0.21",
+    aliases: ["kotlin", "kotlinVersion"],
+    label: "Kotlin"
+  },
+  {
+    key: "agp",
+    required: "8.13.2",
+    aliases: ["agp", "androidGradlePlugin", "gradlePlugin"],
+    label: "Android Gradle Plugin"
+  },
+  {
+    key: "composeBom",
+    required: "2024.10.00",
+    aliases: ["composeBom", "compose-bom", "composeBomVersion"],
+    label: "Jetpack Compose BOM"
+  },
+  // ── AndroidX libraries — newer releases require AGP 8.9+, which
+  //    breaks against our pinned AGP. Pin to the latest release that
+  //    works with AGP 8.13.x. Versions track KetoyVMTest's catalog.
+  {
+    key: "coreKtx",
+    required: "1.13.1",
+    aliases: ["coreKtx", "core-ktx", "androidxCoreKtx"],
+    label: "androidx.core:core-ktx"
+  },
+  {
+    key: "lifecycleRuntimeKtx",
+    required: "2.8.6",
+    aliases: ["lifecycleRuntimeKtx", "lifecycle-runtime-ktx", "androidxLifecycle"],
+    label: "androidx.lifecycle:lifecycle-runtime-ktx"
+  },
+  {
+    key: "activityCompose",
+    required: "1.9.3",
+    aliases: ["activityCompose", "activity-compose", "androidxActivityCompose"],
+    label: "androidx.activity:activity-compose"
+  },
+  {
+    key: "junitVersion",
+    required: "1.2.1",
+    aliases: ["junitVersion", "androidxJunit", "androidx-junit", "androidxJunitExt"],
+    label: "androidx.test.ext:junit"
+  },
+  {
+    key: "espressoCore",
+    required: "3.6.1",
+    aliases: ["espressoCore", "espresso-core", "androidxEspresso"],
+    label: "androidx.test.espresso:espresso-core"
+  }
+];
+
+// src/commands/init/plan.ts
+async function fileExists3(p) {
+  try {
+    await access3(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var COMPILER_PLUGIN_ID = "dev.ketoy.compiler";
+var APP_CLASS = "MyApplication";
+var SCREEN_ENTRY_POINT = "HelloKetoyScreen";
+var BUNDLE_ASSET = "ketoy/main.ktx";
+async function planInit(detection, planOptions = { installKetoyScreen: true }) {
+  const warnings = [];
+  const actions = [];
+  const ketoyVersion = await getKetoyVersion();
+  if (detection.minSdk < 26) {
+    warnings.push(
+      `Project minSdk is ${detection.minSdk}; Ketoy requires API 26+. Bump minSdk to 26 (or higher) in app/build.gradle.kts before continuing.`
+    );
+  }
+  const root = detection.projectRoot;
+  const appBuildRel = relative(root, detection.buildGradleKtsPath);
+  const manifestRel = relative(root, detection.manifestPath);
+  const pkg = detection.applicationId;
+  const pkgDirRel = relative(root, detection.packagePath);
+  const versionCatalogRel = "gradle/libs.versions.toml";
+  const versionCatalogPath = join3(root, versionCatalogRel);
+  if (await fileExists3(versionCatalogPath)) {
+    const labels = ALPHA_PINS.map((p) => `${p.label}=${p.required}`).join(", ");
+    actions.push({
+      kind: "pin-alpha-versions",
+      description: `Pin alpha-required versions in ${versionCatalogRel}: ${labels}`,
+      targetRel: versionCatalogRel,
+      payload: { pins: ALPHA_PINS },
+      highRisk: true
+    });
+  } else {
+    const labels = ALPHA_PINS.map((p) => `${p.label} ${p.required}`).join(", ");
+    warnings.push(
+      `No gradle/libs.versions.toml found \u2014 verify your project uses ${labels} manually. Ketoy 0.3.x will not build against newer Kotlin/AGP/Compose. This pinning requirement is temporary and goes away with ADR-0004.`
+    );
+  }
+  actions.push({
+    kind: "ensure-gradle-property",
+    description: "Ensure android.useAndroidX=true in gradle.properties (required by AGP 8.7)",
+    targetRel: "gradle.properties",
+    payload: { key: "android.useAndroidX", value: "true" },
+    highRisk: true
+  });
+  actions.push({
+    kind: "ensure-gradle-property",
+    description: "Ensure android.enableJetifier=false in gradle.properties",
+    targetRel: "gradle.properties",
+    payload: { key: "android.enableJetifier", value: "false" },
+    highRisk: true
+  });
+  actions.push({
+    kind: "agp8-compat",
+    description: `Rewrite block-style compileSdk { ... } in ${appBuildRel} to the AGP-8.x property form (compileSdk = N)`,
+    targetRel: appBuildRel,
+    highRisk: true
+  });
+  if (detection.versionCatalogPath) {
+    actions.push({
+      kind: "ensure-toml-plugin",
+      description: `Add kotlin-android plugin to [plugins] in gradle/libs.versions.toml`,
+      targetRel: relative(root, detection.versionCatalogPath),
+      payload: {
+        key: "kotlin-android",
+        id: "org.jetbrains.kotlin.android",
+        versionRef: "kotlin"
+      },
+      highRisk: true
+    });
+  } else {
+    warnings.push(
+      "No gradle/libs.versions.toml found \u2014 add the kotlin-android plugin alias manually."
+    );
+  }
+  if (detection.rootBuildGradlePath) {
+    actions.push({
+      kind: "insert-plugin-alias",
+      description: `Declare alias(libs.plugins.kotlin.android) apply false in root build.gradle.kts`,
+      targetRel: relative(root, detection.rootBuildGradlePath),
+      payload: {
+        aliasPath: "libs.plugins.kotlin.android",
+        applyFalse: true
+      },
+      highRisk: true
+    });
+  } else {
+    warnings.push(
+      "No root build.gradle.kts \u2014 add `alias(libs.plugins.kotlin.android) apply false` manually."
+    );
+  }
+  actions.push({
+    kind: "insert-plugin-alias",
+    description: `Insert alias(libs.plugins.kotlin.android) into plugins { } in ${appBuildRel}`,
+    targetRel: appBuildRel,
+    payload: {
+      aliasPath: "libs.plugins.kotlin.android",
+      applyFalse: false
+    },
+    highRisk: true
+  });
+  actions.push({
+    kind: "insert-plugin",
+    description: `Insert id("${COMPILER_PLUGIN_ID}") version "${ketoyVersion}" into plugins { } in ${appBuildRel}`,
+    targetRel: appBuildRel,
+    payload: { pluginId: COMPILER_PLUGIN_ID, version: ketoyVersion },
+    highRisk: true
+  });
+  const deps = [
+    { configuration: "implementation", notation: `platform("dev.ketoy.vm:ketoy-bom:${ketoyVersion}")` },
+    { configuration: "implementation", notation: `"dev.ketoy.vm:ketoy-runtime"` },
+    { configuration: "implementation", notation: `"dev.ketoy.vm:ketoy-annotations"` },
+    { configuration: "implementation", notation: `"dev.ketoy.vm:ketoy-capabilities-core"` },
+    { configuration: "implementation", notation: `"dev.ketoy.vm:ketoy-capabilities-navigation"` },
+    { configuration: "implementation", notation: `"dev.ketoy.vm:ketoy-adapters-material3"` }
+  ];
+  actions.push({
+    kind: "append-deps",
+    description: `Append Ketoy ${ketoyVersion} dependencies to dependencies { } in ${appBuildRel}`,
+    targetRel: appBuildRel,
+    payload: { groupComment: `Ketoy ${ketoyVersion}`, entries: deps },
+    highRisk: true
+  });
+  const ketoyBlockBody = [
+    "// ADR-0003 inline-source app bundle: compile the @KetoyComposable",
+    "// closure inside this module into ONE signed .ktx at compileReleaseKotlin.",
+    "exportFromAppModule.set(true)",
+    'bundleId.set("main")',
+    'bundleVariant.set("release")',
+    'capabilityRegistryFile.set(file("ketoy-capabilities.json"))',
+    "// minimum host APK versionCode required to activate this bundle.",
+    "// 0 = universally compatible (default).",
+    "minAppVersion.set(0)",
+    "// Emit source line numbers for the dev overlay.",
+    "debugMode.set(true)",
+    "",
+    "// Optional: sign the bundle with Ed25519. Generate via:",
+    "//   openssl genpkey -algorithm Ed25519 -outform DER -out key.der",
+    "//   tail -c 32 key.der > app/keys/release-private.key",
+    "// Without a key the plugin emits an unsigned bundle gracefully.",
+    'val signingKey = file("keys/release-private.key")',
+    "if (signingKey.exists()) {",
+    "    signingKeyFile.set(signingKey)",
+    "}"
+  ].join("\n");
+  actions.push({
+    kind: "append-block",
+    description: `Append ketoy { ... } block to ${appBuildRel}`,
+    targetRel: appBuildRel,
+    payload: { blockName: "ketoy", body: ketoyBlockBody },
+    highRisk: true
+  });
+  actions.push({
+    kind: "bump-java-compatibility",
+    description: `Set compileOptions.{source,target}Compatibility to JavaVersion.VERSION_17 in ${appBuildRel}`,
+    targetRel: appBuildRel,
+    payload: { minLevel: 17 },
+    highRisk: true
+  });
+  const kotlinBlockBody = [
+    "compilerOptions {",
+    "    jvmTarget.set(org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17)",
+    "}"
+  ].join("\n");
+  actions.push({
+    kind: "append-block",
+    description: `Append kotlin { compilerOptions { jvmTarget = JVM_17 } } block to ${appBuildRel}`,
+    targetRel: appBuildRel,
+    payload: { blockName: "kotlin", body: kotlinBlockBody },
+    highRisk: true
+  });
+  if (detection.existingApplicationClassFq) {
+    warnings.push(
+      `Existing Application class detected: ${detection.existingApplicationClassFq}. We will NOT touch the manifest's android:name. Integrate the Ketoy runtime + bundle loader bootstrap into your existing Application class manually \u2014 see the new ${APP_CLASS}.kt example we will write next to it for the canonical setup.`
+    );
+    actions.push({
+      kind: "write-file",
+      description: `Create reference ${join3(pkgDirRel, `${APP_CLASS}.kt`)} (alongside your existing Application \u2014 copy bootstrap code into yours)`,
+      targetRel: join3(pkgDirRel, `${APP_CLASS}.kt`),
+      payload: { template: "MyApplication.kt.tmpl", vars: { PACKAGE: pkg } }
+    });
+  } else {
+    actions.push({
+      kind: "set-manifest-name",
+      description: `Set android:name=".${APP_CLASS}" on <application> in ${manifestRel}`,
+      targetRel: manifestRel,
+      payload: { value: `.${APP_CLASS}` },
+      highRisk: true
+    });
+    actions.push({
+      kind: "write-file",
+      description: `Create ${join3(pkgDirRel, `${APP_CLASS}.kt`)} (KetoyRuntime + KetoyConfig + adapter registration + bundle loader)`,
+      targetRel: join3(pkgDirRel, `${APP_CLASS}.kt`),
+      payload: { template: "MyApplication.kt.tmpl", vars: { PACKAGE: pkg } }
+    });
+  }
+  if (detection.existingMainActivityPath) {
+    if (planOptions.installKetoyScreen) {
+      const maRel = relative(root, detection.existingMainActivityPath);
+      actions.push({
+        kind: "wrap-main-activity",
+        description: `Install KetoyScreen + simple Hello Android fallback inside the theme block in ${maRel}`,
+        targetRel: maRel,
+        payload: {
+          packageOfApp: pkg,
+          appClassSimpleName: APP_CLASS,
+          entryPoint: SCREEN_ENTRY_POINT,
+          bundleAsset: BUNDLE_ASSET
+        },
+        highRisk: true
+      });
+    } else {
+      warnings.push(
+        "Skipping MainActivity edit (declined). Integrate KetoyScreen manually \u2014 see the snippet printed at the end of init, https://ketoy.dev/docs, or run `ketoy chat`."
+      );
+    }
+  } else if (planOptions.installKetoyScreen) {
+    actions.push({
+      kind: "write-file",
+      description: `Create ${join3(pkgDirRel, "MainActivity.kt")}`,
+      targetRel: join3(pkgDirRel, "MainActivity.kt"),
+      payload: { template: "MainActivity.kt.tmpl", vars: { PACKAGE: pkg } }
+    });
+  } else {
+    warnings.push(
+      "No MainActivity.kt found and KetoyScreen install declined \u2014 you must create one manually. See `ketoy chat` or the docs."
+    );
+  }
+  actions.push({
+    kind: "write-file",
+    description: `Create ${join3(pkgDirRel, `${SCREEN_ENTRY_POINT}.kt`)}`,
+    targetRel: join3(pkgDirRel, `${SCREEN_ENTRY_POINT}.kt`),
+    payload: { template: "HelloKetoyScreen.kt.tmpl", vars: { PACKAGE: pkg } }
+  });
+  actions.push({
+    kind: "write-file",
+    description: `Create app/ketoy-capabilities.json`,
+    targetRel: "app/ketoy-capabilities.json",
+    payload: { template: "ketoy-capabilities.json.tmpl", vars: { PACKAGE: pkg } }
+  });
+  actions.push({
+    kind: "gitignore",
+    description: "Add `**/keys/*-private.key` to .gitignore",
+    targetRel: ".gitignore",
+    payload: { entries: ["**/keys/*-private.key"] }
+  });
+  const finalActions = [];
+  for (const a of actions) {
+    if (a.kind === "write-file") {
+      const abs = join3(root, a.targetRel);
+      if (await fileExists3(abs)) {
+        warnings.push(`File already exists, skipping: ${a.targetRel}`);
+        continue;
+      }
+    }
+    finalActions.push(a);
+  }
+  return { actions: finalActions, warnings };
+}
+
+// src/commands/init/edit.ts
+import { mkdir as mkdir2, writeFile as writeFile10 } from "fs/promises";
+import { dirname as dirname3, join as join5 } from "path";
+
+// src/safe-edit/gradle-kts.ts
+import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+function findBlockBounds(source, header) {
+  const m = header.exec(source);
+  if (!m) return null;
+  const headerEnd = m.index + m[0].length;
+  let depth = 1;
+  let i = headerEnd;
+  while (i < source.length && depth > 0) {
+    const ch = source[i];
+    if (ch === "{") depth++;
+    else if (ch === "}") depth--;
+    if (depth === 0) return { open: headerEnd, close: i };
+    i++;
+  }
+  return null;
+}
+function indentationOf(line) {
+  const m = /^[ \t]*/.exec(line);
+  return m ? m[0] : "";
+}
+function insertInsideBlock(source, open, close, body) {
+  const before = source.slice(0, close);
+  const after = source.slice(close);
+  const lastNewline = before.lastIndexOf("\n");
+  const closingLine = lastNewline >= 0 ? before.slice(lastNewline + 1) : before;
+  const baseIndent = indentationOf(closingLine);
+  const lineIndent = baseIndent + "    ";
+  const indented = body.split("\n").map((l) => l.length === 0 ? l : lineIndent + l).join("\n");
+  const needsLeadingNewline = lastNewline === -1 || before[before.length - 1] !== "\n";
+  const prefix = needsLeadingNewline ? "\n" : "";
+  return source.slice(0, close) + prefix + indented + "\n" + baseIndent + after.slice(0);
+}
+async function insertPlugin(path, pluginId, options = {}) {
+  const source = await readFile3(path, "utf-8");
+  if (new RegExp(`id\\s*\\(\\s*"${pluginId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}"\\s*\\)`).test(source)) {
+    return { changed: false };
+  }
+  const bounds = findBlockBounds(source, /\bplugins\s*\{/);
+  if (!bounds) {
+    throw new Error(`No top-level plugins { } block found in ${path}.`);
+  }
+  const line = options.version ? `id("${pluginId}") version "${options.version}"` : `id("${pluginId}")`;
+  const updated = insertInsideBlock(source, bounds.open, bounds.close, line);
+  await writeFile2(path, updated, "utf-8");
+  return { changed: true };
+}
+async function appendDependencyGroup(path, groupComment, entries) {
+  const source = await readFile3(path, "utf-8");
+  const bounds = findBlockBounds(source, /\bdependencies\s*\{/);
+  if (!bounds) {
+    throw new Error(`No top-level dependencies { } block found in ${path}.`);
+  }
+  const missing = entries.filter((e) => !source.includes(e.notation));
+  if (missing.length === 0) return { changed: false, addedCount: 0 };
+  const lines = [`// ${groupComment}`];
+  for (const e of missing) lines.push(`${e.configuration}(${e.notation})`);
+  const body = lines.join("\n");
+  const updated = insertInsideBlock(source, bounds.open, bounds.close, body);
+  await writeFile2(path, updated, "utf-8");
+  return { changed: true, addedCount: missing.length };
+}
+async function topLevelBlockExists(path, blockName) {
+  const source = await readFile3(path, "utf-8");
+  return new RegExp(`(^|\\n)\\s*${blockName}\\s*\\{`).test(source);
+}
+async function appendTopLevelBlock(path, blockName, body) {
+  if (await topLevelBlockExists(path, blockName)) return { changed: false };
+  const source = await readFile3(path, "utf-8");
+  const trimmed = source.replace(/\s+$/, "");
+  const block = `${blockName} {
+${body.split("\n").map((l) => l.length === 0 ? l : "    " + l).join("\n")}
+}
+`;
+  await writeFile2(path, trimmed + "\n\n" + block, "utf-8");
+  return { changed: true };
+}
+async function insertPluginAlias(path, aliasPath, options = {}) {
+  const source = await readFile3(path, "utf-8");
+  const escaped = aliasPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  if (new RegExp(`alias\\s*\\(\\s*${escaped}\\s*\\)`).test(source)) {
+    return { changed: false };
+  }
+  const bounds = findBlockBounds(source, /\bplugins\s*\{/);
+  if (!bounds) {
+    throw new Error(`No top-level plugins { } block found in ${path}.`);
+  }
+  const line = options.applyFalse ? `alias(${aliasPath}) apply false` : `alias(${aliasPath})`;
+  const updated = insertInsideBlock(source, bounds.open, bounds.close, line);
+  await writeFile2(path, updated, "utf-8");
+  return { changed: true };
+}
+var JAVA_VERSION_NUM = {
+  VERSION_1_8: 8,
+  VERSION_9: 9,
+  VERSION_10: 10,
+  VERSION_11: 11,
+  VERSION_12: 12,
+  VERSION_13: 13,
+  VERSION_14: 14,
+  VERSION_15: 15,
+  VERSION_16: 16,
+  VERSION_17: 17,
+  VERSION_18: 18,
+  VERSION_19: 19,
+  VERSION_20: 20,
+  VERSION_21: 21
+};
+async function bumpJavaCompatibility(path, minLevel) {
+  let source = await readFile3(path, "utf-8");
+  const rewrites = [];
+  for (const prop of ["sourceCompatibility", "targetCompatibility"]) {
+    const re = new RegExp(`(\\b${prop}\\s*=\\s*JavaVersion\\.)(VERSION_[\\w_]+)`);
+    const m = re.exec(source);
+    if (m && m[2]) {
+      const currentName = m[2];
+      const current = JAVA_VERSION_NUM[currentName] ?? null;
+      if (current === null || current >= minLevel) continue;
+      const newName = `VERSION_${minLevel}`;
+      source = source.slice(0, m.index) + m[1] + newName + source.slice(m.index + m[0].length);
+      rewrites.push(`${prop} ${currentName} \u2192 ${newName}`);
+    }
+  }
+  const compileOptionsBlock = findBlockBounds(source, /\bcompileOptions\s*\{/);
+  if (compileOptionsBlock) {
+    for (const prop of ["sourceCompatibility", "targetCompatibility"]) {
+      if (!new RegExp(`\\b${prop}\\s*=`).test(source.slice(compileOptionsBlock.open, compileOptionsBlock.close))) {
+        const line = `${prop} = JavaVersion.VERSION_${minLevel}`;
+        source = insertInsideBlock(source, compileOptionsBlock.open, compileOptionsBlock.close, line);
+        rewrites.push(`added ${prop} = VERSION_${minLevel}`);
+        const refreshed = findBlockBounds(source, /\bcompileOptions\s*\{/);
+        if (refreshed) {
+          compileOptionsBlock.open = refreshed.open;
+          compileOptionsBlock.close = refreshed.close;
+        }
+      }
+    }
+  }
+  if (rewrites.length === 0) {
+    return { changed: false, rewrites: [] };
+  }
+  await writeFile2(path, source, "utf-8");
+  return { changed: true, rewrites };
+}
+
+// src/safe-edit/manifest-xml.ts
+import { readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
+import { XMLParser } from "fast-xml-parser";
+var APP_TAG_RE = /<application\b([^>]*)>/;
+async function setApplicationName(path, androidName) {
+  const source = await readFile4(path, "utf-8");
+  const match = APP_TAG_RE.exec(source);
+  if (!match) {
+    throw new Error(`No <application> tag found in ${path}.`);
+  }
+  const tagAttrs = match[1] ?? "";
+  const tagStart = match.index;
+  const tagEnd = tagStart + match[0].length;
+  const nameAttr = /\bandroid:name\s*=\s*"([^"]*)"/.exec(tagAttrs);
+  if (nameAttr && nameAttr[1] === androidName) {
+    return { changed: false, previousValue: nameAttr[1] };
+  }
+  let newAttrs;
+  let previousValue;
+  if (nameAttr) {
+    previousValue = nameAttr[1] ?? null;
+    newAttrs = tagAttrs.replace(
+      /\bandroid:name\s*=\s*"[^"]*"/,
+      `android:name="${androidName}"`
+    );
+  } else {
+    previousValue = null;
+    const trimmed = tagAttrs.replace(/\s+$/, "");
+    newAttrs = `${trimmed.length > 0 ? trimmed : ""}
+        android:name="${androidName}"`;
+  }
+  const replacement = `<application${newAttrs}>`;
+  const updated = source.slice(0, tagStart) + replacement + source.slice(tagEnd);
+  await writeFile3(path, updated, "utf-8");
+  return { changed: true, previousValue };
+}
+
+// src/safe-edit/gitignore.ts
+import { readFile as readFile5, writeFile as writeFile4, access as access4 } from "fs/promises";
+async function fileExists4(path) {
+  try {
+    await access4(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureGitignoreEntries(path, entries) {
+  const exists = await fileExists4(path);
+  const source = exists ? await readFile5(path, "utf-8") : "";
+  const lines = new Set(
+    source.split("\n").map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#"))
+  );
+  const added = entries.filter((e) => !lines.has(e.trim()));
+  if (added.length === 0) return { added: [] };
+  const prefix = source.length === 0 || source.endsWith("\n") ? "" : "\n";
+  const block = "\n# Ketoy\n" + added.join("\n") + "\n";
+  await writeFile4(path, source + prefix + block, "utf-8");
+  return { added };
+}
+
+// src/safe-edit/main-activity-wrap.ts
+import { readFile as readFile7, writeFile as writeFile6 } from "fs/promises";
+
+// src/safe-edit/kotlin-file.ts
+import { readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
+async function addImport(path, importStatement) {
+  const source = await readFile6(path, "utf-8");
+  const target = `import ${importStatement}`;
+  if (new RegExp(`^${target.replace(/\./g, "\\.")}\\b`, "m").test(source)) {
+    return { changed: false };
+  }
+  const importBlockRe = /(?:^|\n)import\s+[\w.*]+\s*$/gm;
+  let lastIdx = -1;
+  for (let m; m = importBlockRe.exec(source); ) {
+    lastIdx = m.index + m[0].length;
+  }
+  if (lastIdx >= 0) {
+    const updated = source.slice(0, lastIdx) + `
+${target}` + source.slice(lastIdx);
+    await writeFile5(path, updated, "utf-8");
+    return { changed: true };
+  }
+  const pkgRe = /^package\s+[\w.]+\s*$/m;
+  const pkg = pkgRe.exec(source);
+  if (pkg) {
+    const insertAt = pkg.index + pkg[0].length;
+    const updated = source.slice(0, insertAt) + `
+
+${target}` + source.slice(insertAt);
+    await writeFile5(path, updated, "utf-8");
+    return { changed: true };
+  }
+  await writeFile5(path, target + "\n\n" + source, "utf-8");
+  return { changed: true };
+}
+
+// src/safe-edit/main-activity-wrap.ts
+var MARKER = "LocalKetoyRuntime provides app.ketoyRuntime";
+async function wrapMainActivityWithKetoyScreen(path, options) {
+  let source = await readFile7(path, "utf-8");
+  if (source.includes(MARKER)) {
+    return { changed: false, reason: "Already wrapped" };
+  }
+  const setContentMatch = /setContent\s*\{/.exec(source);
+  if (!setContentMatch) {
+    return { changed: false, reason: "No setContent { \u2026 } block found in MainActivity" };
+  }
+  const setContentOpen = setContentMatch.index + setContentMatch[0].length;
+  const setContentClose = findMatchingBrace(source, setContentOpen);
+  if (setContentClose === -1) {
+    return { changed: false, reason: "Could not balance braces in setContent { \u2026 }" };
+  }
+  const setContentBody = source.slice(setContentOpen, setContentClose);
+  const themeRe = /\b([A-Z][A-Za-z0-9_]*Theme)\s*\{/;
+  const themeMatch = themeRe.exec(setContentBody);
+  if (themeMatch) {
+    const themeOpenAbs = setContentOpen + themeMatch.index + themeMatch[0].length;
+    const themeCloseAbs = findMatchingBrace(source, themeOpenAbs);
+    if (themeCloseAbs === -1) {
+      return { changed: false, reason: "Could not balance theme braces" };
+    }
+    const themeStartAbs = setContentOpen + themeMatch.index;
+    const themeOuterIndent = lineIndentBefore(source, themeStartAbs);
+    const themeBodyIndent = themeOuterIndent + "    ";
+    const snippet = buildKetoyScreenSnippet(themeBodyIndent, options);
+    source = source.slice(0, themeOpenAbs) + "\n" + snippet + "\n" + themeOuterIndent + source.slice(themeCloseAbs);
+  } else {
+    const setContentLineIndent = lineIndentBefore(source, setContentMatch.index);
+    const bodyIndent = setContentLineIndent + "    ";
+    const snippet = buildKetoyScreenSnippet(bodyIndent, options);
+    source = source.slice(0, setContentOpen) + "\n" + snippet + "\n" + setContentLineIndent + source.slice(setContentClose);
+  }
+  const appAssignment = `val app = application as ${options.appClassSimpleName}`;
+  if (!source.includes(appAssignment)) {
+    const superMatch = /super\.onCreate\s*\([^)]*\)\s*\n/.exec(source);
+    if (superMatch) {
+      const insertAt = superMatch.index + superMatch[0].length;
+      const indent = lineIndentBefore(source, superMatch.index);
+      source = source.slice(0, insertAt) + `${indent}${appAssignment}
+` + source.slice(insertAt);
+    }
+  }
+  await writeFile6(path, source, "utf-8");
+  const imports = [
+    "androidx.compose.foundation.layout.Arrangement",
+    "androidx.compose.foundation.layout.Column",
+    "androidx.compose.foundation.layout.fillMaxSize",
+    "androidx.compose.material3.Text",
+    "androidx.compose.runtime.CompositionLocalProvider",
+    "androidx.compose.ui.Alignment",
+    "androidx.compose.ui.Modifier",
+    "dev.ketoy.runtime.bundle.KetoyBundleSource",
+    "dev.ketoy.runtime.compose.KetoyScreen",
+    "dev.ketoy.runtime.compose.LocalKetoyBundleLoader",
+    "dev.ketoy.runtime.compose.LocalKetoyRuntime",
+    `${options.packageOfApp}.${options.appClassSimpleName}`
+  ];
+  for (const imp of imports) {
+    await addImport(path, imp);
+  }
+  return { changed: true };
+}
+function ketoyScreenManualSnippet(options) {
+  return [
+    `// In MainActivity.onCreate:`,
+    `val app = application as ${options.appClassSimpleName}`,
+    ``,
+    `// Inside your existing setContent { <YourAppTheme> { \u2026 } } block, replace`,
+    `// the theme's body with:`,
+    buildKetoyScreenSnippet("", options)
+  ].join("\n");
+}
+function buildKetoyScreenSnippet(indent, options) {
+  return [
+    `${indent}CompositionLocalProvider(`,
+    `${indent}    LocalKetoyRuntime provides app.ketoyRuntime,`,
+    `${indent}    LocalKetoyBundleLoader provides app.ketoyBundleLoader,`,
+    `${indent}) {`,
+    `${indent}    KetoyScreen(`,
+    `${indent}        entryPoint = "${options.entryPoint}",`,
+    `${indent}        bundleSource = KetoyBundleSource.Asset("${options.bundleAsset}"),`,
+    `${indent}    ) {`,
+    `${indent}        // Native fallback \u2014 rendered when the .ktx bundle is absent,`,
+    `${indent}        // incompatible, or corrupt. Replace with your own native screen.`,
+    `${indent}        Column(`,
+    `${indent}            modifier = Modifier.fillMaxSize(),`,
+    `${indent}            verticalArrangement = Arrangement.Center,`,
+    `${indent}            horizontalAlignment = Alignment.CenterHorizontally,`,
+    `${indent}        ) {`,
+    `${indent}            Text("Hello Android")`,
+    `${indent}        }`,
+    `${indent}    }`,
+    `${indent}}`
+  ].join("\n");
+}
+function findMatchingBrace(source, afterOpen) {
+  let depth = 1;
+  for (let i = afterOpen; i < source.length; i++) {
+    const ch = source[i];
+    if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+function lineIndentBefore(source, pos) {
+  const lineStart = source.lastIndexOf("\n", Math.max(0, pos - 1)) + 1;
+  const lineUpTo = source.slice(lineStart, pos);
+  const m = /^[ \t]*/.exec(lineUpTo);
+  return m ? m[0] : "";
+}
+
+// src/safe-edit/version-catalog.ts
+import { readFile as readFile8, writeFile as writeFile7 } from "fs/promises";
+async function applyVersionPins(path, pins) {
+  let source = await readFile8(path, "utf-8");
+  let section = findVersionsSection(source);
+  if (!section) {
+    throw new Error(`No [versions] section in ${path}.`);
+  }
+  const results = [];
+  for (const pin of pins) {
+    const candidates = pin.aliases ?? [pin.key];
+    let found = null;
+    for (const k of candidates) {
+      const m = findKeyInRange(source, section, k);
+      if (m) {
+        found = m;
+        break;
+      }
+    }
+    if (found) {
+      if (found.value === pin.required) {
+        results.push({
+          key: found.key,
+          required: pin.required,
+          oldValue: found.value,
+          action: "unchanged",
+          label: pin.label
+        });
+        continue;
+      }
+      const newLine = `${found.indent}${found.key} = "${pin.required}"`;
+      source = source.slice(0, found.lineStart) + newLine + source.slice(found.lineEnd);
+      section = findVersionsSection(source) ?? section;
+      results.push({
+        key: found.key,
+        required: pin.required,
+        oldValue: found.value,
+        action: "pinned",
+        label: pin.label
+      });
+    } else {
+      const before = source.slice(0, section.end);
+      const after = source.slice(section.end);
+      const lead = before.endsWith("\n") ? "" : "\n";
+      const newLine = `${lead}${pin.key} = "${pin.required}"
+`;
+      source = before + newLine + after;
+      section = findVersionsSection(source) ?? section;
+      results.push({
+        key: pin.key,
+        required: pin.required,
+        oldValue: null,
+        action: "added",
+        label: pin.label
+      });
+    }
+  }
+  await writeFile7(path, source, "utf-8");
+  return results;
+}
+function findVersionsSection(source) {
+  return findSection(source, "versions");
+}
+function findSection(source, name) {
+  const header = new RegExp(`^\\[${escapeRegex(name)}\\]\\s*$`, "m").exec(source);
+  if (!header) return null;
+  const start = header.index + header[0].length;
+  const nextHeaderRe = /\n\[[^\]]+\]/g;
+  nextHeaderRe.lastIndex = start;
+  const next = nextHeaderRe.exec(source);
+  const end = next ? next.index : source.length;
+  return { start, end };
+}
+async function ensurePluginEntry(path, options) {
+  let source = await readFile8(path, "utf-8");
+  let section = findSection(source, "plugins");
+  if (!section) {
+    const trimmed = source.replace(/\s+$/, "");
+    const newBlock = `
+
+[plugins]
+${options.key} = { id = "${options.id}", version.ref = "${options.versionRef}" }
+`;
+    await writeFile7(path, trimmed + newBlock, "utf-8");
+    return { changed: true };
+  }
+  const region = source.slice(section.start, section.end);
+  const idRe = new RegExp(`\\bid\\s*=\\s*"${escapeRegex(options.id)}"`);
+  const keyRe = new RegExp(`(^|\\n)\\s*${escapeRegex(options.key)}\\s*=`);
+  if (idRe.test(region) || keyRe.test(region)) {
+    return { changed: false, reason: "Plugin already declared in [plugins]" };
+  }
+  const before = source.slice(0, section.end);
+  const after = source.slice(section.end);
+  const lead = before.endsWith("\n") ? "" : "\n";
+  const newLine = `${lead}${options.key} = { id = "${options.id}", version.ref = "${options.versionRef}" }
+`;
+  source = before + newLine + after;
+  await writeFile7(path, source, "utf-8");
+  return { changed: true };
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function findKeyInRange(source, section, key) {
+  const region = source.slice(section.start, section.end);
+  const re = new RegExp(
+    `(^|\\n)([ \\t]*)(${escapeRegex(key)})[ \\t]*=[ \\t]*"([^"]*)"`,
+    ""
+  );
+  const m = re.exec(region);
+  if (!m) return null;
+  const leadingNl = m[1] ?? "";
+  const indent = m[2] ?? "";
+  const matchedKey = m[3] ?? "";
+  const value = m[4] ?? "";
+  const lineStart = section.start + m.index + leadingNl.length;
+  const lineEnd = lineStart + indent.length + matchedKey.length + ' = "'.length + value.length + 1;
+  return { key: matchedKey, value, indent, lineStart, lineEnd };
+}
+
+// src/safe-edit/agp8-compat.ts
+import { readFile as readFile9, writeFile as writeFile8 } from "fs/promises";
+async function migrateAgp8AndroidBlock(path) {
+  const original = await readFile9(path, "utf-8");
+  const { source, mutations } = transformSource(original);
+  if (mutations.length === 0) {
+    return { mutations: [], changed: false };
+  }
+  await writeFile8(path, source, "utf-8");
+  return { mutations, changed: true };
+}
+function transformSource(input3) {
+  let source = input3;
+  const mutations = [];
+  for (const property of ["compileSdk", "targetSdk"]) {
+    const result = transformOne(source, property);
+    if (result) {
+      source = result.source;
+      mutations.push(result.mutation);
+    }
+  }
+  return { source, mutations };
+}
+function transformOne(source, property) {
+  const blockHeader = new RegExp(`(^|\\n)([ \\t]*)${escape(property)}\\s*\\{`, "g");
+  const match = blockHeader.exec(source);
+  if (!match) return null;
+  const headerStart = match.index + (match[1] ?? "").length;
+  const indent = match[2] ?? "";
+  const openBraceIdx = match.index + match[0].length - 1;
+  const closeBraceIdx = findMatchingBrace2(source, openBraceIdx + 1);
+  if (closeBraceIdx === -1) return null;
+  const body = source.slice(openBraceIdx + 1, closeBraceIdx);
+  const releaseMatch = /\brelease\s*\(\s*(\d+)\s*\)/.exec(body);
+  if (!releaseMatch) {
+    return null;
+  }
+  const apiLevel = Number(releaseMatch[1]);
+  const droppedMinor = /\bminorApiLevel\s*=\s*\d+/.test(body);
+  const replacement = `${indent}${property} = ${apiLevel}`;
+  const updated = source.slice(0, headerStart) + replacement + source.slice(closeBraceIdx + 1);
+  return {
+    source: updated,
+    mutation: { property, apiLevel, droppedMinor }
+  };
+}
+function findMatchingBrace2(source, after) {
+  let depth = 1;
+  for (let i = after; i < source.length; i++) {
+    const ch = source[i];
+    if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+function escape(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/safe-edit/gradle-properties.ts
+import { readFile as readFile10, writeFile as writeFile9, access as access5 } from "fs/promises";
+async function fileExists5(p) {
+  try {
+    await access5(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureGradleProperty(path, key, value) {
+  const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const exists = await fileExists5(path);
+  const source = exists ? await readFile10(path, "utf-8") : "";
+  const lineRe = new RegExp(`^(${escaped})\\s*=\\s*(.*)$`, "m");
+  const match = lineRe.exec(source);
+  if (match) {
+    const currentValue = (match[2] ?? "").trim();
+    if (currentValue === value) {
+      return { changed: false, previousValue: currentValue, conflict: false };
+    }
+    return { changed: false, previousValue: currentValue, conflict: true };
+  }
+  const prefix = source.length === 0 || source.endsWith("\n") ? "" : "\n";
+  const block = `${prefix}
+# Ketoy alpha \u2014 required for AGP 8.7 compatibility
+${key}=${value}
+`;
+  await writeFile9(path, source + block, "utf-8");
+  return { changed: true, previousValue: null, conflict: false };
+}
+
+// src/templates.ts
+import { readFile as readFile11 } from "fs/promises";
+import { dirname as dirname2, join as join4, resolve } from "path";
+import { fileURLToPath } from "url";
+var cachedRoot = null;
+async function getTemplatesRoot() {
+  if (cachedRoot) return cachedRoot;
+  const here = dirname2(fileURLToPath(import.meta.url));
+  const candidates = [
+    resolve(here, "..", "templates"),
+    resolve(here, "..", "..", "templates")
+  ];
+  for (const c of candidates) {
+    try {
+      await readFile11(join4(c, "MyApplication.kt.tmpl"), "utf-8");
+      cachedRoot = c;
+      return c;
+    } catch {
+    }
+  }
+  throw new Error("Could not locate templates directory.");
+}
+async function loadTemplate(name, vars) {
+  const root = await getTemplatesRoot();
+  const raw = await readFile11(join4(root, name), "utf-8");
+  return Object.entries(vars).reduce(
+    (acc, [k, v]) => acc.replaceAll(`{{${k}}}`, v),
+    raw
+  );
+}
+
+// src/commands/init/edit.ts
+async function applyPlan(projectRoot, plan) {
+  const result = { appliedCount: 0, skipped: [], errors: [] };
+  let step = 0;
+  const total = plan.actions.length;
+  for (const action of plan.actions) {
+    step++;
+    log.step(step, total, action.description);
+    try {
+      const ok = await applyAction(projectRoot, action);
+      if (ok) result.appliedCount++;
+      else result.skipped.push(action.description);
+    } catch (e) {
+      const msg = `${action.description}: ${e.message}`;
+      result.errors.push(msg);
+      log.error(msg);
+    }
+  }
+  return result;
+}
+async function applyAction(projectRoot, action) {
+  const target = join5(projectRoot, action.targetRel);
+  switch (action.kind) {
+    case "insert-plugin": {
+      const { pluginId, version } = action.payload;
+      const { changed } = await insertPlugin(target, pluginId, version ? { version } : {});
+      if (!changed) log.detail("Already applied; skipping.");
+      return changed;
+    }
+    case "append-deps": {
+      const { groupComment, entries } = action.payload;
+      const { changed, addedCount } = await appendDependencyGroup(target, groupComment, entries);
+      if (!changed) log.detail("All dependencies already declared; skipping.");
+      else log.detail(`Added ${addedCount} dependency entries.`);
+      return changed;
+    }
+    case "append-block": {
+      const { blockName, body } = action.payload;
+      const { changed } = await appendTopLevelBlock(target, blockName, body);
+      if (!changed) log.detail(`${blockName} { } block already present; skipping.`);
+      return changed;
+    }
+    case "set-manifest-name": {
+      const { value } = action.payload;
+      const { changed, previousValue } = await setApplicationName(target, value);
+      if (!changed) log.detail("Already set; skipping.");
+      else if (previousValue) log.detail(`Replaced previous value: ${previousValue}`);
+      return changed;
+    }
+    case "write-file": {
+      const { template, vars } = action.payload;
+      const content = await loadTemplate(template, vars);
+      await mkdir2(dirname3(target), { recursive: true });
+      await writeFile10(target, content, "utf-8");
+      return true;
+    }
+    case "wrap-main-activity": {
+      const { packageOfApp, appClassSimpleName, entryPoint, bundleAsset } = action.payload;
+      const result = await wrapMainActivityWithKetoyScreen(target, {
+        packageOfApp,
+        appClassSimpleName,
+        entryPoint,
+        bundleAsset
+      });
+      if (!result.changed) {
+        log.detail(result.reason ?? "No change needed.");
+        return false;
+      }
+      return true;
+    }
+    case "gitignore": {
+      const { entries } = action.payload;
+      const { added } = await ensureGitignoreEntries(target, entries);
+      if (added.length === 0) {
+        log.detail("All entries already present; skipping.");
+        return false;
+      }
+      log.detail(`Added: ${added.join(", ")}`);
+      return true;
+    }
+    case "ensure-toml-plugin": {
+      const { key, id, versionRef } = action.payload;
+      const { changed, reason } = await ensurePluginEntry(target, { key, id, versionRef });
+      if (!changed) {
+        log.detail(reason ?? "Already declared; skipping.");
+        return false;
+      }
+      log.detail(`Added: ${key} = { id = "${id}", version.ref = "${versionRef}" }`);
+      return true;
+    }
+    case "insert-plugin-alias": {
+      const { aliasPath, applyFalse } = action.payload;
+      const { changed } = await insertPluginAlias(target, aliasPath, { applyFalse });
+      if (!changed) {
+        log.detail("Already applied; skipping.");
+        return false;
+      }
+      log.detail(`Added: alias(${aliasPath})${applyFalse ? " apply false" : ""}`);
+      return true;
+    }
+    case "bump-java-compatibility": {
+      const { minLevel } = action.payload;
+      const { changed, rewrites } = await bumpJavaCompatibility(target, minLevel);
+      if (!changed) {
+        log.detail(`compileOptions already at JavaVersion.VERSION_${minLevel} or higher; skipping.`);
+        return false;
+      }
+      for (const r of rewrites) log.detail(r);
+      return true;
+    }
+    // REMOVABLE (alpha pinning) — see src/alpha-pins.ts header for the deletion checklist.
+    case "ensure-gradle-property": {
+      const { key, value } = action.payload;
+      const result = await ensureGradleProperty(target, key, value);
+      if (result.conflict) {
+        log.detail(
+          `${key} already set to "${result.previousValue}" \u2014 leaving alone (requested "${value}"). Verify this is intentional.`
+        );
+        return false;
+      }
+      if (!result.changed) {
+        log.detail(`${key}=${value} already set; skipping.`);
+        return false;
+      }
+      log.detail(`Added: ${key}=${value}`);
+      return true;
+    }
+    // REMOVABLE (alpha pinning) — see src/alpha-pins.ts header for the deletion checklist.
+    case "agp8-compat": {
+      const { mutations, changed } = await migrateAgp8AndroidBlock(target);
+      if (!changed) {
+        log.detail("Already in AGP-8.x property form; skipping.");
+        return false;
+      }
+      for (const m of mutations) {
+        const minor = m.droppedMinor ? pc.dim(" (dropped minorApiLevel \u2014 AGP 8.x has no equivalent)") : "";
+        log.detail(`${m.property}: block-style \u2192 ${m.property} = ${m.apiLevel}${minor}`);
+      }
+      return true;
+    }
+    // REMOVABLE (alpha pinning) — see src/alpha-pins.ts header for the deletion checklist.
+    case "pin-alpha-versions": {
+      const { pins } = action.payload;
+      const results = await applyVersionPins(target, pins);
+      let changed = false;
+      for (const r of results) {
+        const label = r.label ?? r.key;
+        if (r.action === "unchanged") {
+          log.detail(`${label}: already at ${r.required}.`);
+        } else if (r.action === "pinned") {
+          changed = true;
+          log.detail(`${label}: ${pc.yellow(r.oldValue ?? "?")} \u2192 ${pc.green(r.required)}`);
+        } else {
+          changed = true;
+          log.detail(`${label}: added ${r.key} = ${pc.green(r.required)}`);
+        }
+      }
+      return changed;
+    }
+    default: {
+      const exhaustive = action.kind;
+      throw new Error(`Unhandled action kind: ${String(exhaustive)}`);
+    }
+  }
+}
+
+// src/config/project-state.ts
+import { mkdir as mkdir3, readFile as readFile12, writeFile as writeFile11, access as access6 } from "fs/promises";
+import { dirname as dirname4, join as join6 } from "path";
+async function saveProjectState(projectRoot, state) {
+  const path = join6(projectRoot, PROJECT_STATE_FILE);
+  await mkdir3(dirname4(path), { recursive: true });
+  await writeFile11(path, JSON.stringify(state, null, 2) + "\n", "utf-8");
+}
+
+// src/commands/init/index.ts
+async function runInitCommand(projectRoot, options) {
+  log.info(`Detecting project structure at ${pc.dim(projectRoot)}\u2026`);
+  const detection = await detectProject(projectRoot);
+  log.detail(
+    `namespace=${detection.namespace}, applicationId=${detection.applicationId}, minSdk=${detection.minSdk}`
+  );
+  log.detail(`hilt detected in project=${detection.hasHilt}, srcRoot=${detection.packageSrcRoot}`);
+  let useHilt;
+  if (options.hilt !== null) {
+    useHilt = options.hilt;
+  } else if (detection.hasHilt) {
+    log.warn(
+      "Hilt usage detected in the existing project. Ketoy init produces a non-Hilt bootstrap by default."
+    );
+    useHilt = await confirm({
+      message: "Generate a Hilt-aware Ketoy setup instead?",
+      default: false
+    }).catch(() => false);
+  } else {
+    useHilt = false;
+  }
+  if (useHilt) {
+    log.warn("Hilt setup requires app-specific decisions and is not scaffolded by `ketoy init`.");
+    log.info(
+      `Run ${pc.bold("ketoy chat")} and ask:
+  ${pc.dim('"Set up Ketoy with Hilt in this project \u2014 wire KetoyCapabilityProvider and the')}
+  ${pc.dim('  config customizer into my existing @Module / @InstallIn(SingletonComponent::class)."')}
+
+The agent has full access to your build files and existing Hilt modules, and will apply
+surgical, additive edits \u2014 the same safety guarantees as \`ketoy init\` itself. Aborting init.`
+    );
+    throw new UserAbortError("Hilt setup deferred to `ketoy chat`.");
+  }
+  let installScreen;
+  if (options.installKetoyScreen !== null) {
+    installScreen = options.installKetoyScreen;
+  } else if (options.yes) {
+    log.warn(
+      "--yes without --install-screen / --no-install-screen \u2014 defaulting to NOT installing KetoyScreen in MainActivity. Use ketoy chat or the docs to integrate manually."
+    );
+    installScreen = false;
+  } else {
+    log.info("");
+    log.info(pc.bold("Install KetoyScreen in MainActivity?"));
+    log.detail(pc.green("Recommended") + " if this is a fresh Android Studio project (the default");
+    log.detail("Greeting() UI is replaced with KetoyScreen + a simple Hello Android fallback).");
+    log.detail(pc.yellow("Decline") + " if MainActivity has custom UI you want to keep \u2014 instead use");
+    log.detail("the docs (https://ketoy.dev/docs) or `ketoy chat` to integrate KetoyScreen by hand.");
+    installScreen = await confirm({
+      message: "Replace setContent body with KetoyScreen?",
+      default: true
+    }).catch(() => false);
+  }
+  const plan = await planInit(detection, { installKetoyScreen: installScreen });
+  log.info(`Plan \u2014 non-Hilt setup, ${plan.actions.length} action(s):`);
+  for (const a of plan.actions) {
+    const tag = a.highRisk ? pc.yellow("  \u26A0") : pc.cyan("  \u2022");
+    log.raw(`${tag} ${a.description}
+`);
+  }
+  if (plan.warnings.length > 0) {
+    log.raw("\n");
+    for (const w of plan.warnings) log.warn(w);
+  }
+  if (detection.minSdk < 26) {
+    throw new DetectionError(
+      `Ketoy requires minSdk >= 26. Current: ${detection.minSdk}. Update app/build.gradle.kts and re-run.`
+    );
+  }
+  if (options.dryRun) {
+    log.info("Dry run \u2014 no files were modified.");
+    return;
+  }
+  log.raw("\n");
+  if (!options.yes) {
+    const ok = await confirm({
+      message: `Apply ${plan.actions.length} action(s) to ${detection.appModuleRelative}/?`,
+      default: true
+    }).catch(() => false);
+    if (!ok) throw new UserAbortError();
+  }
+  log.raw("\n");
+  const result = await applyPlan(projectRoot, plan);
+  log.raw("\n");
+  if (result.errors.length > 0) {
+    log.error(`Init completed with ${result.errors.length} error(s).`);
+  } else {
+    log.success(`Init complete \u2014 ${result.appliedCount} action(s) applied.`);
+  }
+  await saveProjectState(projectRoot, {
+    ketoyVersion: await getKetoyVersion(),
+    initRanOn: (/* @__PURE__ */ new Date()).toISOString(),
+    hilt: false,
+    applicationId: detection.applicationId,
+    namespace: detection.namespace,
+    packagePath: detection.packagePath,
+    bundlePath: "app/src/main/assets/ketoy/main.ktx"
+  });
+  log.info("Next steps:");
+  log.detail("1. Sync Gradle (Android Studio: File \u2192 Sync Project)");
+  log.detail("2. ./gradlew :app:assembleDebug   # produces the .ktx bundle and the APK");
+  if (installScreen) {
+    log.detail("3. Install and run \u2014 the KBC HelloKetoyScreen renders inside MainActivity");
+    log.detail("4. ketoy chat                     # ask the agent to add screens, capabilities, etc.");
+  } else {
+    log.detail("3. Integrate KetoyScreen into MainActivity yourself \u2014 snippet below");
+    log.detail("4. ketoy chat                     # ask the agent to wire it up if needed");
+    log.info("");
+    log.info(pc.bold("Manual integration \u2014 paste inside your MainActivity setContent { YourAppTheme { \u2026 } }:"));
+    log.raw("\n");
+    log.raw(
+      ketoyScreenManualSnippet({
+        packageOfApp: detection.applicationId,
+        appClassSimpleName: "MyApplication",
+        entryPoint: "HelloKetoyScreen",
+        bundleAsset: "ketoy/main.ktx"
+      })
+    );
+    log.raw("\n\n");
+  }
+  if (result.errors.length > 0) {
+    throw new KetoyCliError("init completed with errors \u2014 see above.");
+  }
+}
+
+// src/commands/chat.ts
+import { input as input2, confirm as confirm5 } from "@inquirer/prompts";
+
+// src/agent/loop.ts
+import { streamText } from "ai";
+
+// src/agent/model.ts
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createMistral } from "@ai-sdk/mistral";
+import { createGroq } from "@ai-sdk/groq";
+import { createXai } from "@ai-sdk/xai";
+import { createOpenRouter } from "@openrouter/ai-sdk-provider";
+import { createOllama } from "ollama-ai-provider";
+async function resolveModel(modelIdOverride) {
+  const config = await loadConfig();
+  const modelId = modelIdOverride ?? config.model;
+  const { provider, name } = parseModelId(modelId);
+  const info = PROVIDERS[provider];
+  const apiKey = config.apiKeys[provider];
+  if (provider !== "ollama" && !apiKey) {
+    throw new ConfigError(
+      `No API key configured for ${info.displayName}. Run: ketoy auth ${provider}`
+    );
+  }
+  switch (provider) {
+    case "anthropic":
+      return { model: createAnthropic({ apiKey })(name), providerId: provider, modelName: name };
+    case "openai":
+      return { model: createOpenAI({ apiKey })(name), providerId: provider, modelName: name };
+    case "google":
+      return {
+        model: createGoogleGenerativeAI({ apiKey })(name),
+        providerId: provider,
+        modelName: name
+      };
+    case "mistral":
+      return { model: createMistral({ apiKey })(name), providerId: provider, modelName: name };
+    case "groq":
+      return { model: createGroq({ apiKey })(name), providerId: provider, modelName: name };
+    case "xai":
+      return { model: createXai({ apiKey })(name), providerId: provider, modelName: name };
+    case "openrouter":
+      return {
+        model: createOpenRouter({ apiKey }).chat(name),
+        providerId: provider,
+        modelName: name
+      };
+    case "ollama":
+      return {
+        model: createOllama({ baseURL: `${config.ollama.baseUrl}/api` })(name),
+        providerId: provider,
+        modelName: name
+      };
+    default: {
+      const exhaustive = provider;
+      throw new Error(`Unhandled provider: ${String(exhaustive)}`);
+    }
+  }
+}
+
+// src/skill/loader.ts
+import { readFile as readFile13, readdir, stat } from "fs/promises";
+import { join as join7, dirname as dirname5, resolve as resolve2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var cachedRoot2 = null;
+async function dirExists(path) {
+  try {
+    const s = await stat(path);
+    return s.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function getSkillRoot() {
+  if (cachedRoot2) return cachedRoot2;
+  const envOverride = process.env["KETOY_SKILL_DIR"];
+  if (envOverride && await dirExists(envOverride)) {
+    cachedRoot2 = resolve2(envOverride);
+    return cachedRoot2;
+  }
+  const here = dirname5(fileURLToPath2(import.meta.url));
+  const candidates = [
+    resolve2(here, "..", "skills", "ketoy"),
+    resolve2(here, "..", "..", "skills", "ketoy"),
+    resolve2(here, "..", "..", "..", "skills", "ketoy")
+  ];
+  for (const c of candidates) {
+    if (await dirExists(c)) {
+      cachedRoot2 = c;
+      return cachedRoot2;
+    }
+  }
+  throw new Error(
+    `Could not locate the Ketoy skill directory. Set KETOY_SKILL_DIR to override. Tried: ${candidates.join(", ")}`
+  );
+}
+async function readSkillFile(relName) {
+  const root = await getSkillRoot();
+  const normalized = relName.replace(/\\/g, "/").replace(/^\/+/, "");
+  if (normalized.includes("..")) return null;
+  const path = join7(root, normalized);
+  try {
+    return await readFile13(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function listSkillFiles() {
+  const root = await getSkillRoot();
+  const out = [];
+  async function walk(dir, prefix) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const e of entries) {
+      const full = join7(dir, e.name);
+      const rel = prefix ? `${prefix}/${e.name}` : e.name;
+      if (e.isDirectory()) {
+        await walk(full, rel);
+      } else if (e.isFile()) {
+        out.push(rel);
+      }
+    }
+  }
+  await walk(root, "");
+  return out.sort();
+}
+async function buildSkillContext(taskHint) {
+  const main = await readSkillFile("SKILL.md");
+  if (main === null) throw new Error("SKILL.md missing from skill root.");
+  const lower = taskHint.toLowerCase();
+  const toLoad = /* @__PURE__ */ new Set(["SKILL.md"]);
+  const add = (name) => toLoad.add(name);
+  if (/\b(init|scaffold|set up|setup|add ketoy|integrate)\b/.test(lower)) {
+    add("guides/init-project.md");
+    add("guides/safe-edits.md");
+  }
+  if (/\b(migrate|migration|convert|port)\b/.test(lower)) {
+    add("guides/migrate.md");
+  }
+  if (/\b(error|fail|broken|crash|diagnose|fix|why)\b/.test(lower)) {
+    add("guides/diagnose-errors.md");
+  }
+  if (/\b(supported|can i use|is there|available|catalog)\b/.test(lower)) {
+    add("reference/supported-composables.md");
+    add("reference/forbidden-apis.md");
+  }
+  if (/\b(capability|stub|host registry|capabilityregistry|capability id)\b/.test(lower)) {
+    add("reference/capabilities.md");
+  }
+  if (/\b(modifier|padding|fillmax)\b/.test(lower)) {
+    add("reference/supported-modifiers.md");
+  }
+  if (/\b(bundle|\.ktx|analyze|inspect|build)\b/.test(lower)) {
+    add("guides/build-and-analyze.md");
+  }
+  if (toLoad.size === 1) {
+    add("reference/architecture-cheatsheet.md");
+  }
+  const parts = [main];
+  const loaded = ["SKILL.md"];
+  for (const name of toLoad) {
+    if (name === "SKILL.md") continue;
+    const content = await readSkillFile(name);
+    if (content !== null) {
+      parts.push(`
+
+--- BEGIN ${name} ---
+
+${content}
+
+--- END ${name} ---
+`);
+      loaded.push(name);
+    }
+  }
+  return { systemPrompt: parts.join(""), loadedFiles: loaded };
+}
+
+// src/agent/prompts.ts
+async function buildSystemPrompt(opts) {
+  const [{ systemPrompt: skill, loadedFiles }, ketoyVersion] = await Promise.all([
+    buildSkillContext(opts.taskHint),
+    getKetoyVersion()
+  ]);
+  const header = `You are the Ketoy CLI agent, version ${CLI_VERSION}, targeting Ketoy ${ketoyVersion}.
+You are running on model "${opts.modelName}".
+Working directory: ${opts.projectRoot}
+Today: ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}
+
+Operating principles:
+- Be specific. Quote real symbol names from the user's tree. Don't paraphrase.
+- Use tools to inspect the user's actual code before answering. Never assume.
+- For multi-step work, state the plan, then execute step by step with intermediate verification.
+- NEVER rewrite existing files in full. Edits to build.gradle.kts, AndroidManifest.xml,
+  MainActivity.kt, Application classes, and settings.gradle.kts MUST be surgical \u2014 single-line
+  additions or single-block appends at well-identified anchors. The user has invested work
+  in those files; treat them as sacred.
+- For high-risk file edits, the edit_file tool will show a diff and ask the user. Do not
+  try to bypass this.
+- Refuse whole-project migrations. Migration is per-file, one-shot. Always audit first.
+- Publishing is deferred until the Ketoy backend ships. Don't write publish code.
+
+Tools available:
+- read_file, write_file, edit_file, grep, glob, bash, analyze_ktx, skill_file
+
+The skill below is your operational manual. Treat reference/ as ground truth.
+=== SKILL CONTENT ===
+
+`;
+  return { prompt: header + skill, loadedFiles };
+}
+
+// src/agent/tools/read-file.ts
+import { readFile as readFile14, stat as stat2 } from "fs/promises";
+import { z as z2 } from "zod";
+import { tool } from "ai";
+
+// src/agent/tools/paths.ts
+import { isAbsolute, relative as relative2, resolve as resolve3, sep } from "path";
+function safeJoin(projectRoot, path) {
+  const rootAbs = resolve3(projectRoot);
+  const abs = resolve3(rootAbs, path);
+  if (abs !== rootAbs && !abs.startsWith(rootAbs + sep)) return null;
+  const rel = relative2(rootAbs, abs);
+  if (rel.startsWith("..") || isAbsolute(rel)) return null;
+  return { abs, rel };
+}
+
+// src/agent/tools/read-file.ts
+var MAX_BYTES = 256 * 1024;
+function makeReadFileTool(projectRoot) {
+  return tool({
+    description: "Read a file from the working project. Returns up to 256 KB of UTF-8 text. Use this before editing any file.",
+    parameters: z2.object({
+      path: z2.string().describe("Path relative to project root, or absolute under it.")
+    }),
+    execute: async ({ path }) => {
+      const joined = safeJoin(projectRoot, path);
+      if (!joined) return { error: `Refusing to read outside project root: ${path}` };
+      const { abs, rel } = joined;
+      const st = await stat2(abs).catch(() => null);
+      if (!st) return { error: `File not found: ${rel}` };
+      if (st.isDirectory()) return { error: `Path is a directory: ${rel}` };
+      if (st.size > MAX_BYTES) {
+        return { error: `File too large (${st.size} bytes, limit ${MAX_BYTES}): ${rel}` };
+      }
+      const content = await readFile14(abs, "utf-8");
+      return { path: rel, bytes: st.size, content };
+    }
+  });
+}
+
+// src/agent/tools/write-file.ts
+import { mkdir as mkdir4, writeFile as writeFile12, access as access7 } from "fs/promises";
+import { dirname as dirname6 } from "path";
+import { z as z3 } from "zod";
+import { tool as tool2 } from "ai";
+import { confirm as confirm2 } from "@inquirer/prompts";
+async function fileExists6(path) {
+  try {
+    await access7(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function makeWriteFileTool(projectRoot, opts) {
+  return tool2({
+    description: "Create a NEW file at the given path. Fails if the file already exists \u2014 use edit_file instead. Always prefer surgical edits over creating new files when the user has existing code.",
+    parameters: z3.object({
+      path: z3.string().describe("Path relative to project root."),
+      content: z3.string().describe("Full UTF-8 file content.")
+    }),
+    execute: async ({ path, content }) => {
+      const joined = safeJoin(projectRoot, path);
+      if (!joined) return { error: `Refusing to write outside project root: ${path}` };
+      const { abs, rel } = joined;
+      if (await fileExists6(abs)) {
+        return { error: `File already exists: ${rel}. Use edit_file to modify it.` };
+      }
+      log.info(`Agent wants to create ${pc.bold(rel)} (${content.length} bytes)`);
+      if (!opts.autoApprove) {
+        const ok = await confirm2({ message: `Create ${rel}?`, default: true });
+        if (!ok) return { error: "User declined." };
+      }
+      await mkdir4(dirname6(abs), { recursive: true });
+      await writeFile12(abs, content, "utf-8");
+      log.success(`Created ${rel}`);
+      return { path: rel, bytes: content.length, created: true };
+    }
+  });
+}
+
+// src/agent/tools/edit-file.ts
+import { readFile as readFile15, writeFile as writeFile13 } from "fs/promises";
+import { z as z4 } from "zod";
+import { tool as tool3 } from "ai";
+import { confirm as confirm3 } from "@inquirer/prompts";
+
+// src/safe-edit/diff.ts
+function renderUnifiedDiff(oldText, newText, label = "file") {
+  if (oldText === newText) return pc.dim("(no changes)");
+  const oldLines = oldText.split("\n");
+  const newLines = newText.split("\n");
+  const out = [pc.bold(`--- ${label}`), pc.bold(`+++ ${label}`)];
+  let i = 0;
+  let j = 0;
+  while (i < oldLines.length || j < newLines.length) {
+    if (i < oldLines.length && j < newLines.length && oldLines[i] === newLines[j]) {
+      out.push(pc.dim(`  ${oldLines[i]}`));
+      i++;
+      j++;
+      continue;
+    }
+    let aheadOld = i;
+    let aheadNew = j;
+    while (aheadOld < oldLines.length && aheadNew < newLines.length && oldLines[aheadOld] !== newLines[aheadNew]) {
+      aheadOld++;
+      aheadNew++;
+    }
+    for (let k = i; k < aheadOld; k++) out.push(pc.red(`- ${oldLines[k]}`));
+    for (let k = j; k < aheadNew; k++) out.push(pc.green(`+ ${newLines[k]}`));
+    i = aheadOld;
+    j = aheadNew;
+    if (i === oldLines.length && j < newLines.length) {
+      for (let k = j; k < newLines.length; k++) out.push(pc.green(`+ ${newLines[k]}`));
+      break;
+    }
+    if (j === newLines.length && i < oldLines.length) {
+      for (let k = i; k < oldLines.length; k++) out.push(pc.red(`- ${oldLines[k]}`));
+      break;
+    }
+  }
+  return out.join("\n");
+}
+var HIGH_RISK_PATTERNS = [
+  /(^|\/)build\.gradle\.kts$/,
+  /(^|\/)settings\.gradle\.kts$/,
+  /(^|\/)AndroidManifest\.xml$/,
+  /(^|\/)MainActivity\.kt$/,
+  /(^|\/)App\.kt$/,
+  /(^|\/)Application\.kt$/,
+  /\/keys\/.*-private\.key$/
+];
+function isHighRisk(relPath) {
+  return HIGH_RISK_PATTERNS.some((p) => p.test(relPath));
+}
+
+// src/agent/tools/edit-file.ts
+function makeEditFileTool(projectRoot, opts) {
+  return tool3({
+    description: "Surgically edit an existing file by replacing exact text. old_string must appear EXACTLY ONCE in the file. For high-risk files (build.gradle.kts, AndroidManifest.xml, MainActivity.kt, Application classes) the user is shown a diff and must confirm. Never use this to rewrite entire files \u2014 make minimal, additive edits.",
+    parameters: z4.object({
+      path: z4.string().describe("Path relative to project root."),
+      old_string: z4.string().describe("Exact text to replace. Must occur once."),
+      new_string: z4.string().describe("Replacement text.")
+    }),
+    execute: async ({ path, old_string, new_string }) => {
+      const joined = safeJoin(projectRoot, path);
+      if (!joined) return { error: `Refusing to edit outside project root: ${path}` };
+      const { abs, rel } = joined;
+      const original = await readFile15(abs, "utf-8").catch(() => null);
+      if (original === null) return { error: `File not found: ${rel}` };
+      const occurrences = original.split(old_string).length - 1;
+      if (occurrences === 0) {
+        return { error: `old_string not found in ${rel}. Read the file again and use exact text.` };
+      }
+      if (occurrences > 1) {
+        return {
+          error: `old_string occurs ${occurrences} times in ${rel}. Add surrounding context to make it unique.`
+        };
+      }
+      if (old_string === new_string) {
+        return { error: "old_string and new_string are identical \u2014 no edit to perform." };
+      }
+      const updated = original.replace(old_string, new_string);
+      const risky = isHighRisk(rel);
+      if (risky || !opts.autoApprove) {
+        log.info(`Agent wants to edit ${pc.bold(rel)}${risky ? pc.yellow(" (high-risk file)") : ""}`);
+        log.raw(renderUnifiedDiff(original, updated, rel) + "\n");
+        const ok = await confirm3({ message: `Apply edit to ${rel}?`, default: !risky });
+        if (!ok) return { error: "User declined the edit." };
+      }
+      await writeFile13(abs, updated, "utf-8");
+      log.success(`Edited ${rel}`);
+      return { path: rel, edited: true };
+    }
+  });
+}
+
+// src/agent/tools/grep.ts
+import { z as z5 } from "zod";
+import { tool as tool4 } from "ai";
+import { glob as glob2 } from "tinyglobby";
+import { readFile as readFile16 } from "fs/promises";
+import { relative as relative3 } from "path";
+var MAX_MATCHES = 200;
+var MAX_FILE_SIZE = 1024 * 1024;
+function makeGrepTool(projectRoot) {
+  return tool4({
+    description: "Search file contents using a JavaScript regular expression. Returns up to 200 matches with file path + line number + matching line text. Useful for finding usages, imports, FQ names.",
+    parameters: z5.object({
+      pattern: z5.string().describe("JavaScript-compatible regex pattern."),
+      glob_pattern: z5.string().default("**/*.{kt,kts,xml,json,gradle,properties}").describe("Glob to filter files. Default: Android/Kotlin source files."),
+      case_sensitive: z5.boolean().default(true)
+    }),
+    execute: async ({ pattern, glob_pattern, case_sensitive }) => {
+      let regex;
+      try {
+        regex = new RegExp(pattern, case_sensitive ? "g" : "gi");
+      } catch (e) {
+        return { error: `Invalid regex: ${e.message}` };
+      }
+      const files = await glob2(glob_pattern, {
+        cwd: projectRoot,
+        absolute: true,
+        ignore: ["**/node_modules/**", "**/build/**", "**/.gradle/**", "**/dist/**", "**/.git/**"],
+        onlyFiles: true
+      });
+      const matches = [];
+      for (const abs of files) {
+        if (matches.length >= MAX_MATCHES) break;
+        const content = await readFile16(abs, "utf-8").catch(() => null);
+        if (content === null || content.length > MAX_FILE_SIZE) continue;
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          if (line === void 0) continue;
+          regex.lastIndex = 0;
+          if (regex.test(line)) {
+            matches.push({ file: relative3(projectRoot, abs), line: i + 1, text: line.trim().slice(0, 300) });
+            if (matches.length >= MAX_MATCHES) break;
+          }
+        }
+      }
+      return { matchCount: matches.length, matches, truncated: matches.length >= MAX_MATCHES };
+    }
+  });
+}
+
+// src/agent/tools/glob.ts
+import { z as z6 } from "zod";
+import { tool as tool5 } from "ai";
+import { glob as glob3 } from "tinyglobby";
+import { relative as relative4 } from "path";
+var MAX_RESULTS = 500;
+function makeGlobTool(projectRoot) {
+  return tool5({
+    description: "List files matching a glob pattern. Returns up to 500 paths. Use for locating files by name.",
+    parameters: z6.object({
+      pattern: z6.string().describe('Glob pattern (e.g. "**/*.kt", "app/src/main/**/MainActivity.kt").')
+    }),
+    execute: async ({ pattern }) => {
+      const results = await glob3(pattern, {
+        cwd: projectRoot,
+        absolute: true,
+        ignore: ["**/node_modules/**", "**/build/**", "**/.gradle/**", "**/dist/**", "**/.git/**"],
+        onlyFiles: true
+      });
+      const paths = results.slice(0, MAX_RESULTS).map((p) => relative4(projectRoot, p));
+      return { count: paths.length, paths, truncated: results.length > MAX_RESULTS };
+    }
+  });
+}
+
+// src/agent/tools/bash.ts
+import { z as z7 } from "zod";
+import { tool as tool6 } from "ai";
+import { execa } from "execa";
+import { confirm as confirm4 } from "@inquirer/prompts";
+var SAFE_BIN_ALLOWLIST = /* @__PURE__ */ new Set([
+  "./gradlew",
+  "./gradlew.bat",
+  "git",
+  "ls",
+  "cat",
+  "pwd",
+  "find",
+  "echo",
+  "wc",
+  "head",
+  "tail",
+  "grep",
+  "rg",
+  "xxd",
+  "file",
+  "tree"
+]);
+var HARD_DENY = [/rm\s+-rf\s+\//, /:\(\)\s*\{\s*:\s*\|\s*:/, /mkfs/i, /dd\s+if=/i, />\s*\/dev\/sda/];
+var COMPOUND_METACHARS = /[;&|`$()<>]|\$\(/;
+function firstToken(command) {
+  const trimmed = command.trim();
+  return trimmed.split(/\s+/)[0] ?? "";
+}
+function isSafe(command) {
+  for (const pattern of HARD_DENY) if (pattern.test(command)) return false;
+  if (COMPOUND_METACHARS.test(command)) return false;
+  const tok = firstToken(command);
+  return SAFE_BIN_ALLOWLIST.has(tok);
+}
+var MAX_OUTPUT = 32 * 1024;
+function makeBashTool(projectRoot, opts) {
+  return tool6({
+    description: "Run a shell command from the project root. Read-only and gradle commands run without prompting; any other command requires user approval. Output is truncated at 32 KB.",
+    parameters: z7.object({
+      command: z7.string().describe("Shell command to execute."),
+      timeout_ms: z7.number().int().min(1e3).max(9e5).default(12e4)
+    }),
+    execute: async ({ command, timeout_ms }) => {
+      for (const pattern of HARD_DENY) {
+        if (pattern.test(command)) return { error: `Refusing destructive command: ${command}` };
+      }
+      const safe = isSafe(command);
+      if (!safe || !opts.autoApproveSafe) {
+        log.info(`Agent wants to run: ${pc.bold(command)}`);
+        const ok = await confirm4({ message: "Run this command?", default: safe });
+        if (!ok) return { error: "User declined the command." };
+      }
+      try {
+        const result = await execa(command, {
+          cwd: projectRoot,
+          shell: true,
+          timeout: timeout_ms,
+          reject: false,
+          all: true
+        });
+        const all = (result.all ?? `${result.stdout}
+${result.stderr}`).slice(0, MAX_OUTPUT);
+        return {
+          command,
+          exitCode: result.exitCode ?? null,
+          output: all,
+          truncated: (result.all?.length ?? 0) > MAX_OUTPUT,
+          timedOut: result.timedOut
+        };
+      } catch (e) {
+        return { error: `Execution failed: ${e.message}` };
+      }
+    }
+  });
+}
+
+// src/agent/tools/analyze-ktx.ts
+import { z as z8 } from "zod";
+import { tool as tool7 } from "ai";
+
+// src/ktx/reader.ts
+import { readFile as readFile17 } from "fs/promises";
+import { brotliDecompressSync } from "zlib";
+var KTX_MAGIC = Buffer.from([75, 84, 79, 89]);
+var SIGNATURE_SIZE = 64;
+var HEADER_SIZE = 14;
+var SECTION_STRING_POOL = 1;
+var SECTION_MODIFIER_TABLE = 2;
+var SECTION_ADAPTER_MANIFEST = 3;
+var SECTION_CONSTRUCTOR_MANIFEST = 4;
+var SECTION_CAPABILITY_MANIFEST = 5;
+var SECTION_FUNCTION_TABLE = 6;
+var SECTION_CODE = 7;
+var SECTION_DEBUG_INFO = 8;
+var SECTION_ENTRY_POINTS = 9;
+var SECTION_BUNDLE_METADATA = 10;
+var FLAG_DEBUG_INFO_PRESENT = 1;
+var FLAG_UNSIGNED = 2;
+function sectionName(type) {
+  switch (type) {
+    case SECTION_STRING_POOL:
+      return "STRING_POOL";
+    case SECTION_ADAPTER_MANIFEST:
+      return "ADAPTER_MANIFEST";
+    case SECTION_CONSTRUCTOR_MANIFEST:
+      return "CONSTRUCTOR_MANIFEST";
+    case SECTION_CAPABILITY_MANIFEST:
+      return "CAPABILITY_MANIFEST";
+    case SECTION_FUNCTION_TABLE:
+      return "FUNCTION_TABLE";
+    case SECTION_CODE:
+      return "CODE";
+    case SECTION_MODIFIER_TABLE:
+      return "MODIFIER_TABLE";
+    case SECTION_DEBUG_INFO:
+      return "DEBUG_INFO";
+    case SECTION_ENTRY_POINTS:
+      return "ENTRY_POINTS";
+    case SECTION_BUNDLE_METADATA:
+      return "BUNDLE_METADATA";
+    default:
+      return `UNKNOWN(0x${type.toString(16).padStart(2, "0").toUpperCase()})`;
+  }
+}
+var Reader = class {
+  constructor(buf) {
+    this.buf = buf;
+  }
+  buf;
+  offset = 0;
+  pos() {
+    return this.offset;
+  }
+  remaining() {
+    return this.buf.length - this.offset;
+  }
+  u8() {
+    if (this.remaining() < 1) throw new Error("Unexpected EOF (u8)");
+    const v = this.buf.readUInt8(this.offset);
+    this.offset += 1;
+    return v;
+  }
+  u16() {
+    if (this.remaining() < 2) throw new Error("Unexpected EOF (u16)");
+    const v = this.buf.readUInt16BE(this.offset);
+    this.offset += 2;
+    return v;
+  }
+  i32() {
+    if (this.remaining() < 4) throw new Error("Unexpected EOF (i32)");
+    const v = this.buf.readInt32BE(this.offset);
+    this.offset += 4;
+    return v;
+  }
+  u32() {
+    if (this.remaining() < 4) throw new Error("Unexpected EOF (u32)");
+    const v = this.buf.readUInt32BE(this.offset);
+    this.offset += 4;
+    return v;
+  }
+  bytes(n) {
+    if (this.remaining() < n) throw new Error(`Unexpected EOF (bytes ${n})`);
+    const out = this.buf.subarray(this.offset, this.offset + n);
+    this.offset += n;
+    return out;
+  }
+  skip(n) {
+    if (this.remaining() < n) throw new Error(`Unexpected EOF (skip ${n})`);
+    this.offset += n;
+  }
+};
+function decompressIfNeeded(s) {
+  if (!s.compressed) return s.payload;
+  if (s.onDiskSize === s.uncompressedSize) return s.payload;
+  return brotliDecompressSync(s.payload);
+}
+function parseStringPool(payload) {
+  const r = new Reader(payload);
+  const count = r.i32();
+  const result = [];
+  for (let i = 0; i < count; i++) {
+    const len = r.u16();
+    const text = r.bytes(len).toString("utf-8");
+    result.push(text);
+  }
+  return result;
+}
+function parseManifest(payload, pool) {
+  const r = new Reader(payload);
+  const count = r.u16();
+  const out = [];
+  for (let i = 0; i < count; i++) {
+    const id = r.u16();
+    const nameIdx = r.u16();
+    const required = r.u8() !== 0;
+    out.push({ id, name: pool[nameIdx] ?? `?@${nameIdx}`, required });
+  }
+  return out;
+}
+function parseFunctionTable(payload) {
+  const r = new Reader(payload);
+  return { count: r.u16() };
+}
+function parseEntryPoints(payload, pool) {
+  const r = new Reader(payload);
+  const count = r.u16();
+  const out = [];
+  for (let i = 0; i < count; i++) {
+    const nameIdx = r.u16();
+    const fnIdx = r.u16();
+    out.push({ name: pool[nameIdx] ?? `?@${nameIdx}`, functionIndex: fnIdx });
+  }
+  return out;
+}
+function parseModifierTable(payload) {
+  const r = new Reader(payload);
+  return r.u16();
+}
+function parseBundleMetadata(payload, pool) {
+  const r = new Reader(payload);
+  const bundleIdIdx = r.u16();
+  const bundleId = pool[bundleIdIdx] ?? "";
+  const composableCount = r.u16();
+  for (let i = 0; i < composableCount; i++) {
+    r.i32();
+    r.u16();
+    const paramCount = r.u16();
+    r.skip(paramCount * 2);
+    r.u8();
+    r.u8();
+    r.u16();
+  }
+  const vmCount = r.u16();
+  for (let i = 0; i < vmCount; i++) {
+    r.u16();
+    r.i32();
+    const eventCount = r.u16();
+    for (let j = 0; j < eventCount; j++) {
+      r.u16();
+      r.i32();
+    }
+    const stateCount = r.u16();
+    r.skip(stateCount * 2);
+  }
+  const minAppVersion = r.remaining() >= 4 ? r.i32() : 0;
+  return { bundleId, composableCount, viewModelCount: vmCount, minAppVersion };
+}
+async function readKtxFile(path) {
+  const buf = await readFile17(path);
+  return readKtxBuffer(buf, path);
+}
+function readKtxBuffer(buf, path = "<buffer>") {
+  if (buf.length < HEADER_SIZE + SIGNATURE_SIZE) {
+    throw new Error(`File too small (${buf.length} bytes) to be a .ktx bundle.`);
+  }
+  if (buf.subarray(0, 4).compare(KTX_MAGIC) !== 0) {
+    throw new Error(`Wrong magic bytes \u2014 not a .ktx bundle. Got ${buf.subarray(0, 4).toString("hex")}.`);
+  }
+  const r = new Reader(buf);
+  r.skip(4);
+  const formatVersion = r.u16();
+  const minRuntimeVersion = r.u16();
+  const flags = r.u32();
+  const sectionCount = r.u16();
+  const sections = [];
+  for (let i = 0; i < sectionCount; i++) {
+    const type = r.u8();
+    const compressed = r.u8() !== 0;
+    const uncompressedSize = r.u32();
+    const onDiskSize = r.u32();
+    const rawOffset = r.pos();
+    const payload = r.bytes(onDiskSize);
+    sections.push({ type, typeName: sectionName(type), compressed, uncompressedSize, onDiskSize, rawOffset, payload });
+  }
+  const sigOffset = buf.length - SIGNATURE_SIZE;
+  if (r.pos() > sigOffset) {
+    throw new Error(`Section payloads overrun signature trailer (sections end at ${r.pos()}, sig at ${sigOffset}).`);
+  }
+  const signatureBytes = buf.subarray(sigOffset);
+  const unsigned = (flags & FLAG_UNSIGNED) !== 0;
+  const signed = !unsigned && signatureBytes.some((b) => b !== 0);
+  const pool = sections.find((s) => s.type === SECTION_STRING_POOL);
+  const stringPool = pool ? parseStringPool(decompressIfNeeded(pool)) : null;
+  const safeMan = (type) => {
+    if (!stringPool) return null;
+    const s = sections.find((sec) => sec.type === type);
+    if (!s) return null;
+    return parseManifest(decompressIfNeeded(s), stringPool);
+  };
+  const fnTable = sections.find((s) => s.type === SECTION_FUNCTION_TABLE);
+  const functionCount = fnTable ? parseFunctionTable(decompressIfNeeded(fnTable)).count : null;
+  const entries = sections.find((s) => s.type === SECTION_ENTRY_POINTS);
+  const entryPoints = entries && stringPool ? parseEntryPoints(decompressIfNeeded(entries), stringPool) : null;
+  const modTable = sections.find((s) => s.type === SECTION_MODIFIER_TABLE);
+  const modifierTableSize = modTable ? parseModifierTable(decompressIfNeeded(modTable)) : null;
+  const meta = sections.find((s) => s.type === SECTION_BUNDLE_METADATA);
+  const metadata = meta && stringPool ? parseBundleMetadata(decompressIfNeeded(meta), stringPool) : null;
+  return {
+    path,
+    bytes: buf.length,
+    formatVersion,
+    minRuntimeVersion,
+    flags,
+    signed,
+    debugInfoFlagSet: (flags & FLAG_DEBUG_INFO_PRESENT) !== 0,
+    sectionCount,
+    sections: sections.map((s) => ({
+      type: s.type,
+      typeName: s.typeName,
+      compressed: s.compressed,
+      uncompressedSize: s.uncompressedSize,
+      onDiskSize: s.onDiskSize
+    })),
+    signature: { present: signed, hex: signed ? signatureBytes.toString("hex") : null },
+    stringPool,
+    adapterManifest: safeMan(SECTION_ADAPTER_MANIFEST),
+    constructorManifest: safeMan(SECTION_CONSTRUCTOR_MANIFEST),
+    capabilityManifest: safeMan(SECTION_CAPABILITY_MANIFEST),
+    functionCount,
+    entryPoints,
+    modifierTableSize,
+    bundleId: metadata?.bundleId ?? null,
+    composableCount: metadata?.composableCount ?? null,
+    viewModelCount: metadata?.viewModelCount ?? null,
+    minAppVersion: metadata?.minAppVersion ?? null
+  };
+}
+
+// src/agent/tools/analyze-ktx.ts
+function makeAnalyzeKtxTool(projectRoot) {
+  return tool7({
+    description: "Parse a .ktx bundle and return its structure: format version, sections, manifests (adapter/constructor/capability), function count, entry points, signature status, bundle id. Use to diagnose runtime load errors and verify bundle contents.",
+    parameters: z8.object({
+      path: z8.string().describe('Path to .ktx file relative to project root (e.g. "app/src/main/assets/ketoy/main.ktx").')
+    }),
+    execute: async ({ path }) => {
+      const joined = safeJoin(projectRoot, path);
+      if (!joined) return { error: `Refusing to read outside project root: ${path}` };
+      const { abs, rel } = joined;
+      try {
+        const summary = await readKtxFile(abs);
+        return { ...summary, path: rel };
+      } catch (e) {
+        return { error: `Failed to parse ${rel}: ${e.message}` };
+      }
+    }
+  });
+}
+
+// src/agent/tools/skill-file.ts
+import { z as z9 } from "zod";
+import { tool as tool8 } from "ai";
+function makeSkillFileTool() {
+  return tool8({
+    description: "Read a file from the Ketoy skill (reference/, guides/, examples/, templates/). Useful when the agent needs deeper context than the system prompt carries \u2014 e.g. specific capability IDs, modifier patterns, or the migration playbook.",
+    parameters: z9.object({
+      name: z9.string().describe('Relative skill path, e.g. "reference/capabilities.md" or "examples/todo-screen.kt".')
+    }),
+    execute: async ({ name }) => {
+      const available = await listSkillFiles();
+      const content = await readSkillFile(name);
+      if (content === null) {
+        return { error: `Skill file not found: ${name}`, available };
+      }
+      return { name, content };
+    }
+  });
+}
+
+// src/agent/tools/index.ts
+async function buildTools(opts) {
+  const config = await loadConfig();
+  const { projectRoot } = opts;
+  return {
+    read_file: makeReadFileTool(projectRoot),
+    write_file: makeWriteFileTool(projectRoot, { autoApprove: false }),
+    edit_file: makeEditFileTool(projectRoot, { autoApprove: false }),
+    grep: makeGrepTool(projectRoot),
+    glob: makeGlobTool(projectRoot),
+    bash: makeBashTool(projectRoot, { autoApproveSafe: config.agent.autoApproveSafeBash }),
+    analyze_ktx: makeAnalyzeKtxTool(projectRoot),
+    skill_file: makeSkillFileTool()
+  };
+}
+
+// src/agent/loop.ts
+async function runAgent(opts) {
+  const config = await loadConfig();
+  const { model, modelName, providerId } = await resolveModel(opts.modelOverride);
+  const { prompt: system, loadedFiles } = await buildSystemPrompt({
+    taskHint: opts.userPrompt,
+    projectRoot: opts.projectRoot,
+    modelName
+  });
+  const tools = await buildTools({ projectRoot: opts.projectRoot });
+  if (!opts.silent) {
+    log.detail(
+      `model=${providerId}:${modelName} \xB7 skill=${loadedFiles.length} file(s) loaded \xB7 tools=${Object.keys(tools).length}`
+    );
+  }
+  const messages = [
+    ...opts.history ?? [],
+    { role: "user", content: opts.userPrompt }
+  ];
+  const result = streamText({
+    model,
+    system,
+    messages,
+    tools,
+    maxSteps: config.agent.maxSteps,
+    onStepFinish: ({ toolCalls, finishReason }) => {
+      if (opts.silent) return;
+      if (toolCalls && toolCalls.length > 0) {
+        for (const tc of toolCalls) {
+          log.detail(`${pc.cyan("\u2192")} ${tc.toolName}`);
+        }
+      }
+      if (finishReason && finishReason !== "stop" && finishReason !== "tool-calls") {
+        log.detail(`finish: ${finishReason}`);
+      }
+    }
+  });
+  if (!opts.silent) log.raw("\n");
+  for await (const chunk of result.textStream) {
+    if (!opts.silent) log.raw(chunk);
+  }
+  if (!opts.silent) log.raw("\n\n");
+  const response = await result.response;
+  const usage = await result.usage;
+  const steps = await result.steps;
+  return {
+    history: [...messages, ...response.messages],
+    loadedSkillFiles: loadedFiles,
+    steps: steps.length,
+    usage: {
+      promptTokens: usage.promptTokens,
+      completionTokens: usage.completionTokens,
+      totalTokens: usage.totalTokens
+    }
+  };
+}
+
+// src/commands/chat.ts
+async function runChatCommand(opts) {
+  log.info(pc.bold("Ketoy chat") + pc.dim(" \u2014 type your request, /exit to quit, /clear to reset history."));
+  log.detail(`Working dir: ${opts.projectRoot}`);
+  if (opts.model) log.detail(`Model override: ${opts.model}`);
+  let history = [];
+  let prompt = opts.initialPrompt;
+  while (true) {
+    let userInput;
+    if (prompt !== void 0) {
+      userInput = prompt;
+      prompt = void 0;
+      log.raw(`${pc.bold("\u203A ")}${userInput}
+`);
+    } else {
+      try {
+        userInput = await input2({ message: pc.bold("\u203A"), validate: (v) => v.trim().length > 0 });
+      } catch (e) {
+        if (e.name === "ExitPromptError") throw new UserAbortError();
+        throw e;
+      }
+    }
+    const trimmed = userInput.trim();
+    if (trimmed === "/exit" || trimmed === "/quit") {
+      log.info("Bye.");
+      return;
+    }
+    if (trimmed === "/clear") {
+      history = [];
+      log.info("History cleared.");
+      continue;
+    }
+    if (trimmed === "/help") {
+      printHelp();
+      continue;
+    }
+    if (trimmed === "/cost") {
+      log.info("Cost tracking is coming in v0.3.x.");
+      continue;
+    }
+    if (trimmed.startsWith("/")) {
+      log.warn(`Unknown command: ${trimmed}. Use /help.`);
+      continue;
+    }
+    try {
+      const result = await runAgent({
+        userPrompt: userInput,
+        projectRoot: opts.projectRoot,
+        modelOverride: opts.model,
+        history
+      });
+      history = result.history;
+      const tot = result.usage.totalTokens;
+      const tokenLine = tot ? pc.dim(
+        `${result.steps} step(s), ${tot} tokens (${result.usage.promptTokens}\u2191 ${result.usage.completionTokens}\u2193)`
+      ) : pc.dim(`${result.steps} step(s)`);
+      log.detail(tokenLine);
+    } catch (e) {
+      log.error(e.message);
+      const cont = await confirm5({ message: "Continue chatting?", default: true }).catch(() => false);
+      if (!cont) return;
+    }
+  }
+}
+function printHelp() {
+  log.info("Slash commands:");
+  log.detail("/exit   \u2014 quit the chat session");
+  log.detail("/clear  \u2014 clear conversation history");
+  log.detail("/help   \u2014 show this help");
+}
+
+// src/commands/migrate.ts
+import { resolve as resolve5, relative as relative5 } from "path";
+import { access as access8 } from "fs/promises";
+async function fileExists7(p) {
+  try {
+    await access8(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runMigrateCommand(opts) {
+  if (opts.files.length === 0) {
+    throw new KetoyCliError("Pass at least one file path to migrate.");
+  }
+  for (const f of opts.files) {
+    const abs = resolve5(opts.projectRoot, f);
+    if (!await fileExists7(abs)) {
+      throw new KetoyCliError(`File not found: ${f}`);
+    }
+  }
+  const list = opts.files.map((f) => relative5(opts.projectRoot, resolve5(opts.projectRoot, f)));
+  log.info(`Migrating ${list.length} file(s) to KBC: ${list.join(", ")}`);
+  const prompt = `Migrate the following Compose source files to Ketoy KBC. Follow the migration playbook in skills/ketoy/guides/migrate.md strictly:
+
+` + list.map((f) => `- ${f}`).join("\n") + `
+
+Procedure (do all steps, do not skip):
+1. Read each file in full.
+2. Audit each: list composables, state holders, side effects, forbidden APIs.
+3. For each unsupported call, propose a capability or alternative.
+4. Show me the migration plan as a checklist and ASK for confirmation before editing.
+5. After I confirm: update Capabilities.kt, ketoy-capabilities.json, and the host CapabilityRegistry; then rewrite each file with @KetoyComposable + @KetoyEntryPoint, replacing forbidden calls with capability calls.
+6. Run \`./gradlew :app:ketoyBundle --rerun-tasks\` and resolve any KetoyBC errors.
+7. Report what changed and any items I need to wire up host-side.
+
+Do not silently rewrite. Use edit_file with surgical changes where files already exist.`;
+  log.detail(`Sending migration task to agent \u2014 this will take several turns.`);
+  log.raw("\n");
+  const result = await runAgent({
+    userPrompt: prompt,
+    projectRoot: opts.projectRoot,
+    modelOverride: opts.model
+  });
+  log.detail(
+    pc.dim(
+      `Migration agent finished in ${result.steps} step(s)${result.usage.totalTokens ? `, ${result.usage.totalTokens} tokens` : ""}.`
+    )
+  );
+}
+
+// src/commands/doctor.ts
+import { execa as execa2 } from "execa";
+import { join as join8 } from "path";
+import { access as access9 } from "fs/promises";
+async function fileExists8(p) {
+  try {
+    await access9(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runDoctorCommand(opts) {
+  const gradlew = process.platform === "win32" ? join8(opts.projectRoot, "gradlew.bat") : join8(opts.projectRoot, "gradlew");
+  if (!await fileExists8(gradlew)) {
+    throw new KetoyCliError(`No gradle wrapper found at ${gradlew}.`);
+  }
+  log.info(`Running ${pc.bold(`./gradlew ${opts.task}`)} to capture output\u2026`);
+  const taskArgs = opts.task.split(/\s+/).filter((s) => s.length > 0);
+  const result = await execa2(gradlew, [...taskArgs, "--console=plain", "--stacktrace"], {
+    cwd: opts.projectRoot,
+    reject: false,
+    all: true
+  });
+  const fullLog = result.all ?? `${result.stdout}
+${result.stderr}`;
+  const trimmed = fullLog.length > 32 * 1024 ? fullLog.slice(-32 * 1024) : fullLog;
+  if (result.exitCode === 0) {
+    log.success(`Task ${opts.task} succeeded \u2014 no errors to diagnose.`);
+    return;
+  }
+  log.warn(`Task failed with exit code ${result.exitCode}. Asking the agent to diagnose\u2026`);
+  log.raw("\n");
+  const prompt = `The Gradle task \`${opts.task}\` failed. Below is the captured output (last 32 KB).
+
+Please:
+1. Identify each distinct error (especially "KetoyBC:" diagnostics).
+2. For each one, explain the root cause briefly and propose the minimal fix.
+3. Reference the skill (guides/diagnose-errors.md) when relevant.
+4. If a fix requires editing files, ASK before applying \u2014 use edit_file for surgical edits only.
+5. If multiple unrelated errors, prioritize the first KBC compile error since later ones often cascade.
+
+=== BEGIN OUTPUT ===
+${trimmed}
+=== END OUTPUT ===`;
+  await runAgent({
+    userPrompt: prompt,
+    projectRoot: opts.projectRoot,
+    modelOverride: opts.model
+  });
+}
+
+// src/commands/build.ts
+import { execa as execa3 } from "execa";
+import { join as join9 } from "path";
+import { access as access10, stat as stat3 } from "fs/promises";
+async function fileExists9(p) {
+  try {
+    await access10(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runBuildCommand(opts) {
+  const gradlew = process.platform === "win32" ? join9(opts.projectRoot, "gradlew.bat") : join9(opts.projectRoot, "gradlew");
+  if (!await fileExists9(gradlew)) {
+    throw new KetoyCliError(`No gradle wrapper found at ${gradlew}. Run from the Android project root.`);
+  }
+  const taskArgs = opts.variant === "bundle" ? [":app:ketoyBundle", "--rerun-tasks"] : opts.variant === "debug" ? [":app:assembleDebug"] : [":app:assembleRelease"];
+  log.info(`Running ${pc.bold(`./gradlew ${taskArgs.join(" ")}`)} \u2026`);
+  const result = await execa3(gradlew, [...taskArgs, "--console=plain"], {
+    cwd: opts.projectRoot,
+    reject: false,
+    stdio: "inherit"
+  });
+  if (result.exitCode !== 0) {
+    throw new KetoyCliError(`Build failed (exit ${result.exitCode}). Run \`ketoy doctor\` to analyze.`, result.exitCode ?? 1);
+  }
+  const bundlePath = join9(opts.projectRoot, "app", "src", "main", "assets", "ketoy", "main.ktx");
+  if (await fileExists9(bundlePath)) {
+    const s = await stat3(bundlePath);
+    log.success(`Build succeeded \u2014 bundle at ${pc.bold("app/src/main/assets/ketoy/main.ktx")} (${s.size} bytes).`);
+  } else {
+    log.success("Build succeeded.");
+    log.warn("Bundle not found at the expected path. Confirm `ketoy { exportFromAppModule = true }` is set in app/build.gradle.kts.");
+  }
+}
+
+// src/commands/analyze.ts
+import { resolve as resolve6 } from "path";
+async function runAnalyzeCommand(opts) {
+  const abs = resolve6(process.cwd(), opts.path);
+  let summary;
+  try {
+    summary = await readKtxFile(abs);
+  } catch (e) {
+    throw new KetoyCliError(`Could not parse ${opts.path}: ${e.message}`);
+  }
+  if (opts.json) {
+    const sanitized = {
+      ...summary,
+      stringPool: opts.showStrings ? summary.stringPool : null,
+      adapterManifest: opts.showManifest ? summary.adapterManifest : null,
+      constructorManifest: opts.showManifest ? summary.constructorManifest : null,
+      capabilityManifest: opts.showManifest ? summary.capabilityManifest : null
+    };
+    log.raw(JSON.stringify(sanitized, null, 2) + "\n");
+    return;
+  }
+  log.info(pc.bold(opts.path));
+  log.detail(`bytes:             ${summary.bytes.toLocaleString()}`);
+  log.detail(`formatVersion:     ${summary.formatVersion}`);
+  log.detail(`minRuntimeVersion: ${summary.minRuntimeVersion}`);
+  log.detail(`flags:             0x${summary.flags.toString(16).padStart(8, "0")}`);
+  log.detail(`signed:            ${summary.signed ? pc.green("yes") : pc.dim("no")}`);
+  if (summary.bundleId !== null) log.detail(`bundleId:          ${summary.bundleId || pc.dim("(empty)")}`);
+  if (summary.minAppVersion !== null) log.detail(`minAppVersion:     ${summary.minAppVersion}`);
+  if (summary.functionCount !== null) log.detail(`functions:         ${summary.functionCount}`);
+  if (summary.composableCount !== null) log.detail(`composables:       ${summary.composableCount}`);
+  if (summary.viewModelCount !== null) log.detail(`viewModels:        ${summary.viewModelCount}`);
+  if (summary.modifierTableSize !== null) log.detail(`modifierTable:     ${summary.modifierTableSize} entries`);
+  log.info("Sections:");
+  for (const s of summary.sections) {
+    const cmp = s.compressed ? pc.cyan(" brotli") : "";
+    log.detail(
+      `${s.typeName.padEnd(22)} ${String(s.onDiskSize).padStart(8)} on-disk / ${String(s.uncompressedSize).padStart(8)} uncompressed${cmp}`
+    );
+  }
+  if (summary.entryPoints && summary.entryPoints.length > 0) {
+    log.info("Entry points:");
+    for (const e of summary.entryPoints) log.detail(`${e.name.padEnd(28)} fn#${e.functionIndex}`);
+  }
+  if (opts.showManifest) {
+    printManifest("Adapter manifest", summary.adapterManifest);
+    printManifest("Constructor manifest", summary.constructorManifest);
+    printManifest("Capability manifest", summary.capabilityManifest);
+  }
+  if (opts.showStrings && summary.stringPool) {
+    log.info(`String pool (${summary.stringPool.length} entries):`);
+    summary.stringPool.forEach((s, i) => {
+      log.detail(`[${i}] ${s}`);
+    });
+  }
+}
+function printManifest(title, entries) {
+  if (!entries) return;
+  if (entries.length === 0) {
+    log.info(`${title}: ${pc.dim("(empty)")}`);
+    return;
+  }
+  log.info(`${title} (${entries.length}):`);
+  for (const e of entries) {
+    const id = `0x${e.id.toString(16).padStart(4, "0").toUpperCase()}`;
+    const req = e.required ? "" : pc.dim(" (optional)");
+    log.detail(`${id}  ${e.name}${req}`);
+  }
+}
+
+// src/cli.ts
+function buildCli() {
+  const program = new Command();
+  program.name("ketoy").description("AI-powered CLI for Ketoy \u2014 scaffold, write, migrate, diagnose, and build .ktx bundles.").version(CLI_VERSION, "-v, --version", "Show CLI + Ketoy target versions");
+  program.command("version").description("Print CLI + Ketoy versions and default model").action(async () => {
+    await runVersionCommand();
+  });
+  const auth = program.command("auth [provider]").description("Configure API credentials for an AI provider (anthropic, openai, google, mistral, groq, xai, openrouter, ollama)").option("--remove", "Remove the saved credentials for the given provider").option("--list", "List configured providers without prompting").action(async (provider, opts) => {
+    if (opts.list) {
+      await listAuthStatus();
+      return;
+    }
+    await runAuthCommand({ provider, remove: opts.remove });
+  });
+  void auth;
+  const config = program.command("config").description("Inspect or modify global CLI configuration");
+  config.command("list").description("Show current configuration").action(async () => {
+    await runConfigList();
+  });
+  config.command("get <key>").description("Read a single config value (supports dotted keys like agent.maxSteps)").action(async (key) => {
+    await runConfigGet(key);
+  });
+  config.command("set <key> <value>").description("Set a config value").action(async (key, value) => {
+    await runConfigSet(key, value);
+  });
+  program.command("init").description("Add Ketoy to the current Android project via surgical edits").option("--hilt", "Force Hilt-aware setup").option("--no-hilt", "Force non-Hilt setup").option("--install-screen", "Install KetoyScreen in MainActivity (replaces setContent body \u2014 fresh projects)").option("--no-install-screen", "Skip MainActivity edit; integrate KetoyScreen manually").option("-y, --yes", "Skip confirmation prompts", false).option("--dry-run", "Print the plan without writing any files", false).action(async (opts) => {
+    const hiltOption = opts.hilt === void 0 ? null : opts.hilt;
+    const installScreenOption = opts.installScreen === void 0 ? null : opts.installScreen;
+    await runInitCommand(process2.cwd(), {
+      hilt: hiltOption,
+      installKetoyScreen: installScreenOption,
+      yes: opts.yes,
+      dryRun: opts.dryRun
+    });
+  });
+  program.command("chat [prompt...]").description("Open an AI-powered Ketoy assistant in the current project").option("-m, --model <id>", "Override the default model (e.g. openai:gpt-4o)").action(async (prompt, opts) => {
+    await runChatCommand({
+      projectRoot: process2.cwd(),
+      model: opts.model,
+      initialPrompt: prompt && prompt.length > 0 ? prompt.join(" ") : void 0
+    });
+  });
+  program.command("migrate <files...>").description("AI-driven per-file migration of Compose source(s) to KBC").option("-m, --model <id>", "Override the default model").action(async (files, opts) => {
+    await runMigrateCommand({ projectRoot: process2.cwd(), files, model: opts.model });
+  });
+  program.command("doctor [task]").description("Run a Gradle task, capture output, and ask the agent to diagnose failures").option("-m, --model <id>", "Override the default model").action(async (task, opts) => {
+    await runDoctorCommand({
+      projectRoot: process2.cwd(),
+      task: task ?? ":app:ketoyBundle --rerun-tasks",
+      model: opts.model
+    });
+  });
+  program.command("build").description("Run the Ketoy bundle / Android assemble Gradle task").option("--variant <name>", "bundle, debug, or release", "bundle").action(async (opts) => {
+    const variant = opts.variant === "debug" || opts.variant === "release" || opts.variant === "bundle" ? opts.variant : "bundle";
+    await runBuildCommand({ projectRoot: process2.cwd(), variant });
+  });
+  program.command("analyze <path>").description("Inspect a .ktx bundle").option("--manifest", "Print adapter / constructor / capability manifests").option("--strings", "Print the string pool").option("--json", "Emit JSON instead of human-readable output").action(async (path, opts) => {
+    await runAnalyzeCommand({
+      path,
+      showManifest: !!opts.manifest,
+      showStrings: !!opts.strings,
+      json: !!opts.json
+    });
+  });
+  program.command("publish").description("Publish a bundle (deferred until Ketoy backend GA)").action(() => {
+    log.warn(
+      "Publishing is deferred until the Ketoy backend ships. Until then, upload `.ktx` files to your CDN directly and consume via KetoyBundleSource.Remote(url)."
+    );
+  });
+  return program;
+}
+async function runCli(argv) {
+  const program = buildCli();
+  try {
+    await program.parseAsync([...argv]);
+  } catch (e) {
+    if (e instanceof UserAbortError) {
+      log.warn(e.message);
+      process2.exit(e.exitCode);
+    }
+    if (e instanceof KetoyCliError) {
+      log.error(e.message);
+      process2.exit(e.exitCode);
+    }
+    const err = e;
+    if (err.name === "ExitPromptError") {
+      log.warn("Aborted.");
+      process2.exit(130);
+    }
+    log.error(err.message ?? String(e));
+    if (process2.env["KETOY_DEBUG"]) {
+      console.error(err);
+    }
+    process2.exit(1);
+  }
+}
+
+// bin/ketoy.ts
+await runCli(process.argv);
+//# sourceMappingURL=ketoy.js.map