@cowsea2012/distill 0.1.31 → 0.1.33

package/bin/distill.js

@@ -1,179 +1,25 @@
 #!/usr/bin/env node
 
-const { spawn } = require("node:child_process");
+const fs = require("node:fs");
 const path = require("node:path");
-const { createRequire } = require("node:module");
 
-const requireFromHere = createRequire(__filename);
 const cliPackage = require(path.join(__dirname, "..", "package.json"));
+const entryCandidates = [
+  path.join(__dirname, "..", "dist", "cli.js"),
+  path.resolve(__dirname, "..", "..", "..", ".dist", "npm", "cli.js")
+];
 
-function getPlatformPackageName(target) {
-  const optionalDependencies = Object.keys(cliPackage.optionalDependencies ?? {});
-  return optionalDependencies.find((packageName) => packageName.endsWith(`-${target}`));
-}
-
-function resolveBinaryPath() {
-  const target = `${process.platform}-${process.arch}`;
-  const packageName = getPlatformPackageName(target);
-
-  if (!packageName) {
-    console.error(
-      `[distill] Unsupported platform: ${process.platform}/${process.arch}.`
-    );
-    process.exit(1);
+function resolveEntryPath() {
+  for (const candidate of entryCandidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
   }
 
-  try {
-    const packageJsonPath = requireFromHere.resolve(`${packageName}/package.json`);
-    return path.join(path.dirname(packageJsonPath), "bin", "distill");
-  } catch (error) {
-    console.error(
-      `[distill] Missing platform package ${packageName}. Reinstall ${cliPackage.name} for this platform.`
-    );
-    process.exit(1);
-  }
-}
-
-const PROGRESS_PREFIX = "__DISTILL_PROGRESS__:";
-const PROGRESS_FRAMES = ["-", "\\", "|", "/"];
-const PROGRESS_DOT_FRAMES = ["", ".", "..", "...", "..", "."];
-const PROGRESS_LABELS = {
-  collecting: "distill: waiting",
-  summarizing: "distill: summarizing"
-};
-
-const binPath = resolveBinaryPath();
-const progressWriter = process.stderr.isTTY ? process.stderr : process.stdout.isTTY ? process.stdout : null;
-let progressPhase = "collecting";
-let progressFrame = 0;
-let progressTimer = null;
-let progressVisible = false;
-let childStderrBuffer = "";
-
-function renderProgress() {
-  if (!progressWriter) {
-    return;
-  }
-
-  const frame = PROGRESS_FRAMES[progressFrame % PROGRESS_FRAMES.length];
-  const dots =
-    PROGRESS_DOT_FRAMES[
-      Math.floor(progressFrame / PROGRESS_FRAMES.length) % PROGRESS_DOT_FRAMES.length
-    ];
-  progressFrame += 1;
-  progressWriter.write(
-    `\r\u001b[2K${frame} ${PROGRESS_LABELS[progressPhase] || PROGRESS_LABELS.collecting}${dots}`
+  console.error(
+    `[distill] Missing bundled CLI entrypoint. Rebuild or reinstall ${cliPackage.name}.`
   );
-  progressVisible = true;
-}
-
-function startProgress() {
-  if (!progressWriter || progressTimer) {
-    return;
-  }
-
-  renderProgress();
-  progressTimer = setInterval(renderProgress, 120);
-}
-
-function stopProgress() {
-  if (progressTimer) {
-    clearInterval(progressTimer);
-    progressTimer = null;
-  }
-
-  if (progressVisible && progressWriter) {
-    progressWriter.write("\r\u001b[2K");
-    progressVisible = false;
-  }
-}
-
-function handleChildStderrLine(line) {
-  if (!line) {
-    return;
-  }
-
-  if (!line.startsWith(PROGRESS_PREFIX)) {
-    stopProgress();
-    process.stderr.write(`${line}\n`);
-    return;
-  }
-
-  if (line === `${PROGRESS_PREFIX}stop`) {
-    stopProgress();
-    return;
-  }
-
-  if (line.startsWith(`${PROGRESS_PREFIX}phase:`)) {
-    progressPhase = line.slice(`${PROGRESS_PREFIX}phase:`.length) || "collecting";
-    progressFrame = 0;
-    renderProgress();
-  }
-}
-
-function flushChildStderr(force = false) {
-  if (!force && !childStderrBuffer.includes("\n")) {
-    return;
-  }
-
-  const parts = childStderrBuffer.split("\n");
-  childStderrBuffer = force ? "" : parts.pop() || "";
-
-  for (const line of parts) {
-    handleChildStderrLine(line);
-  }
-
-  if (force && childStderrBuffer) {
-    handleChildStderrLine(childStderrBuffer);
-    childStderrBuffer = "";
-  }
-}
-
-const child = spawn(binPath, process.argv.slice(2), {
-  stdio: ["inherit", "pipe", "pipe"],
-  env: {
-    ...process.env,
-    DISTILL_PROGRESS_PROTOCOL: "stderr"
-  }
-});
-
-startProgress();
-
-child.stdout.on("data", (chunk) => {
-  stopProgress();
-  process.stdout.write(chunk);
-});
-
-child.stderr.on("data", (chunk) => {
-  childStderrBuffer += chunk.toString("utf8");
-  flushChildStderr();
-});
-
-const forwardSignal = (signal) => {
-  if (!child.killed) {
-    child.kill(signal);
-  }
-};
-
-["SIGINT", "SIGTERM", "SIGHUP"].forEach((signal) => {
-  process.on(signal, () => forwardSignal(signal));
-});
-
-child.on("error", (error) => {
-  stopProgress();
-  console.error(`[distill] Failed to launch native binary: ${error.message}`);
   process.exit(1);
-});
-
-child.on("exit", (code, signal) => {
-  flushChildStderr(true);
-  stopProgress();
-
-  if (signal) {
-    process.removeAllListeners(signal);
-    process.kill(process.pid, signal);
-    return;
-  }
+}
 
-  process.exit(code ?? 1);
-});
+require(resolveEntryPath());

package/dist/cli.js

@@ -0,0 +1,1138 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+// packages/cli/package.json
+var package_default = {
+  name: "@cowsea2012/distill",
+  version: "0.1.33",
+  description: "Compress command output for downstream LLMs.",
+  license: "MIT",
+  bin: {
+    distill: "bin/distill.js"
+  },
+  files: [
+    "bin/distill.js",
+    "dist/cli.js",
+    "README.md"
+  ],
+  engines: {
+    node: ">=18"
+  },
+  publishConfig: {
+    access: "public"
+  }
+};
+
+// src/omlx-config.ts
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"));
+var DEFAULT_OMLX_BASE_URL = "http://127.0.0.1:8000/v1";
+var DEFAULT_OMLX_MODEL = "auto";
+function trimString(value) {
+  if (typeof value !== "string") {
+    return;
+  }
+  const trimmed = value.trim();
+  return trimmed ? trimmed : undefined;
+}
+function resolveOmlxHome(env) {
+  const explicit = trimString(env.OMLX_HOME);
+  if (explicit) {
+    return explicit;
+  }
+  const home = trimString(env.HOME);
+  return home ? import_node_path.default.join(home, ".omlx") : undefined;
+}
+function resolveSettingsPath(env) {
+  const explicit = trimString(env.OMLX_SETTINGS_PATH);
+  if (explicit) {
+    return explicit;
+  }
+  const omlxHome = resolveOmlxHome(env);
+  return omlxHome ? import_node_path.default.join(omlxHome, "settings.json") : undefined;
+}
+function readSettings(env) {
+  const settingsPath = resolveSettingsPath(env);
+  if (!settingsPath || !import_node_fs.existsSync(settingsPath)) {
+    return;
+  }
+  try {
+    const raw = import_node_fs.readFileSync(settingsPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
+function visibleSubdirectories(dirPath) {
+  try {
+    return import_node_fs.readdirSync(dirPath, { withFileTypes: true }).filter((entry) => !entry.name.startsWith(".") && entry.isDirectory()).map((entry) => entry.name).sort((left, right) => left.localeCompare(right));
+  } catch {
+    return [];
+  }
+}
+function directoryLooksLikeOrganizationFolder(dirPath) {
+  try {
+    const entries = import_node_fs.readdirSync(dirPath, { withFileTypes: true }).filter((entry) => !entry.name.startsWith("."));
+    return entries.length > 0 && entries.every((entry) => entry.isDirectory());
+  } catch {
+    return false;
+  }
+}
+function findDefaultModelName(modelDirs) {
+  for (const modelDir of modelDirs) {
+    const topLevel = visibleSubdirectories(modelDir);
+    for (const candidate of topLevel) {
+      const candidatePath = import_node_path.default.join(modelDir, candidate);
+      if (directoryLooksLikeOrganizationFolder(candidatePath)) {
+        const nested = visibleSubdirectories(candidatePath)[0];
+        if (nested) {
+          return nested;
+        }
+      }
+      return candidate;
+    }
+  }
+  return;
+}
+function resolveModelDirs(env, settings) {
+  const envDir = trimString(env.OMLX_MODEL_DIR);
+  if (envDir) {
+    return [envDir];
+  }
+  const configuredDir = trimString(settings?.model?.model_dir);
+  if (configuredDir) {
+    return [configuredDir];
+  }
+  const configuredDirs = (settings?.model?.model_dirs ?? []).map((entry) => trimString(entry)).filter((entry) => Boolean(entry));
+  if (configuredDirs.length > 0) {
+    return configuredDirs;
+  }
+  const omlxHome = resolveOmlxHome(env);
+  return omlxHome ? [import_node_path.default.join(omlxHome, "models")] : [];
+}
+function resolveOmlxDefaults(env) {
+  const settings = readSettings(env);
+  const host = trimString(settings?.server?.host);
+  const port = typeof settings?.server?.port === "number" && Number.isFinite(settings.server.port) ? settings.server.port : undefined;
+  const model = findDefaultModelName(resolveModelDirs(env, settings));
+  return {
+    apiKey: trimString(env.OMLX_API_KEY) ?? trimString(settings?.auth?.api_key),
+    baseUrl: host && port ? `http://${host}:${port}/v1` : undefined,
+    model
+  };
+}
+
+// src/config.ts
+var DISTILL_VERSION = package_default.version;
+var DEFAULT_PROVIDER = "omlx";
+var DEFAULT_OLLAMA_MODEL = "qwen3.5:2b";
+var DEFAULT_OPENAI_MODEL = "gpt-4.1-mini";
+var DEFAULT_MODEL = DEFAULT_OMLX_MODEL;
+var DEFAULT_OLLAMA_HOST = "http://127.0.0.1:11434";
+var DEFAULT_HOST = DEFAULT_OMLX_BASE_URL;
+var DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
+var DEFAULT_TIMEOUT_MS = 90000;
+var DEFAULT_IDLE_MS = 1200;
+var DEFAULT_INTERACTIVE_GAP_MS = 180;
+var DEFAULT_PROGRESS_FRAME_MS = 120;
+
+class UsageError extends Error {
+  exitCode = 2;
+  constructor(message) {
+    super(message);
+    this.name = "UsageError";
+  }
+}
+function readFlagValue(argv, index, name) {
+  const current = argv[index];
+  const inline = current.slice(name.length + 1);
+  if (inline.length > 0) {
+    return { value: inline, nextIndex: index };
+  }
+  const next = argv[index + 1];
+  if (!next) {
+    throw new UsageError(`Missing value for ${name}.`);
+  }
+  return { value: next, nextIndex: index + 1 };
+}
+function coerceTimeout(input) {
+  const value = Number(input ?? DEFAULT_TIMEOUT_MS);
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new UsageError("Timeout must be a positive number.");
+  }
+  return Math.floor(value);
+}
+function parseBoolean(input, name) {
+  const value = input.trim().toLowerCase();
+  switch (value) {
+    case "true":
+    case "1":
+    case "yes":
+    case "on":
+      return true;
+    case "false":
+    case "0":
+    case "no":
+    case "off":
+      return false;
+    default:
+      throw new UsageError(`${name} must be true or false.`);
+  }
+}
+function normalizeHost(input) {
+  const value = (input ?? DEFAULT_HOST).trim();
+  if (!value) {
+    throw new UsageError("Host cannot be empty.");
+  }
+  return value.endsWith("/") ? value.slice(0, -1) : value;
+}
+function parseProvider(input) {
+  const value = input.trim().toLowerCase();
+  if (value === "ollama" || value === "openai" || value === "omlx") {
+    return value;
+  }
+  throw new UsageError(`Provider must be "ollama", "openai", or "omlx".`);
+}
+function resolveRuntimeDefaults(env, persisted) {
+  const omlxDefaults = resolveOmlxDefaults(env);
+  const provider = parseProvider(env.DISTILL_PROVIDER ?? persisted.provider ?? DEFAULT_PROVIDER);
+  const model = env.DISTILL_MODEL ?? persisted.model ?? (provider === "openai" ? DEFAULT_OPENAI_MODEL : provider === "ollama" ? DEFAULT_OLLAMA_MODEL : omlxDefaults.model ?? DEFAULT_MODEL);
+  const host = normalizeHost(provider === "openai" ? env.OPENAI_BASE_URL ?? persisted.host ?? DEFAULT_OPENAI_BASE_URL : provider === "ollama" ? env.OLLAMA_HOST ?? persisted.host ?? DEFAULT_OLLAMA_HOST : env.OMLX_BASE_URL ?? persisted.host ?? omlxDefaults.baseUrl ?? DEFAULT_HOST);
+  const apiKey = provider === "openai" ? env.OPENAI_API_KEY ?? persisted.apiKey ?? "" : provider === "omlx" ? env.OMLX_API_KEY ?? persisted.apiKey ?? omlxDefaults.apiKey ?? "" : "";
+  const timeoutMs = coerceTimeout(env.DISTILL_TIMEOUT_MS ?? String(persisted.timeoutMs ?? DEFAULT_TIMEOUT_MS));
+  const thinking = parseBoolean(env.DISTILL_THINKING ?? String(persisted.thinking ?? false), "Thinking");
+  return {
+    provider,
+    model,
+    host,
+    apiKey,
+    timeoutMs,
+    thinking
+  };
+}
+function parseConfigCommand(argv) {
+  if (argv.length === 1) {
+    return { kind: "configShow" };
+  }
+  const key = argv[1];
+  if (!["provider", "model", "host", "api-key", "timeout-ms", "thinking"].includes(key)) {
+    throw new UsageError(`Unknown config key: ${argv[1]}`);
+  }
+  if (argv.length === 2) {
+    return { kind: "configGet", key };
+  }
+  const rawValue = argv.slice(2).join(" ").trim();
+  if (!rawValue) {
+    throw new UsageError(`Missing value for config key ${key}.`);
+  }
+  if (key === "provider") {
+    return {
+      kind: "configSet",
+      key,
+      value: parseProvider(rawValue)
+    };
+  }
+  if (key === "thinking") {
+    return {
+      kind: "configSet",
+      key,
+      value: parseBoolean(rawValue, "Thinking")
+    };
+  }
+  if (key === "timeout-ms") {
+    return {
+      kind: "configSet",
+      key,
+      value: coerceTimeout(rawValue)
+    };
+  }
+  if (key === "host") {
+    return {
+      kind: "configSet",
+      key,
+      value: normalizeHost(rawValue)
+    };
+  }
+  return {
+    kind: "configSet",
+    key,
+    value: rawValue
+  };
+}
+function parseCommand(argv, env, persisted = {}) {
+  if (argv[0] === "config") {
+    return parseConfigCommand(argv);
+  }
+  if (argv.length === 1 && (argv[0] === "--help" || argv[0] === "-h")) {
+    return { kind: "help" };
+  }
+  if (argv.length === 1 && (argv[0] === "--version" || argv[0] === "-v")) {
+    return { kind: "version" };
+  }
+  const defaults = resolveRuntimeDefaults(env, persisted);
+  let provider = defaults.provider;
+  let model = defaults.model;
+  let host = defaults.host;
+  let apiKey = defaults.apiKey;
+  let timeoutMs = defaults.timeoutMs;
+  let thinking = defaults.thinking;
+  const questionParts = [];
+  for (let index = 0;index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === "--") {
+      questionParts.push(...argv.slice(index + 1));
+      break;
+    }
+    if (token === "--provider" || token.startsWith("--provider=")) {
+      const parsed = readFlagValue(argv, index, "--provider");
+      provider = parseProvider(parsed.value);
+      index = parsed.nextIndex;
+      continue;
+    }
+    if (token === "--model" || token.startsWith("--model=")) {
+      const parsed = readFlagValue(argv, index, "--model");
+      model = parsed.value;
+      index = parsed.nextIndex;
+      continue;
+    }
+    if (token === "--host" || token.startsWith("--host=")) {
+      const parsed = readFlagValue(argv, index, "--host");
+      host = parsed.value;
+      index = parsed.nextIndex;
+      continue;
+    }
+    if (token === "--api-key" || token.startsWith("--api-key=")) {
+      const parsed = readFlagValue(argv, index, "--api-key");
+      apiKey = parsed.value;
+      index = parsed.nextIndex;
+      continue;
+    }
+    if (token === "--timeout-ms" || token.startsWith("--timeout-ms=")) {
+      const parsed = readFlagValue(argv, index, "--timeout-ms");
+      timeoutMs = coerceTimeout(parsed.value);
+      index = parsed.nextIndex;
+      continue;
+    }
+    if (token === "--thinking" || token.startsWith("--thinking=")) {
+      const parsed = readFlagValue(argv, index, "--thinking");
+      thinking = parseBoolean(parsed.value, "Thinking");
+      index = parsed.nextIndex;
+      continue;
+    }
+    if (token.startsWith("-")) {
+      throw new UsageError(`Unknown flag: ${token}`);
+    }
+    questionParts.push(token);
+  }
+  const question = questionParts.join(" ").trim();
+  if (!question) {
+    throw new UsageError("A question is required.");
+  }
+  if (provider === "openai" && !apiKey) {
+    throw new UsageError("An API key is required for the openai provider. Set OPENAI_API_KEY or use --api-key.");
+  }
+  return {
+    kind: "run",
+    config: {
+      question,
+      provider,
+      model,
+      host: normalizeHost(host),
+      apiKey,
+      timeoutMs,
+      thinking
+    }
+  };
+}
+function formatUsage() {
+  return [
+    "Usage:",
+    '  cmd 2>&1 | distill "question"',
+    '  distill config model "Qwen3.5-2B"',
+    "  distill config thinking false",
+    "  distill config provider omlx",
+    "",
+    "Options:",
+    `  --provider <name>     LLM provider: ollama, openai, or omlx (default: ${DEFAULT_PROVIDER})`,
+    `  --model <name>        Model name (default: ${DEFAULT_MODEL}; omlx auto-detects local models)`,
+    "  --host <url>          API base URL (provider-specific; omlx defaults to local settings)",
+    "  --api-key <key>       API key for openai or omlx (env: OPENAI_API_KEY / OMLX_API_KEY)",
+    `  --timeout-ms <ms>     Request timeout in milliseconds (default: ${DEFAULT_TIMEOUT_MS})`,
+    "  --thinking <bool>     Enable or disable model thinking (default: false)",
+    "  --help                Show usage",
+    "  --version             Show version",
+    "",
+    "omlx defaults:",
+    "  Reads ~/.omlx/settings.json when available for host and api key."
+  ].join(`
+`);
+}
+
+// src/ollama.ts
+async function requestOllama({
+  host,
+  model,
+  prompt,
+  timeoutMs,
+  thinking,
+  fetchImpl = fetch
+}) {
+  const controller = new AbortController;
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const url = new URL("/api/generate", `${host}/`);
+    const response = await fetchImpl(url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        model,
+        prompt,
+        stream: false,
+        think: thinking,
+        options: {
+          temperature: 0.1,
+          num_predict: 80
+        }
+      }),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      throw new Error(`Ollama request failed with ${response.status}.`);
+    }
+    const rawText = await response.text();
+    let payload;
+    try {
+      payload = JSON.parse(rawText);
+    } catch {
+      throw new Error("Ollama returned invalid JSON.");
+    }
+    if (typeof payload !== "object" || payload === null || typeof payload.response !== "string") {
+      throw new Error("Ollama returned an invalid response payload.");
+    }
+    const output = payload.response.trim();
+    if (!output) {
+      throw new Error("Ollama returned an empty response.");
+    }
+    return output;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+// src/openai.ts
+function buildAuthHeaders(apiKey) {
+  const key = apiKey.trim();
+  return key ? { authorization: `Bearer ${key}` } : {};
+}
+async function resolveModelName(baseUrl, apiKey, fetchImpl, signal, requestedModel) {
+  const model = requestedModel.trim();
+  if (model && model !== "auto") {
+    return model;
+  }
+  const response = await fetchImpl(new URL("/v1/models", `${baseUrl}/`), {
+    method: "GET",
+    headers: buildAuthHeaders(apiKey),
+    signal
+  });
+  if (!response.ok) {
+    throw new Error(`OpenAI-compatible model discovery failed with ${response.status}.`);
+  }
+  const rawText = await response.text();
+  let payload;
+  try {
+    payload = JSON.parse(rawText);
+  } catch {
+    throw new Error("OpenAI-compatible model discovery returned invalid JSON.");
+  }
+  const models = Array.isArray(payload.data) ? payload.data.map((entry) => typeof entry.id === "string" ? entry.id.trim() : "").filter(Boolean) : [];
+  if (models.length === 0) {
+    throw new Error("OpenAI-compatible model discovery returned no models.");
+  }
+  return models[0];
+}
+async function requestOpenAI({
+  baseUrl,
+  apiKey,
+  model,
+  prompt,
+  timeoutMs,
+  fetchImpl = fetch
+}) {
+  const controller = new AbortController;
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const resolvedModel = await resolveModelName(baseUrl, apiKey, fetchImpl, controller.signal, model);
+    const url = new URL("/v1/chat/completions", `${baseUrl}/`);
+    const response = await fetchImpl(url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...buildAuthHeaders(apiKey)
+      },
+      body: JSON.stringify({
+        model: resolvedModel,
+        messages: [{ role: "user", content: prompt }],
+        temperature: 0.1,
+        max_tokens: 200
+      }),
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      throw new Error(`OpenAI request failed with ${response.status}.`);
+    }
+    const rawText = await response.text();
+    let payload;
+    try {
+      payload = JSON.parse(rawText);
+    } catch {
+      throw new Error("OpenAI returned invalid JSON.");
+    }
+    if (typeof payload !== "object" || payload === null || !Array.isArray(payload.choices) || payload.choices.length === 0) {
+      throw new Error("OpenAI returned an invalid response payload.");
+    }
+    const choice = payload.choices[0];
+    const content = choice?.message?.content?.trim();
+    if (!content) {
+      throw new Error("OpenAI returned an empty response.");
+    }
+    return content;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+// src/prompt.ts
+function buildBatchPrompt(question, input) {
+  return [
+    "You compress command output for another paid language model.",
+    "Rules:",
+    "- Answer only what the question asks.",
+    "- Use the same language as the question.",
+    "- No markdown.",
+    "- Keep the answer extremely short (but complete) unless explicitly asked to elaborate or not summarize.",
+    "- Prefer one sentence. Never exceed three short lines.",
+    "- Never ask for more input.",
+    '- If the command output is insufficient, reply only with "distill: Insufficient information to output anything." in the same language as the question.',
+    "- If the source is already shorter than your answer would be, prefer a minimal answer or reuse the source wording.",
+    "",
+    `Question: ${question}`,
+    "",
+    "Command output:",
+    input
+  ].join(`
+`);
+}
+function buildWatchPrompt(question, previousCycle, currentCycle) {
+  return [
+    "You compare two consecutive watch-mode command cycles for another paid language model.",
+    "Rules:",
+    "- Answer only what the question asks.",
+    "- Focus on what changed from the previous cycle to the current cycle.",
+    "- Use the same language as the question.",
+    "- No markdown.",
+    "- Keep the answer extremely short (but complete) unless explicitly asked to elaborate or not summarize.",
+    "- Prefer one sentence. Never exceed three short lines.",
+    '- If nothing relevant changed, reply only with "No relevant change." in the same language as the question.',
+    "- Never ask for more input.",
+    "",
+    `Question: ${question}`,
+    "",
+    "Previous cycle:",
+    previousCycle,
+    "",
+    "Current cycle:",
+    currentCycle
+  ].join(`
+`);
+}
+
+// src/summarizer.ts
+function requestLLM(config, prompt, fetchImpl) {
+  if (config.provider === "openai" || config.provider === "omlx") {
+    return requestOpenAI({
+      baseUrl: config.host,
+      apiKey: config.apiKey,
+      model: config.model,
+      prompt,
+      timeoutMs: config.timeoutMs,
+      fetchImpl
+    });
+  }
+  return requestOllama({
+    host: config.host,
+    model: config.model,
+    prompt,
+    timeoutMs: config.timeoutMs,
+    thinking: config.thinking,
+    fetchImpl
+  });
+}
+function createSummarizer(config, fetchImpl) {
+  return {
+    summarizeBatch(input) {
+      return requestLLM(config, buildBatchPrompt(config.question, input), fetchImpl);
+    },
+    summarizeWatch(previousCycle, currentCycle) {
+      return requestLLM(config, buildWatchPrompt(config.question, previousCycle, currentCycle), fetchImpl);
+    }
+  };
+}
+
+// src/text.ts
+var ANSI_PATTERN = /\u001B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
+var PROMPT_PATTERN = /(?:\[[Yy]\/[Nn]\]|\[[Nn]\/[Yy]\]|\([Yy]\/[Nn]\)|\([Nn]\/[Yy]\)|password:|passphrase:|continue\?|proceed\?)\s*$/i;
+function normalizeForModel(input) {
+  return input.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`).replace(ANSI_PATTERN, "").replace(/[ \t]+\n/g, `
+`).replace(/\n{3,}/g, `
+
+`).trim();
+}
+function hasPromptLikeTail(input) {
+  const tail = input.slice(-256);
+  return PROMPT_PATTERN.test(tail.trimEnd());
+}
+function hasRedrawSignal(input) {
+  return input.includes("\r") || input.includes("\x1B[2J") || input.includes("\x1Bc");
+}
+function structuralSignature(input) {
+  return normalizeForModel(input).split(`
+`).map((line) => line.toLowerCase().replace(/\b\d+\b/g, "#").replace(/[0-9a-f]{7,}/g, "<hex>").replace(/\s+/g, " ").trim()).filter(Boolean).slice(0, 24);
+}
+function structuralSimilarity(a, b) {
+  const left = structuralSignature(a);
+  const right = structuralSignature(b);
+  if (left.length === 0 || right.length === 0) {
+    return 0;
+  }
+  const leftSet = new Set(left);
+  const rightSet = new Set(right);
+  let overlap = 0;
+  for (const value of leftSet) {
+    if (rightSet.has(value)) {
+      overlap += 1;
+    }
+  }
+  return 2 * overlap / (leftSet.size + rightSet.size);
+}
+function looksLikeBadDistillation(source, candidate) {
+  const normalizedSource = normalizeForModel(source);
+  const normalizedCandidate = normalizeForModel(candidate);
+  if (!normalizedCandidate) {
+    return true;
+  }
+  const lowerCandidate = normalizedCandidate.toLowerCase();
+  if (lowerCandidate.includes("please provide") || lowerCandidate.includes("wish summarized") || lowerCandidate.includes("provided command output")) {
+    return true;
+  }
+  if (normalizedSource.length >= 1024) {
+    return normalizedCandidate.length >= normalizedSource.length * 0.8;
+  }
+  if (normalizedSource.length > 0) {
+    return normalizedCandidate === normalizedSource || normalizedCandidate.length > normalizedSource.length + 40;
+  }
+  return false;
+}
+function ensureTrailingNewline(text) {
+  return text.endsWith(`
+`) ? text : `${text}
+`;
+}
+
+// src/stream-distiller.ts
+var PROGRESS_FRAMES = ["-", "\\", "|", "/"];
+var PROGRESS_DOT_FRAMES = ["", ".", "..", "...", "..", "."];
+var PROGRESS_LABELS = {
+  collecting: "distill: waiting",
+  summarizing: "distill: summarizing"
+};
+
+class DistillSession {
+  summarizer;
+  stdout;
+  isTTY;
+  progress;
+  onProgressPhase;
+  onProgressStop;
+  idleMs;
+  interactiveGapMs;
+  progressFrameMs;
+  rawBuffers = [];
+  completedBursts = [];
+  currentBurstBuffers = [];
+  mode = "undecided";
+  progressPhase = "collecting";
+  sawRedraw = false;
+  idleTimer = null;
+  interactiveTimer = null;
+  progressTimer = null;
+  queue = Promise.resolve();
+  nextBurstId = 1;
+  renderedPairs = new Set;
+  emittedWatchOutput = false;
+  passthrough = false;
+  progressVisible = false;
+  progressFrameIndex = 0;
+  lastProgressRenderAt = 0;
+  constructor(options) {
+    this.summarizer = options.summarizer;
+    this.stdout = options.stdout;
+    this.isTTY = options.isTTY;
+    this.progress = options.progress ?? null;
+    this.onProgressPhase = options.onProgressPhase ?? null;
+    this.onProgressStop = options.onProgressStop ?? null;
+    this.idleMs = options.idleMs ?? DEFAULT_IDLE_MS;
+    this.interactiveGapMs = options.interactiveGapMs ?? DEFAULT_INTERACTIVE_GAP_MS;
+    this.progressFrameMs = options.progressFrameMs ?? DEFAULT_PROGRESS_FRAME_MS;
+    this.onProgressPhase?.(this.progressPhase);
+    this.startProgress();
+  }
+  push(chunk) {
+    if (chunk.length === 0) {
+      return;
+    }
+    if (this.passthrough) {
+      this.stdout.write(chunk);
+      return;
+    }
+    if (this.mode !== "watch") {
+      this.rawBuffers.push(chunk);
+    }
+    this.currentBurstBuffers.push(chunk);
+    this.sawRedraw ||= hasRedrawSignal(chunk.toString("utf8"));
+    this.restartIdleTimer();
+    this.restartInteractiveTimer();
+    this.renderProgressIfDue();
+  }
+  async end() {
+    this.clearTimers();
+    if (this.passthrough) {
+      this.stopProgress(true);
+      return;
+    }
+    this.closeCurrentBurst();
+    if (this.mode === "watch") {
+      this.scheduleLatestWatchRender();
+      await this.queue;
+      return;
+    }
+    const rawInput = Buffer.concat(this.rawBuffers).toString("utf8");
+    if (!rawInput) {
+      this.stopProgress(true);
+      return;
+    }
+    try {
+      this.setProgressPhase("summarizing");
+      const summary = await this.summarizer.summarizeBatch(normalizeForModel(rawInput));
+      if (looksLikeBadDistillation(rawInput, summary)) {
+        this.stopProgress(true);
+        this.stdout.write(Buffer.concat(this.rawBuffers));
+        return;
+      }
+      this.stopProgress(true);
+      this.stdout.write(ensureTrailingNewline(summary.trim()));
+    } catch {
+      this.stopProgress(true);
+      this.stdout.write(Buffer.concat(this.rawBuffers));
+    }
+  }
+  restartIdleTimer() {
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+    }
+    this.idleTimer = setTimeout(() => {
+      this.closeCurrentBurst();
+      if (this.mode === "undecided" && this.shouldPromoteToWatch()) {
+        this.promoteToWatch();
+        this.scheduleLatestWatchRender();
+      }
+    }, this.idleMs);
+  }
+  restartInteractiveTimer() {
+    if (this.mode !== "undecided") {
+      return;
+    }
+    if (this.interactiveTimer) {
+      clearTimeout(this.interactiveTimer);
+    }
+    const tail = this.getTail();
+    if (!hasPromptLikeTail(tail)) {
+      return;
+    }
+    this.interactiveTimer = setTimeout(() => {
+      if (this.mode !== "undecided") {
+        return;
+      }
+      if (!hasPromptLikeTail(this.getTail())) {
+        return;
+      }
+      this.mode = "interactive";
+      this.passthrough = true;
+      this.clearTimers();
+      this.stopProgress(true);
+      this.stdout.write(Buffer.concat(this.rawBuffers));
+    }, this.interactiveGapMs);
+  }
+  clearTimers() {
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = null;
+    }
+    if (this.interactiveTimer) {
+      clearTimeout(this.interactiveTimer);
+      this.interactiveTimer = null;
+    }
+  }
+  startProgress() {
+    if (!this.progress || this.progressFrameMs <= 0 || this.progressTimer) {
+      return;
+    }
+    this.renderProgress();
+    this.progressTimer = setInterval(() => {
+      if (this.progressTimer === null || this.mode === "watch" || this.passthrough) {
+        return;
+      }
+      this.renderProgress();
+    }, this.progressFrameMs);
+  }
+  setProgressPhase(phase) {
+    if (this.progressPhase === phase) {
+      return;
+    }
+    this.progressPhase = phase;
+    this.progressFrameIndex = 0;
+    this.onProgressPhase?.(phase);
+    this.renderProgress();
+  }
+  renderProgressIfDue() {
+    if (!this.progress || this.mode === "watch" || this.passthrough) {
+      return;
+    }
+    if (Date.now() - this.lastProgressRenderAt < this.progressFrameMs) {
+      return;
+    }
+    this.renderProgress();
+  }
+  renderProgress() {
+    if (!this.progress) {
+      return;
+    }
+    const frame = PROGRESS_FRAMES[this.progressFrameIndex % PROGRESS_FRAMES.length];
+    const dots = PROGRESS_DOT_FRAMES[Math.floor(this.progressFrameIndex / PROGRESS_FRAMES.length) % PROGRESS_DOT_FRAMES.length];
+    this.progressFrameIndex += 1;
+    this.lastProgressRenderAt = Date.now();
+    this.progress.write(`\r\x1B[2K${frame} ${PROGRESS_LABELS[this.progressPhase]}${dots}`);
+    this.progressVisible = true;
+  }
+  stopProgress(clearLine = false) {
+    if (this.progressTimer) {
+      clearInterval(this.progressTimer);
+      this.progressTimer = null;
+    }
+    this.onProgressStop?.();
+    if (!clearLine || !this.progressVisible || !this.progress) {
+      return;
+    }
+    this.progress.write("\r\x1B[2K");
+    this.progressVisible = false;
+  }
+  closeCurrentBurst() {
+    if (this.currentBurstBuffers.length === 0 || this.passthrough) {
+      return;
+    }
+    const raw = Buffer.concat(this.currentBurstBuffers).toString("utf8");
+    this.currentBurstBuffers = [];
+    if (!raw) {
+      return;
+    }
+    this.completedBursts.push({
+      id: this.nextBurstId,
+      raw,
+      normalized: normalizeForModel(raw)
+    });
+    this.nextBurstId += 1;
+  }
+  shouldPromoteToWatch() {
+    if (this.completedBursts.length < 2) {
+      return false;
+    }
+    const previous = this.completedBursts[this.completedBursts.length - 2];
+    const current = this.completedBursts[this.completedBursts.length - 1];
+    const similarity = structuralSimilarity(previous.raw, current.raw);
+    return this.sawRedraw || similarity >= 0.55;
+  }
+  promoteToWatch() {
+    if (this.mode === "watch") {
+      return;
+    }
+    this.mode = "watch";
+    this.rawBuffers.length = 0;
+    this.clearTimers();
+    this.stopProgress(true);
+  }
+  scheduleLatestWatchRender() {
+    if (this.completedBursts.length < 2) {
+      return;
+    }
+    const previous = this.completedBursts[this.completedBursts.length - 2];
+    const current = this.completedBursts[this.completedBursts.length - 1];
+    const key = `${previous.id}:${current.id}`;
+    if (this.renderedPairs.has(key)) {
+      return;
+    }
+    this.renderedPairs.add(key);
+    this.queue = this.queue.then(async () => {
+      try {
+        const summary = await this.summarizer.summarizeWatch(previous.normalized, current.normalized);
+        if (looksLikeBadDistillation(current.raw, summary)) {
+          this.renderWatchFallback(current.raw);
+          return;
+        }
+        this.renderWatchSummary(summary.trim());
+        this.trimWatchHistory();
+      } catch {
+        this.renderWatchFallback(current.raw);
+      }
+    });
+  }
+  renderWatchSummary(summary) {
+    const output = ensureTrailingNewline(summary);
+    if (this.isTTY) {
+      this.stdout.write(`\x1B[2J\x1B[H${output}`);
+      this.emittedWatchOutput = true;
+      return;
+    }
+    if (this.emittedWatchOutput) {
+      this.stdout.write(`
+`);
+    }
+    this.stdout.write(output);
+    this.emittedWatchOutput = true;
+  }
+  renderWatchFallback(raw) {
+    this.mode = "interactive";
+    this.passthrough = true;
+    this.stopProgress(true);
+    this.stdout.write(raw);
+  }
+  getTail() {
+    const tailBuffers = [];
+    let remaining = 256;
+    for (let index = this.rawBuffers.length - 1;index >= 0 && remaining > 0; index -= 1) {
+      const chunk = this.rawBuffers[index];
+      if (chunk.length <= remaining) {
+        tailBuffers.unshift(chunk);
+        remaining -= chunk.length;
+        continue;
+      }
+      tailBuffers.unshift(chunk.subarray(chunk.length - remaining));
+      remaining = 0;
+    }
+    return Buffer.concat(tailBuffers).toString("utf8");
+  }
+  trimWatchHistory() {
+    if (this.mode !== "watch" || this.completedBursts.length <= 2) {
+      return;
+    }
+    this.completedBursts.splice(0, this.completedBursts.length - 2);
+  }
+}
+
+// src/user-config.ts
+var import_promises = require("node:fs/promises");
+var import_node_path2 = __toESM(require("node:path"));
+function resolveConfigBaseDir(env) {
+  const xdg = env.XDG_CONFIG_HOME?.trim();
+  if (xdg) {
+    return import_node_path2.default.join(xdg, "distill");
+  }
+  const home = env.HOME?.trim();
+  if (!home) {
+    throw new Error("Could not resolve a home directory for distill config.");
+  }
+  return import_node_path2.default.join(home, ".config", "distill");
+}
+function resolveConfigPath(env) {
+  const explicit = env.DISTILL_CONFIG_PATH?.trim();
+  if (explicit) {
+    return explicit;
+  }
+  return import_node_path2.default.join(resolveConfigBaseDir(env), "config.json");
+}
+async function readPersistedConfig(env) {
+  const configPath = resolveConfigPath(env);
+  try {
+    const raw = await import_promises.readFile(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") {
+      return {};
+    }
+    return parsed;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return {};
+    }
+    throw error;
+  }
+}
+async function writePersistedConfig(env, config) {
+  const configPath = resolveConfigPath(env);
+  await import_promises.mkdir(import_node_path2.default.dirname(configPath), { recursive: true });
+  await import_promises.writeFile(configPath, `${JSON.stringify(config, null, 2)}
+`);
+}
+async function setPersistedConfigValue(env, key, value) {
+  const current = await readPersistedConfig(env);
+  if (key === "provider") {
+    current.provider = String(value);
+  } else if (key === "timeout-ms") {
+    current.timeoutMs = Number(value);
+  } else if (key === "thinking") {
+    current.thinking = Boolean(value);
+  } else if (key === "host") {
+    current.host = String(value);
+  } else if (key === "api-key") {
+    current.apiKey = String(value);
+  } else {
+    current.model = String(value);
+  }
+  await writePersistedConfig(env, current);
+  return current;
+}
+function getPersistedConfigValue(config, key) {
+  if (key === "provider") {
+    return config.provider;
+  }
+  if (key === "timeout-ms") {
+    return config.timeoutMs;
+  }
+  if (key === "thinking") {
+    return config.thinking;
+  }
+  if (key === "host") {
+    return config.host;
+  }
+  if (key === "api-key") {
+    return config.apiKey;
+  }
+  return config.model;
+}
+
+// src/cli.ts
+async function run() {
+  const persisted = await readPersistedConfig(process.env);
+  const command = parseCommand(process.argv.slice(2), process.env, persisted);
+  if (command.kind === "help") {
+    process.stdout.write(`${formatUsage()}
+`);
+    return 0;
+  }
+  if (command.kind === "version") {
+    process.stdout.write(`${DISTILL_VERSION}
+`);
+    return 0;
+  }
+  if (command.kind === "configShow") {
+    process.stdout.write([
+      `path=${resolveConfigPath(process.env)}`,
+      `provider=${persisted.provider ?? ""}`,
+      `model=${persisted.model ?? ""}`,
+      `host=${persisted.host ?? ""}`,
+      `api-key=${persisted.apiKey ? "***" : ""}`,
+      `timeout-ms=${persisted.timeoutMs ?? ""}`,
+      `thinking=${persisted.thinking ?? ""}`
+    ].join(`
+`) + `
+`);
+    return 0;
+  }
+  if (command.kind === "configGet") {
+    const value = getPersistedConfigValue(persisted, command.key);
+    process.stdout.write(`${value ?? ""}
+`);
+    return 0;
+  }
+  if (command.kind === "configSet") {
+    await setPersistedConfigValue(process.env, command.key, command.value);
+    process.stdout.write(`${command.key}=${String(command.value)}
+`);
+    return 0;
+  }
+  if (process.stdin.isTTY) {
+    throw new UsageError("stdin is required.");
+  }
+  const progressProtocol = process.env.DISTILL_PROGRESS_PROTOCOL === "stderr";
+  const progress = progressProtocol ? undefined : process.stderr.isTTY ? process.stderr : process.stdout.isTTY ? process.stdout : undefined;
+  const emitProgressPhase = progressProtocol ? (phase) => {
+    process.stderr.write(`__DISTILL_PROGRESS__:phase:${phase}
+`);
+  } : undefined;
+  const emitProgressStop = progressProtocol ? () => {
+    process.stderr.write(`__DISTILL_PROGRESS__:stop
+`);
+  } : undefined;
+  const session = new DistillSession({
+    summarizer: createSummarizer(command.config),
+    stdout: process.stdout,
+    isTTY: Boolean(process.stdout.isTTY),
+    progress,
+    onProgressPhase: emitProgressPhase,
+    onProgressStop: emitProgressStop
+  });
+  await new Promise((resolve, reject) => {
+    process.stdin.on("data", (chunk) => {
+      session.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    });
+    process.stdin.on("end", resolve);
+    process.stdin.on("error", reject);
+    process.stdin.resume();
+  });
+  await session.end();
+  return 0;
+}
+run().then((code) => {
+  process.exit(code);
+}).catch((error) => {
+  if (error instanceof UsageError) {
+    process.stderr.write(`${error.message}
+
+${formatUsage()}
+`);
+    process.exit(error.exitCode);
+  }
+  process.stderr.write(error instanceof Error ? `${error.message}
+` : `Unexpected error.
+`);
+  process.exit(1);
+});

package/package.json

@@ -1,27 +1,19 @@
 {
   "name": "@cowsea2012/distill",
-  "version": "0.1.31",
+  "version": "0.1.33",
   "description": "Compress command output for downstream LLMs.",
   "license": "MIT",
   "bin": {
     "distill": "bin/distill.js"
   },
-  "scripts": {
-    "prepack": "node ../../scripts/prepack-check.js"
-  },
   "files": [
-    "bin",
+    "bin/distill.js",
+    "dist/cli.js",
     "README.md"
   ],
   "engines": {
     "node": ">=18"
   },
-  "optionalDependencies": {
-    "@cowsea2012/distill-darwin-arm64": "0.1.31",
-    "@cowsea2012/distill-darwin-x64": "0.1.31",
-    "@cowsea2012/distill-linux-arm64": "0.1.31",
-    "@cowsea2012/distill-linux-x64": "0.1.31"
-  },
   "publishConfig": {
     "access": "public"
   }