flavor-code 1.4.2 → 1.4.3

package/dist/chunk-RV3EXUXM.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { createRequire as createFlavorRequire } from "node:module"; const require = createFlavorRequire(import.meta.url);
+
+// src/utils/version.ts
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+var cached;
+function packageVersion() {
+  if (cached !== void 0) return cached;
+  let directory = dirname(fileURLToPath(import.meta.url));
+  for (; ; ) {
+    try {
+      const manifest = JSON.parse(readFileSync(join(directory, "package.json"), "utf8"));
+      if (typeof manifest.version === "string" && manifest.version.length > 0) {
+        cached = manifest.version;
+        return cached;
+      }
+    } catch {
+    }
+    const parent = dirname(directory);
+    if (parent === directory) break;
+    directory = parent;
+  }
+  throw new Error("package.json with a version field was not found");
+}
+
+export {
+  packageVersion
+};

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
+};