@warlock.js/ai-cli 0.0.0-stage → 5.31.0

package/esm/cli.mjs

@@ -0,0 +1,61 @@
+import { cliModel } from "./model/cli-model.mjs";
+import { createCliAgent } from "./cli-agent.mjs";
+import { aiderAdapter } from "./adapters/aider.mjs";
+import { ampAdapter } from "./adapters/amp.mjs";
+import { antigravityAdapter } from "./adapters/antigravity.mjs";
+import { claudeCodeAdapter } from "./adapters/claude-code.mjs";
+import { codexAdapter } from "./adapters/codex.mjs";
+import { copilotAdapter } from "./adapters/copilot.mjs";
+import { cursorAdapter } from "./adapters/cursor.mjs";
+import { droidAdapter } from "./adapters/droid.mjs";
+import { grokAdapter } from "./adapters/grok.mjs";
+import { kimiAdapter } from "./adapters/kimi.mjs";
+import { mistralVibeAdapter } from "./adapters/mistral-vibe.mjs";
+import { opencodeAdapter } from "./adapters/opencode.mjs";
+import { qwenCodeAdapter } from "./adapters/qwen-code.mjs";
+import { reasonixAdapter } from "./adapters/reasonix.mjs";
+import { ai } from "@warlock.js/ai";
+
+//#region ../../packages/ai-cli/src/cli.ts
+/** Every built-in adapter, keyed by its factory name. */
+const cliAdapters = {
+	claudeCode: claudeCodeAdapter,
+	codex: codexAdapter,
+	antigravity: antigravityAdapter,
+	qwenCode: qwenCodeAdapter,
+	kimi: kimiAdapter,
+	cursor: cursorAdapter,
+	copilot: copilotAdapter,
+	grok: grokAdapter,
+	opencode: opencodeAdapter,
+	amp: ampAdapter,
+	droid: droidAdapter,
+	mistralVibe: mistralVibeAdapter,
+	aider: aiderAdapter,
+	reasonix: reasonixAdapter
+};
+const factories = Object.fromEntries(Object.entries(cliAdapters).map(([vendor, adapter]) => [vendor, (options) => createCliAgent(adapter, options)]));
+/**
+* The CLI-agent namespace: one factory per vendor, `custom()` for your own
+* adapter, `model()` to hand a CLI agent to `ai.agent`. Also available as
+* `ai.cli` once the package is imported.
+*
+* @example
+* import { cli } from "@warlock.js/ai-cli";
+*
+* const claude = cli.claudeCode({ model: "sonnet", cwd: "/srv/repo" });
+* const session = await claude.run("Fix the failing test");
+* for await (const event of session.events) console.log(event.type);
+* const { text, usage, sessionRef } = await session.done();
+*/
+const cli = {
+	...factories,
+	custom: (adapter, options) => createCliAgent(adapter, options),
+	model: cliModel,
+	adapters: cliAdapters
+};
+ai.cli = cli;
+
+//#endregion
+export { cli, cliAdapters };
+//# sourceMappingURL=cli.mjs.map

package/esm/cli.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.mjs","names":[],"sources":["../../../../../../../packages/ai-cli/src/cli.ts"],"sourcesContent":["import { ai } from \"@warlock.js/ai\";\nimport { aiderAdapter } from \"./adapters/aider\";\nimport { ampAdapter } from \"./adapters/amp\";\nimport { antigravityAdapter } from \"./adapters/antigravity\";\nimport { claudeCodeAdapter } from \"./adapters/claude-code\";\nimport { codexAdapter } from \"./adapters/codex\";\nimport { copilotAdapter } from \"./adapters/copilot\";\nimport { cursorAdapter } from \"./adapters/cursor\";\nimport { droidAdapter } from \"./adapters/droid\";\nimport { grokAdapter } from \"./adapters/grok\";\nimport { kimiAdapter } from \"./adapters/kimi\";\nimport { mistralVibeAdapter } from \"./adapters/mistral-vibe\";\nimport { opencodeAdapter } from \"./adapters/opencode\";\nimport { qwenCodeAdapter } from \"./adapters/qwen-code\";\nimport { reasonixAdapter } from \"./adapters/reasonix\";\nimport { type CliAgent, createCliAgent } from \"./cli-agent\";\nimport type { CliAdapter, CliAgentOptions } from \"./contracts\";\nimport { cliModel } from \"./model/cli-model\";\n\n/** Every built-in adapter, keyed by its factory name. */\nexport const cliAdapters = {\n  claudeCode: claudeCodeAdapter,\n  codex: codexAdapter,\n  antigravity: antigravityAdapter,\n  qwenCode: qwenCodeAdapter,\n  kimi: kimiAdapter,\n  cursor: cursorAdapter,\n  copilot: copilotAdapter,\n  grok: grokAdapter,\n  opencode: opencodeAdapter,\n  amp: ampAdapter,\n  droid: droidAdapter,\n  mistralVibe: mistralVibeAdapter,\n  aider: aiderAdapter,\n  reasonix: reasonixAdapter,\n} as const;\n\n/** Name of a built-in adapter factory. */\nexport type CliVendor = keyof typeof cliAdapters;\n\ntype VendorFactories = { [Vendor in CliVendor]: (options?: CliAgentOptions) => CliAgent };\n\nconst factories = Object.fromEntries(\n  Object.entries(cliAdapters).map(([vendor, adapter]) => [\n    vendor,\n    (options?: CliAgentOptions) => createCliAgent(adapter, options),\n  ]),\n) as VendorFactories;\n\n/**\n * The CLI-agent namespace: one factory per vendor, `custom()` for your own\n * adapter, `model()` to hand a CLI agent to `ai.agent`. Also available as\n * `ai.cli` once the package is imported.\n *\n * @example\n * import { cli } from \"@warlock.js/ai-cli\";\n *\n * const claude = cli.claudeCode({ model: \"sonnet\", cwd: \"/srv/repo\" });\n * const session = await claude.run(\"Fix the failing test\");\n * for await (const event of session.events) console.log(event.type);\n * const { text, usage, sessionRef } = await session.done();\n */\nexport const cli: VendorFactories & {\n  /** A CLI agent for an adapter you wrote. */\n  custom(adapter: CliAdapter, options?: CliAgentOptions): CliAgent;\n  /** A CLI agent as an `ai.agent` model. */\n  model: typeof cliModel;\n  /** The built-in adapters, for inspection or extension. */\n  adapters: typeof cliAdapters;\n} = {\n  ...factories,\n  custom: (adapter, options) => createCliAgent(adapter, options),\n  model: cliModel,\n  adapters: cliAdapters,\n};\n\ndeclare module \"@warlock.js/ai\" {\n  interface Ai {\n    /** Drive vendor coding CLIs (Claude Code, Codex, Copilot, …) as agents. */\n    cli: typeof cli;\n  }\n}\n\n// Runtime registration: importing the package attaches `cli` to the shared `ai` object.\nai.cli = cli;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAoBA,MAAa,cAAc;CACzB,YAAY;CACZ,OAAO;CACP,aAAa;CACb,UAAU;CACV,MAAM;CACN,QAAQ;CACR,SAAS;CACT,MAAM;CACN,UAAU;CACV,KAAK;CACL,OAAO;CACP,aAAa;CACb,OAAO;CACP,UAAU;AACZ;AAOA,MAAM,YAAY,OAAO,YACvB,OAAO,QAAQ,WAAW,CAAC,CAAC,KAAK,CAAC,QAAQ,aAAa,CACrD,SACC,YAA8B,eAAe,SAAS,OAAO,CAChE,CAAC,CACH;;;;;;;;;;;;;;AAeA,MAAa,MAOT;CACF,GAAG;CACH,SAAS,SAAS,YAAY,eAAe,SAAS,OAAO;CAC7D,OAAO;CACP,UAAU;AACZ;AAUA,GAAG,MAAM"}

package/esm/contracts/adapter.contract.d.mts

@@ -0,0 +1,154 @@
+import { CliParsedEvent } from "./events.type.mjs";
+import { CliMcpServers } from "./mcp.type.mjs";
+import { ReasoningEffort } from "@warlock.js/ai";
+
+//#region ../../packages/ai-cli/src/contracts/adapter.contract.d.ts
+/**
+ * Permission mode for a run.
+ *
+ * - `standard` (default) — the CLI's own non-interactive approval rules: tools
+ *   that would need a human approval are refused, never auto-approved.
+ * - `bypass` — every tool call is approved without asking (each vendor's
+ *   "yolo"/"dangerously skip permissions" switch). Opt in per agent or per run.
+ */
+type CliPermission = "standard" | "bypass";
+/**
+ * How the prompt reaches the CLI: as an argv element, written to stdin, or
+ * written to a file in the run directory whose path is passed (for CLIs
+ * with a `--prompt-file` flag).
+ */
+type CliPromptTransport = "argv" | "stdin" | "file";
+/**
+ * Everything an adapter needs to build one launch. Built by the runner;
+ * adapters only read it.
+ */
+type CliLaunchContext = {
+  prompt: string; /** Where the prompt must go for this plan. */
+  transport: CliPromptTransport; /** Absolute working directory of the run. */
+  cwd: string;
+  model?: string; /** Requested reasoning effort; the adapter maps it to the vendor's scale. */
+  effort?: ReasoningEffort;
+  permission: CliPermission; /** Session reference to resume (from a previous `session.started` / `done().sessionRef`). */
+  resume?: string;
+  mcp?: CliMcpServers;
+  /**
+   * The run's API key. The runner already exports it as the adapter's first
+   * `apiKeyEnv` variable; an adapter only reads it when its CLI insists on a
+   * key file (written into a private home, mode 0600).
+   */
+  apiKey?: string;
+  /**
+   * The CLI's config home for this run, or `undefined` when the run uses
+   * the CLI's normal home (`home: "inherit"`).
+   */
+  home?: string;
+  /**
+   * `true` when `home` was created for this run and is deleted afterwards —
+   * the adapter may write home-level config files (for example Codex's
+   * `config.toml`) into it. `false` for a caller-owned or inherited home.
+   */
+  homeIsPrivate: boolean; /** A private directory (mode 0700) for run-scoped files; deleted after the run. */
+  runDir: string;
+  platform: NodeJS.Platform;
+};
+/** A file the runner writes (mode 0600, parent directories 0700) before spawning. */
+type CliLaunchFile = {
+  /** Absolute path, inside `context.runDir` or a private `context.home`. */path: string;
+  content: string;
+};
+/** What an adapter returns for one launch. */
+type CliLaunchPlan = {
+  /** argv after the executable (subcommand and flags). */args: string[];
+  /**
+   * argv that must come last, after any caller `args` — typically the
+   * positional prompt (`transport: "argv"`).
+   */
+  tail?: string[]; /** Text written to stdin before it is closed (the prompt, for `transport: "stdin"`). */
+  stdin?: string; /** Environment the CLI needs on top of the inherited one (config home variables, …). */
+  env?: Record<string, string>; /** Files to write before spawning (MCP config, …). */
+  files?: CliLaunchFile[];
+  /**
+   * The flags (and subcommands) this plan relies on, spelled as `--help`
+   * prints them. The capability probe requires each one; a missing entry
+   * fails the run before anything is spawned.
+   */
+  requires: string[];
+};
+/** How the capability probe reads the CLI's help and version. */
+type CliProbeSpec = {
+  /** Each entry is one help invocation; their outputs are searched together. */help: string[][]; /** Version invocation. */
+  version: string[];
+};
+/** Where an adapter's flags and stream format were verified, recorded per adapter. */
+type CliAdapterVerification = {
+  /** CLI version the adapter was checked against. */version: string; /** `help` — checked against the real `--help` output; `docs` — official docs/source only. */
+  verifiedBy: "help" | "docs"; /** Official documentation / source URLs. */
+  sources: string[]; /** ISO date of the check. */
+  checkedAt: string;
+};
+/**
+ * A stateful parser for one session's stdout. The runner feeds it complete
+ * lines (without the trailing newline) and calls `end()` once stdout closes.
+ */
+type CliStreamParser = {
+  line(line: string): CliParsedEvent[];
+  end(): CliParsedEvent[];
+  /**
+   * The session reference, for CLIs that reveal it only at the end of the
+   * stream (after `session.started` was emitted). Read once the stream
+   * closes; wins over a ref from `session.started`.
+   */
+  sessionRef?(): string | undefined;
+};
+/**
+ * A vendor adapter: the launch plan and the stream parser for one coding
+ * CLI. Implement this to drive a CLI the package does not ship.
+ *
+ * @example
+ * const myCli: CliAdapter = {
+ *   name: "my-cli",
+ *   title: "My CLI",
+ *   command: "my-cli",
+ *   apiKeyEnv: ["MY_CLI_API_KEY"],
+ *   homeEnv: ["MY_CLI_HOME"],
+ *   transports: ["argv"],
+ *   probe: { help: [["--help"]], version: ["--version"] },
+ *   verification: { version: "1.2.0", verifiedBy: "help", sources: ["https://example.com/docs"], checkedAt: "2026-10-17" },
+ *   plan: (context) => ({
+ *     args: ["--print", "--json"],
+ *     tail: [context.prompt],
+ *     env: context.home ? { MY_CLI_HOME: context.home } : undefined,
+ *     requires: ["--print", "--json"],
+ *   }),
+ *   parser: () => jsonLinesParser((record) =>
+ *     record.type === "text" ? [{ type: "message", text: String(record.text), delta: false }] : [],
+ *   ),
+ * };
+ */
+type CliAdapter = {
+  /** Stable id, e.g. `"claude-code"`. Used in errors and as the model provider name. */readonly name: string; /** Human name, e.g. `"Claude Code"`. */
+  readonly title: string; /** Default executable name looked up on `PATH`. */
+  readonly command: string; /** Environment variables that receive an API key (the first is used for the `apiKey` option). */
+  readonly apiKeyEnv: readonly string[];
+  /**
+   * Environment variables pointed at the config home. Empty when the CLI
+   * cannot relocate its config, in which case `home` other than `"inherit"`
+   * is refused for it.
+   */
+  readonly homeEnv: readonly string[]; /** Prompt transports the CLI accepts, in order of preference. */
+  readonly transports: readonly CliPromptTransport[]; /** Whether the adapter maps `effort` to a vendor flag. */
+  readonly effort?: boolean; /** Whether the adapter can attach per-run MCP servers. */
+  readonly mcp?: boolean;
+  readonly probe: CliProbeSpec;
+  readonly verification: CliAdapterVerification;
+  plan(context: CliLaunchContext): CliLaunchPlan;
+  /**
+   * A fresh parser for one session. Receives the launch context of the
+   * chosen plan, so a parser can read a file the CLI writes into
+   * `context.runDir` when its stream ends.
+   */
+  parser(context: CliLaunchContext): CliStreamParser;
+};
+//#endregion
+export { CliAdapter, CliAdapterVerification, CliLaunchContext, CliLaunchFile, CliLaunchPlan, CliPermission, CliProbeSpec, CliPromptTransport, CliStreamParser };
+//# sourceMappingURL=adapter.contract.d.mts.map

package/esm/contracts/adapter.contract.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.contract.d.mts","names":[],"sources":["../../../../../../../../packages/ai-cli/src/contracts/adapter.contract.ts"],"mappings":";;;;;;;AAYA;;;;AAAyB;AAOzB;KAPY,aAAA;;;AAOkB;AAM9B;;KANY,kBAAA;;;;;KAMA,gBAAA;EACV,MAAA,UA+ByB;EA7BzB,SAAA,EAAW,kBAAA,EAAX;EAEA,GAAA;EACA,KAAA;EAEA,MAAA,GAAS,eAAA;EACT,UAAA,EAAY,aAAA,EAAZ;EAEA,MAAA;EACA,GAAA,GAAM,aAAA;EAAN;;;;;EAMA,MAAA;EAcA;;;;EATA,IAAA;EAaU;;;;AAGH;EAVP,aAAA,WAcuB;EAZvB,MAAA;EACA,QAAA,EAAU,MAAA,CAAO,QAAA;AAAA;;KAIP,aAAA;EAkBV,0EAhBA,IAAA;EACA,OAAO;AAAA;;KAIG,aAAA;EAmBF,wDAjBR,IAAA;EAqBsB;;;AAIf;EApBP,IAAA,aAwBgC;EAtBhC,KAAA,WAsBgC;EApBhC,GAAA,GAAM,MAAA,kBAwBN;EAtBA,KAAA,GAAQ,aAAa;EA0BrB;;AAAS;AAOX;;EA3BE,QAAA;AAAA;;KAIU,YAAA;EAwBU,8EAtBpB,IAAA,cAuBO;EArBP,OAAO;AAAA;AA2BG;AAAA,KAvBA,sBAAA;EAmDU,mDAjDpB,OAAA,UAiE8B;EA/D9B,UAAA,mBAqEuB;EAnEvB,OAAA,YAoEiC;EAlEjC,SAAA;AAAA;;;;;KAOU,eAAA;EACV,IAAA,CAAK,IAAA,WAAe,cAAA;EACpB,GAAA,IAAO,cAAc;EAkDZ;;;;;EA5CT,UAAA;AAAA;;;;;;;;;;;AAyDkD;;;;;;;;;;;;;;;KA7BxC,UAAA;iGAED,IAAA;WAEA,KAAA;WAEA,OAAA;WAEA,SAAA;;;;;;WAMA,OAAA;WAEA,UAAA,WAAqB,kBAAA;WAErB,MAAA;WAEA,GAAA;EAAA,SACA,KAAA,EAAO,YAAA;EAAA,SACP,YAAA,EAAc,sBAAA;EACvB,IAAA,CAAK,OAAA,EAAS,gBAAA,GAAmB,aAAA;;;;;;EAMjC,MAAA,CAAO,OAAA,EAAS,gBAAA,GAAmB,eAAA;AAAA"}

package/esm/contracts/events.type.d.mts

@@ -0,0 +1,111 @@
+//#region ../../packages/ai-cli/src/contracts/events.type.d.ts
+/**
+ * Token usage a CLI session reported, normalized across vendors.
+ *
+ * Every field except `input`/`output`/`total` is optional because vendors
+ * report different subsets: Claude Code reports cache reads/writes and a
+ * USD cost, Codex reports cached and reasoning tokens, Aider reports a
+ * cost line, some CLIs report nothing at all.
+ *
+ * @example
+ * const usage: CliUsage = { input: 1200, output: 340, total: 1540, cachedTokens: 800 };
+ */
+type CliUsage = {
+  /** Input/prompt tokens (includes `cachedTokens` when the vendor counts them together). */input: number; /** Output/completion tokens. */
+  output: number; /** `input + output`. */
+  total: number; /** Input tokens served from the vendor's prompt cache. */
+  cachedTokens?: number; /** Input tokens written to the vendor's prompt cache. */
+  cacheWriteTokens?: number; /** Output tokens spent on reasoning, when the vendor reports them. */
+  reasoningTokens?: number; /** Cost in USD as reported by the CLI itself (never computed by this package). */
+  costUSD?: number;
+};
+/**
+ * How a CLI session ended.
+ *
+ * - `completed` — the process exited 0 and the stream reported no fatal error.
+ * - `failed` — non-zero exit, a spawn failure, or a fatal error in the stream.
+ * - `cancelled` — the run's `signal` aborted (or `session.cancel()` was called).
+ * - `timeout` — `timeoutMs` elapsed and the process tree was killed.
+ */
+type CliEndStatus = "completed" | "failed" | "cancelled" | "timeout";
+/** A session started; carries the vendor's session/thread id when it reported one. */
+type CliSessionStartedEvent = {
+  type: "session.started"; /** Reference to pass back as `resume` to continue this session. */
+  sessionRef?: string; /** Model the CLI reported it is using. */
+  model?: string; /** The vendor's original record, for debugging. */
+  raw?: unknown;
+};
+/**
+ * Assistant text. `delta: true` is a streamed fragment of the message being
+ * written; `delta: false` is a complete message. `final: true` marks the
+ * vendor's own "final answer" record (for example Claude Code's `result`).
+ */
+type CliMessageEvent = {
+  type: "message";
+  text: string;
+  delta: boolean;
+  final?: boolean;
+  raw?: unknown;
+};
+/** The CLI invoked one of its tools (or an MCP tool). */
+type CliToolCallEvent = {
+  type: "tool.call"; /** Vendor call id, used to pair the call with its `tool.result`. */
+  id: string;
+  name: string;
+  input: unknown;
+  raw?: unknown;
+};
+/** A tool finished. `output` is the tool's text output (stringified when structured). */
+type CliToolResultEvent = {
+  type: "tool.result";
+  id: string;
+  output: string;
+  isError: boolean;
+  raw?: unknown;
+};
+/**
+ * Token usage. `cumulative: true` replaces the running total (the vendor
+ * reported totals for the whole session so far); `cumulative: false` adds
+ * to it (the vendor reported one turn).
+ */
+type CliUsageEvent = {
+  type: "usage";
+  usage: CliUsage;
+  cumulative: boolean;
+  raw?: unknown;
+};
+/**
+ * Something went wrong. `fatal: true` means the vendor reported the run as
+ * failed; the session then ends `failed` even when the process exits 0.
+ */
+type CliErrorEvent = {
+  type: "error";
+  message: string;
+  fatal?: boolean;
+  raw?: unknown;
+};
+/** The process exited and the stream is drained. Always the last event. */
+type CliSessionEndedEvent = {
+  type: "session.ended";
+  status: CliEndStatus; /** Process exit code; `null` when the process never started or died by signal. */
+  exitCode: number | null; /** Terminating signal, when the process died by one. */
+  signal: string | null;
+  sessionRef?: string;
+  durationMs: number;
+};
+/**
+ * The unified event model every adapter's stream is reduced to.
+ * Discriminate on `type`.
+ *
+ * @example
+ * for await (const event of session.events) {
+ *   if (event.type === "message" && event.delta) process.stdout.write(event.text);
+ *   if (event.type === "tool.call") console.log("→", event.name, event.input);
+ * }
+ */
+type CliEvent = CliSessionStartedEvent | CliMessageEvent | CliToolCallEvent | CliToolResultEvent | CliUsageEvent | CliErrorEvent | CliSessionEndedEvent;
+/** Events an adapter's stream parser may emit (`session.ended` is emitted by the runner). */
+type CliParsedEvent = Exclude<CliEvent, CliSessionEndedEvent>;
+//#endregion
+export { CliEndStatus, CliErrorEvent, CliEvent, CliMessageEvent, CliParsedEvent, CliSessionEndedEvent, CliSessionStartedEvent, CliToolCallEvent, CliToolResultEvent, CliUsage, CliUsageEvent };
+//# sourceMappingURL=events.type.d.mts.map

package/esm/contracts/events.type.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.type.d.mts","names":[],"sources":["../../../../../../../../packages/ai-cli/src/contracts/events.type.ts"],"mappings":";;AAWA;;;;;;;;;;KAAY,QAAA;EAcH,0FAZP,KAAA,UAuBU;EArBV,MAAA;EAEA,KAAA,UAmBsB;EAjBtB,YAAA,WAoBgC;EAlBhC,gBAAA,WAkBgC;EAhBhC,eAAA,WAmBA;EAjBA,OAAA;AAAA;;AAqBG;AAQL;;;;;;KAlBY,YAAA;;KAGA,sBAAA;EACV,IAAA,qBAmBG;EAjBH,UAAA,WAqB0B;EAnB1B,KAAA,WAmB0B;EAjB1B,GAAA;AAAA;;;;;AAuBG;KAfO,eAAA;EACV,IAAA;EACA,IAAA;EACA,KAAA;EACA,KAAA;EACA,GAAA;AAAA;;KAIU,gBAAA;EACV,IAAA,eAcG;EAZH,EAAA;EACA,IAAA;EACA,KAAA;EACA,GAAA;AAAA;;KAIU,kBAAA;EACV,IAAA;EACA,EAAA;EACA,MAAA;EACA,OAAA;EACA,GAAA;AAAA;;;;;;KAQU,aAAA;EACV,IAAA;EACA,KAAA,EAAO,QAAQ;EACf,UAAA;EACA,GAAA;AAAA;;;;;KAOU,aAAA;EACV,IAAA;EACA,OAAA;EACA,KAAA;EACA,GAAA;AAAA;AAyBF;AAAA,KArBY,oBAAA;EACV,IAAA;EACA,MAAA,EAAQ,YAAY,EAqBlB;EAnBF,QAAA,iBAqBE;EAnBF,MAAA;EACA,UAAA;EACA,UAAA;AAAA;;;;;;;;;;AAoBsB;KAPZ,QAAA,GACR,sBAAA,GACA,eAAA,GACA,gBAAA,GACA,kBAAA,GACA,aAAA,GACA,aAAA,GACA,oBAAA;;KAGQ,cAAA,GAAiB,OAAA,CAAQ,QAAA,EAAU,oBAAA"}

package/esm/contracts/index.d.mts

@@ -0,0 +1,4 @@
+import { CliEndStatus, CliErrorEvent, CliEvent, CliMessageEvent, CliParsedEvent, CliSessionEndedEvent, CliSessionStartedEvent, CliToolCallEvent, CliToolResultEvent, CliUsage, CliUsageEvent } from "./events.type.mjs";
+import { CliMcpRemoteServer, CliMcpServer, CliMcpServers, CliMcpStdioServer } from "./mcp.type.mjs";
+import { CliAdapter, CliAdapterVerification, CliLaunchContext, CliLaunchFile, CliLaunchPlan, CliPermission, CliProbeSpec, CliPromptTransport, CliStreamParser } from "./adapter.contract.mjs";
+import { CliAgentOptions, CliHome, CliProbeResult, CliResult, CliRunOptions, CliSession } from "./options.type.mjs";

package/esm/contracts/mcp.type.d.mts

@@ -0,0 +1,29 @@
+//#region ../../packages/ai-cli/src/contracts/mcp.type.d.ts
+/**
+ * An MCP server started by the CLI as a child process (stdio transport).
+ * `env` values usually hold tokens — they are written only into a 0600
+ * config file inside the run's private directory, never into argv.
+ */
+type CliMcpStdioServer = {
+  type: "stdio";
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+};
+/**
+ * A remote MCP server (streamable HTTP, or the older SSE transport).
+ * `headers` usually hold an `Authorization` token — written only into the
+ * run's 0600 config file, never into argv.
+ */
+type CliMcpRemoteServer = {
+  type: "http" | "sse";
+  url: string;
+  headers?: Record<string, string>;
+};
+/** One MCP server, in the vendor-neutral shape every adapter renders to its own config format. */
+type CliMcpServer = CliMcpStdioServer | CliMcpRemoteServer;
+/** MCP servers for a run, keyed by the server name the CLI will show. */
+type CliMcpServers = Record<string, CliMcpServer>;
+//#endregion
+export { CliMcpRemoteServer, CliMcpServer, CliMcpServers, CliMcpStdioServer };
+//# sourceMappingURL=mcp.type.d.mts.map

package/esm/contracts/mcp.type.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.type.d.mts","names":[],"sources":["../../../../../../../../packages/ai-cli/src/contracts/mcp.type.ts"],"mappings":";;AAKA;;;;KAAY,iBAAA;EACV,IAAA;EACA,OAAA;EACA,IAAA;EACA,GAAA,GAAM,MAAM;AAAA;AAAA;AAQd;;;;AARc,KAQF,kBAAA;EACV,IAAA;EACA,GAAA;EACA,OAAA,GAAU,MAAM;AAAA;AAAA;AAAA,KAIN,YAAA,GAAe,iBAAA,GAAoB,kBAAkB;;KAGrD,aAAA,GAAgB,MAAM,SAAS,YAAA"}

package/esm/contracts/options.type.d.mts

@@ -0,0 +1,87 @@
+import { CliEndStatus, CliEvent, CliUsage } from "./events.type.mjs";
+import { CliMcpServers } from "./mcp.type.mjs";
+import { CliPermission } from "./adapter.contract.mjs";
+import { ReasoningEffort } from "@warlock.js/ai";
+
+//#region ../../packages/ai-cli/src/contracts/options.type.d.ts
+/**
+ * Where the CLI keeps its config for a run.
+ *
+ * - `"private"` (default) — a fresh directory (mode 0700) created for the run
+ *   and deleted after it. Nothing from your own login leaks in or out;
+ *   authenticate with `apiKey` / `env`.
+ * - an absolute path — a home you own and keep (for example one you logged
+ *   in to once with `CLAUDE_CONFIG_DIR=/srv/claude claude`). The adapter
+ *   points its home variable at it; run-scoped files still go to a private
+ *   per-run directory.
+ * - `"inherit"` — the CLI's normal home of the current user.
+ */
+type CliHome = "private" | "inherit" | (string & {});
+/** Options shared by a CLI agent's defaults and a single run. */
+type CliRunOptions = {
+  /** Working directory of the run. Default: `process.cwd()`. */cwd?: string; /** Session reference to resume (`done().sessionRef` of an earlier run). */
+  resume?: string; /** Cancels the run and kills the CLI's whole process tree. */
+  signal?: AbortSignal; /** Kills the process tree after this many milliseconds (status `timeout`). */
+  timeoutMs?: number; /** Vendor model id or alias, passed to the CLI's model flag. */
+  model?: string; /** Reasoning effort, mapped to the vendor's scale. Refused for CLIs without an effort control. */
+  effort?: ReasoningEffort; /** `"standard"` (default) or `"bypass"` (approve every tool call — opt in only). */
+  permission?: CliPermission; /** Per-run MCP servers, written to a 0600 config file — never argv. */
+  mcp?: CliMcpServers; /** Extra environment for the CLI (wins over inherited variables). */
+  env?: Record<string, string>; /** API key, exported as the adapter's first `apiKeyEnv` variable. Never placed in argv. */
+  apiKey?: string; /** Extra argv appended after the adapter's own flags. Do not put secrets here. */
+  args?: string[];
+};
+/** Configuration of a CLI agent (`cli.claudeCode({...})`). */
+type CliAgentOptions = CliRunOptions & {
+  /** Executable to run instead of the adapter's default (a name on `PATH` or an absolute path). */command?: string; /** Config home. Default `"private"`. */
+  home?: CliHome;
+  /**
+   * Which of the current process's environment variables the CLI inherits.
+   * `true` (default) inherits everything except the adapter's own home
+   * variables; `false` passes only a minimal system set (PATH, HOME, TEMP,
+   * locale, proxy and Windows system variables); a list passes the minimal
+   * set plus those names.
+   */
+  inheritEnv?: boolean | string[];
+  /**
+   * Run the capability probe (`--help`/`--version`) before the first run.
+   * Default `true`. Turning it off skips the flag check — a CLI version
+   * whose flags changed then fails at run time instead of up front.
+   */
+  probe?: boolean; /** Grace period between SIGTERM and SIGKILL when a run is cancelled (POSIX). Default 2000 ms. */
+  killGraceMs?: number;
+};
+/** What `session.done()` resolves to. */
+type CliResult = {
+  status: CliEndStatus; /** The final answer: the vendor's final record, else the last assistant message. */
+  text: string; /** Every complete assistant message, in order. */
+  messages: string[]; /** Accumulated usage, or `undefined` when the CLI reported none. */
+  usage?: CliUsage; /** Pass as `resume` to continue this session. */
+  sessionRef?: string;
+  exitCode: number | null;
+  signal: string | null; /** First fatal error, or a summary of stderr when the run failed. */
+  error?: string; /** The last 64 KiB of stderr. */
+  stderr: string;
+  durationMs: number;
+};
+/** A running CLI session. */
+type CliSession = {
+  /** Adapter name, e.g. `"claude-code"`. */readonly adapter: string; /** Process id of the spawned CLI. */
+  readonly pid: number | undefined;
+  /**
+   * The normalized event stream. Every iteration replays from the first
+   * event, so several consumers may read it; it ends after `session.ended`.
+   */
+  readonly events: AsyncIterable<CliEvent>; /** Resolves once the process exits and the stream is drained. Never rejects. */
+  done(): Promise<CliResult>; /** Cancel the run (kills the process tree); `done()` then resolves `cancelled`. */
+  cancel(): void;
+};
+/** Result of the capability probe. */
+type CliProbeResult = {
+  /** Resolved executable path. */executable: string; /** First version-looking token of `--version`, or the trimmed output. */
+  version: string; /** Concatenated help output the required flags are checked against. */
+  help: string;
+};
+//#endregion
+export { CliAgentOptions, CliHome, CliProbeResult, CliResult, CliRunOptions, CliSession };
+//# sourceMappingURL=options.type.d.mts.map

package/esm/contracts/options.type.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.type.d.mts","names":[],"sources":["../../../../../../../../packages/ai-cli/src/contracts/options.type.ts"],"mappings":";;;;;;;;AAiBA;;;;AAAmB;AAGnB;;;;;KAHY,OAAA;;KAGA,aAAA;EAkBE,8DAhBZ,GAAA;EAEA,MAAA,WAEA;EAAA,MAAA,GAAS,WAAA,EAET;EAAA,SAAA,WAIA;EAFA,KAAA,WAIA;EAFA,MAAA,GAAS,eAAA,EAIT;EAFA,UAAA,GAAa,aAAA,EAIb;EAFA,GAAA,GAAM,aAAA,EAIN;EAFA,GAAA,GAAM,MAAA,kBAIF;EAFJ,MAAA,WAMU;EAJV,IAAA;AAAA;;KAIU,eAAA,GAAkB,aAAA;EAE5B,iGAAA,OAAA,WAEO;EAAP,IAAA,GAAO,OAAO;EAcd;;;AAEW;AAIb;;;EAZE,UAAA;EAaA;;;;;EAPA,KAAA,YAeA;EAbA,WAAA;AAAA;;KAIU,SAAA;EACV,MAAA,EAAQ,YAAA,EAeE;EAbV,IAAA,UAiBU;EAfV,QAAA;EAEA,KAAA,GAAQ,QAAQ,EAsBC;EApBjB,UAAA;EACA,QAAA;EACA,MAAA,iBAoBe;EAlBf,KAAA,WAWS;EATT,MAAA;EACA,UAAA;AAAA;;KAIU,UAAA;EAWM,mDATP,OAAA,UAWH;EAAA,SATG,GAAA;EAaC;;;;EAAA,SARD,MAAA,EAAQ,aAAA,CAAc,QAAA,GAY/B;EAVA,IAAA,IAAQ,OAAA,CAAQ,SAAA,GAYZ;EAVJ,MAAA;AAAA;;KAIU,cAAA;kCAEV,UAAA;EAEA,OAAA;EAEA,IAAA;AAAA"}

package/esm/errors.d.mts

@@ -0,0 +1,46 @@
+import { AIErrorOptions, ProviderError } from "@warlock.js/ai";
+
+//#region ../../packages/ai-cli/src/errors.d.ts
+/**
+ * Why a CLI agent refused or failed a run.
+ *
+ * - `not-found` — the executable is not on `PATH` (or the given path does not exist).
+ * - `capability` — the installed CLI's `--help` does not list a flag the run needs.
+ * - `probe-failed` — `--help`/`--version` could not be run.
+ * - `unsupported-option` — the adapter has no way to honour an option (effort, MCP, home, …).
+ * - `prompt-transport` — the prompt fits neither argv nor stdin for this CLI and platform.
+ * - `run-failed` — the session ended `failed` or `timeout` (raised by the model adapter).
+ */
+type CliErrorType = "not-found" | "capability" | "probe-failed" | "unsupported-option" | "prompt-transport" | "run-failed";
+type CliErrorOptions = AIErrorOptions & {
+  type: CliErrorType; /** Adapter name, e.g. `"codex"`. */
+  adapter: string; /** The missing flag, for `capability`. */
+  flag?: string; /** Detected CLI version, when known. */
+  version?: string; /** Resolved executable, when known. */
+  executable?: string;
+};
+/**
+ * A CLI agent error. Extends the framework `ProviderError`, so agents,
+ * fallbacks and observers treat it like any other provider failure; branch
+ * on `error.type` for the specific reason.
+ *
+ * @example
+ * try {
+ *   await claude.run("hi");
+ * } catch (error) {
+ *   if (error instanceof CliError && error.type === "capability") {
+ *     console.error(`Upgrade ${error.adapter}: missing ${error.flag} in ${error.version}`);
+ *   }
+ * }
+ */
+declare class CliError extends ProviderError {
+  readonly type: CliErrorType;
+  readonly adapter: string;
+  readonly flag?: string;
+  readonly version?: string;
+  readonly executable?: string;
+  constructor(message: string, options: CliErrorOptions);
+}
+//#endregion
+export { CliError, CliErrorOptions, CliErrorType };
+//# sourceMappingURL=errors.d.mts.map

package/esm/errors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.mts","names":[],"sources":["../../../../../../../packages/ai-cli/src/errors.ts"],"mappings":";;;;;AAYA;;;;AAAwB;AAQxB;;;KARY,YAAA;AAAA,KAQA,eAAA,GAAkB,cAAA;EAC5B,IAAA,EAAM,YAAY,EAAZ;EAEN,OAAA,UAEA;EAAA,IAAA,WAIA;EAFA,OAAA,WAEU;EAAV,UAAA;AAAA;;;;;;;;;;;;;;;cAiBW,QAAA,SAAiB,aAAA;EAAA,SACZ,IAAA,EAAM,YAAA;EAAA,SACN,OAAA;EAAA,SACA,IAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA;cAEG,OAAA,UAAiB,OAAA,EAAS,eAAA;AAAA"}

package/esm/errors.mjs

@@ -0,0 +1,32 @@
+import { ProviderError } from "@warlock.js/ai";
+
+//#region ../../packages/ai-cli/src/errors.ts
+/**
+* A CLI agent error. Extends the framework `ProviderError`, so agents,
+* fallbacks and observers treat it like any other provider failure; branch
+* on `error.type` for the specific reason.
+*
+* @example
+* try {
+*   await claude.run("hi");
+* } catch (error) {
+*   if (error instanceof CliError && error.type === "capability") {
+*     console.error(`Upgrade ${error.adapter}: missing ${error.flag} in ${error.version}`);
+*   }
+* }
+*/
+var CliError = class extends ProviderError {
+	constructor(message, options) {
+		super(message, options, options.type === "unsupported-option" || options.type === "prompt-transport" ? "PROVIDER_INVALID_REQUEST" : "PROVIDER_ERROR");
+		this.name = "CliError";
+		this.type = options.type;
+		this.adapter = options.adapter;
+		this.flag = options.flag;
+		this.version = options.version;
+		this.executable = options.executable;
+	}
+};
+
+//#endregion
+export { CliError };
+//# sourceMappingURL=errors.mjs.map

package/esm/errors.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.mjs","names":[],"sources":["../../../../../../../packages/ai-cli/src/errors.ts"],"sourcesContent":["import { type AIErrorOptions, ProviderError } from \"@warlock.js/ai\";\n\n/**\n * Why a CLI agent refused or failed a run.\n *\n * - `not-found` — the executable is not on `PATH` (or the given path does not exist).\n * - `capability` — the installed CLI's `--help` does not list a flag the run needs.\n * - `probe-failed` — `--help`/`--version` could not be run.\n * - `unsupported-option` — the adapter has no way to honour an option (effort, MCP, home, …).\n * - `prompt-transport` — the prompt fits neither argv nor stdin for this CLI and platform.\n * - `run-failed` — the session ended `failed` or `timeout` (raised by the model adapter).\n */\nexport type CliErrorType =\n  | \"not-found\"\n  | \"capability\"\n  | \"probe-failed\"\n  | \"unsupported-option\"\n  | \"prompt-transport\"\n  | \"run-failed\";\n\nexport type CliErrorOptions = AIErrorOptions & {\n  type: CliErrorType;\n  /** Adapter name, e.g. `\"codex\"`. */\n  adapter: string;\n  /** The missing flag, for `capability`. */\n  flag?: string;\n  /** Detected CLI version, when known. */\n  version?: string;\n  /** Resolved executable, when known. */\n  executable?: string;\n};\n\n/**\n * A CLI agent error. Extends the framework `ProviderError`, so agents,\n * fallbacks and observers treat it like any other provider failure; branch\n * on `error.type` for the specific reason.\n *\n * @example\n * try {\n *   await claude.run(\"hi\");\n * } catch (error) {\n *   if (error instanceof CliError && error.type === \"capability\") {\n *     console.error(`Upgrade ${error.adapter}: missing ${error.flag} in ${error.version}`);\n *   }\n * }\n */\nexport class CliError extends ProviderError {\n  public readonly type: CliErrorType;\n  public readonly adapter: string;\n  public readonly flag?: string;\n  public readonly version?: string;\n  public readonly executable?: string;\n\n  public constructor(message: string, options: CliErrorOptions) {\n    super(\n      message,\n      options,\n      options.type === \"unsupported-option\" || options.type === \"prompt-transport\"\n        ? \"PROVIDER_INVALID_REQUEST\"\n        : \"PROVIDER_ERROR\",\n    );\n\n    this.name = \"CliError\";\n    this.type = options.type;\n    this.adapter = options.adapter;\n    this.flag = options.flag;\n    this.version = options.version;\n    this.executable = options.executable;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA8CA,IAAa,WAAb,cAA8B,cAAc;CAO1C,AAAO,YAAY,SAAiB,SAA0B;EAC5D,MACE,SACA,SACA,QAAQ,SAAS,wBAAwB,QAAQ,SAAS,qBACtD,6BACA,gBACN;EAEA,KAAK,OAAO;EACZ,KAAK,OAAO,QAAQ;EACpB,KAAK,UAAU,QAAQ;EACvB,KAAK,OAAO,QAAQ;EACpB,KAAK,UAAU,QAAQ;EACvB,KAAK,aAAa,QAAQ;CAC5B;AACF"}

package/esm/index.d.mts

@@ -0,0 +1,31 @@
+import { CliEndStatus, CliErrorEvent, CliEvent, CliMessageEvent, CliParsedEvent, CliSessionEndedEvent, CliSessionStartedEvent, CliToolCallEvent, CliToolResultEvent, CliUsage, CliUsageEvent } from "./contracts/events.type.mjs";
+import { CliMcpRemoteServer, CliMcpServer, CliMcpServers, CliMcpStdioServer } from "./contracts/mcp.type.mjs";
+import { CliAdapter, CliAdapterVerification, CliLaunchContext, CliLaunchFile, CliLaunchPlan, CliPermission, CliProbeSpec, CliPromptTransport, CliStreamParser } from "./contracts/adapter.contract.mjs";
+import { CliAgentOptions, CliHome, CliProbeResult, CliResult, CliRunOptions, CliSession } from "./contracts/options.type.mjs";
+import { CliError, CliErrorOptions, CliErrorType } from "./errors.mjs";
+import { CliModelConfig, cliModel, renderPrompt, toUsage } from "./model/cli-model.mjs";
+import { CmdShimTarget, CommandLookup, SpawnTarget, findExecutable, parseCmdShim, resolveSpawnTarget } from "./spawn/resolve-command.mjs";
+import { CliAgent, CliHost, createCliAgent, currentHost } from "./cli-agent.mjs";
+import { JsonRecord, asArray, asRecord, jsonLinesParser, numberField, outputText, parseJsonLine, recordField, stringField } from "./stream/json-lines.mjs";
+import { TomlTable, TomlValue, toToml } from "./utils/toml.mjs";
+import { helpLists, missingFlags, parseVersion } from "./probe/probe.mjs";
+import { Invocation, buildInvocation, fitsCommandLine, quoteForCmd } from "./spawn/invocation.mjs";
+import { aiderAdapter, createAiderParser, parseAiderCount } from "./adapters/aider.mjs";
+import { ampAdapter } from "./adapters/amp.mjs";
+import { antigravityAdapter, createAntigravityParser } from "./adapters/antigravity.mjs";
+import { claudeCodeAdapter } from "./adapters/claude-code.mjs";
+import { ClaudeStreamUsage, createClaudeStreamParser } from "./adapters/claude-stream.mjs";
+import { codexAdapter, createCodexParser } from "./adapters/codex.mjs";
+import { copilotAdapter, createCopilotParser } from "./adapters/copilot.mjs";
+import { createCursorParser, cursorAdapter } from "./adapters/cursor.mjs";
+import { createDroidParser, droidAdapter } from "./adapters/droid.mjs";
+import { createGrokParser, grokAdapter } from "./adapters/grok.mjs";
+import { createKimiParser, kimiAdapter } from "./adapters/kimi.mjs";
+import { createVibeParser, mistralVibeAdapter } from "./adapters/mistral-vibe.mjs";
+import { createOpencodeParser, opencodeAdapter } from "./adapters/opencode.mjs";
+import { qwenCodeAdapter } from "./adapters/qwen-code.mjs";
+import { createReasonixParser, reasonixAdapter } from "./adapters/reasonix.mjs";
+import { anthropicUsage, argvPrompt, dotenvFile, jsonFile, mapEffort, mcpServersJson, parseArguments, promptFile, requirePrivateHome, unsupportedOption, usageOf } from "./adapters/shared.mjs";
+import { CliVendor, cli, cliAdapters } from "./cli.mjs";
+export { type ClaudeStreamUsage, type CliAdapter, type CliAdapterVerification, type CliAgent, type CliAgentOptions, type CliEndStatus, CliError, type CliErrorEvent, type CliErrorOptions, type CliErrorType, type CliEvent, type CliHome, type CliHost, type CliLaunchContext, type CliLaunchFile, type CliLaunchPlan, type CliMcpRemoteServer, type CliMcpServer, type CliMcpServers, type CliMcpStdioServer, type CliMessageEvent, type CliModelConfig, type CliParsedEvent, type CliPermission, type CliProbeResult, type CliProbeSpec, type CliPromptTransport, type CliResult, type CliRunOptions, type CliSession, type CliSessionEndedEvent, type CliSessionStartedEvent, type CliStreamParser, type CliToolCallEvent, type CliToolResultEvent, type CliUsage, type CliUsageEvent, type CliVendor, type CmdShimTarget, type CommandLookup, type Invocation, type JsonRecord, type SpawnTarget, type TomlTable, type TomlValue, aiderAdapter, ampAdapter, anthropicUsage, antigravityAdapter, argvPrompt, asArray, asRecord, buildInvocation, claudeCodeAdapter, cli, cliAdapters, cliModel, codexAdapter, copilotAdapter, createAiderParser, createAntigravityParser, createClaudeStreamParser, createCliAgent, createCodexParser, createCopilotParser, createCursorParser, createDroidParser, createGrokParser, createKimiParser, createOpencodeParser, createReasonixParser, createVibeParser, currentHost, cursorAdapter, dotenvFile, droidAdapter, findExecutable, fitsCommandLine, grokAdapter, helpLists, jsonFile, jsonLinesParser, kimiAdapter, mapEffort, mcpServersJson, missingFlags, mistralVibeAdapter, numberField, opencodeAdapter, outputText, parseAiderCount, parseArguments, parseCmdShim, parseJsonLine, parseVersion, promptFile, quoteForCmd, qwenCodeAdapter, reasonixAdapter, recordField, renderPrompt, requirePrivateHome, resolveSpawnTarget, stringField, toToml, toUsage, unsupportedOption, usageOf };
+import "./cli.mjs";

package/esm/index.mjs

@@ -0,0 +1,28 @@
+import { CliError } from "./errors.mjs";
+import { cliModel, renderPrompt, toUsage } from "./model/cli-model.mjs";
+import { buildInvocation, fitsCommandLine, quoteForCmd } from "./spawn/invocation.mjs";
+import { helpLists, missingFlags, parseVersion } from "./probe/probe.mjs";
+import { findExecutable, parseCmdShim, resolveSpawnTarget } from "./spawn/resolve-command.mjs";
+import { createCliAgent, currentHost } from "./cli-agent.mjs";
+import { asArray, asRecord, jsonLinesParser, numberField, outputText, parseJsonLine, recordField, stringField } from "./stream/json-lines.mjs";
+import { toToml } from "./utils/toml.mjs";
+import { anthropicUsage, argvPrompt, dotenvFile, jsonFile, mapEffort, mcpServersJson, parseArguments, promptFile, requirePrivateHome, unsupportedOption, usageOf } from "./adapters/shared.mjs";
+import { aiderAdapter, createAiderParser, parseAiderCount } from "./adapters/aider.mjs";
+import { createClaudeStreamParser } from "./adapters/claude-stream.mjs";
+import { ampAdapter } from "./adapters/amp.mjs";
+import { antigravityAdapter, createAntigravityParser } from "./adapters/antigravity.mjs";
+import { claudeCodeAdapter } from "./adapters/claude-code.mjs";
+import { codexAdapter, createCodexParser } from "./adapters/codex.mjs";
+import { copilotAdapter, createCopilotParser } from "./adapters/copilot.mjs";
+import { createCursorParser, cursorAdapter } from "./adapters/cursor.mjs";
+import { createDroidParser, droidAdapter } from "./adapters/droid.mjs";
+import { createGrokParser, grokAdapter } from "./adapters/grok.mjs";
+import { createKimiParser, kimiAdapter } from "./adapters/kimi.mjs";
+import { createVibeParser, mistralVibeAdapter } from "./adapters/mistral-vibe.mjs";
+import { createOpencodeParser, opencodeAdapter } from "./adapters/opencode.mjs";
+import { qwenCodeAdapter } from "./adapters/qwen-code.mjs";
+import { createReasonixParser, reasonixAdapter } from "./adapters/reasonix.mjs";
+import "./adapters/index.mjs";
+import { cli, cliAdapters } from "./cli.mjs";
+
+export { CliError, aiderAdapter, ampAdapter, anthropicUsage, antigravityAdapter, argvPrompt, asArray, asRecord, buildInvocation, claudeCodeAdapter, cli, cliAdapters, cliModel, codexAdapter, copilotAdapter, createAiderParser, createAntigravityParser, createClaudeStreamParser, createCliAgent, createCodexParser, createCopilotParser, createCursorParser, createDroidParser, createGrokParser, createKimiParser, createOpencodeParser, createReasonixParser, createVibeParser, currentHost, cursorAdapter, dotenvFile, droidAdapter, findExecutable, fitsCommandLine, grokAdapter, helpLists, jsonFile, jsonLinesParser, kimiAdapter, mapEffort, mcpServersJson, missingFlags, mistralVibeAdapter, numberField, opencodeAdapter, outputText, parseAiderCount, parseArguments, parseCmdShim, parseJsonLine, parseVersion, promptFile, quoteForCmd, qwenCodeAdapter, reasonixAdapter, recordField, renderPrompt, requirePrivateHome, resolveSpawnTarget, stringField, toToml, toUsage, unsupportedOption, usageOf };