clawvault 3.2.1 → 3.4.0

package/dist/chunk-ZKWPCBYT.js

@@ -0,0 +1,600 @@
+import {
+  parseSessionFile
+} from "./chunk-MW5C6ZQA.js";
+import {
+  Compressor
+} from "./chunk-J3YUXVID.js";
+import {
+  normalizeObservationContent,
+  parseObservationMarkdown
+} from "./chunk-FHFUXL6G.js";
+
+// src/commands/benchmark.ts
+import * as path2 from "path";
+
+// src/observer/benchmark/format.ts
+function percent(value) {
+  return `${(value * 100).toFixed(1)}%`;
+}
+function formatObserverBenchmarkSummary(report) {
+  const lines = [];
+  lines.push("Observer benchmark report");
+  lines.push(`Generated: ${report.generatedAt}`);
+  lines.push(`Fixtures: ${report.fixtureCount}`);
+  lines.push(`Provider: ${report.provider}${report.model ? ` (${report.model})` : ""}`);
+  lines.push("");
+  lines.push("Aggregate metrics");
+  lines.push(`- Precision: ${percent(report.aggregate.precision)} (noise ${percent(report.aggregate.noiseRatio)})`);
+  lines.push(`- Recall (important events): ${percent(report.aggregate.recall)}`);
+  lines.push(`- Keyword preservation: ${percent(report.aggregate.keywordPreservation)}`);
+  lines.push(`- Type accuracy: ${percent(report.aggregate.typeAccuracy)}`);
+  lines.push(`- Overall score: ${percent(report.aggregate.overall)}`);
+  lines.push("");
+  lines.push("Per-fixture");
+  for (const fixture of report.fixtures) {
+    lines.push(`- ${fixture.fixtureId}`);
+    lines.push(`  overall=${percent(fixture.scoring.metrics.overall)} precision=${percent(fixture.scoring.metrics.precision)} recall=${percent(fixture.scoring.metrics.recall)} keyword=${percent(fixture.scoring.metrics.keywordPreservation)} type=${percent(fixture.scoring.metrics.typeAccuracy)}`);
+    lines.push(`  matches=${fixture.scoring.matches.length} expected=${fixture.expectedCount} actual=${fixture.actualCount} missed-important=${fixture.scoring.missedImportant.length} noise=${fixture.scoring.noiseObservations.length}`);
+    if (fixture.scoring.missingKeywords.length > 0) {
+      lines.push(`  missing keywords: ${fixture.scoring.missingKeywords.slice(0, 5).join(", ")}${fixture.scoring.missingKeywords.length > 5 ? " \u2026" : ""}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/observer/benchmark/fixtures.ts
+import * as fs from "fs";
+import * as path from "path";
+function readJsonConfig(configPath) {
+  if (!fs.existsSync(configPath)) {
+    return {};
+  }
+  const raw = fs.readFileSync(configPath, "utf-8").trim();
+  if (!raw) {
+    return {};
+  }
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Invalid fixture config (expected object): ${configPath}`);
+  }
+  return parsed;
+}
+function ensureFile(filePath, label) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Missing ${label}: ${filePath}`);
+  }
+  const stat = fs.statSync(filePath);
+  if (!stat.isFile()) {
+    throw new Error(`${label} is not a file: ${filePath}`);
+  }
+}
+function loadObserverBenchmarkFixtures(fixturesDir) {
+  const resolvedRoot = path.resolve(fixturesDir);
+  if (!fs.existsSync(resolvedRoot)) {
+    throw new Error(`Fixtures directory not found: ${resolvedRoot}`);
+  }
+  if (!fs.statSync(resolvedRoot).isDirectory()) {
+    throw new Error(`Fixtures path is not a directory: ${resolvedRoot}`);
+  }
+  const fixtureDirs = fs.readdirSync(resolvedRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort((left, right) => left.localeCompare(right));
+  const fixtures = [];
+  for (const fixtureId of fixtureDirs) {
+    const fixtureDir = path.join(resolvedRoot, fixtureId);
+    const transcriptPath = path.join(fixtureDir, "transcript.md");
+    const expectedPath = path.join(fixtureDir, "expected.md");
+    const configPath = path.join(fixtureDir, "config.json");
+    ensureFile(transcriptPath, "transcript fixture");
+    ensureFile(expectedPath, "expected observations fixture");
+    const transcript = fs.readFileSync(transcriptPath, "utf-8");
+    const expected = fs.readFileSync(expectedPath, "utf-8");
+    const config = readJsonConfig(configPath);
+    fixtures.push({
+      id: fixtureId,
+      dir: fixtureDir,
+      transcriptPath,
+      expectedPath,
+      transcript,
+      expected,
+      config
+    });
+  }
+  if (fixtures.length === 0) {
+    throw new Error(`No fixture directories found in: ${resolvedRoot}`);
+  }
+  return fixtures;
+}
+
+// src/observer/benchmark/scoring.ts
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "been",
+  "by",
+  "for",
+  "from",
+  "had",
+  "has",
+  "have",
+  "he",
+  "her",
+  "his",
+  "i",
+  "in",
+  "is",
+  "it",
+  "its",
+  "me",
+  "my",
+  "of",
+  "on",
+  "or",
+  "our",
+  "she",
+  "that",
+  "the",
+  "their",
+  "them",
+  "they",
+  "this",
+  "to",
+  "was",
+  "we",
+  "were",
+  "will",
+  "with",
+  "you",
+  "your",
+  "about",
+  "after",
+  "before",
+  "can",
+  "did",
+  "do",
+  "done",
+  "if",
+  "into",
+  "just",
+  "not",
+  "now",
+  "out",
+  "over",
+  "should",
+  "than",
+  "then",
+  "there",
+  "these",
+  "those",
+  "today",
+  "tomorrow",
+  "update",
+  "updated",
+  "working",
+  "session",
+  "assistant",
+  "user"
+]);
+var WORD_TOKEN_RE = /[a-z0-9]+(?:[._/-][a-z0-9]+)*/g;
+var TERM_TOKEN_RE = /[A-Za-z0-9][A-Za-z0-9._/-]{2,}/g;
+function clamp01(value) {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  if (value < 0) {
+    return 0;
+  }
+  if (value > 1) {
+    return 1;
+  }
+  return value;
+}
+function round(value) {
+  return Math.round(clamp01(value) * 1e4) / 1e4;
+}
+function splitTokens(text) {
+  const lowered = normalizeObservationContent(text);
+  const matches = lowered.match(WORD_TOKEN_RE) ?? [];
+  return matches.filter((token) => token.length >= 2 && !STOPWORDS.has(token));
+}
+function toTokenSet(text) {
+  return new Set(splitTokens(text));
+}
+function overlapScore(expectedTokens, actualTokens) {
+  if (expectedTokens.size === 0 || actualTokens.size === 0) {
+    return 0;
+  }
+  let overlap = 0;
+  for (const token of expectedTokens) {
+    if (actualTokens.has(token)) {
+      overlap += 1;
+    }
+  }
+  return overlap / expectedTokens.size;
+}
+function containsTerm(haystack, term) {
+  const normalizedHaystack = haystack.toLowerCase();
+  const normalizedTerm = term.toLowerCase();
+  if (!normalizedTerm) {
+    return false;
+  }
+  if (/[^a-z0-9]/.test(normalizedTerm)) {
+    return normalizedHaystack.includes(normalizedTerm);
+  }
+  const escaped = normalizedTerm.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const regex = new RegExp(`\\b${escaped}\\b`, "i");
+  return regex.test(normalizedHaystack);
+}
+function extractSearchTerms(text, minimumLength = 6) {
+  const matches = text.match(TERM_TOKEN_RE) ?? [];
+  const seen = /* @__PURE__ */ new Set();
+  const terms = [];
+  for (const raw of matches) {
+    const normalized = raw.toLowerCase();
+    if (normalized.length < minimumLength) {
+      continue;
+    }
+    if (STOPWORDS.has(normalized)) {
+      continue;
+    }
+    const hasSignal = /[A-Z]/.test(raw) || /\d/.test(raw) || /[._/-]/.test(raw) || normalized.length >= 8;
+    if (!hasSignal) {
+      continue;
+    }
+    if (!seen.has(normalized)) {
+      seen.add(normalized);
+      terms.push(raw);
+    }
+  }
+  return terms;
+}
+function extractKeywordSetFromTranscript(transcript, hints = []) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const term of extractSearchTerms(transcript, 4)) {
+    const key = term.toLowerCase();
+    const current = counts.get(key) ?? { raw: term, count: 0 };
+    current.count += 1;
+    counts.set(key, current);
+  }
+  for (const hint of hints) {
+    const trimmed = hint.trim();
+    if (!trimmed) {
+      continue;
+    }
+    const key = trimmed.toLowerCase();
+    const current = counts.get(key) ?? { raw: trimmed, count: 0 };
+    current.count += 2;
+    counts.set(key, current);
+  }
+  const ranked = [...counts.values()].sort((left, right) => right.count - left.count || right.raw.length - left.raw.length || left.raw.localeCompare(right.raw)).map((entry) => entry.raw);
+  if (ranked.length > 0) {
+    return ranked.slice(0, 25);
+  }
+  const fallback = [...new Set(splitTokens(transcript))].filter((token) => token.length >= 5).slice(0, 12);
+  return fallback;
+}
+function matchObservationRecords(expected, actual, threshold = 0.35) {
+  const expectedTokens = expected.map((record) => toTokenSet(record.content));
+  const actualTokens = actual.map((record) => toTokenSet(record.content));
+  const expectedOrder = expected.map((record, index) => ({ index, importance: record.importance })).sort((left, right) => right.importance - left.importance).map((entry) => entry.index);
+  const usedActual = /* @__PURE__ */ new Set();
+  const matches = [];
+  for (const expectedIndex of expectedOrder) {
+    let bestIndex = -1;
+    let bestScore = 0;
+    for (let actualIndex = 0; actualIndex < actual.length; actualIndex += 1) {
+      if (usedActual.has(actualIndex)) {
+        continue;
+      }
+      const score = overlapScore(expectedTokens[expectedIndex] ?? /* @__PURE__ */ new Set(), actualTokens[actualIndex] ?? /* @__PURE__ */ new Set());
+      if (score > bestScore) {
+        bestScore = score;
+        bestIndex = actualIndex;
+      }
+    }
+    if (bestIndex >= 0 && bestScore >= threshold) {
+      usedActual.add(bestIndex);
+      matches.push({
+        expectedIndex,
+        actualIndex: bestIndex,
+        similarity: round(bestScore)
+      });
+    }
+  }
+  return matches.sort((left, right) => left.expectedIndex - right.expectedIndex);
+}
+function computeMetrics(expected, actual, matches, keywordSet, minimumImportanceForRecall) {
+  const matchedExpected = new Set(matches.map((match) => match.expectedIndex));
+  const matchedActual = new Set(matches.map((match) => match.actualIndex));
+  const precision = actual.length === 0 ? expected.length === 0 ? 1 : 0 : matchedActual.size / actual.length;
+  const noiseRatio = actual.length === 0 ? 0 : (actual.length - matchedActual.size) / actual.length;
+  const importantExpected = expected.filter((record) => record.importance >= minimumImportanceForRecall);
+  const totalImportantWeight = importantExpected.reduce((sum, record) => sum + record.importance, 0);
+  const matchedImportantWeight = matches.reduce((sum, match) => {
+    const record = expected[match.expectedIndex];
+    if (!record || record.importance < minimumImportanceForRecall) {
+      return sum;
+    }
+    return sum + record.importance;
+  }, 0);
+  const recall = totalImportantWeight === 0 ? 1 : matchedImportantWeight / totalImportantWeight;
+  let typeNumerator = 0;
+  let typeDenominator = 0;
+  for (const match of matches) {
+    const expectedRecord = expected[match.expectedIndex];
+    const actualRecord = actual[match.actualIndex];
+    if (!expectedRecord || !actualRecord) {
+      continue;
+    }
+    const weight = Math.max(0.2, expectedRecord.importance);
+    typeDenominator += weight;
+    if (expectedRecord.type === actualRecord.type) {
+      typeNumerator += weight;
+    }
+  }
+  const typeAccuracy = typeDenominator === 0 ? expected.length === 0 && actual.length === 0 ? 1 : 0 : typeNumerator / typeDenominator;
+  const actualCombined = actual.map((record) => record.content).join("\n");
+  const missingKeywords = keywordSet.filter((keyword) => !containsTerm(actualCombined, keyword));
+  const keywordPreservation = keywordSet.length === 0 ? 1 : (keywordSet.length - missingKeywords.length) / keywordSet.length;
+  const keywordRewriteFlags = [];
+  for (const match of matches) {
+    const expectedRecord = expected[match.expectedIndex];
+    const actualRecord = actual[match.actualIndex];
+    if (!expectedRecord || !actualRecord) {
+      continue;
+    }
+    const expectedTerms = extractSearchTerms(expectedRecord.content, 5);
+    if (expectedTerms.length === 0) {
+      continue;
+    }
+    const missing = expectedTerms.filter((term) => !containsTerm(actualRecord.content, term));
+    if (missing.length > 0) {
+      keywordRewriteFlags.push({
+        expected: expectedRecord.content,
+        actual: actualRecord.content,
+        missingTerms: missing
+      });
+    }
+  }
+  const overall = precision * 0.3 + recall * 0.35 + keywordPreservation * 0.2 + typeAccuracy * 0.15;
+  return {
+    metrics: {
+      precision: round(precision),
+      noiseRatio: round(noiseRatio),
+      recall: round(recall),
+      typeAccuracy: round(typeAccuracy),
+      keywordPreservation: round(keywordPreservation),
+      overall: round(overall)
+    },
+    missedImportant: expected.filter((record, index) => record.importance >= minimumImportanceForRecall && !matchedExpected.has(index)),
+    noiseObservations: actual.filter((_, index) => !matchedActual.has(index)),
+    missingKeywords,
+    keywordRewriteFlags
+  };
+}
+function scoreFixtureObservations(input) {
+  const options = input.options ?? {};
+  const minimumImportanceForRecall = clamp01(options.minimumImportanceForRecall ?? 0.5);
+  const threshold = clamp01(options.matchThreshold ?? 0.35);
+  const expected = parseObservationMarkdown(input.expectedMarkdown);
+  const actual = parseObservationMarkdown(input.actualMarkdown);
+  const matches = matchObservationRecords(expected, actual, threshold);
+  const keywordSet = extractKeywordSetFromTranscript(input.transcript, options.keywordHints ?? []);
+  const computed = computeMetrics(expected, actual, matches, keywordSet, minimumImportanceForRecall);
+  return {
+    metrics: computed.metrics,
+    matches,
+    missedImportant: computed.missedImportant,
+    noiseObservations: computed.noiseObservations,
+    keywordSet,
+    missingKeywords: computed.missingKeywords,
+    keywordRewriteFlags: computed.keywordRewriteFlags
+  };
+}
+function compareObservationText(left, right) {
+  return normalizeObservationContent(left) === normalizeObservationContent(right);
+}
+
+// src/observer/benchmark/runner.ts
+var DEFAULT_PROVIDER = "mock";
+var DEFAULT_NOW = /* @__PURE__ */ new Date("2026-03-10T12:00:00.000Z");
+function parseFixtureNow(raw) {
+  if (!raw) {
+    return DEFAULT_NOW;
+  }
+  const parsed = new Date(raw);
+  if (Number.isNaN(parsed.getTime())) {
+    throw new Error(`Invalid fixture config now timestamp: ${raw}`);
+  }
+  return parsed;
+}
+function parseTranscriptMessages(rawTranscript, transcriptPath) {
+  const lineMessages = rawTranscript.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  if (lineMessages.length > 0) {
+    return lineMessages;
+  }
+  return parseSessionFile(transcriptPath);
+}
+function withNoLlm(enabled, task) {
+  if (!enabled) {
+    return task();
+  }
+  const previous = process.env.CLAWVAULT_NO_LLM;
+  process.env.CLAWVAULT_NO_LLM = "1";
+  return task().finally(() => {
+    if (previous === void 0) {
+      delete process.env.CLAWVAULT_NO_LLM;
+      return;
+    }
+    process.env.CLAWVAULT_NO_LLM = previous;
+  });
+}
+function averageMetrics(rows) {
+  if (rows.length === 0) {
+    return {
+      precision: 0,
+      noiseRatio: 0,
+      recall: 0,
+      typeAccuracy: 0,
+      keywordPreservation: 0,
+      overall: 0
+    };
+  }
+  const totals = rows.reduce((acc, metrics) => {
+    acc.precision += metrics.precision;
+    acc.noiseRatio += metrics.noiseRatio;
+    acc.recall += metrics.recall;
+    acc.typeAccuracy += metrics.typeAccuracy;
+    acc.keywordPreservation += metrics.keywordPreservation;
+    acc.overall += metrics.overall;
+    return acc;
+  }, {
+    precision: 0,
+    noiseRatio: 0,
+    recall: 0,
+    typeAccuracy: 0,
+    keywordPreservation: 0,
+    overall: 0
+  });
+  const count = rows.length;
+  const round2 = (value) => Math.round(value / count * 1e4) / 1e4;
+  return {
+    precision: round2(totals.precision),
+    noiseRatio: round2(totals.noiseRatio),
+    recall: round2(totals.recall),
+    typeAccuracy: round2(totals.typeAccuracy),
+    keywordPreservation: round2(totals.keywordPreservation),
+    overall: round2(totals.overall)
+  };
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+async function runObserverBenchmark(options) {
+  const fixtures = loadObserverBenchmarkFixtures(options.fixturesDir);
+  const fixtureResults = [];
+  for (const fixture of fixtures) {
+    const fixtureProvider = fixture.config.compression?.provider ?? options.provider ?? DEFAULT_PROVIDER;
+    const fixtureModel = fixture.config.compression?.model ?? options.model;
+    const fixtureNow = parseFixtureNow(fixture.config.now);
+    const messages = parseTranscriptMessages(fixture.transcript, fixture.transcriptPath);
+    const compressor = new Compressor({
+      provider: fixtureProvider === "mock" ? void 0 : fixtureProvider,
+      model: fixtureModel,
+      baseUrl: fixture.config.compression?.baseUrl,
+      apiKey: fixture.config.compression?.apiKey,
+      now: () => fixtureNow
+    });
+    const outputObservations = await withNoLlm(
+      fixtureProvider === "mock",
+      async () => compressor.compress(messages, fixture.config.existingObservations ?? "")
+    );
+    const scoring = scoreFixtureObservations({
+      transcript: fixture.transcript,
+      expectedMarkdown: fixture.expected,
+      actualMarkdown: outputObservations,
+      options: {
+        matchThreshold: fixture.config.scoring?.matchThreshold,
+        minimumImportanceForRecall: fixture.config.scoring?.minimumImportanceForRecall,
+        keywordHints: fixture.config.scoring?.keywordHints
+      }
+    });
+    const expectedRecords = parseObservationMarkdown(fixture.expected);
+    const actualRecords = parseObservationMarkdown(outputObservations);
+    fixtureResults.push({
+      fixtureId: fixture.id,
+      transcriptPath: fixture.transcriptPath,
+      expectedPath: fixture.expectedPath,
+      provider: fixtureProvider,
+      model: fixtureModel,
+      outputObservations,
+      expectedCount: expectedRecords.length,
+      actualCount: actualRecords.length,
+      expectedTypes: unique(expectedRecords.map((record) => record.type)),
+      actualTypes: unique(actualRecords.map((record) => record.type)),
+      scoring
+    });
+  }
+  const reportProvider = options.provider ?? DEFAULT_PROVIDER;
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    fixturesDir: options.fixturesDir,
+    provider: reportProvider,
+    model: options.model,
+    fixtureCount: fixtureResults.length,
+    aggregate: averageMetrics(fixtureResults.map((row) => row.scoring.metrics)),
+    fixtures: fixtureResults
+  };
+}
+
+// src/commands/benchmark.ts
+var PROVIDERS = [
+  "mock",
+  "anthropic",
+  "openai",
+  "gemini",
+  "xai",
+  "openai-compatible",
+  "ollama",
+  "minimax",
+  "zai"
+];
+function parseReportFormat(raw) {
+  if (!raw || raw === "text") {
+    return "text";
+  }
+  if (raw === "json") {
+    return "json";
+  }
+  throw new Error(`Invalid --report-format value: ${raw}`);
+}
+function parseProvider(raw) {
+  if (!raw) {
+    return "mock";
+  }
+  if (!PROVIDERS.includes(raw)) {
+    throw new Error(`Invalid --provider value: ${raw}`);
+  }
+  return raw;
+}
+async function benchmarkObserverCommand(options) {
+  const provider = parseProvider(options.provider);
+  const reportFormat = parseReportFormat(options.reportFormat);
+  const fixturesDir = path2.resolve(options.fixturesDir ?? path2.join(process.cwd(), "testdata", "observer-benchmark"));
+  const report = await runObserverBenchmark({
+    fixturesDir,
+    provider,
+    model: options.model
+  });
+  if (reportFormat === "json") {
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+  console.log(formatObserverBenchmarkSummary(report));
+}
+function registerBenchmarkCommand(program) {
+  const benchmark = program.command("benchmark").description("Run quality benchmark harnesses");
+  benchmark.command("observer").description("Evaluate observer output quality against annotated transcripts").option("--fixtures-dir <path>", "Fixture root directory (default: testdata/observer-benchmark)").option("--provider <provider>", "Compression provider (mock|anthropic|openai|gemini|xai|openai-compatible|ollama|minimax|zai)", "mock").option("--model <model>", "Model override for live provider runs").option("--report-format <format>", "Report output format (json|text)", "text").action(async (rawOptions) => {
+    await benchmarkObserverCommand({
+      fixturesDir: rawOptions.fixturesDir,
+      provider: rawOptions.provider,
+      model: rawOptions.model,
+      reportFormat: rawOptions.reportFormat
+    });
+  });
+}
+
+export {
+  formatObserverBenchmarkSummary,
+  loadObserverBenchmarkFixtures,
+  extractKeywordSetFromTranscript,
+  matchObservationRecords,
+  scoreFixtureObservations,
+  compareObservationText,
+  runObserverBenchmark,
+  benchmarkObserverCommand,
+  registerBenchmarkCommand
+};

package/dist/cli/index.js

@@ -1,36 +1,43 @@
 import {
   registerCliCommands
-} from "../chunk-IJBFGPCS.js";
-import "../chunk-Y6VJKXGL.js";
+} from "../chunk-DCF4KMFD.js";
+import "../chunk-KCYWJDDW.js";
 import "../chunk-TIGW564L.js";
 import "../chunk-IVRIKYFE.js";
-import "../chunk-4ITRXIVT.js";
-import "../chunk-P5EPF6MB.js";
-import "../chunk-S5OJEGFG.js";
-import "../chunk-MNPUYCHQ.js";
-import "../chunk-WJVWINEM.js";
-import "../chunk-PI4WMLMG.js";
-import "../chunk-Y3TIJEBP.js";
-import "../chunk-AZYOKJYC.js";
+import "../chunk-DOIUYIXV.js";
+import "../chunk-TWMI3SNN.js";
+import "../chunk-OFOCU2V4.js";
+import "../chunk-D5U3Q4N5.js";
+import "../chunk-BLQXXX7Q.js";
+import "../chunk-VXAGOLDP.js";
+import "../chunk-7SWP5FKU.js";
 import "../chunk-HRLWZGMA.js";
-import "../chunk-YDWHS4LJ.js";
+import "../chunk-DVOUSOR3.js";
+import "../chunk-4PY655YM.js";
+import "../chunk-AXSJIFOJ.js";
+import "../chunk-GFCHWMGD.js";
+import "../chunk-T7E764W3.js";
+import "../chunk-HEHO7SMV.js";
+import "../chunk-2PKBIKDH.js";
+import "../chunk-35JCYSRR.js";
 import "../chunk-BSJ6RIT7.js";
-import "../chunk-FHFUXL6G.js";
-import "../chunk-ECRZL5XR.js";
-import "../chunk-WIOLLGAD.js";
-import "../chunk-5PJ4STIC.js";
-import "../chunk-YNIPYN4F.js";
-import "../chunk-URXDAUVH.js";
-import "../chunk-YXQCA6B7.js";
+import "../chunk-ECGJYWNA.js";
 import "../chunk-2CDEETQN.js";
+import "../chunk-FZ5I2NF7.js";
+import "../chunk-PTWPPVC7.js";
+import "../chunk-H3JZIB5O.js";
 import "../chunk-MQUJNOHK.js";
-import "../chunk-GNJL4YGR.js";
-import "../chunk-ZZA73MFY.js";
+import "../chunk-GJO3CFUN.js";
+import "../chunk-ZKWPCBYT.js";
+import "../chunk-MW5C6ZQA.js";
+import "../chunk-J3YUXVID.js";
+import "../chunk-FHFUXL6G.js";
+import "../chunk-33DOSHTA.js";
 import "../chunk-Z2XBWN7A.js";
 import "../chunk-QWQ3TIKS.js";
 import "../chunk-MFAWT5O5.js";
 import "../chunk-7766SIJP.js";
-import "../chunk-U67V476Y.js";
+import "../chunk-2ZDO52B4.js";
 export {
   registerCliCommands
 };

package/dist/commands/archive.js

@@ -1,11 +1,11 @@
 import {
   archiveCommand,
   registerArchiveCommand
-} from "../chunk-2RAZ4ZFE.js";
+} from "../chunk-VBILES4B.js";
 import "../chunk-MQUJNOHK.js";
-import "../chunk-GNJL4YGR.js";
+import "../chunk-GJO3CFUN.js";
 import "../chunk-Z2XBWN7A.js";
-import "../chunk-U67V476Y.js";
+import "../chunk-2ZDO52B4.js";
 export {
   archiveCommand,
   registerArchiveCommand

package/dist/commands/backlog.js

@@ -5,7 +5,7 @@ import {
 } from "../chunk-QWQ3TIKS.js";
 import "../chunk-MFAWT5O5.js";
 import "../chunk-7766SIJP.js";
-import "../chunk-U67V476Y.js";
+import "../chunk-2ZDO52B4.js";
 
 // src/commands/backlog.ts
 function toDateStr(val) {

package/dist/commands/benchmark.d.ts

@@ -0,0 +1,12 @@
+import { Command } from 'commander';
+
+interface BenchmarkObserverCommandOptions {
+    fixturesDir?: string;
+    provider?: string;
+    model?: string;
+    reportFormat?: string;
+}
+declare function benchmarkObserverCommand(options: BenchmarkObserverCommandOptions): Promise<void>;
+declare function registerBenchmarkCommand(program: Command): void;
+
+export { type BenchmarkObserverCommandOptions, benchmarkObserverCommand, registerBenchmarkCommand };