flavor-code 1.4.1 → 1.4.3-beta.2

package/dist/chunk-TIEOVQW6.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import { createRequire as createFlavorRequire } from "node:module"; const require = createFlavorRequire(import.meta.url);
+
+// src/utils/intl.ts
+var graphemeSegmenter;
+function getGraphemeSegmenter() {
+  return graphemeSegmenter ??= new Intl.Segmenter(void 0, { granularity: "grapheme" });
+}
+function detectSystemLocale() {
+  try {
+    const locale = Intl.DateTimeFormat().resolvedOptions().locale;
+    if (locale && locale.length >= 2) return locale;
+  } catch {
+  }
+  for (const key of ["LANG", "LC_ALL", "LC_MESSAGES"]) {
+    const raw = process.env[key];
+    if (!raw || raw === "C" || raw === "POSIX") continue;
+    const match = raw.match(/^([a-z]{2})_([A-Z]{2})(?:[.@].*)?$/);
+    if (match) return `${match[1]}-${match[2]}`;
+  }
+  return "zh-CN";
+}
+function resolveLanguage(explicit) {
+  if (explicit !== void 0) return explicit;
+  return detectSystemLocale();
+}
+function languageInstruction(language) {
+  const label = LANG_LABELS.get(language) ?? language;
+  return `Always respond in ${label}. Do NOT reply in any other language unless the user explicitly asks for it.`;
+}
+var LANG_LABELS = /* @__PURE__ */ new Map([
+  ["zh-CN", "Simplified Chinese (zh-CN)"],
+  ["zh-TW", "Traditional Chinese (zh-TW)"],
+  ["zh-HK", "Traditional Chinese (zh-HK)"],
+  ["ja-JP", "Japanese (ja-JP)"],
+  ["ko-KR", "Korean (ko-KR)"],
+  ["en-US", "English (en-US)"],
+  ["en-GB", "English (en-GB)"],
+  ["fr-FR", "French (fr-FR)"],
+  ["de-DE", "German (de-DE)"],
+  ["es-ES", "Spanish (es-ES)"],
+  ["pt-BR", "Portuguese (pt-BR)"],
+  ["ru-RU", "Russian (ru-RU)"],
+  ["ar-SA", "Arabic (ar-SA)"],
+  ["vi-VN", "Vietnamese (vi-VN)"],
+  ["th-TH", "Thai (th-TH)"],
+  ["id-ID", "Indonesian (id-ID)"]
+]);
+
+// src/utils/envUtils.ts
+function isEnvTruthy(value) {
+  if (typeof value === "boolean") return value;
+  return value === "1" || value?.toLowerCase() === "true" || value?.toLowerCase() === "yes";
+}
+
+export {
+  isEnvTruthy,
+  getGraphemeSegmenter,
+  resolveLanguage,
+  languageInstruction
+};

package/dist/chunk-WLZUAVVU.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { createRequire as createFlavorRequire } from "node:module"; const require = createFlavorRequire(import.meta.url);
+
+// src/utils/redact.ts
+function redactErrorText(text) {
+  return text.replace(/\bsk-[A-Za-z0-9_-]+\b/g, "[redacted]").replace(/(authorization|api[_ -]?key|token)\s*[:=]\s*\S+/gi, "$1=[redacted]");
+}
+function redactSecrets(input, secrets) {
+  return secrets.reduce((text, secret) => text.replaceAll(secret, "[redacted]"), input);
+}
+
+export {
+  redactErrorText,
+  redactSecrets
+};

package/dist/chunk-X442CJJH.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+import { createRequire as createFlavorRequire } from "node:module"; const require = createFlavorRequire(import.meta.url);
+
+// src/utils/usage-summary.ts
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function parseUsageEntries(raw) {
+  const entries = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (parsed.event !== "flavor-usage") continue;
+    if (typeof parsed.provider !== "string" || typeof parsed.model !== "string") continue;
+    entries.push({
+      event: "flavor-usage",
+      sessionId: typeof parsed.sessionId === "string" ? parsed.sessionId : void 0,
+      provider: parsed.provider,
+      model: parsed.model,
+      inputTokens: asNumber(parsed.inputTokens),
+      cacheReadTokens: asNumber(parsed.cacheReadTokens),
+      cacheCreationTokens: asNumber(parsed.cacheCreationTokens),
+      totalInputTokens: asNumber(parsed.totalInputTokens),
+      cacheHitRatio: asNumber(parsed.cacheHitRatio)
+    });
+  }
+  return entries;
+}
+function summarizeUsage(entries) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const key = `${entry.provider}:${entry.model}`;
+    let stats = groups.get(key);
+    if (stats === void 0) {
+      stats = {
+        provider: entry.provider,
+        model: entry.model,
+        requests: 0,
+        inputTokens: 0,
+        cacheReadTokens: 0,
+        cacheCreationTokens: 0,
+        totalInputTokens: 0,
+        minHitRatio: Number.POSITIVE_INFINITY,
+        averageHitRatio: 0
+      };
+      groups.set(key, stats);
+    }
+    stats.requests += 1;
+    stats.inputTokens += entry.inputTokens;
+    stats.cacheReadTokens += entry.cacheReadTokens;
+    stats.cacheCreationTokens += entry.cacheCreationTokens;
+    stats.totalInputTokens += entry.totalInputTokens;
+    stats.minHitRatio = Math.min(stats.minHitRatio, entry.cacheHitRatio);
+    stats.averageHitRatio += entry.cacheHitRatio;
+  }
+  const byModel = [...groups.values()].map((stats) => ({
+    ...stats,
+    minHitRatio: Number.isFinite(stats.minHitRatio) ? stats.minHitRatio : 0,
+    averageHitRatio: stats.requests > 0 ? stats.averageHitRatio / stats.requests : 0
+  })).sort((left, right) => right.totalInputTokens - left.totalInputTokens);
+  const totalInputTokens = entries.reduce((sum, entry) => sum + entry.totalInputTokens, 0);
+  const totalCacheReadTokens = entries.reduce((sum, entry) => sum + entry.cacheReadTokens, 0);
+  return {
+    requests: entries.length,
+    sessionId: entries.length > 0 ? entries[entries.length - 1]?.sessionId : void 0,
+    byModel,
+    totalInputTokens,
+    totalCacheReadTokens,
+    cacheShare: totalInputTokens > 0 ? totalCacheReadTokens / totalInputTokens : 0
+  };
+}
+function formatTokens(value) {
+  if (value < 1e3) return String(value);
+  return `${(value / 1e3).toFixed(1)}k`;
+}
+function formatUsageSummary(summary) {
+  if (summary.requests === 0) return "No usage recorded in this session yet.";
+  const sessionLabel = summary.sessionId ?? "unknown";
+  const header = `Usage for session ${sessionLabel} (${summary.requests} request${summary.requests === 1 ? "" : "s"}):`;
+  const columns = summary.byModel.map((stats) => [
+    stats.provider,
+    stats.model,
+    String(stats.requests),
+    `${stats.minHitRatio.toFixed(2)}\u2192${stats.averageHitRatio.toFixed(2)}`,
+    formatTokens(stats.inputTokens),
+    formatTokens(stats.cacheReadTokens),
+    formatTokens(stats.cacheCreationTokens)
+  ]);
+  const titles = ["provider", "model", "reqs", "hit(min\u2192avg)", "input", "cacheRead", "cacheWrite"];
+  const widths = titles.map(
+    (title, index) => Math.max(title.length, ...columns.map((row) => row[index]?.length ?? 0))
+  );
+  const render = (row, indent) => indent + row.map((cell, index) => cell.padEnd(widths[index] ?? cell.length)).join("  ").trimEnd();
+  const table = [render(titles, "  "), ...columns.map((row) => render(row, "  "))].join("\n");
+  const cachePercent = (summary.cacheShare * 100).toFixed(1);
+  const total = `Total input tokens: ${formatTokens(summary.totalInputTokens)} (cache read ${formatTokens(summary.totalCacheReadTokens)}, ${cachePercent}%)`;
+  return `${header}
+
+${table}
+
+${total}`;
+}
+
+export {
+  parseUsageEntries,
+  summarizeUsage,
+  formatUsageSummary
+};

package/dist/{chunk-RAYH6K2H.js → chunk-Y7EH4NVO.js}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { createRequire } from "node:module"; const require = createRequire(import.meta.url);
+import { createRequire as createFlavorRequire } from "node:module"; const require = createFlavorRequire(import.meta.url);
 
 // src/ui/task-progress-model.ts
 var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];

package/dist/{chunk-S32JRDZK.js → chunk-ZKKVSR37.js}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { createRequire } from "node:module"; const require = createRequire(import.meta.url);
+import { createRequire as createFlavorRequire } from "node:module"; const require = createFlavorRequire(import.meta.url);
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -15,6 +15,10 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -35,5 +39,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 export {
   __require,
   __commonJS,
+  __export,
   __toESM
 };

package/dist/{claude-ink-JZXNSAQS.js → claude-ink-BE56DB6N.js}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { createRequire } from "node:module"; const require = createRequire(import.meta.url);
+import { createRequire as createFlavorRequire } from "node:module"; const require = createFlavorRequire(import.meta.url);
 import {
   AlternateScreen,
   Box_default,
@@ -10,9 +10,14 @@ import {
   useStdout,
   use_app_default,
   use_input_default
-} from "./chunk-VMQWXQEC.js";
-import "./chunk-ZJCAQXA7.js";
-import "./chunk-S32JRDZK.js";
+} from "./chunk-T6RE76D2.js";
+import "./chunk-PULWAH6E.js";
+import "./chunk-AA4QNKTF.js";
+import "./chunk-TIEOVQW6.js";
+import "./chunk-IU3UBETC.js";
+import "./chunk-3UX2CGDW.js";
+import "./chunk-KRWWCVXA.js";
+import "./chunk-ZKKVSR37.js";
 export {
   AlternateScreen,
   Box_default as Box,

package/dist/cli-3MF6EL2H.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+import { createRequire as createFlavorRequire } from "node:module"; const require = createFlavorRequire(import.meta.url);
+import {
+  createExecutionEnvironment,
+  createProductionRuntime
+} from "./chunk-IDJAHEG6.js";
+import "./chunk-TIEOVQW6.js";
+import "./chunk-OKHV7CTB.js";
+import {
+  DEFAULT_MAX_OUTPUT_BYTES,
+  executeShell
+} from "./chunk-K7UGGWJV.js";
+import "./chunk-IU3UBETC.js";
+import "./chunk-PZ5NKRVA.js";
+import "./chunk-6F66UXBI.js";
+import "./chunk-3UX2CGDW.js";
+import "./chunk-7Y64WNBB.js";
+import "./chunk-CVP5OUHD.js";
+import "./chunk-3563SW4X.js";
+import "./chunk-RBAZLFKB.js";
+import "./chunk-FAJ6YDZK.js";
+import "./chunk-WLZUAVVU.js";
+import "./chunk-RV3EXUXM.js";
+import "./chunk-IQEEFDEE.js";
+import "./chunk-GTFP2R5I.js";
+import "./chunk-HGTCIHWA.js";
+import "./chunk-SJUIIHIA.js";
+import "./chunk-BDX777JR.js";
+import "./chunk-6X62CGMA.js";
+import {
+  external_exports
+} from "./chunk-EWD7FWTH.js";
+import "./chunk-KRWWCVXA.js";
+import "./chunk-X442CJJH.js";
+import "./chunk-ZKKVSR37.js";
+
+// src/eval/cli.ts
+import { readFile, writeFile } from "fs/promises";
+import { dirname, resolve } from "path";
+
+// src/execution/local.ts
+var LocalExecutionEnvironment = class {
+  kind = "local";
+  exec(request, signal) {
+    const cancellation = signal ?? new AbortController().signal;
+    return executeShell(request.cwd, {
+      command: request.command,
+      args: [...request.args],
+      cwd: request.cwd,
+      ...request.timeoutMs === void 0 ? {} : { timeoutMs: request.timeoutMs }
+    }, cancellation, DEFAULT_MAX_OUTPUT_BYTES);
+  }
+  async dispose() {
+  }
+};
+
+// src/eval/schema.ts
+var EvaluationSpecSchema = external_exports.object({
+  name: external_exports.string().trim().min(1).max(256),
+  workspace: external_exports.string().trim().min(1).max(32768),
+  prompt: external_exports.string().trim().min(1).max(1e6),
+  verification: external_exports.array(external_exports.object({
+    command: external_exports.string().trim().min(1).max(32768),
+    args: external_exports.array(external_exports.string()).max(1e3),
+    timeoutMs: external_exports.number().int().positive().max(864e5).optional()
+  }).strict()).min(1).max(100),
+  maxTokens: external_exports.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional()
+}).strict();
+
+// src/eval/runner.ts
+var DEFAULT_VERIFICATION_TIMEOUT_MS = 10 * 6e4;
+async function runEvaluation(spec, dependencies) {
+  const now = dependencies.now ?? Date.now;
+  const started = now();
+  let input = 0;
+  let output = 0;
+  const runtime = await dependencies.createRuntime({
+    workspace: spec.workspace,
+    output: (event) => {
+      if (event.type === "usage") {
+        input = event.totalInputTokens;
+        output = event.totalOutputTokens;
+      } else if (event.type === "done" && input === 0 && output === 0) {
+        input = event.usage.inputTokens;
+        output = event.usage.outputTokens;
+      }
+    }
+  });
+  try {
+    await runtime.session.start();
+    await runtime.session.submit(spec.prompt);
+  } finally {
+    await runtime.session.close();
+    await runtime.dispose();
+  }
+  const verification = [];
+  for (const check of spec.verification) {
+    const result = await dependencies.executionEnvironment.exec({
+      command: check.command,
+      args: check.args,
+      cwd: spec.workspace,
+      timeoutMs: check.timeoutMs ?? DEFAULT_VERIFICATION_TIMEOUT_MS
+    });
+    verification.push({
+      command: [check.command, ...check.args].join(" "),
+      exitCode: result.exitCode,
+      passed: result.exitCode === 0,
+      stdout: result.stdout,
+      stderr: result.stderr
+    });
+  }
+  const total = input + output;
+  const withinBudget = spec.maxTokens === void 0 || total <= spec.maxTokens;
+  return {
+    name: spec.name,
+    workspace: spec.workspace,
+    passed: withinBudget && verification.every((item) => item.passed),
+    durationMs: Math.max(0, now() - started),
+    tokens: { input, output, total, withinBudget },
+    verification
+  };
+}
+
+// src/eval/cli.ts
+async function runEvaluationFile(path, outputPath) {
+  const specPath = resolve(path);
+  const parsed = EvaluationSpecSchema.parse(JSON.parse(await readFile(specPath, "utf8")));
+  const workspace = resolve(dirname(specPath), parsed.workspace);
+  const spec = {
+    name: parsed.name,
+    prompt: parsed.prompt,
+    workspace,
+    verification: parsed.verification.map((step) => ({
+      command: step.command,
+      args: step.args,
+      ...step.timeoutMs === void 0 ? {} : { timeoutMs: step.timeoutMs }
+    })),
+    ...parsed.maxTokens === void 0 ? {} : { maxTokens: parsed.maxTokens }
+  };
+  const configured = await import("./load-QK6CMLDF.js").then(({ loadConfig }) => loadConfig({ cwd: workspace, home: process.env.USERPROFILE ?? process.env.HOME ?? workspace }));
+  const environment = createExecutionEnvironment(workspace, configured.config.execution) ?? new LocalExecutionEnvironment();
+  let report;
+  try {
+    report = await runEvaluation(spec, {
+      createRuntime: (options) => createProductionRuntime({
+        ...options,
+        home: process.env.USERPROFILE ?? process.env.HOME ?? workspace,
+        approvalPolicy: "deny"
+      }),
+      executionEnvironment: environment
+    });
+  } finally {
+    await environment.dispose();
+  }
+  const body = `${JSON.stringify(report, null, 2)}
+`;
+  if (outputPath === void 0) process.stdout.write(body);
+  else await writeFile(resolve(outputPath), body, "utf8");
+  return report.passed ? 0 : 1;
+}
+export {
+  runEvaluationFile
+};