@hugo.bastidas/agent-foundation 0.1.0 → 0.2.1

package/dist/cli.js

@@ -1,12 +1,1429 @@
 #!/usr/bin/env node
-import { existsSync } from 'node:fs';
-import { writeAgentFoundation, removeAgentFoundation, agentFoundationPath } from './foundation.js';
-import { HOSTS, ALL_HOSTS, parseHosts } from './hosts.js';
-const USAGE = `agent-foundation — install personal agent conventions across AI coding hosts
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/sisteransi/src/index.js
+var require_src = __commonJS({
+  "node_modules/sisteransi/src/index.js"(exports, module) {
+    "use strict";
+    var ESC2 = "\x1B";
+    var CSI2 = `${ESC2}[`;
+    var beep = "\x07";
+    var cursor3 = {
+      to(x, y) {
+        if (!y) return `${CSI2}${x + 1}G`;
+        return `${CSI2}${y + 1};${x + 1}H`;
+      },
+      move(x, y) {
+        let ret = "";
+        if (x < 0) ret += `${CSI2}${-x}D`;
+        else if (x > 0) ret += `${CSI2}${x}C`;
+        if (y < 0) ret += `${CSI2}${-y}A`;
+        else if (y > 0) ret += `${CSI2}${y}B`;
+        return ret;
+      },
+      up: (count = 1) => `${CSI2}${count}A`,
+      down: (count = 1) => `${CSI2}${count}B`,
+      forward: (count = 1) => `${CSI2}${count}C`,
+      backward: (count = 1) => `${CSI2}${count}D`,
+      nextLine: (count = 1) => `${CSI2}E`.repeat(count),
+      prevLine: (count = 1) => `${CSI2}F`.repeat(count),
+      left: `${CSI2}G`,
+      hide: `${CSI2}?25l`,
+      show: `${CSI2}?25h`,
+      save: `${ESC2}7`,
+      restore: `${ESC2}8`
+    };
+    var scroll = {
+      up: (count = 1) => `${CSI2}S`.repeat(count),
+      down: (count = 1) => `${CSI2}T`.repeat(count)
+    };
+    var erase3 = {
+      screen: `${CSI2}2J`,
+      up: (count = 1) => `${CSI2}1J`.repeat(count),
+      down: (count = 1) => `${CSI2}J`.repeat(count),
+      line: `${CSI2}2K`,
+      lineEnd: `${CSI2}K`,
+      lineStart: `${CSI2}1K`,
+      lines(count) {
+        let clear = "";
+        for (let i2 = 0; i2 < count; i2++)
+          clear += this.line + (i2 < count - 1 ? cursor3.up() : "");
+        if (count)
+          clear += cursor3.left;
+        return clear;
+      }
+    };
+    module.exports = { cursor: cursor3, scroll, erase: erase3, beep };
+  }
+});
+
+// src/cli.ts
+import { existsSync as existsSync2 } from "node:fs";
+
+// src/foundation.ts
+import { readFile, writeFile, mkdir, rm } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+var AGENT_FOUNDATION_START = "<!-- >>> agent-foundation >>> -->";
+var AGENT_FOUNDATION_END = "<!-- <<< agent-foundation <<< -->";
+var AGENT_FOUNDATION_FILE = "AGENT_FOUNDATION.md";
+var AGENT_FOUNDATION_INSTRUCTIONS = [
+  "## Agent Foundation",
+  "",
+  "### Code conventions",
+  "",
+  "| Element | Language |",
+  "|---|---|",
+  "| Variables, functions, constants | English |",
+  "| Classes and types | English |",
+  "| File names | English |",
+  "| Inline/block comments | Spanish |",
+  "| User-facing UI text | Spanish unless the project targets a specific locale |",
+  "",
+  "These conventions apply across TypeScript, JavaScript, Python, Astro, CSS, and other stacks.",
+  "",
+  "### Code quality and security",
+  "",
+  "- Write optimal code: avoid redundant logic, unnecessary loops, avoidable re-renders, N+1 queries, and preventable inefficiencies.",
+  "- Write secure code: prevent OWASP Top 10 issues, never hardcode secrets, and validate inputs at system boundaries.",
+  "- Boundary input validation and secret/security controls are required even when the user did not explicitly request them.",
+  "- Prefer simple, direct solutions over premature abstractions.",
+  "- Do not add error handling, validations, or features that were not explicitly requested unless they are necessary for boundary security, data integrity, or safe failure of the requested behavior.",
+  "",
+  "### Documentation lookups",
+  "",
+  "- When current library, framework, SDK, API, CLI, or cloud-service documentation is needed, use the available Context7 MCP/tooling first.",
+  "- If Context7 is unavailable or does not cover the requested technology, use the best available official documentation source.",
+  "- Do not rely on memory alone for version-sensitive syntax, setup, migration, or API behavior.",
+  "",
+  "### Required project structure",
+  "",
+  "Every new or existing project should have:",
+  "",
+  "1. `.env` \u2014 real environment variables, never committed.",
+  "2. `.env.example` \u2014 same keys without sensitive values, committed.",
+  "3. `.gitignore` \u2014 adjusted to the project stack.",
+  "4. Lock file \u2014 commit it (`package-lock.json`, `uv.lock`, `go.sum`, etc.). Never add lock files to `.gitignore`.",
+  "",
+  "The `.gitignore` should include at minimum:",
+  "",
+  "- Node/JS/TS: `node_modules/`, `dist/`, `.env`, `.env.local`, `*.log`",
+  "- Python: `__pycache__/`, `*.pyc`, `.venv/`, `.env`, `dist/`, `*.egg-info/`",
+  "- Astro: Node entries plus `.astro/`",
+  "- General: `.DS_Store`, `Thumbs.db`, `.idea/`, `.vscode/` unless team settings are intentionally shared.",
+  "- AI tool artifacts: `.minimax/runs/`, `.minimax/cli-tests/`, `.minimax/multimodal-tests/`",
+  "",
+  "If these files are missing, tell the user and offer to create them.",
+  "",
+  "### Node.js workflow",
+  "",
+  "Use `npm` by default. Do not switch to yarn, pnpm, or bun unless the project already uses one of them (check for `yarn.lock`, `pnpm-lock.yaml`, or `bun.lockb`). Commit `package-lock.json` \u2014 never gitignore it.",
+  "",
+  "Do not install a package to do something the runtime or an already-present dependency already handles.",
+  "",
+  "### Python workflow",
+  "",
+  "Always use `uv` for Python projects. Use `pyproject.toml` plus `uv.lock` as the default dependency contract, create/update dependencies with `uv add` or `uv remove`, install reproducibly with `uv sync --locked` (or `uv sync --frozen` when the project already standardizes on that flag), and run tools through `uv run` (for example `uv run pytest`, `uv run ruff check .`, `uv run mypy src`, or `uv run python -m package`). Do not introduce raw `pip`, manual `venv` setup, Poetry, Pipenv, or requirements-only workflows unless the user explicitly asks for compatibility with an existing project that already depends on them.",
+  "",
+  "### Testing",
+  "",
+  "Write tests only when explicitly requested or when the project already has a test suite and new code clearly belongs in it. Do not create a test suite from scratch unless asked.",
+  "",
+  "When writing tests:",
+  "- Test observable behavior, not implementation details.",
+  "- Follow the naming and placement convention already used in the project (e.g., `foo.test.ts` next to source, or a `/tests` directory at the project root).",
+  "- Prefer integration-level assertions over mocking internals.",
+  "",
+  "### Git repository initialization",
+  "",
+  "When starting or scaffolding any new project:",
+  "",
+  "1. Verify the directory is a git repository (`git status`). If not, run `git init` immediately before creating any project files.",
+  "2. Verify `.gitignore` exists and covers the project stack (see above). Create or update it before making any commit.",
+  "3. Make the initial commit only after `.gitignore`, `.env.example`, and the main documentation file (`AGENTS.md` or `README.md`) are in place.",
+  "",
+  "If any of these are missing when starting work on a new project, tell the user and offer to create them.",
+  "",
+  "### Git commit conventions",
+  "",
+  "When making commits in any project:",
+  "",
+  "- Use the Conventional Commits format: `type(scope): short description`",
+  "- Write commit title and body bullets in Spanish.",
+  "- Allowed types: `feat`, `fix`, `refactor`, `style`, `chore`, `docs`, `test`, `perf`, `ci`, `build`",
+  "- Keep the title concise (under 72 characters), lowercase, no trailing period.",
+  "- Add a body with bullet points when 3+ files change or changes clearly span different areas.",
+  "- Never include secrets, tokens, keys, or env variable values in commit messages.",
+  "- Always show the proposed message to the user and ask for confirmation before running `git commit`.",
+  "- After committing, ask the user whether to also run `git push`.",
+  "",
+  "Examples:",
+  "",
+  "```",
+  "fix(auth): corregir validaci\xF3n de token expirado",
+  "```",
+  "",
+  "```",
+  "feat(install): agregar componente de alias de shell y selecci\xF3n de hosts",
+  "",
+  "- agregar shell-alias.ts para generar alias mmx en bash/zsh",
+  "- ampliar el instalador con selecci\xF3n m\xFAltiple de hosts Claude",
+  "- expandir estad\xEDsticas de uso con desglose por herramienta",
+  "```",
+  "",
+  "### Required project documentation",
+  "",
+  "All local project documentation files (AGENTS.md, README.md, ARCHITECTURE.md, DESIGN.md) must be written in Spanish. Global sidecars (AGENT_FOUNDATION.md and any other host-level references you have installed) remain in English.",
+  "",
+  "Every new project must include these files at the repository root:",
+  "",
+  '1. `CLAUDE.md` \u2014 keep it free of project content; it only points the agent to `AGENTS.md`. Use a single line such as: "Always read and follow `AGENTS.md` for all project context and instructions."',
+  "2. `AGENTS.md` \u2014 the canonical project brief. It holds the most relevant information: project purpose, stack, run/build/test commands, project-specific constraints, and agent guidance. This is where the real instructions live.",
+  "3. `ARCHITECTURE.md` \u2014 a short, high-level map of the system (see below). Create it once the project has more than a couple of modules.",
+  "4. `DESIGN.md` \u2014 the design-system contract for the UI (see below). **Frontend projects only.**",
+  "",
+  "A project-local `AGENTS.md` must contain ONLY what is unique to that project. Never copy, paraphrase, or summarize sections already provided by global sidecars (`AGENT_FOUNDATION.md` or any other host-level references you have installed).",
+  "",
+  "**Never include in a local AGENTS.md:**",
+  "- Code conventions (variables, comments, file names, UI text language)",
+  "- Code quality or security rules",
+  "- Documentation lookup instructions (Context7, etc.)",
+  "- Required project structure (.env, .gitignore, lock file rules)",
+  "- Node.js or Python workflow rules",
+  "- Git repository initialization steps",
+  "- Git commit conventions or examples",
+  "- Any tool-specific routing or delegation policy (belongs in that tool's own sidecar)",
+  "- Any section that would be identical or near-identical across projects",
+  "",
+  "**A correct local AGENTS.md contains only:**",
+  "- What this project does (1\u20133 sentences)",
+  "- Stack and key dependencies",
+  "- How to build, test, and run the project",
+  "- Project-specific constraints or domain rules not covered globally",
+  "",
+  "When in doubt, omit the section. The global sidecars are always active \u2014 repeating them wastes tokens and creates drift when the global rule changes.",
+  "",
+  "#### ARCHITECTURE.md (keep it to ~1 page; point to code, do not duplicate it)",
+  "",
+  "- Overview: a few sentences on what the system does and its bird's-eye shape.",
+  "- Codemap: name the important modules, files, and types and what each is responsible for. Refer to them by name so symbol search can find them; avoid links that go stale.",
+  '- Invariants: rules that must always hold, especially "absence" rules (e.g. the model layer never imports the view layer).',
+  "- Boundaries: the seams between layers/systems and what each side may assume about the other.",
+  "- Cross-cutting concerns: logging, auth, error handling, configuration \u2014 anything that spans modules.",
+  "- Update it when the coarse structure changes, not on every edit.",
+  "",
+  "#### DESIGN.md (frontend only)",
+  "",
+  "A machine- and human-readable design-system spec so the UI stays consistent (format: github.com/google-labs-code/design.md):",
+  "",
+  "- YAML front matter with design tokens: colors (hex), typography (family, size, weight, line height), spacing scale, radius scale, and components that reference those tokens.",
+  "- Markdown body with the rationale: design philosophy and how/when to apply each token.",
+  "- Recommended sections, in order: Overview, Colors, Typography, Layout, Elevation & Depth, Shapes, Components, Do's and Don'ts.",
+  "- Treat it as the source of truth for styling; generate framework tokens (e.g. Tailwind) from it instead of hardcoding values.",
+  "",
+  "If any required documentation file is missing when starting or scaffolding a project, tell the user and offer to create it."
+].join("\n");
+var LEGACY_CLAUDE_SECTION_PATTERNS = [
+  /## Ruta del usuario\n[\s\S]*?(?=\n## Convenciones de código|\n## Calidad y seguridad del código|\n## Estructura obligatoria de proyectos|\n@RTK\.md|\n<!-- >>> minimax-plugin >>>|$)/g,
+  /## Convenciones de código \(aplican a todos los proyectos\)\n[\s\S]*?(?=\n## Calidad y seguridad del código|\n## Estructura obligatoria de proyectos|\n@RTK\.md|\n<!-- >>> minimax-plugin >>>|$)/g,
+  /## Calidad y seguridad del código\n[\s\S]*?(?=\n## Estructura obligatoria de proyectos|\n@RTK\.md|\n<!-- >>> minimax-plugin >>>|$)/g,
+  /## Estructura obligatoria de proyectos\n[\s\S]*?(?=\n@RTK\.md|\n<!-- >>> minimax-plugin >>>|$)/g
+];
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function normalizeLf(content) {
+  return content.replace(/\r\n/g, "\n");
+}
+function stripManagedAgentFoundation(content) {
+  return normalizeLf(content).replace(
+    new RegExp(`${escapeRegExp(AGENT_FOUNDATION_START)}[\\s\\S]*?${escapeRegExp(AGENT_FOUNDATION_END)}`, "g"),
+    ""
+  ).trim();
+}
+function stripLegacyClaudeSections(content) {
+  return LEGACY_CLAUDE_SECTION_PATTERNS.reduce((current, pattern) => current.replace(pattern, ""), normalizeLf(content)).replace(/\n{3,}/g, "\n\n").trim();
+}
+function instructionReference(filePath) {
+  return `@${resolve(filePath).replace(/\\/g, "/")}`;
+}
+function managedReferenceBlock(targetPath) {
+  return [
+    AGENT_FOUNDATION_START,
+    instructionReference(targetPath),
+    AGENT_FOUNDATION_END
+  ].join("\n");
+}
+function agentFoundationPath(globalInstructionsPath) {
+  return join(dirname(globalInstructionsPath), AGENT_FOUNDATION_FILE);
+}
+async function writeAgentFoundation(filePath) {
+  const targetPath = agentFoundationPath(filePath);
+  let existing = "";
+  try {
+    existing = await readFile(filePath, "utf8");
+  } catch {
+  }
+  const stripped = stripLegacyClaudeSections(stripManagedAgentFoundation(existing));
+  const block2 = managedReferenceBlock(targetPath);
+  const updated = stripped ? `${block2}
+
+${stripped}
+` : `${block2}
+`;
+  await mkdir(dirname(filePath), { recursive: true });
+  await mkdir(dirname(targetPath), { recursive: true });
+  await writeFile(targetPath, `${AGENT_FOUNDATION_INSTRUCTIONS}
+`, "utf8");
+  await writeFile(filePath, updated, "utf8");
+}
+async function removeAgentFoundation(filePath) {
+  let existing = "";
+  try {
+    existing = await readFile(filePath, "utf8");
+  } catch {
+    await rm(agentFoundationPath(filePath), { force: true });
+    return;
+  }
+  const stripped = stripManagedAgentFoundation(existing);
+  await writeFile(filePath, stripped ? `${stripped}
+` : "", "utf8");
+  await rm(agentFoundationPath(filePath), { force: true });
+}
+
+// src/hosts.ts
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+var HOSTS = {
+  claude: { label: "Claude Code", instructions: join2(homedir(), ".claude", "CLAUDE.md") },
+  codex: { label: "Codex", instructions: join2(homedir(), ".codex", "AGENTS.md") },
+  opencode: { label: "OpenCode", instructions: join2(homedir(), ".config", "opencode", "AGENTS.md") },
+  pi: { label: "Pi Agent", instructions: join2(homedir(), ".pi", "agent", "AGENTS.md") }
+};
+var ALL_HOSTS = ["claude", "codex", "opencode", "pi"];
+function parseHosts(value) {
+  if (!value || value === "all") return ALL_HOSTS;
+  const requested = value.split(",").map((host) => host.trim().toLowerCase());
+  const invalid = requested.filter((host) => !(host in HOSTS));
+  if (invalid.length) {
+    throw new Error(`Unknown host(s): ${invalid.join(", ")}. Valid hosts: ${ALL_HOSTS.join(", ")}, all`);
+  }
+  return [...new Set(requested)];
+}
+
+// node_modules/@clack/core/dist/index.mjs
+import { stdout, stdin } from "node:process";
+import l__default from "node:readline";
+
+// node_modules/fast-string-truncated-width/dist/utils.js
+var getCodePointsLength = /* @__PURE__ */ (() => {
+  const SURROGATE_PAIR_RE = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+  return (input) => {
+    let surrogatePairsNr = 0;
+    SURROGATE_PAIR_RE.lastIndex = 0;
+    while (SURROGATE_PAIR_RE.test(input)) {
+      surrogatePairsNr += 1;
+    }
+    return input.length - surrogatePairsNr;
+  };
+})();
+var isFullWidth = (x) => {
+  return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
+};
+var isWideNotCJKTNotEmoji = (x) => {
+  return x === 8987 || x === 9001 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12771 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 19903 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
+};
+
+// node_modules/fast-string-truncated-width/dist/index.js
+var ANSI_RE = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]|\u001b\]8;[^;]*;.*?(?:\u0007|\u001b\u005c)/y;
+var CONTROL_RE = /[\x00-\x08\x0A-\x1F\x7F-\x9F]{1,1000}/y;
+var CJKT_WIDE_RE = /(?:(?![\uFF61-\uFF9F\uFF00-\uFFEF])[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Tangut}]){1,1000}/yu;
+var TAB_RE = /\t{1,1000}/y;
+var EMOJI_RE = new RegExp("[\\u{1F1E6}-\\u{1F1FF}]{2}|\\u{1F3F4}[\\u{E0061}-\\u{E007A}]{2}[\\u{E0030}-\\u{E0039}\\u{E0061}-\\u{E007A}]{1,3}\\u{E007F}|(?:\\p{Emoji}\\uFE0F\\u20E3?|\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation})(?:\\u200D(?:\\p{Emoji_Modifier_Base}\\p{Emoji_Modifier}?|\\p{Emoji_Presentation}|\\p{Emoji}\\uFE0F\\u20E3?))*", "yu");
+var LATIN_RE = /(?:[\x20-\x7E\xA0-\xFF](?!\uFE0F)){1,1000}/y;
+var MODIFIER_RE = new RegExp("\\p{M}+", "gu");
+var NO_TRUNCATION = { limit: Infinity, ellipsis: "" };
+var getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {}) => {
+  const LIMIT = truncationOptions.limit ?? Infinity;
+  const ELLIPSIS = truncationOptions.ellipsis ?? "";
+  const ELLIPSIS_WIDTH = truncationOptions?.ellipsisWidth ?? (ELLIPSIS ? getStringTruncatedWidth(ELLIPSIS, NO_TRUNCATION, widthOptions).width : 0);
+  const ANSI_WIDTH = 0;
+  const CONTROL_WIDTH = widthOptions.controlWidth ?? 0;
+  const TAB_WIDTH = widthOptions.tabWidth ?? 8;
+  const EMOJI_WIDTH = widthOptions.emojiWidth ?? 2;
+  const FULL_WIDTH_WIDTH = 2;
+  const REGULAR_WIDTH = widthOptions.regularWidth ?? 1;
+  const WIDE_WIDTH = widthOptions.wideWidth ?? FULL_WIDTH_WIDTH;
+  const PARSE_BLOCKS = [
+    [LATIN_RE, REGULAR_WIDTH],
+    [ANSI_RE, ANSI_WIDTH],
+    [CONTROL_RE, CONTROL_WIDTH],
+    [TAB_RE, TAB_WIDTH],
+    [EMOJI_RE, EMOJI_WIDTH],
+    [CJKT_WIDE_RE, WIDE_WIDTH]
+  ];
+  let indexPrev = 0;
+  let index = 0;
+  let length = input.length;
+  let lengthExtra = 0;
+  let truncationEnabled = false;
+  let truncationIndex = length;
+  let truncationLimit = Math.max(0, LIMIT - ELLIPSIS_WIDTH);
+  let unmatchedStart = 0;
+  let unmatchedEnd = 0;
+  let width = 0;
+  let widthExtra = 0;
+  outer: while (true) {
+    if (unmatchedEnd > unmatchedStart || index >= length && index > indexPrev) {
+      const unmatched = input.slice(unmatchedStart, unmatchedEnd) || input.slice(indexPrev, index);
+      lengthExtra = 0;
+      for (const char of unmatched.replaceAll(MODIFIER_RE, "")) {
+        const codePoint = char.codePointAt(0) || 0;
+        if (isFullWidth(codePoint)) {
+          widthExtra = FULL_WIDTH_WIDTH;
+        } else if (isWideNotCJKTNotEmoji(codePoint)) {
+          widthExtra = WIDE_WIDTH;
+        } else {
+          widthExtra = REGULAR_WIDTH;
+        }
+        if (width + widthExtra > truncationLimit) {
+          truncationIndex = Math.min(truncationIndex, Math.max(unmatchedStart, indexPrev) + lengthExtra);
+        }
+        if (width + widthExtra > LIMIT) {
+          truncationEnabled = true;
+          break outer;
+        }
+        lengthExtra += char.length;
+        width += widthExtra;
+      }
+      unmatchedStart = unmatchedEnd = 0;
+    }
+    if (index >= length) {
+      break outer;
+    }
+    for (let i2 = 0, l = PARSE_BLOCKS.length; i2 < l; i2++) {
+      const [BLOCK_RE, BLOCK_WIDTH] = PARSE_BLOCKS[i2];
+      BLOCK_RE.lastIndex = index;
+      if (BLOCK_RE.test(input)) {
+        lengthExtra = BLOCK_RE === CJKT_WIDE_RE ? getCodePointsLength(input.slice(index, BLOCK_RE.lastIndex)) : BLOCK_RE === EMOJI_RE ? 1 : BLOCK_RE.lastIndex - index;
+        widthExtra = lengthExtra * BLOCK_WIDTH;
+        if (width + widthExtra > truncationLimit) {
+          truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width) / BLOCK_WIDTH));
+        }
+        if (width + widthExtra > LIMIT) {
+          truncationEnabled = true;
+          break outer;
+        }
+        width += widthExtra;
+        unmatchedStart = indexPrev;
+        unmatchedEnd = index;
+        index = indexPrev = BLOCK_RE.lastIndex;
+        continue outer;
+      }
+    }
+    index += 1;
+  }
+  return {
+    width: truncationEnabled ? truncationLimit : width,
+    index: truncationEnabled ? truncationIndex : length,
+    truncated: truncationEnabled,
+    ellipsed: truncationEnabled && LIMIT >= ELLIPSIS_WIDTH
+  };
+};
+var dist_default = getStringTruncatedWidth;
+
+// node_modules/fast-string-width/dist/index.js
+var NO_TRUNCATION2 = {
+  limit: Infinity,
+  ellipsis: "",
+  ellipsisWidth: 0
+};
+var fastStringWidth = (input, options = {}) => {
+  return dist_default(input, NO_TRUNCATION2, options).width;
+};
+var dist_default2 = fastStringWidth;
+
+// node_modules/fast-wrap-ansi/lib/main.js
+var ESC = "\x1B";
+var CSI = "\x9B";
+var END_CODE = 39;
+var ANSI_ESCAPE_BELL = "\x07";
+var ANSI_CSI = "[";
+var ANSI_OSC = "]";
+var ANSI_SGR_TERMINATOR = "m";
+var ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+var GROUP_REGEX = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`, "y");
+var getClosingCode = (openingCode) => {
+  if (openingCode >= 30 && openingCode <= 37)
+    return 39;
+  if (openingCode >= 90 && openingCode <= 97)
+    return 39;
+  if (openingCode >= 40 && openingCode <= 47)
+    return 49;
+  if (openingCode >= 100 && openingCode <= 107)
+    return 49;
+  if (openingCode === 1 || openingCode === 2)
+    return 22;
+  if (openingCode === 3)
+    return 23;
+  if (openingCode === 4)
+    return 24;
+  if (openingCode === 7)
+    return 27;
+  if (openingCode === 8)
+    return 28;
+  if (openingCode === 9)
+    return 29;
+  if (openingCode === 0)
+    return 0;
+  return void 0;
+};
+var wrapAnsiCode = (code) => `${ESC}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+var wrapAnsiHyperlink = (url) => `${ESC}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`;
+var wrapWord = (rows, word, columns) => {
+  const characters = word[Symbol.iterator]();
+  let isInsideEscape = false;
+  let isInsideLinkEscape = false;
+  let lastRow = rows.at(-1);
+  let visible = lastRow === void 0 ? 0 : dist_default2(lastRow);
+  let currentCharacter = characters.next();
+  let nextCharacter = characters.next();
+  let rawCharacterIndex = 0;
+  while (!currentCharacter.done) {
+    const character = currentCharacter.value;
+    const characterLength = dist_default2(character);
+    if (visible + characterLength <= columns) {
+      rows[rows.length - 1] += character;
+    } else {
+      rows.push(character);
+      visible = 0;
+    }
+    if (character === ESC || character === CSI) {
+      isInsideEscape = true;
+      isInsideLinkEscape = word.startsWith(ANSI_ESCAPE_LINK, rawCharacterIndex + 1);
+    }
+    if (isInsideEscape) {
+      if (isInsideLinkEscape) {
+        if (character === ANSI_ESCAPE_BELL) {
+          isInsideEscape = false;
+          isInsideLinkEscape = false;
+        }
+      } else if (character === ANSI_SGR_TERMINATOR) {
+        isInsideEscape = false;
+      }
+    } else {
+      visible += characterLength;
+      if (visible === columns && !nextCharacter.done) {
+        rows.push("");
+        visible = 0;
+      }
+    }
+    currentCharacter = nextCharacter;
+    nextCharacter = characters.next();
+    rawCharacterIndex += character.length;
+  }
+  lastRow = rows.at(-1);
+  if (!visible && lastRow !== void 0 && lastRow.length && rows.length > 1) {
+    rows[rows.length - 2] += rows.pop();
+  }
+};
+var stringVisibleTrimSpacesRight = (string) => {
+  const words = string.split(" ");
+  let last = words.length;
+  while (last) {
+    if (dist_default2(words[last - 1])) {
+      break;
+    }
+    last--;
+  }
+  if (last === words.length) {
+    return string;
+  }
+  return words.slice(0, last).join(" ") + words.slice(last).join("");
+};
+var exec = (string, columns, options = {}) => {
+  if (options.trim !== false && string.trim() === "") {
+    return "";
+  }
+  let returnValue = "";
+  let escapeCode;
+  let escapeUrl;
+  const words = string.split(" ");
+  let rows = [""];
+  let rowLength = 0;
+  for (let index = 0; index < words.length; index++) {
+    const word = words[index];
+    if (options.trim !== false) {
+      const row = rows.at(-1) ?? "";
+      const trimmed = row.trimStart();
+      if (row.length !== trimmed.length) {
+        rows[rows.length - 1] = trimmed;
+        rowLength = dist_default2(trimmed);
+      }
+    }
+    if (index !== 0) {
+      if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+        rows.push("");
+        rowLength = 0;
+      }
+      if (rowLength || options.trim === false) {
+        rows[rows.length - 1] += " ";
+        rowLength++;
+      }
+    }
+    const wordLength = dist_default2(word);
+    if (options.hard && wordLength > columns) {
+      const remainingColumns = columns - rowLength;
+      const breaksStartingThisLine = 1 + Math.floor((wordLength - remainingColumns - 1) / columns);
+      const breaksStartingNextLine = Math.floor((wordLength - 1) / columns);
+      if (breaksStartingNextLine < breaksStartingThisLine) {
+        rows.push("");
+      }
+      wrapWord(rows, word, columns);
+      rowLength = dist_default2(rows.at(-1) ?? "");
+      continue;
+    }
+    if (rowLength + wordLength > columns && rowLength && wordLength) {
+      if (options.wordWrap === false && rowLength < columns) {
+        wrapWord(rows, word, columns);
+        rowLength = dist_default2(rows.at(-1) ?? "");
+        continue;
+      }
+      rows.push("");
+      rowLength = 0;
+    }
+    if (rowLength + wordLength > columns && options.wordWrap === false) {
+      wrapWord(rows, word, columns);
+      rowLength = dist_default2(rows.at(-1) ?? "");
+      continue;
+    }
+    rows[rows.length - 1] += word;
+    rowLength += wordLength;
+  }
+  if (options.trim !== false) {
+    rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+  }
+  const preString = rows.join("\n");
+  let inSurrogate = false;
+  for (let i2 = 0; i2 < preString.length; i2++) {
+    const character = preString[i2];
+    returnValue += character;
+    if (!inSurrogate) {
+      inSurrogate = character >= "\uD800" && character <= "\uDBFF";
+      if (inSurrogate) {
+        continue;
+      }
+    } else {
+      inSurrogate = false;
+    }
+    if (character === ESC || character === CSI) {
+      GROUP_REGEX.lastIndex = i2 + 1;
+      const groupsResult = GROUP_REGEX.exec(preString);
+      const groups = groupsResult?.groups;
+      if (groups?.code !== void 0) {
+        const code = Number.parseFloat(groups.code);
+        escapeCode = code === END_CODE ? void 0 : code;
+      } else if (groups?.uri !== void 0) {
+        escapeUrl = groups.uri.length === 0 ? void 0 : groups.uri;
+      }
+    }
+    if (preString[i2 + 1] === "\n") {
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink("");
+      }
+      const closingCode = escapeCode ? getClosingCode(escapeCode) : void 0;
+      if (escapeCode && closingCode) {
+        returnValue += wrapAnsiCode(closingCode);
+      }
+    } else if (character === "\n") {
+      if (escapeCode && getClosingCode(escapeCode)) {
+        returnValue += wrapAnsiCode(escapeCode);
+      }
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink(escapeUrl);
+      }
+    }
+  }
+  return returnValue;
+};
+var CRLF_OR_LF = /\r?\n/;
+function wrapAnsi(string, columns, options) {
+  return String(string).normalize().split(CRLF_OR_LF).map((line) => exec(line, columns, options)).join("\n");
+}
+
+// node_modules/@clack/core/dist/index.mjs
+var import_sisteransi = __toESM(require_src(), 1);
+function findCursor(s, o2, l) {
+  if (!l.some((r2) => !r2.disabled))
+    return s;
+  const t2 = s + o2, n2 = Math.max(l.length - 1, 0), e = t2 < 0 ? n2 : t2 > n2 ? 0 : t2;
+  return l[e].disabled ? findCursor(e, o2 < 0 ? -1 : 1, l) : e;
+}
+var a$2 = ["up", "down", "left", "right", "space", "enter", "cancel"];
+var t = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var settings = {
+  actions: new Set(a$2),
+  aliases: /* @__PURE__ */ new Map([
+    // vim support
+    ["k", "up"],
+    ["j", "down"],
+    ["h", "left"],
+    ["l", "right"],
+    ["", "cancel"],
+    // opinionated defaults!
+    ["escape", "cancel"]
+  ]),
+  messages: {
+    cancel: "Canceled",
+    error: "Something went wrong"
+  },
+  withGuide: true,
+  date: {
+    monthNames: [...t],
+    messages: {
+      required: "Please enter a valid date",
+      invalidMonth: "There are only 12 months in a year",
+      invalidDay: (n2, e) => `There are only ${n2} days in ${e}`,
+      afterMin: (n2) => `Date must be on or after ${n2.toISOString().slice(0, 10)}`,
+      beforeMax: (n2) => `Date must be on or before ${n2.toISOString().slice(0, 10)}`
+    }
+  }
+};
+function isActionKey(n2, e) {
+  if (typeof n2 == "string")
+    return settings.aliases.get(n2) === e;
+  for (const s of n2)
+    if (s !== void 0 && isActionKey(s, e))
+      return true;
+  return false;
+}
+function diffLines(i2, s) {
+  if (i2 === s) return;
+  const e = i2.split(`
+`), t2 = s.split(`
+`), r2 = Math.max(e.length, t2.length), f = [];
+  for (let n2 = 0; n2 < r2; n2++)
+    e[n2] !== t2[n2] && f.push(n2);
+  return {
+    lines: f,
+    numLinesBefore: e.length,
+    numLinesAfter: t2.length,
+    numLines: r2
+  };
+}
+var R = globalThis.process.platform.startsWith("win");
+var CANCEL_SYMBOL = /* @__PURE__ */ Symbol("clack:cancel");
+function isCancel(e) {
+  return e === CANCEL_SYMBOL;
+}
+function setRawMode(e, r2) {
+  const o2 = e;
+  o2.isTTY && o2.setRawMode(r2);
+}
+var getColumns = (e) => "columns" in e && typeof e.columns == "number" ? e.columns : 80;
+var getRows = (e) => "rows" in e && typeof e.rows == "number" ? e.rows : 20;
+function wrapTextWithPrefix(e, r2, o2, t2 = o2, s = o2, n2) {
+  const f = getColumns(e ?? stdout);
+  return wrapAnsi(r2, f - o2.length, {
+    hard: true,
+    trim: false
+  }).split(`
+`).map((c2, i2, m) => {
+    const d2 = n2 ? n2(c2, i2) : c2;
+    return i2 === 0 ? `${t2}${d2}` : i2 === m.length - 1 ? `${s}${d2}` : `${o2}${d2}`;
+  }).join(`
+`);
+}
+function runValidation(e, n2) {
+  if ("~standard" in e) {
+    const a3 = e["~standard"].validate(n2);
+    if (a3 instanceof Promise)
+      throw new TypeError(
+        "Schema validation must be synchronous. Update `validate()` and remove any asynchronous logic."
+      );
+    return a3.issues?.at(0)?.message;
+  }
+  return e(n2);
+}
+var V = class {
+  input;
+  output;
+  _abortSignal;
+  rl;
+  opts;
+  _render;
+  _track = false;
+  _prevFrame = "";
+  _subscribers = /* @__PURE__ */ new Map();
+  _cursor = 0;
+  state = "initial";
+  error = "";
+  value;
+  userInput = "";
+  constructor(t2, e = true) {
+    const { input: i2 = stdin, output: n2 = stdout, render: s, signal: r2, ...o2 } = t2;
+    this.opts = o2, this.onKeypress = this.onKeypress.bind(this), this.close = this.close.bind(this), this.render = this.render.bind(this), this._render = s.bind(this), this._track = e, this._abortSignal = r2, this.input = i2, this.output = n2;
+  }
+  /**
+   * Unsubscribe all listeners
+   */
+  unsubscribe() {
+    this._subscribers.clear();
+  }
+  /**
+   * Set a subscriber with opts
+   * @param event - The event name
+   */
+  setSubscriber(t2, e) {
+    const i2 = this._subscribers.get(t2) ?? [];
+    i2.push(e), this._subscribers.set(t2, i2);
+  }
+  /**
+   * Subscribe to an event
+   * @param event - The event name
+   * @param cb - The callback
+   */
+  on(t2, e) {
+    this.setSubscriber(t2, { cb: e });
+  }
+  /**
+   * Subscribe to an event once
+   * @param event - The event name
+   * @param cb - The callback
+   */
+  once(t2, e) {
+    this.setSubscriber(t2, { cb: e, once: true });
+  }
+  /**
+   * Emit an event with data
+   * @param event - The event name
+   * @param data - The data to pass to the callback
+   */
+  emit(t2, ...e) {
+    const i2 = this._subscribers.get(t2) ?? [], n2 = [];
+    for (const s of i2)
+      s.cb(...e), s.once && n2.push(() => i2.splice(i2.indexOf(s), 1));
+    for (const s of n2)
+      s();
+  }
+  prompt() {
+    return new Promise((t2) => {
+      if (this._abortSignal) {
+        if (this._abortSignal.aborted)
+          return this.state = "cancel", this.close(), t2(CANCEL_SYMBOL);
+        this._abortSignal.addEventListener(
+          "abort",
+          () => {
+            this.state = "cancel", this.close();
+          },
+          { once: true }
+        );
+      }
+      this.rl = l__default.createInterface({
+        input: this.input,
+        tabSize: 2,
+        prompt: "",
+        escapeCodeTimeout: 50,
+        terminal: true
+      }), this.rl.prompt(), this.opts.initialUserInput !== void 0 && this._setUserInput(this.opts.initialUserInput, true), this.input.on("keypress", this.onKeypress), setRawMode(this.input, true), this.output.on("resize", this.render), this.render(), this.once("submit", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t2(this.value);
+      }), this.once("cancel", () => {
+        this.output.write(import_sisteransi.cursor.show), this.output.off("resize", this.render), setRawMode(this.input, false), t2(CANCEL_SYMBOL);
+      });
+    });
+  }
+  _isActionKey(t2, e) {
+    return t2 === "	";
+  }
+  _shouldSubmit(t2, e) {
+    return true;
+  }
+  _setValue(t2) {
+    this.value = t2, this.emit("value", this.value);
+  }
+  _setUserInput(t2, e) {
+    this.userInput = t2 ?? "", this.emit("userInput", this.userInput), e && this._track && this.rl && (this.rl.write(this.userInput), this._cursor = this.rl.cursor);
+  }
+  _clearUserInput() {
+    this.rl?.write(null, { ctrl: true, name: "u" }), this._setUserInput("");
+  }
+  onKeypress(t2, e) {
+    if (this._track && e.name !== "return" && (e.name && this._isActionKey(t2, e) && this.rl?.write(null, { ctrl: true, name: "h" }), this._cursor = this.rl?.cursor ?? 0, this._setUserInput(this.rl?.line)), this.state === "error" && (this.state = "active"), e?.name && (!this._track && settings.aliases.has(e.name) && this.emit("cursor", settings.aliases.get(e.name)), settings.actions.has(e.name) && this.emit("cursor", e.name)), t2 && (t2.toLowerCase() === "y" || t2.toLowerCase() === "n") && this.emit("confirm", t2.toLowerCase() === "y"), this.emit("key", t2, e), e?.name === "return" && this._shouldSubmit(t2, e)) {
+      if (this.opts.validate) {
+        const i2 = runValidation(this.opts.validate, this.value);
+        i2 && (this.error = i2 instanceof Error ? i2.message : i2, this.state = "error", this.rl?.write(this.userInput));
+      }
+      this.state !== "error" && (this.state = "submit");
+    }
+    isActionKey([t2, e?.name, e?.sequence], "cancel") && (this.state = "cancel"), (this.state === "submit" || this.state === "cancel") && this.emit("finalize"), this.render(), (this.state === "submit" || this.state === "cancel") && this.close();
+  }
+  close() {
+    this.input.unpipe(), this.input.removeListener("keypress", this.onKeypress), this.output.write(`
+`), setRawMode(this.input, false), this.rl?.close(), this.rl = void 0, this.emit(`${this.state}`, this.value), this.unsubscribe();
+  }
+  restoreCursor() {
+    const t2 = wrapAnsi(this._prevFrame, process.stdout.columns, { hard: true, trim: false }).split(`
+`).length - 1;
+    this.output.write(import_sisteransi.cursor.move(-999, t2 * -1));
+  }
+  render() {
+    const t2 = wrapAnsi(this._render(this) ?? "", process.stdout.columns, {
+      hard: true,
+      trim: false
+    });
+    if (t2 !== this._prevFrame) {
+      if (this.state === "initial")
+        this.output.write(import_sisteransi.cursor.hide);
+      else {
+        const e = diffLines(this._prevFrame, t2), i2 = getRows(this.output);
+        if (this.restoreCursor(), e) {
+          const n2 = Math.max(0, e.numLinesAfter - i2), s = Math.max(0, e.numLinesBefore - i2);
+          let r2 = e.lines.find((o2) => o2 >= n2);
+          if (r2 === void 0) {
+            this._prevFrame = t2;
+            return;
+          }
+          if (e.lines.length === 1) {
+            this.output.write(import_sisteransi.cursor.move(0, r2 - s)), this.output.write(import_sisteransi.erase.lines(1));
+            const o2 = t2.split(`
+`);
+            this.output.write(o2[r2]), this._prevFrame = t2, this.output.write(import_sisteransi.cursor.move(0, o2.length - r2 - 1));
+            return;
+          } else if (e.lines.length > 1) {
+            if (n2 < s)
+              r2 = n2;
+            else {
+              const h2 = r2 - s;
+              h2 > 0 && this.output.write(import_sisteransi.cursor.move(0, h2));
+            }
+            this.output.write(import_sisteransi.erase.down());
+            const f = t2.split(`
+`).slice(r2);
+            this.output.write(f.join(`
+`)), this._prevFrame = t2;
+            return;
+          }
+        }
+        this.output.write(import_sisteransi.erase.down());
+      }
+      this.output.write(t2), this.state === "initial" && (this.state = "active"), this._prevFrame = t2;
+    }
+  }
+};
+var a$1 = class a extends V {
+  options;
+  cursor = 0;
+  get _value() {
+    return this.options[this.cursor].value;
+  }
+  get _enabledOptions() {
+    return this.options.filter((e) => e.disabled !== true);
+  }
+  toggleAll() {
+    const e = this._enabledOptions, i2 = this.value !== void 0 && this.value.length === e.length;
+    this.value = i2 ? [] : e.map((t2) => t2.value);
+  }
+  toggleInvert() {
+    const e = this.value;
+    if (!e)
+      return;
+    const i2 = this._enabledOptions.filter((t2) => !e.includes(t2.value));
+    this.value = i2.map((t2) => t2.value);
+  }
+  toggleValue() {
+    this.value === void 0 && (this.value = []);
+    const e = this.value.includes(this._value);
+    this.value = e ? this.value.filter((i2) => i2 !== this._value) : [...this.value, this._value];
+  }
+  constructor(e) {
+    super(e, false), this.options = e.options, this.value = [...e.initialValues ?? []];
+    const i2 = Math.max(
+      this.options.findIndex(({ value: t2 }) => t2 === e.cursorAt),
+      0
+    );
+    this.cursor = this.options[i2].disabled ? findCursor(i2, 1, this.options) : i2, this.on("key", (t2, l) => {
+      l.name === "a" && this.toggleAll(), l.name === "i" && this.toggleInvert();
+    }), this.on("cursor", (t2) => {
+      switch (t2) {
+        case "left":
+        case "up":
+          this.cursor = findCursor(this.cursor, -1, this.options);
+          break;
+        case "down":
+        case "right":
+          this.cursor = findCursor(this.cursor, 1, this.options);
+          break;
+        case "space":
+          this.toggleValue();
+          break;
+      }
+    });
+  }
+};
+var a2 = class extends V {
+  options;
+  cursor = 0;
+  get _selectedValue() {
+    return this.options[this.cursor];
+  }
+  changeValue() {
+    this.value = this._selectedValue.value;
+  }
+  constructor(t2) {
+    super(t2, false), this.options = t2.options;
+    const i2 = this.options.findIndex(({ value: s }) => s === t2.initialValue), e = i2 === -1 ? 0 : i2;
+    this.cursor = this.options[e].disabled ? findCursor(e, 1, this.options) : e, this.changeValue(), this.on("cursor", (s) => {
+      switch (s) {
+        case "left":
+        case "up":
+          this.cursor = findCursor(this.cursor, -1, this.options);
+          break;
+        case "down":
+        case "right":
+          this.cursor = findCursor(this.cursor, 1, this.options);
+          break;
+      }
+      this.changeValue();
+    });
+  }
+};
+
+// node_modules/@clack/prompts/dist/index.mjs
+import { styleText, stripVTControlCharacters } from "node:util";
+import process$1 from "node:process";
+var import_sisteransi2 = __toESM(require_src(), 1);
+function isUnicodeSupported() {
+  if (process$1.platform !== "win32") {
+    return process$1.env.TERM !== "linux";
+  }
+  return Boolean(process$1.env.CI) || Boolean(process$1.env.WT_SESSION) || Boolean(process$1.env.TERMINUS_SUBLIME) || process$1.env.ConEmuTask === "{cmd::Cmder}" || process$1.env.TERM_PROGRAM === "Terminus-Sublime" || process$1.env.TERM_PROGRAM === "vscode" || process$1.env.TERM === "xterm-256color" || process$1.env.TERM === "alacritty" || process$1.env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+var unicode = isUnicodeSupported();
+var unicodeOr = (e, o2) => unicode ? e : o2;
+var S_STEP_ACTIVE = unicodeOr("\u25C6", "*");
+var S_STEP_CANCEL = unicodeOr("\u25A0", "x");
+var S_STEP_ERROR = unicodeOr("\u25B2", "x");
+var S_STEP_SUBMIT = unicodeOr("\u25C7", "o");
+var S_BAR_START = unicodeOr("\u250C", "T");
+var S_BAR = unicodeOr("\u2502", "|");
+var S_BAR_END = unicodeOr("\u2514", "\u2014");
+var S_BAR_START_RIGHT = unicodeOr("\u2510", "T");
+var S_BAR_END_RIGHT = unicodeOr("\u2518", "\u2014");
+var S_RADIO_ACTIVE = unicodeOr("\u25CF", ">");
+var S_RADIO_INACTIVE = unicodeOr("\u25CB", " ");
+var S_CHECKBOX_ACTIVE = unicodeOr("\u25FB", "[\u2022]");
+var S_CHECKBOX_SELECTED = unicodeOr("\u25FC", "[+]");
+var S_CHECKBOX_INACTIVE = unicodeOr("\u25FB", "[ ]");
+var S_PASSWORD_MASK = unicodeOr("\u25AA", "\u2022");
+var S_BAR_H = unicodeOr("\u2500", "-");
+var S_CORNER_TOP_RIGHT = unicodeOr("\u256E", "+");
+var S_CONNECT_LEFT = unicodeOr("\u251C", "+");
+var S_CORNER_BOTTOM_RIGHT = unicodeOr("\u256F", "+");
+var S_CORNER_BOTTOM_LEFT = unicodeOr("\u2570", "+");
+var S_CORNER_TOP_LEFT = unicodeOr("\u256D", "+");
+var S_INFO = unicodeOr("\u25CF", "\u2022");
+var S_SUCCESS = unicodeOr("\u25C6", "*");
+var S_WARN = unicodeOr("\u25B2", "!");
+var S_ERROR = unicodeOr("\u25A0", "x");
+var symbol = (e) => {
+  switch (e) {
+    case "initial":
+    case "active":
+      return styleText("cyan", S_STEP_ACTIVE);
+    case "cancel":
+      return styleText("red", S_STEP_CANCEL);
+    case "error":
+      return styleText("yellow", S_STEP_ERROR);
+    case "submit":
+      return styleText("green", S_STEP_SUBMIT);
+  }
+};
+var symbolBar = (e) => {
+  switch (e) {
+    case "initial":
+    case "active":
+      return styleText("cyan", S_BAR);
+    case "cancel":
+      return styleText("red", S_BAR);
+    case "error":
+      return styleText("yellow", S_BAR);
+    case "submit":
+      return styleText("green", S_BAR);
+  }
+};
+var E$1 = (l, o2, g, c2, h2, O = false) => {
+  let r2 = o2, w = 0;
+  if (O)
+    for (let i2 = c2 - 1; i2 >= g && (r2 -= l[i2].length, w++, !(r2 <= h2)); i2--)
+      ;
+  else
+    for (let i2 = g; i2 < c2 && (r2 -= l[i2].length, w++, !(r2 <= h2)); i2++)
+      ;
+  return { lineCount: r2, removals: w };
+};
+var limitOptions = ({
+  cursor: l,
+  options: o2,
+  style: g,
+  output: c2 = process.stdout,
+  maxItems: h2 = Number.POSITIVE_INFINITY,
+  columnPadding: O = 0,
+  rowPadding: r2 = 4
+}) => {
+  const i2 = getColumns(c2) - O, I = getRows(c2), C = styleText("dim", "..."), x = Math.max(I - r2, 0), m = Math.max(Math.min(h2, x), 5);
+  let p = 0;
+  l >= m - 3 && (p = Math.max(
+    Math.min(l - m + 3, o2.length - m),
+    0
+  ));
+  let f = m < o2.length && p > 0, u3 = m < o2.length && p + m < o2.length;
+  const W = Math.min(
+    p + m,
+    o2.length
+  ), e = [];
+  let d2 = 0;
+  f && d2++, u3 && d2++;
+  const v = p + (f ? 1 : 0), P = W - (u3 ? 1 : 0);
+  for (let t2 = v; t2 < P; t2++) {
+    const n2 = wrapAnsi(g(o2[t2], t2 === l), i2, {
+      hard: true,
+      trim: false
+    }).split(`
+`);
+    e.push(n2), d2 += n2.length;
+  }
+  if (d2 > x) {
+    let t2 = 0, n2 = 0, s = d2;
+    const M = l - v;
+    let a3 = x;
+    const T = () => E$1(e, s, 0, M, a3), L = () => E$1(
+      e,
+      s,
+      M + 1,
+      e.length,
+      a3,
+      true
+    );
+    f ? ({ lineCount: s, removals: t2 } = T(), s > a3 && (u3 || (a3 -= 1), { lineCount: s, removals: n2 } = L())) : (u3 || (a3 -= 1), { lineCount: s, removals: n2 } = L(), s > a3 && (a3 -= 1, { lineCount: s, removals: t2 } = T())), t2 > 0 && (f = true, e.splice(0, t2)), n2 > 0 && (u3 = true, e.splice(e.length - n2, n2));
+  }
+  const b = [];
+  f && b.push(C);
+  for (const t2 of e)
+    for (const n2 of t2)
+      b.push(n2);
+  return u3 && b.push(C), b;
+};
+var outro = (o2 = "", t2) => {
+  const i2 = t2?.output ?? process.stdout, e = t2?.withGuide ?? settings.withGuide ? `${styleText("gray", S_BAR)}
+${styleText("gray", S_BAR_END)}  ` : "";
+  i2.write(`${e}${o2}
+
+`);
+};
+var d = (n2, a3) => n2.split(`
+`).map((m) => a3(m)).join(`
+`);
+var multiselect = (n2) => {
+  const a3 = (t2, o2) => {
+    const r2 = t2.label ?? String(t2.value);
+    return o2 === "disabled" ? `${styleText("gray", S_CHECKBOX_INACTIVE)} ${d(r2, (l) => styleText(["strikethrough", "gray"], l))}${t2.hint ? ` ${styleText("dim", `(${t2.hint ?? "disabled"})`)}` : ""}` : o2 === "active" ? `${styleText("cyan", S_CHECKBOX_ACTIVE)} ${r2}${t2.hint ? ` ${styleText("dim", `(${t2.hint})`)}` : ""}` : o2 === "selected" ? `${styleText("green", S_CHECKBOX_SELECTED)} ${d(r2, (l) => styleText("dim", l))}${t2.hint ? ` ${styleText("dim", `(${t2.hint})`)}` : ""}` : o2 === "cancelled" ? `${d(r2, (l) => styleText(["strikethrough", "dim"], l))}` : o2 === "active-selected" ? `${styleText("green", S_CHECKBOX_SELECTED)} ${r2}${t2.hint ? ` ${styleText("dim", `(${t2.hint})`)}` : ""}` : o2 === "submitted" ? `${d(r2, (l) => styleText("dim", l))}` : `${styleText("dim", S_CHECKBOX_INACTIVE)} ${d(r2, (l) => styleText("dim", l))}`;
+  }, m = n2.required ?? true;
+  return new a$1({
+    options: n2.options,
+    signal: n2.signal,
+    input: n2.input,
+    output: n2.output,
+    initialValues: n2.initialValues,
+    required: m,
+    cursorAt: n2.cursorAt,
+    validate(t2) {
+      if (m && (t2 === void 0 || t2.length === 0))
+        return `Please select at least one option.
+${styleText(
+          "reset",
+          styleText(
+            "dim",
+            `Press ${styleText(["gray", "bgWhite", "inverse"], " space ")} to select, ${styleText(
+              "gray",
+              styleText("bgWhite", styleText("inverse", " enter "))
+            )} to submit`
+          )
+        )}`;
+    },
+    render() {
+      const t2 = n2.withGuide ?? settings.withGuide, o2 = wrapTextWithPrefix(
+        n2.output,
+        n2.message,
+        t2 ? `${symbolBar(this.state)}  ` : "",
+        `${symbol(this.state)}  `
+      ), r2 = `${t2 ? `${styleText("gray", S_BAR)}
+` : ""}${o2}
+`, l = this.value ?? [], g = (i2, u3) => {
+        if (i2.disabled)
+          return a3(i2, "disabled");
+        const s = l.includes(i2.value);
+        return u3 && s ? a3(i2, "active-selected") : s ? a3(i2, "selected") : a3(i2, u3 ? "active" : "inactive");
+      };
+      switch (this.state) {
+        case "submit": {
+          const i2 = this.options.filter(({ value: s }) => l.includes(s)).map((s) => a3(s, "submitted")).join(styleText("dim", ", ")) || styleText("dim", "none"), u3 = wrapTextWithPrefix(
+            n2.output,
+            i2,
+            t2 ? `${styleText("gray", S_BAR)}  ` : ""
+          );
+          return `${r2}${u3}`;
+        }
+        case "cancel": {
+          const i2 = this.options.filter(({ value: s }) => l.includes(s)).map((s) => a3(s, "cancelled")).join(styleText("dim", ", "));
+          if (i2.trim() === "")
+            return `${r2}${styleText("gray", S_BAR)}`;
+          const u3 = wrapTextWithPrefix(
+            n2.output,
+            i2,
+            t2 ? `${styleText("gray", S_BAR)}  ` : ""
+          );
+          return `${r2}${u3}${t2 ? `
+${styleText("gray", S_BAR)}` : ""}`;
+        }
+        case "error": {
+          const i2 = t2 ? `${styleText("yellow", S_BAR)}  ` : "", u3 = this.error.split(`
+`).map(
+            (h2, x) => x === 0 ? `${t2 ? `${styleText("yellow", S_BAR_END)}  ` : ""}${styleText("yellow", h2)}` : `   ${h2}`
+          ).join(`
+`), s = r2.split(`
+`).length, v = u3.split(`
+`).length + 1;
+          return `${r2}${i2}${limitOptions({
+            output: n2.output,
+            options: this.options,
+            cursor: this.cursor,
+            maxItems: n2.maxItems,
+            columnPadding: i2.length,
+            rowPadding: s + v,
+            style: g
+          }).join(`
+${i2}`)}
+${u3}
+`;
+        }
+        default: {
+          const i2 = t2 ? `${styleText("cyan", S_BAR)}  ` : "", u3 = r2.split(`
+`).length, s = t2 ? 2 : 1;
+          return `${r2}${i2}${limitOptions({
+            output: n2.output,
+            options: this.options,
+            cursor: this.cursor,
+            maxItems: n2.maxItems,
+            columnPadding: i2.length,
+            rowPadding: u3 + s,
+            style: g
+          }).join(`
+${i2}`)}
+${t2 ? styleText("cyan", S_BAR_END) : ""}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var u2 = {
+  light: unicodeOr("\u2500", "-"),
+  heavy: unicodeOr("\u2501", "="),
+  block: unicodeOr("\u2588", "#")
+};
+var c = (e, a3) => e.includes(`
+`) ? e.split(`
+`).map((t2) => a3(t2)).join(`
+`) : a3(e);
+var select = (e) => {
+  const a3 = (t2, d2) => {
+    const s = t2.label ?? String(t2.value);
+    switch (d2) {
+      case "disabled":
+        return `${styleText("gray", S_RADIO_INACTIVE)} ${c(s, (n2) => styleText("gray", n2))}${t2.hint ? ` ${styleText("dim", `(${t2.hint ?? "disabled"})`)}` : ""}`;
+      case "selected":
+        return `${c(s, (n2) => styleText("dim", n2))}`;
+      case "active":
+        return `${styleText("green", S_RADIO_ACTIVE)} ${s}${t2.hint ? ` ${styleText("dim", `(${t2.hint})`)}` : ""}`;
+      case "cancelled":
+        return `${c(s, (n2) => styleText(["strikethrough", "dim"], n2))}`;
+      default:
+        return `${styleText("dim", S_RADIO_INACTIVE)} ${c(s, (n2) => styleText("dim", n2))}`;
+    }
+  };
+  return new a2({
+    options: e.options,
+    signal: e.signal,
+    input: e.input,
+    output: e.output,
+    initialValue: e.initialValue,
+    render() {
+      const t2 = e.withGuide ?? settings.withGuide, d2 = `${symbol(this.state)}  `, s = `${symbolBar(this.state)}  `, n2 = wrapTextWithPrefix(
+        e.output,
+        e.message,
+        s,
+        d2
+      ), u3 = `${t2 ? `${styleText("gray", S_BAR)}
+` : ""}${n2}
+`;
+      switch (this.state) {
+        case "submit": {
+          const r2 = t2 ? `${styleText("gray", S_BAR)}  ` : "", l = wrapTextWithPrefix(
+            e.output,
+            a3(this.options[this.cursor], "selected"),
+            r2
+          );
+          return `${u3}${l}`;
+        }
+        case "cancel": {
+          const r2 = t2 ? `${styleText("gray", S_BAR)}  ` : "", l = wrapTextWithPrefix(
+            e.output,
+            a3(this.options[this.cursor], "cancelled"),
+            r2
+          );
+          return `${u3}${l}${t2 ? `
+${styleText("gray", S_BAR)}` : ""}`;
+        }
+        default: {
+          const r2 = t2 ? `${styleText("cyan", S_BAR)}  ` : "", l = t2 ? styleText("cyan", S_BAR_END) : "", g = u3.split(`
+`).length, h2 = t2 ? 2 : 1;
+          return `${u3}${r2}${limitOptions({
+            output: e.output,
+            cursor: this.cursor,
+            options: this.options,
+            maxItems: e.maxItems,
+            columnPadding: r2.length,
+            rowPadding: g + h2,
+            style: (p, b) => a3(p, p.disabled ? "disabled" : b ? "active" : "inactive")
+          }).join(`
+${r2}`)}
+${l}
+`;
+        }
+      }
+    }
+  }).prompt();
+};
+var i = `${styleText("gray", S_BAR)}  `;
+
+// src/installer.ts
+import { existsSync, mkdirSync } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+var OWL = `
+    ,_,
+   (O,O)
+   (   )
+    " "`;
+function printBanner() {
+  console.log(OWL);
+  console.log(`  agent-foundation v${"0.2.1"}`);
+  console.log("  Install your AI agent conventions\n");
+}
+async function selectHosts() {
+  const result = await multiselect({
+    message: "Target hosts (space to select, enter to confirm)",
+    options: ALL_HOSTS.map((id) => ({ value: id, label: HOSTS[id].label })),
+    required: true
+  });
+  if (isCancel(result)) process.exit(0);
+  return result;
+}
+async function runInstall(hosts) {
+  for (const host of hosts) {
+    const { instructions } = HOSTS[host];
+    const dir = dirname2(instructions);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    await writeAgentFoundation(instructions);
+    console.log(`  \u2713 Installed in ${instructions}`);
+  }
+}
+async function runRemove(hosts) {
+  for (const host of hosts) {
+    await removeAgentFoundation(HOSTS[host].instructions);
+    console.log(`  \u2713 Removed from ${HOSTS[host].instructions}`);
+  }
+}
+function runStatus() {
+  console.table(
+    ALL_HOSTS.map((host) => ({
+      Host: HOSTS[host].label,
+      Instructions: existsSync(HOSTS[host].instructions) ? "yes" : "no",
+      Foundation: existsSync(agentFoundationPath(HOSTS[host].instructions)) ? "installed" : "missing"
+    }))
+  );
+}
+async function runInteractive() {
+  printBanner();
+  const action = await select({
+    message: "Choose an action",
+    options: [
+      { value: "install", label: "Install", hint: "Write AGENT_FOUNDATION.md to selected hosts" },
+      { value: "remove", label: "Remove", hint: "Remove AGENT_FOUNDATION.md from selected hosts" },
+      { value: "status", label: "Status", hint: "Show installation status per host" },
+      { value: "exit", label: "Exit" }
+    ]
+  });
+  if (isCancel(action) || action === "exit") {
+    outro("Goodbye");
+    process.exit(0);
+  }
+  if (action === "status") {
+    runStatus();
+    outro("Done");
+    return;
+  }
+  const hosts = await selectHosts();
+  if (action === "install") await runInstall(hosts);
+  if (action === "remove") await runRemove(hosts);
+  outro("Done");
+}
+
+// src/cli.ts
+var USAGE = `agent-foundation \u2014 install personal agent conventions across AI coding hosts
 
 Usage:
-  agent-foundation install [--host <claude|codex|opencode|all>]
-  agent-foundation remove  [--host <claude|codex|opencode|all>]
+  agent-foundation install [--host <claude|codex|opencode|pi|all>]
+  agent-foundation remove  [--host <claude|codex|opencode|pi|all>]
   agent-foundation status
   agent-foundation --help
 
@@ -14,57 +1431,55 @@ Writes AGENT_FOUNDATION.md next to each host's global instructions file and
 injects a managed @reference block. "remove" deletes both. Default host: all.
 Hosts accept a comma-separated list (e.g. --host claude,codex).`;
 function getHostFlag(args) {
-    const index = args.indexOf('--host');
-    if (index === -1)
-        return undefined;
-    const value = args[index + 1];
-    if (!value || value.startsWith('--'))
-        throw new Error('--host requires a value');
-    return value;
+  const index = args.indexOf("--host");
+  if (index === -1) return void 0;
+  const value = args[index + 1];
+  if (!value || value.startsWith("--")) throw new Error("--host requires a value");
+  return value;
 }
 async function install(hosts) {
-    for (const host of hosts) {
-        await writeAgentFoundation(HOSTS[host].instructions);
-        console.log(`Installed Agent Foundation reference in ${HOSTS[host].instructions}`);
-    }
+  for (const host of hosts) {
+    await writeAgentFoundation(HOSTS[host].instructions);
+    console.log(`Installed Agent Foundation reference in ${HOSTS[host].instructions}`);
+  }
 }
 async function remove(hosts) {
-    for (const host of hosts) {
-        await removeAgentFoundation(HOSTS[host].instructions);
-        console.log(`Removed Agent Foundation reference from ${HOSTS[host].instructions}`);
-    }
+  for (const host of hosts) {
+    await removeAgentFoundation(HOSTS[host].instructions);
+    console.log(`Removed Agent Foundation reference from ${HOSTS[host].instructions}`);
+  }
 }
 function status() {
-    console.table(ALL_HOSTS.map((host) => ({
-        Host: HOSTS[host].label,
-        Instructions: existsSync(HOSTS[host].instructions) ? 'yes' : 'no',
-        Foundation: existsSync(agentFoundationPath(HOSTS[host].instructions)) ? 'installed' : 'missing',
-    })));
+  console.table(ALL_HOSTS.map((host) => ({
+    Host: HOSTS[host].label,
+    Instructions: existsSync2(HOSTS[host].instructions) ? "yes" : "no",
+    Foundation: existsSync2(agentFoundationPath(HOSTS[host].instructions)) ? "installed" : "missing"
+  })));
 }
 async function main() {
-    const [command, ...args] = process.argv.slice(2);
-    if (!command || command === '--help' || command === '-h' || command === 'help') {
-        console.log(USAGE);
-        return;
-    }
-    switch (command) {
-        case 'install':
-            await install(parseHosts(getHostFlag(args)));
-            break;
-        case 'remove':
-            await remove(parseHosts(getHostFlag(args)));
-            break;
-        case 'status':
-            status();
-            break;
-        default:
-            console.error(`Unknown command: ${command}\n`);
-            console.log(USAGE);
-            process.exit(1);
-    }
+  const [command, ...args] = process.argv.slice(2);
+  if (!command || command === "--help" || command === "-h" || command === "help") {
+    await runInteractive();
+    return;
+  }
+  switch (command) {
+    case "install":
+      await install(parseHosts(getHostFlag(args)));
+      break;
+    case "remove":
+      await remove(parseHosts(getHostFlag(args)));
+      break;
+    case "status":
+      status();
+      break;
+    default:
+      console.error(`Unknown command: ${command}
+`);
+      console.log(USAGE);
+      process.exit(1);
+  }
 }
 main().catch((err) => {
-    console.error(err instanceof Error ? err.message : err);
-    process.exit(1);
+  console.error(err instanceof Error ? err.message : err);
+  process.exit(1);
 });
-//# sourceMappingURL=cli.js.map