llmist 0.1.1

package/dist/cli.js

@@ -0,0 +1,987 @@
+#!/usr/bin/env node
+import {
+  createGadget
+} from "./chunk-JEBGLCDW.js";
+import {
+  AgentBuilder,
+  BaseGadget,
+  BreakLoopException,
+  FALLBACK_CHARS_PER_TOKEN,
+  GadgetRegistry,
+  HumanInputException,
+  LLMMessageBuilder,
+  LLMist,
+  createLogger,
+  init_builder,
+  init_client,
+  init_constants2 as init_constants,
+  init_exceptions,
+  init_logger,
+  init_messages,
+  init_registry
+} from "./chunk-TP7HE3MN.js";
+
+// src/cli/constants.ts
+var CLI_NAME = "llmist";
+var CLI_DESCRIPTION = "Command line utilities for llmist agents and direct LLM access.";
+var COMMANDS = {
+  complete: "complete",
+  agent: "agent"
+};
+var LOG_LEVELS = ["silly", "trace", "debug", "info", "warn", "error", "fatal"];
+var DEFAULT_MODEL = "openai:gpt-5-nano";
+var DEFAULT_PARAMETER_FORMAT = "json";
+var OPTION_FLAGS = {
+  model: "-m, --model <identifier>",
+  systemPrompt: "-s, --system <prompt>",
+  temperature: "-t, --temperature <value>",
+  maxTokens: "--max-tokens <count>",
+  maxIterations: "-i, --max-iterations <count>",
+  gadgetModule: "-g, --gadget <module>",
+  parameterFormat: "--parameter-format <format>",
+  logLevel: "--log-level <level>",
+  logFile: "--log-file <path>",
+  noBuiltins: "--no-builtins"
+};
+var OPTION_DESCRIPTIONS = {
+  model: "Model identifier, e.g. openai:gpt-5-nano or anthropic:claude-3-5-sonnet-latest.",
+  systemPrompt: "Optional system prompt prepended to the conversation.",
+  temperature: "Sampling temperature between 0 and 2.",
+  maxTokens: "Maximum number of output tokens requested from the model.",
+  maxIterations: "Maximum number of agent loop iterations before exiting.",
+  gadgetModule: "Path or module specifier for a gadget export. Repeat to register multiple gadgets.",
+  parameterFormat: "Format for gadget parameter schemas: 'json', 'yaml', or 'auto'.",
+  logLevel: "Log level: silly, trace, debug, info, warn, error, fatal.",
+  logFile: "Path to log file. When set, logs are written to file instead of stderr.",
+  noBuiltins: "Disable built-in gadgets (AskUser, TellUser)."
+};
+var SUMMARY_PREFIX = "[llmist]";
+
+// src/cli/program.ts
+import { Command, InvalidArgumentError as InvalidArgumentError3 } from "commander";
+
+// package.json
+var package_default = {
+  name: "llmist",
+  version: "0.1.1",
+  description: "Universal TypeScript LLM client with streaming-first agent framework. Works with any model - no structured outputs or native tool calling required. Implements its own flexible grammar for function calling.",
+  type: "module",
+  main: "dist/index.cjs",
+  module: "dist/index.js",
+  types: "dist/index.d.ts",
+  exports: {
+    ".": {
+      import: {
+        types: "./dist/index.d.ts",
+        default: "./dist/index.js"
+      },
+      require: {
+        types: "./dist/index.d.cts",
+        default: "./dist/index.cjs"
+      }
+    },
+    "./testing": {
+      import: {
+        types: "./dist/testing/index.d.ts",
+        default: "./dist/testing/index.js"
+      },
+      require: {
+        types: "./dist/testing/index.d.cts",
+        default: "./dist/testing/index.cjs"
+      }
+    }
+  },
+  scripts: {
+    cli: "bun run scripts/cli-runner.ts",
+    build: "tsup",
+    typecheck: "tsc --noEmit",
+    lint: "biome lint .",
+    format: "biome format --write .",
+    check: "biome check --write .",
+    test: "bun test",
+    "test:unit": "bun test src/agent src/core src/gadgets src/providers src/testing",
+    "test:watch": "bun test --watch",
+    "test:e2e": "bun test src/e2e --timeout 60000 --bail 1",
+    "test:e2e:watch": "bun test src/e2e --watch --timeout 60000",
+    "test:all": "bun run test && bun run test:e2e",
+    clean: "rimraf dist",
+    postinstall: "node scripts/install-hooks.js"
+  },
+  bin: {
+    llmist: "dist/cli.cjs"
+  },
+  repository: {
+    type: "git",
+    url: "https://github.com/zbigniewsobiecki/llmist.git"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  files: [
+    "dist"
+  ],
+  keywords: [
+    "llm",
+    "ai",
+    "agent",
+    "agents",
+    "openai",
+    "anthropic",
+    "claude",
+    "gemini",
+    "gpt",
+    "streaming",
+    "function-calling",
+    "tool-calling",
+    "typescript",
+    "universal-client",
+    "multi-provider",
+    "hooks",
+    "gadgets"
+  ],
+  author: "",
+  license: "MIT",
+  dependencies: {
+    "@anthropic-ai/sdk": "^0.69.0",
+    "@google/genai": "^1.27.0",
+    chalk: "^5.6.2",
+    commander: "^12.1.0",
+    "js-yaml": "^4.1.0",
+    openai: "^4.0.0",
+    tiktoken: "^1.0.22",
+    tslog: "^4.10.2",
+    zod: "^4.1.12"
+  },
+  devDependencies: {
+    "@biomejs/biome": "^2.3.2",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20.12.7",
+    "bun-types": "^1.3.2",
+    dotenv: "^17.2.3",
+    rimraf: "^5.0.5",
+    tsup: "^8.3.5",
+    typescript: "^5.4.5"
+  }
+};
+
+// src/cli/agent-command.ts
+init_builder();
+init_registry();
+init_constants();
+import { createInterface } from "node:readline/promises";
+import chalk3 from "chalk";
+import { InvalidArgumentError as InvalidArgumentError2 } from "commander";
+
+// src/cli/builtin-gadgets.ts
+import chalk from "chalk";
+import { z } from "zod";
+init_exceptions();
+var askUser = createGadget({
+  name: "AskUser",
+  description: "Ask the user a question when you need more information or clarification. The user's response will be provided back to you.",
+  schema: z.object({
+    question: z.string().describe("The question to ask the user")
+  }),
+  execute: ({ question }) => {
+    throw new HumanInputException(question);
+  }
+});
+var tellUser = createGadget({
+  name: "TellUser",
+  description: "Tell the user something important. Set done=true when your work is complete and you want to end the conversation.",
+  schema: z.object({
+    message: z.string().describe("The message to display to the user"),
+    done: z.boolean().describe("Set to true to end the conversation, false to continue"),
+    type: z.enum(["info", "success", "warning", "error"]).default("info").describe("Message type: info, success, warning, or error")
+  }),
+  execute: ({ message, done, type }) => {
+    const formatters = {
+      info: (msg) => chalk.blue(`\u2139\uFE0F  ${msg}`),
+      success: (msg) => chalk.green(`\u2705 ${msg}`),
+      warning: (msg) => chalk.yellow(`\u26A0\uFE0F  ${msg}`),
+      error: (msg) => chalk.red(`\u274C ${msg}`)
+    };
+    const formatted = formatters[type](message);
+    if (done) {
+      throw new BreakLoopException(formatted);
+    }
+    return formatted;
+  }
+});
+var builtinGadgets = [askUser, tellUser];
+
+// src/cli/gadgets.ts
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+var PATH_PREFIXES = [".", "/", "~"];
+function isGadgetConstructor(value) {
+  if (typeof value !== "function") {
+    return false;
+  }
+  const prototype = value.prototype;
+  return Boolean(prototype) && prototype instanceof BaseGadget;
+}
+function expandHomePath(input) {
+  if (!input.startsWith("~")) {
+    return input;
+  }
+  const home = process.env.HOME;
+  if (!home) {
+    return input;
+  }
+  return path.join(home, input.slice(1));
+}
+function isFileLikeSpecifier(specifier) {
+  return PATH_PREFIXES.some((prefix) => specifier.startsWith(prefix)) || specifier.includes(path.sep);
+}
+function resolveGadgetSpecifier(specifier, cwd) {
+  if (!isFileLikeSpecifier(specifier)) {
+    return specifier;
+  }
+  const expanded = expandHomePath(specifier);
+  const resolvedPath = path.resolve(cwd, expanded);
+  if (!fs.existsSync(resolvedPath)) {
+    throw new Error(`Gadget module not found at ${resolvedPath}`);
+  }
+  return pathToFileURL(resolvedPath).href;
+}
+function extractGadgetsFromModule(moduleExports) {
+  const results = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (value) => {
+    if (value === void 0 || value === null) {
+      return;
+    }
+    if (visited.has(value)) {
+      return;
+    }
+    visited.add(value);
+    if (value instanceof BaseGadget) {
+      results.push(value);
+      return;
+    }
+    if (isGadgetConstructor(value)) {
+      results.push(new value());
+      return;
+    }
+    if (Array.isArray(value)) {
+      for (const entry of value) {
+        visit(entry);
+      }
+      return;
+    }
+    if (typeof value === "object") {
+      for (const entry of Object.values(value)) {
+        visit(entry);
+      }
+    }
+  };
+  visit(moduleExports);
+  return results;
+}
+async function loadGadgets(specifiers, cwd, importer = (specifier) => import(specifier)) {
+  const gadgets = [];
+  for (const specifier of specifiers) {
+    const resolved = resolveGadgetSpecifier(specifier, cwd);
+    let exports;
+    try {
+      exports = await importer(resolved);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to load gadget module '${specifier}': ${message}`);
+    }
+    let extracted;
+    try {
+      extracted = extractGadgetsFromModule(exports);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to initialize gadgets from module '${specifier}': ${message}`);
+    }
+    if (extracted.length === 0) {
+      throw new Error(`Module '${specifier}' does not export any Gadget instances.`);
+    }
+    gadgets.push(...extracted);
+  }
+  return gadgets;
+}
+
+// src/cli/utils.ts
+init_constants();
+import chalk2 from "chalk";
+import { InvalidArgumentError } from "commander";
+function createNumericParser({
+  label,
+  integer = false,
+  min,
+  max
+}) {
+  return (value) => {
+    const parsed = Number(value);
+    if (Number.isNaN(parsed)) {
+      throw new InvalidArgumentError(`${label} must be a number.`);
+    }
+    if (integer && !Number.isInteger(parsed)) {
+      throw new InvalidArgumentError(`${label} must be an integer.`);
+    }
+    if (min !== void 0 && parsed < min) {
+      throw new InvalidArgumentError(`${label} must be greater than or equal to ${min}.`);
+    }
+    if (max !== void 0 && parsed > max) {
+      throw new InvalidArgumentError(`${label} must be less than or equal to ${max}.`);
+    }
+    return parsed;
+  };
+}
+var StreamPrinter = class {
+  constructor(target) {
+    this.target = target;
+  }
+  endedWithNewline = true;
+  /**
+   * Writes text to the target stream and tracks newline state.
+   *
+   * @param text - Text to write
+   */
+  write(text) {
+    if (!text) {
+      return;
+    }
+    this.target.write(text);
+    this.endedWithNewline = text.endsWith("\n");
+  }
+  /**
+   * Ensures output ends with a newline by writing one if needed.
+   */
+  ensureNewline() {
+    if (!this.endedWithNewline) {
+      this.target.write("\n");
+      this.endedWithNewline = true;
+    }
+  }
+};
+function isInteractive(stream) {
+  return Boolean(stream.isTTY);
+}
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var SPINNER_DELAY_MS = 500;
+var StreamProgress = class {
+  constructor(target, isTTY) {
+    this.target = target;
+    this.isTTY = isTTY;
+  }
+  // Animation state
+  frameIndex = 0;
+  interval = null;
+  delayTimeout = null;
+  isRunning = false;
+  hasRendered = false;
+  // Current call stats (streaming mode)
+  mode = "cumulative";
+  model = "";
+  callStartTime = Date.now();
+  callInputTokens = 0;
+  callInputTokensEstimated = true;
+  callOutputTokens = 0;
+  callOutputTokensEstimated = true;
+  callOutputChars = 0;
+  isStreaming = false;
+  // Cumulative stats (cumulative mode)
+  totalStartTime = Date.now();
+  totalTokens = 0;
+  iterations = 0;
+  /**
+   * Starts a new LLM call. Switches to streaming mode.
+   * @param model - Model name being used
+   * @param estimatedInputTokens - Estimated input tokens based on prompt length
+   */
+  startCall(model, estimatedInputTokens) {
+    this.mode = "streaming";
+    this.model = model;
+    this.callStartTime = Date.now();
+    this.callInputTokens = estimatedInputTokens ?? 0;
+    this.callInputTokensEstimated = true;
+    this.callOutputTokens = 0;
+    this.callOutputTokensEstimated = true;
+    this.callOutputChars = 0;
+    this.isStreaming = false;
+    this.start();
+  }
+  /**
+   * Ends the current LLM call. Updates cumulative stats and switches to cumulative mode.
+   * @param usage - Final token usage from the call
+   */
+  endCall(usage) {
+    this.iterations++;
+    if (usage) {
+      this.totalTokens += usage.totalTokens;
+    }
+    this.pause();
+    this.mode = "cumulative";
+  }
+  /**
+   * Sets the input token count for current call (from stream metadata).
+   * @param tokens - Token count
+   * @param estimated - If true, shown with ~ prefix until actual count arrives
+   */
+  setInputTokens(tokens, estimated = false) {
+    if (estimated && !this.callInputTokensEstimated) {
+      return;
+    }
+    this.callInputTokens = tokens;
+    this.callInputTokensEstimated = estimated;
+  }
+  /**
+   * Sets the output token count for current call (from stream metadata).
+   * @param tokens - Token count
+   * @param estimated - If true, shown with ~ prefix until actual count arrives
+   */
+  setOutputTokens(tokens, estimated = false) {
+    if (estimated && !this.callOutputTokensEstimated) {
+      return;
+    }
+    this.callOutputTokens = tokens;
+    this.callOutputTokensEstimated = estimated;
+  }
+  /**
+   * Starts the progress indicator animation after a brief delay.
+   */
+  start() {
+    if (!this.isTTY || this.isRunning) return;
+    this.isRunning = true;
+    this.delayTimeout = setTimeout(() => {
+      if (this.isRunning) {
+        this.interval = setInterval(() => this.render(), 80);
+        this.render();
+      }
+    }, SPINNER_DELAY_MS);
+  }
+  /**
+   * Updates output character count for current call and marks streaming as active.
+   * @param totalChars - Total accumulated character count
+   */
+  update(totalChars) {
+    this.callOutputChars = totalChars;
+    this.isStreaming = true;
+  }
+  render() {
+    const spinner = SPINNER_FRAMES[this.frameIndex++ % SPINNER_FRAMES.length];
+    if (this.mode === "streaming") {
+      this.renderStreamingMode(spinner);
+    } else {
+      this.renderCumulativeMode(spinner);
+    }
+    this.hasRendered = true;
+  }
+  renderStreamingMode(spinner) {
+    const elapsed = ((Date.now() - this.callStartTime) / 1e3).toFixed(1);
+    const outTokens = this.callOutputTokensEstimated ? Math.round(this.callOutputChars / FALLBACK_CHARS_PER_TOKEN) : this.callOutputTokens;
+    const parts = [];
+    if (this.model) {
+      parts.push(chalk2.cyan(this.model));
+    }
+    if (this.callInputTokens > 0) {
+      const prefix = this.callInputTokensEstimated ? "~" : "";
+      parts.push(chalk2.dim("out:") + chalk2.yellow(` ${prefix}${this.callInputTokens}`));
+    }
+    if (this.isStreaming || outTokens > 0) {
+      const prefix = this.callOutputTokensEstimated ? "~" : "";
+      parts.push(chalk2.dim("in:") + chalk2.green(` ${prefix}${outTokens}`));
+    }
+    parts.push(chalk2.dim(`${elapsed}s`));
+    this.target.write(`\r${chalk2.cyan(spinner)} ${parts.join(chalk2.dim(" | "))}`);
+  }
+  renderCumulativeMode(spinner) {
+    const elapsed = ((Date.now() - this.totalStartTime) / 1e3).toFixed(1);
+    const parts = [];
+    if (this.model) {
+      parts.push(chalk2.cyan(this.model));
+    }
+    if (this.totalTokens > 0) {
+      parts.push(chalk2.dim("total:") + chalk2.magenta(` ${this.totalTokens}`));
+    }
+    if (this.iterations > 0) {
+      parts.push(chalk2.dim("iter:") + chalk2.blue(` ${this.iterations}`));
+    }
+    parts.push(chalk2.dim(`${elapsed}s`));
+    this.target.write(`\r${chalk2.cyan(spinner)} ${parts.join(chalk2.dim(" | "))}`);
+  }
+  /**
+   * Pauses the progress indicator and clears the line.
+   * Can be resumed with start().
+   */
+  pause() {
+    if (!this.isTTY || !this.isRunning) return;
+    if (this.delayTimeout) {
+      clearTimeout(this.delayTimeout);
+      this.delayTimeout = null;
+    }
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    this.isRunning = false;
+    if (this.hasRendered) {
+      this.target.write("\r\x1B[K");
+      this.hasRendered = false;
+    }
+  }
+  /**
+   * Completes the progress indicator and clears the line.
+   */
+  complete() {
+    this.pause();
+  }
+  /**
+   * Returns a formatted prompt string with stats (like bash PS1).
+   * Shows current call stats during streaming, cumulative stats otherwise.
+   * Format: "out: 1.2k │ in: ~300 │ 5s > " or "3.6k │ i2 │ 34s > "
+   */
+  formatPrompt() {
+    const parts = [];
+    if (this.mode === "streaming") {
+      const elapsed = Math.round((Date.now() - this.callStartTime) / 1e3);
+      const outTokens = this.callOutputTokensEstimated ? Math.round(this.callOutputChars / FALLBACK_CHARS_PER_TOKEN) : this.callOutputTokens;
+      const outEstimated = this.callOutputTokensEstimated;
+      if (this.callInputTokens > 0) {
+        const prefix = this.callInputTokensEstimated ? "~" : "";
+        parts.push(
+          chalk2.dim("out:") + chalk2.yellow(` ${prefix}${this.formatTokens(this.callInputTokens)}`)
+        );
+      }
+      if (outTokens > 0) {
+        const prefix = outEstimated ? "~" : "";
+        parts.push(chalk2.dim("in:") + chalk2.green(` ${prefix}${this.formatTokens(outTokens)}`));
+      }
+      parts.push(chalk2.dim(`${elapsed}s`));
+    } else {
+      const elapsed = Math.round((Date.now() - this.totalStartTime) / 1e3);
+      if (this.totalTokens > 0) {
+        parts.push(chalk2.magenta(this.formatTokens(this.totalTokens)));
+      }
+      if (this.iterations > 0) {
+        parts.push(chalk2.blue(`i${this.iterations}`));
+      }
+      parts.push(chalk2.dim(`${elapsed}s`));
+    }
+    return `${parts.join(chalk2.dim(" \u2502 "))} ${chalk2.green(">")} `;
+  }
+  /**
+   * Formats token count compactly (3625 -> "3.6k").
+   */
+  formatTokens(tokens) {
+    return tokens >= 1e3 ? `${(tokens / 1e3).toFixed(1)}k` : `${tokens}`;
+  }
+};
+async function readStream(stream) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    if (typeof chunk === "string") {
+      chunks.push(chunk);
+    } else {
+      chunks.push(chunk.toString("utf8"));
+    }
+  }
+  return chunks.join("");
+}
+function normalizePrompt(value) {
+  return value.trim();
+}
+async function resolvePrompt(promptArg, env) {
+  if (promptArg?.trim()) {
+    return normalizePrompt(promptArg);
+  }
+  if (isInteractive(env.stdin)) {
+    throw new Error("Prompt is required. Provide an argument or pipe content via stdin.");
+  }
+  const pipedInput = normalizePrompt(await readStream(env.stdin));
+  if (!pipedInput) {
+    throw new Error("Received empty stdin payload. Provide a prompt to continue.");
+  }
+  return pipedInput;
+}
+function renderSummary(metadata) {
+  const parts = [];
+  if (metadata.iterations !== void 0) {
+    parts.push(chalk2.dim(`iterations: ${metadata.iterations}`));
+  }
+  if (metadata.finishReason) {
+    parts.push(chalk2.dim(`finish: ${metadata.finishReason}`));
+  }
+  if (metadata.usage) {
+    const { inputTokens, outputTokens, totalTokens } = metadata.usage;
+    parts.push(
+      chalk2.dim(`tokens: `) + chalk2.cyan(`${totalTokens}`) + chalk2.dim(` (in: ${inputTokens}, out: ${outputTokens})`)
+    );
+  }
+  if (parts.length === 0) {
+    return null;
+  }
+  return `${chalk2.dim("\u2500".repeat(40))}
+${parts.join(chalk2.dim(" \u2502 "))}`;
+}
+async function executeAction(action, env) {
+  try {
+    await action();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    env.stderr.write(`${chalk2.red.bold("Error:")} ${message}
+`);
+    env.setExitCode(1);
+  }
+}
+
+// src/cli/agent-command.ts
+var PARAMETER_FORMAT_VALUES = ["json", "yaml", "auto"];
+function parseParameterFormat(value) {
+  const normalized = value.toLowerCase();
+  if (!PARAMETER_FORMAT_VALUES.includes(normalized)) {
+    throw new InvalidArgumentError2("Parameter format must be one of 'json', 'yaml', or 'auto'.");
+  }
+  return normalized;
+}
+function createHumanInputHandler(env, progress) {
+  const stdout = env.stdout;
+  if (!isInteractive(env.stdin) || typeof stdout.isTTY !== "boolean" || !stdout.isTTY) {
+    return void 0;
+  }
+  return async (question) => {
+    progress.pause();
+    const rl = createInterface({ input: env.stdin, output: env.stdout });
+    try {
+      const questionLine = question.trim() ? `
+${question.trim()}` : "";
+      let isFirst = true;
+      while (true) {
+        const statsPrompt = progress.formatPrompt();
+        const prompt = isFirst ? `${questionLine}
+${statsPrompt}` : statsPrompt;
+        isFirst = false;
+        const answer = await rl.question(prompt);
+        const trimmed = answer.trim();
+        if (trimmed) {
+          return trimmed;
+        }
+      }
+    } finally {
+      rl.close();
+    }
+  };
+}
+function formatGadgetSummary(result) {
+  const gadgetLabel = chalk3.magenta.bold(result.gadgetName);
+  const timeLabel = chalk3.dim(`${Math.round(result.executionTimeMs)}ms`);
+  if (result.error) {
+    return `${chalk3.red("\u2717")} ${gadgetLabel} ${chalk3.red("error:")} ${result.error} ${timeLabel}`;
+  }
+  if (result.breaksLoop) {
+    return `${chalk3.yellow("\u23F9")} ${gadgetLabel} ${chalk3.yellow("finished:")} ${result.result} ${timeLabel}`;
+  }
+  const maxLen = 80;
+  const resultText = result.result ? result.result.length > maxLen ? `${result.result.slice(0, maxLen)}...` : result.result : "";
+  return `${chalk3.green("\u2713")} ${gadgetLabel} ${chalk3.dim("\u2192")} ${resultText} ${timeLabel}`;
+}
+async function handleAgentCommand(promptArg, options, env) {
+  const prompt = await resolvePrompt(promptArg, env);
+  const client = env.createClient();
+  const registry = new GadgetRegistry();
+  if (options.builtins !== false) {
+    for (const gadget of builtinGadgets) {
+      registry.registerByClass(gadget);
+    }
+  }
+  const gadgetSpecifiers = options.gadget ?? [];
+  if (gadgetSpecifiers.length > 0) {
+    const gadgets2 = await loadGadgets(gadgetSpecifiers, process.cwd());
+    for (const gadget of gadgets2) {
+      registry.registerByClass(gadget);
+    }
+  }
+  const printer = new StreamPrinter(env.stdout);
+  const stderrTTY = env.stderr.isTTY === true;
+  const progress = new StreamProgress(env.stderr, stderrTTY);
+  let finishReason;
+  let usage;
+  let iterations = 0;
+  const estimateMessagesTokens = (messages) => {
+    const totalChars = messages.reduce((sum, m) => sum + (m.content?.length ?? 0), 0);
+    return Math.round(totalChars / FALLBACK_CHARS_PER_TOKEN);
+  };
+  const builder = new AgentBuilder(client).withModel(options.model).withLogger(env.createLogger("llmist:cli:agent")).withHooks({
+    observers: {
+      onLLMCallStart: async (context) => {
+        const estimate = estimateMessagesTokens(context.options.messages);
+        progress.startCall(context.options.model, estimate);
+      },
+      onStreamChunk: async (context) => {
+        progress.update(context.accumulatedText.length);
+        if (context.usage) {
+          if (context.usage.inputTokens) {
+            progress.setInputTokens(context.usage.inputTokens, false);
+          }
+          if (context.usage.outputTokens) {
+            progress.setOutputTokens(context.usage.outputTokens, false);
+          }
+        }
+      },
+      onLLMCallComplete: async (context) => {
+        finishReason = context.finishReason;
+        usage = context.usage;
+        iterations = Math.max(iterations, context.iteration + 1);
+        progress.endCall(context.usage);
+      }
+    }
+  });
+  if (options.system) {
+    builder.withSystem(options.system);
+  }
+  if (options.maxIterations !== void 0) {
+    builder.withMaxIterations(options.maxIterations);
+  }
+  if (options.temperature !== void 0) {
+    builder.withTemperature(options.temperature);
+  }
+  const humanInputHandler = createHumanInputHandler(env, progress);
+  if (humanInputHandler) {
+    builder.onHumanInput(humanInputHandler);
+  }
+  const gadgets = registry.getAll();
+  if (gadgets.length > 0) {
+    builder.withGadgets(...gadgets);
+  }
+  const agent = builder.ask(prompt);
+  for await (const event of agent.run()) {
+    if (event.type === "text") {
+      progress.pause();
+      printer.write(event.content);
+    } else if (event.type === "gadget_result") {
+      progress.pause();
+      env.stderr.write(`${formatGadgetSummary(event.result)}
+`);
+    }
+  }
+  progress.complete();
+  printer.ensureNewline();
+  const summary = renderSummary({ finishReason, usage, iterations });
+  if (summary) {
+    env.stderr.write(`${summary}
+`);
+  }
+}
+function registerAgentCommand(program, env) {
+  program.command(COMMANDS.agent).description("Run the llmist agent loop with optional gadgets.").argument("[prompt]", "Prompt for the agent loop. Falls back to stdin when available.").option(OPTION_FLAGS.model, OPTION_DESCRIPTIONS.model, DEFAULT_MODEL).option(OPTION_FLAGS.systemPrompt, OPTION_DESCRIPTIONS.systemPrompt).option(
+    OPTION_FLAGS.temperature,
+    OPTION_DESCRIPTIONS.temperature,
+    createNumericParser({ label: "Temperature", min: 0, max: 2 })
+  ).option(
+    OPTION_FLAGS.maxIterations,
+    OPTION_DESCRIPTIONS.maxIterations,
+    createNumericParser({ label: "Max iterations", integer: true, min: 1 })
+  ).option(
+    OPTION_FLAGS.gadgetModule,
+    OPTION_DESCRIPTIONS.gadgetModule,
+    (value, previous = []) => [...previous, value],
+    []
+  ).option(
+    OPTION_FLAGS.parameterFormat,
+    OPTION_DESCRIPTIONS.parameterFormat,
+    parseParameterFormat,
+    DEFAULT_PARAMETER_FORMAT
+  ).option(OPTION_FLAGS.noBuiltins, OPTION_DESCRIPTIONS.noBuiltins).action(
+    (prompt, options) => executeAction(() => handleAgentCommand(prompt, options, env), env)
+  );
+}
+
+// src/cli/complete-command.ts
+init_messages();
+init_constants();
+async function handleCompleteCommand(promptArg, options, env) {
+  const prompt = await resolvePrompt(promptArg, env);
+  const client = env.createClient();
+  const builder = new LLMMessageBuilder();
+  if (options.system) {
+    builder.addSystem(options.system);
+  }
+  builder.addUser(prompt);
+  const stream = client.stream({
+    model: options.model,
+    messages: builder.build(),
+    temperature: options.temperature,
+    maxTokens: options.maxTokens
+  });
+  const printer = new StreamPrinter(env.stdout);
+  const stderrTTY = env.stderr.isTTY === true;
+  const progress = new StreamProgress(env.stderr, stderrTTY);
+  const estimatedInputTokens = Math.round(prompt.length / FALLBACK_CHARS_PER_TOKEN);
+  progress.startCall(options.model, estimatedInputTokens);
+  let finishReason;
+  let usage;
+  let totalChars = 0;
+  for await (const chunk of stream) {
+    if (chunk.usage) {
+      usage = chunk.usage;
+      if (chunk.usage.inputTokens) {
+        progress.setInputTokens(chunk.usage.inputTokens, false);
+      }
+      if (chunk.usage.outputTokens) {
+        progress.setOutputTokens(chunk.usage.outputTokens, false);
+      }
+    }
+    if (chunk.text) {
+      progress.pause();
+      totalChars += chunk.text.length;
+      progress.update(totalChars);
+      printer.write(chunk.text);
+    }
+    if (chunk.finishReason !== void 0) {
+      finishReason = chunk.finishReason;
+    }
+  }
+  progress.complete();
+  printer.ensureNewline();
+  const summary = renderSummary({ finishReason, usage });
+  if (summary) {
+    env.stderr.write(`${summary}
+`);
+  }
+}
+function registerCompleteCommand(program, env) {
+  program.command(COMMANDS.complete).description("Stream a single completion from a specified model.").argument("[prompt]", "Prompt to send to the LLM. If omitted, stdin is used when available.").option(OPTION_FLAGS.model, OPTION_DESCRIPTIONS.model, DEFAULT_MODEL).option(OPTION_FLAGS.systemPrompt, OPTION_DESCRIPTIONS.systemPrompt).option(
+    OPTION_FLAGS.temperature,
+    OPTION_DESCRIPTIONS.temperature,
+    createNumericParser({ label: "Temperature", min: 0, max: 2 })
+  ).option(
+    OPTION_FLAGS.maxTokens,
+    OPTION_DESCRIPTIONS.maxTokens,
+    createNumericParser({ label: "Max tokens", integer: true, min: 1 })
+  ).action(
+    (prompt, options) => executeAction(
+      () => handleCompleteCommand(prompt, options, env),
+      env
+    )
+  );
+}
+
+// src/cli/environment.ts
+init_client();
+init_logger();
+import readline from "node:readline";
+import chalk4 from "chalk";
+var LOG_LEVEL_MAP = {
+  silly: 0,
+  trace: 1,
+  debug: 2,
+  info: 3,
+  warn: 4,
+  error: 5,
+  fatal: 6
+};
+function createLoggerFactory(config) {
+  return (name) => {
+    const options = { name };
+    if (config?.logLevel) {
+      const level = config.logLevel.toLowerCase();
+      if (level in LOG_LEVEL_MAP) {
+        options.minLevel = LOG_LEVEL_MAP[level];
+      }
+    }
+    if (config?.logFile) {
+      const originalLogFile = process.env.LLMIST_LOG_FILE;
+      process.env.LLMIST_LOG_FILE = config.logFile;
+      const logger = createLogger(options);
+      if (originalLogFile === void 0) {
+        delete process.env.LLMIST_LOG_FILE;
+      } else {
+        process.env.LLMIST_LOG_FILE = originalLogFile;
+      }
+      return logger;
+    }
+    if (!process.env.LLMIST_LOG_FILE) {
+      options.type = "pretty";
+    }
+    return createLogger(options);
+  };
+}
+function createPromptFunction(stdin, stdout) {
+  return (question) => {
+    return new Promise((resolve) => {
+      const rl = readline.createInterface({
+        input: stdin,
+        output: stdout
+      });
+      stdout.write("\n");
+      stdout.write(`${chalk4.cyan("\u2500".repeat(60))}
+`);
+      stdout.write(chalk4.cyan.bold("\u{1F916} Agent asks:\n"));
+      stdout.write(`${question}
+`);
+      stdout.write(`${chalk4.cyan("\u2500".repeat(60))}
+`);
+      rl.question(chalk4.green.bold("You: "), (answer) => {
+        rl.close();
+        resolve(answer);
+      });
+    });
+  };
+}
+function createDefaultEnvironment(loggerConfig) {
+  const isTTY = Boolean(process.stdin.isTTY);
+  return {
+    argv: process.argv,
+    stdin: process.stdin,
+    stdout: process.stdout,
+    stderr: process.stderr,
+    createClient: () => new LLMist(),
+    setExitCode: (code) => {
+      process.exitCode = code;
+    },
+    loggerConfig,
+    createLogger: createLoggerFactory(loggerConfig),
+    isTTY,
+    prompt: isTTY ? createPromptFunction(process.stdin, process.stdout) : async () => {
+      throw new Error("Cannot prompt for input: stdin is not a TTY");
+    }
+  };
+}
+
+// src/cli/program.ts
+function parseLogLevel(value) {
+  const normalized = value.toLowerCase();
+  if (!LOG_LEVELS.includes(normalized)) {
+    throw new InvalidArgumentError3(`Log level must be one of: ${LOG_LEVELS.join(", ")}`);
+  }
+  return normalized;
+}
+function createProgram(env) {
+  const program = new Command();
+  program.name(CLI_NAME).description(CLI_DESCRIPTION).version(package_default.version).option(OPTION_FLAGS.logLevel, OPTION_DESCRIPTIONS.logLevel, parseLogLevel).option(OPTION_FLAGS.logFile, OPTION_DESCRIPTIONS.logFile).configureOutput({
+    writeOut: (str) => env.stdout.write(str),
+    writeErr: (str) => env.stderr.write(str)
+  });
+  registerCompleteCommand(program, env);
+  registerAgentCommand(program, env);
+  return program;
+}
+async function runCLI(overrides = {}) {
+  const preParser = new Command();
+  preParser.option(OPTION_FLAGS.logLevel, OPTION_DESCRIPTIONS.logLevel, parseLogLevel).option(OPTION_FLAGS.logFile, OPTION_DESCRIPTIONS.logFile).allowUnknownOption().allowExcessArguments().helpOption(false);
+  preParser.parse(process.argv);
+  const globalOpts = preParser.opts();
+  const loggerConfig = {
+    logLevel: globalOpts.logLevel,
+    logFile: globalOpts.logFile
+  };
+  const defaultEnv = createDefaultEnvironment(loggerConfig);
+  const env = { ...defaultEnv, ...overrides };
+  const program = createProgram(env);
+  await program.parseAsync(env.argv);
+}
+
+// src/cli.ts
+runCLI().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`${SUMMARY_PREFIX} Error: ${message}
+`);
+  process.exitCode = 1;
+});
+//# sourceMappingURL=cli.js.map