arcie 0.1.3 → 0.1.5

package/dist/init-5F7CIVLN.js

@@ -0,0 +1,822 @@
+import {
+  renderCliTaggedLine
+} from "./chunk-HVBDOHTL.js";
+import {
+  scaffoldWebChat
+} from "./chunk-SGWQZZ2A.js";
+import {
+  EMPTY_LINE,
+  LiveRegion,
+  applyLineEditorKey,
+  attachKeyStream,
+  createTheme,
+  detectUnicode,
+  inputTextWidth,
+  lineOf,
+  maskLine,
+  sliceVisible,
+  visibleLength,
+  visibleLine
+} from "./chunk-HWD2Z2CH.js";
+import "./chunk-N5R3TEEZ.js";
+
+// src/cli/init.ts
+import {
+  copyFileSync,
+  existsSync as existsSync2,
+  mkdirSync,
+  readdirSync,
+  readFileSync as readFileSync2,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+import { resolve, join as join2, dirname } from "path";
+import { fileURLToPath } from "url";
+import { exec } from "child_process";
+
+// src/cli/model-catalog.ts
+var MODELS = [
+  { id: "anthropic/claude-sonnet-5", name: "Claude Sonnet 5", provider: "Anthropic" },
+  { id: "anthropic/claude-opus-4.8", name: "Claude Opus 4.8", provider: "Anthropic" },
+  { id: "anthropic/claude-haiku-4", name: "Claude Haiku 4", provider: "Anthropic" },
+  { id: "openai/gpt-5.5", name: "GPT 5.5", provider: "OpenAI" },
+  { id: "openai/gpt-5", name: "GPT 5", provider: "OpenAI" },
+  { id: "openai/gpt-4.5", name: "GPT 4.5", provider: "OpenAI" },
+  { id: "openai/gpt-4o", name: "GPT 4o", provider: "OpenAI" },
+  { id: "openai/o3", name: "o3", provider: "OpenAI" },
+  { id: "openai/o4-mini", name: "o4-mini", provider: "OpenAI" },
+  { id: "google/gemini-2.5-pro", name: "Gemini 2.5 Pro", provider: "Google" },
+  { id: "google/gemini-2.5-flash", name: "Gemini 2.5 Flash", provider: "Google" },
+  { id: "google/gemini-2.0-flash", name: "Gemini 2.0 Flash", provider: "Google" },
+  { id: "meta/llama-4", name: "Llama 4", provider: "Meta" },
+  { id: "meta/llama-3.3-70b", name: "Llama 3.3 70B", provider: "Meta" },
+  { id: "meta/llama-3.1-405b", name: "Llama 3.1 405B", provider: "Meta" },
+  { id: "mistral/mistral-large-4", name: "Mistral Large 4", provider: "Mistral" },
+  { id: "mistral/mistral-small-4", name: "Mistral Small 4", provider: "Mistral" },
+  { id: "deepseek/deepseek-v4", name: "DeepSeek V4", provider: "DeepSeek" },
+  { id: "deepseek/deepseek-r1", name: "DeepSeek R1", provider: "DeepSeek" },
+  { id: "groq/llama-3.3-70b-versatile", name: "Llama 3.3 70B Versatile", provider: "Groq" },
+  { id: "groq/llama-3.1-8b-instant", name: "Llama 3.1 8B Instant", provider: "Groq" }
+];
+async function fetchModelCatalog() {
+  await new Promise((r) => setTimeout(r, 600 + Math.random() * 400));
+  return MODELS;
+}
+
+// src/cli/tui/diagnostics.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+var PROVIDER_KEY_MAP = {
+  openai: "OPENAI_API_KEY",
+  anthropic: "ANTHROPIC_API_KEY",
+  groq: "GROQ_API_KEY",
+  deepseek: "DEEPSEEK_API_KEY",
+  mistral: "MISTRAL_API_KEY",
+  google: "GOOGLE_API_KEY",
+  meta: "TOGETHER_API_KEY"
+};
+function providerEnvVar(modelId) {
+  const provider = modelId.split("/")[0];
+  if (!provider) return void 0;
+  const envVar = PROVIDER_KEY_MAP[provider];
+  return envVar ? { provider, envVar } : void 0;
+}
+function isProviderKeySet(agentDir, envVar) {
+  if (process.env[envVar] && process.env[envVar] !== "") return true;
+  const envPath = join(agentDir, "..", ".env.local");
+  if (!existsSync(envPath)) return false;
+  const content = readFileSync(envPath, "utf-8");
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith(`${envVar}=`) && !trimmed.startsWith(`#`)) return true;
+  }
+  return false;
+}
+function checkProviderKeys(agentDir, modelId) {
+  const results = [];
+  const info = providerEnvVar(modelId);
+  if (info === void 0) return results;
+  const { provider, envVar } = info;
+  const envPath = join(agentDir, "..", ".env.local");
+  let hasKey = false;
+  if (existsSync(envPath)) {
+    const content = readFileSync(envPath, "utf-8");
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith(`${envVar}=`) && !trimmed.startsWith(`#`)) {
+        hasKey = true;
+        break;
+      }
+    }
+  }
+  const inProcess = process.env[envVar] && process.env[envVar] !== "";
+  if (!hasKey && !inProcess) {
+    results.push({
+      severity: "warn",
+      message: `Missing ${envVar} for provider: ${provider}`,
+      fix: `Add ${envVar}=your_key_here to .env.local`
+    });
+  } else {
+    results.push({
+      severity: "info",
+      message: `${envVar} is configured`
+    });
+  }
+  return results;
+}
+
+// src/cli/setup/select-input.ts
+function createSelectState(options, init = {}) {
+  const query = init.query ?? "";
+  const matches = filterOptions(options, query);
+  const initial = init.initialValue;
+  const selectedIndex = initial === void 0 ? 0 : Math.max(
+    0,
+    matches.findIndex((option) => option.value === initial)
+  );
+  return { options, matches, selectedIndex, query };
+}
+function setQuery(state, query) {
+  if (query === state.query) return state;
+  const matches = filterOptions(state.options, query);
+  const carried = state.matches[state.selectedIndex];
+  const carriedIndex = carried === void 0 ? -1 : matches.findIndex((option) => option.value === carried.value);
+  return {
+    options: state.options,
+    matches,
+    selectedIndex: carriedIndex >= 0 ? carriedIndex : 0,
+    query
+  };
+}
+function moveUp(state) {
+  const count = state.matches.length;
+  if (count === 0) return state;
+  const selectedIndex = (state.selectedIndex - 1 + count) % count;
+  return { ...state, selectedIndex };
+}
+function moveDown(state) {
+  const count = state.matches.length;
+  if (count === 0) return state;
+  const selectedIndex = (state.selectedIndex + 1) % count;
+  return { ...state, selectedIndex };
+}
+function selected(state) {
+  return state.matches[state.selectedIndex];
+}
+function filterOptions(options, query) {
+  const normalized = query.trim().toLowerCase();
+  if (normalized.length === 0) return options;
+  return options.filter((option) => optionMatches(option, normalized));
+}
+function optionMatches(option, query) {
+  if (option.label.toLowerCase().includes(query)) return true;
+  if (option.description !== void 0 && option.description.toLowerCase().includes(query)) {
+    return true;
+  }
+  return false;
+}
+
+// src/cli/setup/text-input.ts
+function createTextInputState(options) {
+  const line = options.defaultValue ? lineOf(options.defaultValue) : EMPTY_LINE;
+  const state = {
+    line,
+    message: options.message,
+    mask: options.mask ?? false
+  };
+  const result = { ...state };
+  if (options.placeholder !== void 0) result.placeholder = options.placeholder;
+  if (options.validate !== void 0) result.validate = options.validate;
+  return result;
+}
+function applyTextInputKey(state, key) {
+  const nextLine = applyLineEditorKey(state.line, key, { multiline: false });
+  if (nextLine === void 0) return void 0;
+  const next = { ...state, line: nextLine };
+  if (state.validationError !== void 0) {
+    next.validationError = void 0;
+  }
+  return next;
+}
+function validateTextInput(state) {
+  if (state.validate === void 0) return void 0;
+  const error = state.validate(state.line.text);
+  if (error === void 0) return void 0;
+  return { ...state, validationError: error };
+}
+
+// src/cli/setup/setup-panel.ts
+var MAX_VISIBLE_OPTIONS = 10;
+function renderTextPanel(state, theme, width) {
+  const c = theme.colors;
+  const rows = [renderHeader(state.message, theme, width)];
+  const promptGlyph = c.cyan(theme.glyph.prompt);
+  const promptWidth = visibleLength(`${theme.glyph.prompt} `);
+  const budget = Math.max(1, width - promptWidth - 2);
+  const displayLine = state.mask ? maskLine(state.line) : state.line;
+  const view = visibleLine(displayLine, budget);
+  const under = view.under.length === 0 ? " " : view.under;
+  const inputRow = `  ${promptGlyph} ${view.before}${c.inverse(under)}${view.after}`;
+  if (state.line.text.length === 0 && state.placeholder !== void 0) {
+    const placeholder = c.dim(sliceVisible(state.placeholder, budget));
+    rows.push(`  ${promptGlyph} ${c.inverse(" ")}${placeholder}`);
+  } else {
+    rows.push(inputRow);
+  }
+  if (state.validationError !== void 0) {
+    rows.push(`  ${c.red(theme.glyph.error)} ${c.red(state.validationError)}`);
+  }
+  const caretCol = 3 + promptWidth + inputTextWidth(state.mask ? maskLine(state.line).text.slice(0, maskLine(state.line).cursor) : view.before);
+  return { rows, caret: { row: 2, col: caretCol } };
+}
+function renderSelectPanel(state, message, theme, width, options = {}) {
+  const rows = [renderHeader(message, theme, width)];
+  let caretRow = 1;
+  let caretCol = 3;
+  if (options.searchable === true) {
+    const budget = Math.max(1, width - 4);
+    const [filterRow, cursorCol] = renderFilterRow(state.query, budget, theme, options.placeholder);
+    rows.push(filterRow);
+    caretRow = 2;
+    caretCol = cursorCol;
+  }
+  rows.push(...renderOptionRows(state, theme, width));
+  return { rows, caret: { row: caretRow, col: caretCol } };
+}
+function renderHeader(message, theme, width) {
+  const c = theme.colors;
+  const glyph = c.yellow(c.bold(theme.glyph.question));
+  const trimmed = message.trim();
+  const budget = Math.max(1, width - 2);
+  return `${glyph} ${c.bold(sliceVisible(trimmed, budget))}`;
+}
+function renderFilterRow(query, budget, theme, placeholder) {
+  const c = theme.colors;
+  const prefix = `  ${c.dim("/")} `;
+  const prefixWidth = visibleLength(prefix);
+  const empty = query.length === 0;
+  const visible = empty ? placeholder !== void 0 ? c.dim(sliceVisible(placeholder, budget)) : c.dim(sliceVisible("type to filter", budget)) : sliceVisible(query, budget);
+  const row = `${prefix}${empty ? c.inverse(" ") : `${visible}${c.inverse(" ")}`}`;
+  const caretCol = 1 + prefixWidth + (empty ? 0 : visibleLength(visible));
+  return [row, caretCol];
+}
+function renderOptionRows(state, theme, width) {
+  const c = theme.colors;
+  if (state.matches.length === 0) {
+    return [`  ${c.dim("no matches")}`];
+  }
+  const count = state.matches.length;
+  const viewSize = Math.min(count, MAX_VISIBLE_OPTIONS);
+  const start = Math.max(
+    0,
+    Math.min(state.selectedIndex - Math.floor(viewSize / 2), count - viewSize)
+  );
+  const end = Math.min(start + viewSize, count);
+  const visible = state.matches.slice(start, end);
+  const labelWidth = Math.min(
+    Math.max(...visible.map((option) => visibleLength(option.label))),
+    Math.max(8, Math.floor(width * 0.5))
+  );
+  return visible.map((option, offset) => {
+    const isCursor = start + offset === state.selectedIndex;
+    const pointer = isCursor ? c.cyan(theme.glyph.selectedPointer) : " ";
+    const label = padLabel(option.label, labelWidth);
+    const styledLabel = isCursor ? c.bold(label) : label;
+    const description = option.description !== void 0 ? `  ${c.dim(option.description)}` : "";
+    return `${pointer} ${styledLabel}${description}`;
+  });
+}
+function padLabel(label, width) {
+  const visible = visibleLength(label);
+  if (visible >= width) return sliceVisible(label, width);
+  return `${label}${" ".repeat(width - visible)}`;
+}
+
+// src/cli/setup/tui-prompter.ts
+function createTuiPrompter(options = {}) {
+  return new TuiPrompter(options);
+}
+var TuiPrompter = class {
+  #region;
+  #theme;
+  #spinnerIntervalMs;
+  #detachKeys;
+  #spinnerTimer;
+  #spinnerFrame = 0;
+  #spinnerMessage = "";
+  #stopped = false;
+  constructor(options) {
+    this.#theme = options.theme ?? createTheme({ unicode: detectUnicode() });
+    this.#region = new LiveRegion({ output: options.output });
+    this.#spinnerIntervalMs = options.spinnerIntervalMs ?? 90;
+  }
+  get log() {
+    return {
+      info: (message) => this.#writeTagged("info", message, "info"),
+      success: (message) => this.#writeTagged("ok", message, "success"),
+      warning: (message) => this.#writeTagged("warn", message, "warning"),
+      error: (message) => this.#writeTagged("error", message, "danger")
+    };
+  }
+  section(title, lines) {
+    const c = this.#theme.colors;
+    const rows = [c.bold(c.cyan(title))];
+    for (const line of lines) rows.push(`  ${c.dim(line)}`);
+    this.#region.commit(rows);
+  }
+  spinner(message) {
+    this.#stopSpinner();
+    this.#spinnerMessage = message;
+    this.#spinnerFrame = 0;
+    this.#paintSpinner();
+    this.#spinnerTimer = setInterval(() => {
+      this.#spinnerFrame += 1;
+      this.#paintSpinner();
+    }, this.#spinnerIntervalMs);
+    this.#spinnerTimer.unref?.();
+    return {
+      update: (next) => {
+        this.#spinnerMessage = next;
+        this.#paintSpinner();
+      },
+      stop: (outcome = { kind: "silent" }) => {
+        this.#stopSpinner();
+        this.#region.paint([], { row: 1, col: 1 });
+        if (outcome.kind === "silent") return;
+        this.#writeTagged(
+          outcome.kind === "success" ? "ok" : outcome.kind === "warning" ? "warn" : "error",
+          outcome.message ?? this.#spinnerMessage,
+          outcome.kind === "success" ? "success" : outcome.kind === "warning" ? "warning" : "danger"
+        );
+      }
+    };
+  }
+  async text(options) {
+    this.#stopSpinner();
+    return this.#runPrompt((resolve2) => {
+      let state = createTextInputState(options);
+      const paint = () => this.#paintFrame(this.#textFrame(state));
+      paint();
+      return (key) => {
+        if (key.type === "ctrl-c" || key.type === "escape") {
+          resolve2(void 0);
+          return "end";
+        }
+        if (key.type === "enter") {
+          const failed = validateTextInput(state);
+          if (failed !== void 0) {
+            state = failed;
+            paint();
+            return "continue";
+          }
+          resolve2(state.line.text);
+          return "end";
+        }
+        const next = applyTextInputKey(state, key);
+        if (next !== void 0) {
+          state = next;
+          paint();
+        }
+        return "continue";
+      };
+    });
+  }
+  async select(options) {
+    return this.#selectImpl(options, false);
+  }
+  async searchableSelect(options) {
+    return this.#selectImpl(options, true);
+  }
+  async acknowledge(options) {
+    this.#stopSpinner();
+    await this.#runPrompt((resolve2) => {
+      const c = this.#theme.colors;
+      const rows = [`${c.yellow(c.bold(this.#theme.glyph.question))} ${c.bold(options.message)}`];
+      for (const line of options.lines ?? []) rows.push(`  ${c.dim(line)}`);
+      rows.push(`  ${c.dim("press enter to continue")}`);
+      this.#region.paint(rows, { row: rows.length, col: 1 });
+      return (key) => {
+        if (key.type === "ctrl-c" || key.type === "escape" || key.type === "enter") {
+          resolve2();
+          return "end";
+        }
+        return "continue";
+      };
+    });
+  }
+  stop() {
+    if (this.#stopped) return;
+    this.#stopped = true;
+    this.#stopSpinner();
+    this.#detachKeys?.();
+    this.#detachKeys = void 0;
+    this.#region.stop();
+  }
+  async #selectImpl(options, searchable) {
+    this.#stopSpinner();
+    return this.#runPrompt((resolve2) => {
+      let state = createSelectState(options.options, {
+        initialValue: options.initialValue
+      });
+      const placeholder = "placeholder" in options ? options.placeholder : void 0;
+      const paint = () => this.#paintFrame(
+        renderSelectPanel(state, options.message, this.#theme, this.#region.columns, {
+          searchable,
+          placeholder
+        })
+      );
+      paint();
+      return (key) => {
+        if (key.type === "ctrl-c" || key.type === "escape") {
+          resolve2(void 0);
+          return "end";
+        }
+        if (key.type === "enter") {
+          const chosen = selected(state);
+          if (chosen === void 0) return "continue";
+          resolve2(chosen.value);
+          return "end";
+        }
+        if (key.type === "up" || key.type === "ctrl-p") {
+          state = moveUp(state);
+          paint();
+          return "continue";
+        }
+        if (key.type === "down" || key.type === "ctrl-n") {
+          state = moveDown(state);
+          paint();
+          return "continue";
+        }
+        if (searchable) {
+          if (key.type === "backspace") {
+            state = setQuery(state, state.query.slice(0, -1));
+            paint();
+            return "continue";
+          }
+          if (key.type === "text") {
+            state = setQuery(state, `${state.query}${key.value}`);
+            paint();
+            return "continue";
+          }
+          const draft = applyLineEditorKey({ text: state.query, cursor: state.query.length }, key, {
+            multiline: false
+          });
+          if (draft !== void 0 && draft.text !== state.query) {
+            state = setQuery(state, draft.text);
+            paint();
+          }
+        }
+        return "continue";
+      };
+    });
+  }
+  #runPrompt(setup) {
+    return new Promise((resolve2) => {
+      let done = false;
+      const detach = attachKeyStream((key) => {
+        if (done) return;
+        const outcome = onKey(key);
+        if (outcome === "end") {
+          done = true;
+          this.#detachKeys?.();
+          this.#detachKeys = void 0;
+          this.#region.paint([], { row: 1, col: 1 });
+        }
+      });
+      this.#detachKeys = detach;
+      const onKey = setup((value) => resolve2(value));
+    });
+  }
+  #textFrame(state) {
+    return renderTextPanel(state, this.#theme, this.#region.columns);
+  }
+  #paintFrame(frame) {
+    this.#region.paint(frame.rows, frame.caret);
+  }
+  #paintSpinner() {
+    const glyph = this.#theme.spinner[this.#spinnerFrame % this.#theme.spinner.length] ?? "-";
+    const row = `${this.#theme.colors.cyan(glyph)} ${this.#spinnerMessage}`;
+    this.#region.paint([row], { row: 1, col: 1 });
+  }
+  #stopSpinner() {
+    if (this.#spinnerTimer !== void 0) {
+      clearInterval(this.#spinnerTimer);
+      this.#spinnerTimer = void 0;
+    }
+  }
+  #writeTagged(tag, message, tone) {
+    const themeAdapter = {
+      accent: this.#theme.colors.cyan,
+      color: this.#theme.color,
+      danger: this.#theme.colors.red,
+      heading: (t) => this.#theme.colors.bold(this.#theme.colors.cyan(t)),
+      info: this.#theme.colors.blue,
+      label: this.#theme.colors.bold,
+      muted: this.#theme.colors.dim,
+      plain: (t) => t,
+      subagent: this.#theme.colors.orange,
+      success: this.#theme.colors.green,
+      warning: this.#theme.colors.yellow
+    };
+    this.#region.commit([
+      renderCliTaggedLine(themeAdapter, { message, tag, tone })
+    ]);
+  }
+};
+
+// src/cli/init.ts
+var __dirname = dirname(fileURLToPath(import.meta.url));
+function resolveTemplatesDir() {
+  let current = __dirname;
+  for (let i = 0; i < 6; i += 1) {
+    const candidate = resolve(current, "templates");
+    if (existsSync2(candidate)) return candidate;
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return resolve(__dirname, "../../templates");
+}
+var TEMPLATES_DIR = resolveTemplatesDir();
+function copyTemplate(src, dest) {
+  for (const entry of collectFiles(src)) {
+    const relative = entry.replace(src, "").replace(/^\//, "");
+    const destPath = join2(dest, relative);
+    if (entry.endsWith(".gitkeep")) {
+      const parentDir = destPath.replace("/.gitkeep", "");
+      mkdirSync(parentDir, { recursive: true });
+      writeFileSync(join2(parentDir, ".gitkeep"), "");
+      continue;
+    }
+    mkdirSync(dirname(destPath), { recursive: true });
+    copyFileSync(entry, destPath);
+  }
+}
+function collectFiles(dir) {
+  const results = [];
+  for (const entry of readdirSync(dir)) {
+    const full = join2(dir, entry);
+    if (statSync(full).isDirectory()) results.push(...collectFiles(full));
+    else results.push(full);
+  }
+  return results;
+}
+function updatePackageJson(dir, name) {
+  const pkgPath = join2(dir, "package.json");
+  const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+  pkg.name = name;
+  writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+}
+function detectEnvKey() {
+  return process.env.CENCORI_API_KEY ?? null;
+}
+function uncommentEnvLine(envPath, key, value) {
+  const content = readFileSync2(envPath, "utf-8");
+  const lines = content.split("\n");
+  const updated = lines.map((line) => {
+    const trimmed = line.trim();
+    if (trimmed.startsWith(`# ${key}=`) || trimmed.startsWith(`${key}=`)) {
+      return `${key}=${value}`;
+    }
+    return line;
+  });
+  if (updated.join("\n") === content) updated.push(`${key}=${value}`);
+  writeFileSync(envPath, updated.join("\n") + "\n");
+}
+function writeAgentModel(agentDir, model) {
+  const agentFile = join2(agentDir, "agent/agent.ts");
+  const content = readFileSync2(agentFile, "utf-8");
+  const updated = content.replace(/model:\s*"[^"]+"/, `model: "${model}"`);
+  writeFileSync(agentFile, updated);
+}
+function runNpmInstall(cwd) {
+  return new Promise((resolve2, reject) => {
+    const proc = exec("npm install", { cwd });
+    proc.once("exit", (code) => code === 0 ? resolve2() : reject(new Error(`npm exit ${code}`)));
+    proc.once("error", reject);
+  });
+}
+var IGNORED_DIRECTORY_ENTRIES = /* @__PURE__ */ new Set([".DS_Store", ".git", ".gitkeep"]);
+function directoryHasMeaningfulContent(dir) {
+  try {
+    return readdirSync(dir).some((entry) => !IGNORED_DIRECTORY_ENTRIES.has(entry));
+  } catch {
+    return false;
+  }
+}
+function looksLikeArcieProject(dir) {
+  return existsSync2(join2(dir, "agent", "agent.ts"));
+}
+function assertSafeToClear(dir) {
+  const absolute = resolve(dir);
+  const home = homedir();
+  if (absolute === "/" || absolute === home) {
+    throw new Error(`Refusing to clear ${absolute}: too dangerous`);
+  }
+  const parts = absolute.split("/").filter((part) => part.length > 0);
+  if (parts.length < 2) {
+    throw new Error(`Refusing to clear ${absolute}: not enough path depth`);
+  }
+  const dangerousFirst = /* @__PURE__ */ new Set(["etc", "var", "usr", "bin", "sbin", "System", "Library"]);
+  if (parts.length === 2 && dangerousFirst.has(parts[0])) {
+    throw new Error(`Refusing to clear ${absolute}: system path`);
+  }
+}
+function clearDirectoryContents(dir) {
+  assertSafeToClear(dir);
+  for (const entry of readdirSync(dir)) {
+    rmSync(join2(dir, entry), { recursive: true, force: true });
+  }
+}
+async function initCommand(name, options) {
+  const targetDir = name ? resolve(process.cwd(), name) : resolve(process.cwd(), ".");
+  const templateDir = resolve(TEMPLATES_DIR, options.template);
+  if (!existsSync2(templateDir)) {
+    console.error(`  Template not found: ${options.template}`);
+    process.exit(1);
+  }
+  const prompter = createTuiPrompter();
+  try {
+    let mode = "fresh";
+    if (existsSync2(targetDir) && directoryHasMeaningfulContent(targetDir)) {
+      const decision = await resolveExistingDirectory(prompter, targetDir);
+      if (decision === "cancel") return;
+      if (decision === "overwrite") {
+        try {
+          clearDirectoryContents(targetDir);
+          prompter.log.warning(`Cleared ${targetDir}`);
+        } catch (err) {
+          prompter.log.error(err instanceof Error ? err.message : String(err));
+          return;
+        }
+      } else {
+        mode = "resume";
+      }
+    }
+    await runInit(prompter, { targetDir, templateDir, name, mode });
+  } finally {
+    prompter.stop();
+  }
+}
+async function maybeScaffoldWebChat(prompter, targetDir) {
+  const choice = await prompter.select({
+    message: "Add a web chat UI now? (Next.js + shadcn under channels/web)",
+    options: [
+      { value: "yes", label: "Yes \u2014 scaffold channels/web now" },
+      { value: "no", label: "No \u2014 I'll add it later with `arcie channels add web`" }
+    ]
+  });
+  if (choice !== "yes") return;
+  try {
+    const result = scaffoldWebChat(targetDir);
+    if (result.alreadyExisted) {
+      prompter.log.info(`channels/web already exists \u2014 left it untouched`);
+      return;
+    }
+    prompter.log.success(`Scaffolded ${result.targetPath}`);
+    prompter.section("Next steps", [
+      `cd ${result.targetPath.replace(process.cwd() + "/", "")}`,
+      "npm install",
+      "cp .env.local.example .env.local",
+      "npm run dev"
+    ]);
+  } catch (err) {
+    prompter.log.error(err instanceof Error ? err.message : String(err));
+  }
+}
+async function maybePromptProviderKey(prompter, targetDir, modelId) {
+  if (process.env.CENCORI_API_KEY) return;
+  const info = providerEnvVar(modelId);
+  if (info === void 0) return;
+  if (isProviderKeySet(targetDir, info.envVar)) return;
+  const key = await prompter.text({
+    message: `Paste your ${info.envVar} for ${info.provider} (optional \u2014 skip with Enter)`,
+    mask: true
+  });
+  if (key === void 0 || key.length === 0) return;
+  const envPath = join2(targetDir, ".env.local");
+  uncommentEnvLine(envPath, info.envVar, key);
+  process.env[info.envVar] = key;
+  prompter.log.success(`Wrote ${info.envVar} to .env.local`);
+}
+async function resolveExistingDirectory(prompter, targetDir) {
+  const looksArcie = looksLikeArcieProject(targetDir);
+  const message = looksArcie ? `${targetDir} already contains an arcie project.` : `${targetDir} is not empty.`;
+  const options = looksArcie ? [
+    {
+      value: "resume",
+      label: "Resume \u2014 keep files, reconfigure model + API key"
+    },
+    {
+      value: "overwrite",
+      label: "Overwrite \u2014 delete existing files and scaffold fresh"
+    },
+    { value: "cancel", label: "Cancel" }
+  ] : [
+    {
+      value: "overwrite",
+      label: "Overwrite \u2014 delete existing files and scaffold fresh"
+    },
+    {
+      value: "resume",
+      label: "Keep existing files and reconfigure"
+    },
+    { value: "cancel", label: "Cancel" }
+  ];
+  const choice = await prompter.select({ message, options });
+  return choice ?? "cancel";
+}
+async function runInit(prompter, input) {
+  const { targetDir, templateDir, name, mode } = input;
+  const needsScaffold = mode === "fresh" || !looksLikeArcieProject(targetDir);
+  if (needsScaffold) {
+    const scaffold = prompter.spinner(`Creating agent in ${targetDir}`);
+    copyTemplate(templateDir, targetDir);
+    if (name) updatePackageJson(targetDir, name);
+    scaffold.stop({ kind: "success", message: `Created agent in ${targetDir}` });
+  } else {
+    prompter.log.info(`Resuming setup for ${targetDir}`);
+  }
+  const nodeModules = join2(targetDir, "node_modules");
+  if (existsSync2(nodeModules)) {
+    prompter.log.info("Dependencies already installed");
+  } else {
+    const install = prompter.spinner("Installing dependencies");
+    try {
+      await runNpmInstall(targetDir);
+      install.stop({ kind: "success", message: "Installed dependencies" });
+    } catch {
+      install.stop({ kind: "warning", message: "Dependency install skipped" });
+    }
+  }
+  if (detectEnvKey() === null) {
+    const key = await prompter.text({
+      message: "Paste your CENCORI_API_KEY (optional \u2014 skip with Enter)",
+      mask: true
+    });
+    if (key !== void 0 && key.length > 0) {
+      uncommentEnvLine(join2(targetDir, ".env.local"), "CENCORI_API_KEY", key);
+      process.env.CENCORI_API_KEY = key;
+      prompter.log.success("Wrote CENCORI_API_KEY to .env.local");
+    }
+  }
+  const catalogSpinner = prompter.spinner("Loading model catalog");
+  const catalog = await fetchModelCatalog();
+  catalogSpinner.stop();
+  const modelId = await prompter.searchableSelect({
+    message: "What model would you like to use?",
+    placeholder: "type to filter\u2026",
+    options: catalog.map((model) => ({
+      value: model.id,
+      label: model.name,
+      description: model.provider
+    }))
+  });
+  if (modelId === void 0) return;
+  writeAgentModel(targetDir, modelId);
+  prompter.log.success(`Set model to ${modelId}`);
+  await maybePromptProviderKey(prompter, targetDir, modelId);
+  const diagnostics = checkProviderKeys(targetDir, modelId);
+  if (diagnostics.length > 0) {
+    prompter.section(
+      "Checks",
+      diagnostics.map(
+        (d) => `${d.severity === "info" ? "\u2713" : "\u26A0"} ${d.message}${d.fix ? ` \u2014 ${d.fix}` : ""}`
+      )
+    );
+  }
+  await maybeScaffoldWebChat(prompter, targetDir);
+  const action = await prompter.select({
+    message: "How would you like to continue?",
+    options: [
+      { value: "chat", label: `Start arcie dev \u2014 talk to '${name ?? "."}' in your terminal` },
+      { value: "server", label: "Start arcie dev server" },
+      { value: "code", label: "Open in editor" }
+    ]
+  });
+  if (action === void 0) return;
+  switch (action) {
+    case "chat": {
+      const { devCommand } = await import("./dev-ZZDVOWUZ.js");
+      prompter.stop();
+      await devCommand({ port: "3000", agentDir: targetDir, input: true });
+      break;
+    }
+    case "server": {
+      const { devCommand } = await import("./dev-ZZDVOWUZ.js");
+      prompter.stop();
+      await devCommand({ port: "3000", agentDir: targetDir, input: false });
+      break;
+    }
+    case "code": {
+      prompter.log.info(`cd ${name ?? "."} && code .`);
+      break;
+    }
+  }
+}
+export {
+  initCommand
+};
+//# sourceMappingURL=init-5F7CIVLN.js.map