llm-exe 3.0.0 → 3.1.0-beta.1

package/dist/cli/cli.mjs

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+import {
+  loadConfigFromUrl
+} from "../chunk-7W6GBE2Y.mjs";
+import {
+  loadConfigFromFile
+} from "../chunk-PX2FFNZQ.mjs";
+import {
+  executorFromConfig,
+  isLlmExeError
+} from "../chunk-2BUGTOKA.mjs";
+
+// src/cli/cli.ts
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+
+// src/cli/args.ts
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var BOOLEAN_FLAGS = {
+  json: "json",
+  debug: "debug",
+  remote: "remote",
+  help: "help",
+  h: "help",
+  version: "version",
+  v: "version"
+};
+var VALUE_FLAGS = /* @__PURE__ */ new Set(["model", "provider", "parser", "stdin"]);
+function isPlainObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function setNested(target, dottedKey, value) {
+  const parts = dottedKey.split(".").filter((p) => p.length > 0);
+  if (parts.length === 0) {
+    throw new Error("Use --data.<key> <value>, e.g. --data.name World");
+  }
+  for (const part of parts) {
+    if (FORBIDDEN_KEYS.has(part)) {
+      throw new Error(`Illegal key "${part}" in --data.${dottedKey}`);
+    }
+  }
+  let node = target;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!isPlainObject(node[part])) {
+      node[part] = {};
+    }
+    node = node[part];
+  }
+  node[parts[parts.length - 1]] = value;
+}
+function parseArgs(argv) {
+  const result = {
+    data: {},
+    json: false,
+    debug: false,
+    remote: false,
+    help: false,
+    version: false
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (!token.startsWith("-")) {
+      if (result.path !== void 0) {
+        throw new Error(`Unexpected argument: ${token}`);
+      }
+      result.path = token;
+      continue;
+    }
+    const raw = token.replace(/^--?/, "");
+    const eq = raw.indexOf("=");
+    const name = eq === -1 ? raw : raw.slice(0, eq);
+    const inlineValue = eq === -1 ? void 0 : raw.slice(eq + 1);
+    if (name in BOOLEAN_FLAGS) {
+      if (inlineValue !== void 0) {
+        throw new Error(`Option --${name} does not take a value`);
+      }
+      result[BOOLEAN_FLAGS[name]] = true;
+      continue;
+    }
+    const takeValue = () => {
+      if (inlineValue !== void 0) return inlineValue;
+      i++;
+      if (i >= argv.length) {
+        throw new Error(`Option --${name} requires a value`);
+      }
+      return argv[i];
+    };
+    if (name === "data") {
+      throw new Error("Use --data.<key> <value>, e.g. --data.name World");
+    }
+    if (name.startsWith("data.")) {
+      setNested(result.data, name.slice("data.".length), takeValue());
+      continue;
+    }
+    if (VALUE_FLAGS.has(name)) {
+      const value = takeValue();
+      if (name === "stdin") result.stdinKey = value;
+      else if (name === "model") result.model = value;
+      else if (name === "provider") result.provider = value;
+      else if (name === "parser") result.parser = value;
+      continue;
+    }
+    throw new Error(`Unknown option: ${token}`);
+  }
+  return result;
+}
+
+// src/cli/runCli.ts
+var HELP = `llm-exe \u2014 run an llm-exe config file (no code required)
+
+Usage:
+  llm-exe <path> [options]
+  cat input | llm-exe <path> --stdin <key>
+
+Arguments:
+  <path>                  Path to a config file (.json, .yml, .yaml, .md),
+                          or an http(s) URL with --remote
+
+Options:
+  --data.<key> <value>    Set a template variable (dotted keys nest)
+  --model <value>         Override the config's model
+  --provider <value>      Override the config's provider
+  --parser <value>        Override the config's parser
+  --stdin <key>           Bind piped stdin to a data variable
+  --json                  Print { result, metadata } as JSON to stdout
+  --debug                 Print execution metadata to stderr
+  --remote                Allow fetching a config from an http(s) URL
+  -h, --help              Show this help
+  -v, --version           Show version
+
+Auth uses the same environment variables as the package
+(OPENAI_API_KEY, ANTHROPIC_API_KEY, ...). The result goes to stdout;
+metadata and errors go to stderr, so it composes with pipes.`;
+function isUrl(value) {
+  return /^https?:\/\//i.test(value);
+}
+function formatResult(result) {
+  if (typeof result === "string") return result;
+  return JSON.stringify(result, null, 2);
+}
+async function runCli(argv, io) {
+  let args;
+  try {
+    args = parseArgs(argv);
+  } catch (error) {
+    io.stderr(error.message);
+    io.stderr("Run `llm-exe --help` for usage.");
+    return 1;
+  }
+  if (args.help) {
+    io.stdout(HELP);
+    return 0;
+  }
+  if (args.version) {
+    io.stdout(io.version);
+    return 0;
+  }
+  if (!args.path) {
+    io.stderr("Missing config path.");
+    io.stderr("Usage: llm-exe <path> [options] \u2014 see `llm-exe --help`.");
+    return 1;
+  }
+  if (isUrl(args.path) && !args.remote) {
+    io.stderr(
+      `Refusing to fetch a remote config without --remote: ${args.path}`
+    );
+    return 1;
+  }
+  try {
+    const data = { ...args.data };
+    if (args.stdinKey) {
+      data[args.stdinKey] = await io.readStdin();
+    }
+    const patch = {};
+    if (args.model !== void 0) patch.model = args.model;
+    if (args.provider !== void 0) patch.provider = args.provider;
+    if (args.parser !== void 0) patch.parser = args.parser;
+    if (Object.keys(data).length > 0) patch.data = data;
+    const config = isUrl(args.path) ? await loadConfigFromUrl(args.path, patch) : await loadConfigFromFile(args.path, patch);
+    let metadata;
+    const executor = executorFromConfig(config, {
+      hooks: {
+        onComplete(meta) {
+          metadata = meta;
+        }
+      }
+    });
+    const result = await executor.execute(
+      config.data ?? {},
+      config.executorOptions
+    );
+    if (args.debug) {
+      io.stderr(JSON.stringify(metadata, null, 2));
+    }
+    if (args.json) {
+      io.stdout(JSON.stringify({ result, metadata }, null, 2));
+    } else {
+      io.stdout(formatResult(result));
+    }
+    return 0;
+  } catch (error) {
+    if (isLlmExeError(error)) {
+      io.stderr(`Error [${error.code}]: ${error.message}`);
+    } else {
+      io.stderr(`Error: ${error?.message ?? String(error)}`);
+    }
+    return 1;
+  }
+}
+
+// src/cli/cli.ts
+function readVersion() {
+  try {
+    const scriptPath = process.argv[1];
+    const pkgPath = resolve(dirname(scriptPath), "../../package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function readStdin() {
+  return new Promise((resolveFn) => {
+    if (process.stdin.isTTY) {
+      resolveFn("");
+      return;
+    }
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => data += chunk);
+    process.stdin.on("end", () => resolveFn(data));
+    process.stdin.on("error", () => resolveFn(data));
+  });
+}
+function write(stream, text) {
+  stream.write(text.endsWith("\n") ? text : `${text}
+`);
+}
+runCli(process.argv.slice(2), {
+  stdout: (text) => write(process.stdout, text),
+  stderr: (text) => write(process.stderr, text),
+  readStdin,
+  version: readVersion()
+}).then((code) => {
+  process.exitCode = code;
+}).catch((error) => {
+  process.stderr.write(`Fatal: ${error?.message ?? String(error)}
+`);
+  process.exitCode = 1;
+});

package/dist/config/node.d.mts

@@ -0,0 +1,15 @@
+import { E as ExecutorConfigPatch, a as ExecutorConfig, b as ExecutorCreateOptions, L as LlmExecutor, R as RunOverrides } from '../types-CDOBItt6.mjs';
+import 'json-schema-to-ts';
+
+/**
+ * Read and normalize a config from a file path. Format is inferred from the
+ * extension, falling back to "auto". NODE-ONLY (`node:fs/promises`) — reached
+ * via the `llm-exe/node` subpath, never from the browser-safe root barrel.
+ */
+declare function loadConfigFromFile(path: string, patch?: ExecutorConfigPatch): Promise<ExecutorConfig>;
+/** Assemble a native executor from a config file. Mirrors `executorFromConfig`. */
+declare function executorFromFile(path: string, patch?: ExecutorConfigPatch, createOptions?: ExecutorCreateOptions): Promise<LlmExecutor<any, any, any, any>>;
+/** Run a config file once, binding config defaults. The CLI's primitive. */
+declare function runFile(path: string, patch?: ExecutorConfigPatch, overrides?: RunOverrides, createOptions?: ExecutorCreateOptions): Promise<unknown>;
+
+export { executorFromFile, loadConfigFromFile, runFile };

package/dist/config/node.d.ts

@@ -0,0 +1,15 @@
+import { E as ExecutorConfigPatch, a as ExecutorConfig, b as ExecutorCreateOptions, L as LlmExecutor, R as RunOverrides } from '../types-CDOBItt6.js';
+import 'json-schema-to-ts';
+
+/**
+ * Read and normalize a config from a file path. Format is inferred from the
+ * extension, falling back to "auto". NODE-ONLY (`node:fs/promises`) — reached
+ * via the `llm-exe/node` subpath, never from the browser-safe root barrel.
+ */
+declare function loadConfigFromFile(path: string, patch?: ExecutorConfigPatch): Promise<ExecutorConfig>;
+/** Assemble a native executor from a config file. Mirrors `executorFromConfig`. */
+declare function executorFromFile(path: string, patch?: ExecutorConfigPatch, createOptions?: ExecutorCreateOptions): Promise<LlmExecutor<any, any, any, any>>;
+/** Run a config file once, binding config defaults. The CLI's primitive. */
+declare function runFile(path: string, patch?: ExecutorConfigPatch, overrides?: RunOverrides, createOptions?: ExecutorCreateOptions): Promise<unknown>;
+
+export { executorFromFile, loadConfigFromFile, runFile };