@kintsugi-ai/core 0.1.0 → 0.2.0

package/src/comparator.test.ts

@@ -1,97 +0,0 @@
-import { test, describe } from 'node:test';
-import assert from 'node:assert/strict';
-import {
-  createSyntheticUiPng,
-  computePixelDiff,
-  compareScreenshots,
-  diffAriaSnapshots,
-  parseVerdict,
-  DiffResult
-} from './index.js';
-
-describe('Kintsugi Visual Comparator Engine', () => {
-  test('identical images return 0% diff and IDENTICAL status', async () => {
-    const img1 = createSyntheticUiPng();
-    const img2 = createSyntheticUiPng();
-
-    const pixelResult = await computePixelDiff(img1, img2);
-    assert.equal(pixelResult.diffPercent, 0);
-
-    const comp = await compareScreenshots(img1, img2);
-    assert.equal(comp.result, DiffResult.IDENTICAL);
-    assert.equal(comp.pixelDiffPercent, 0);
-  });
-
-  test('large pixel diff without a classifier escalates as CHANGED', async () => {
-    const baseline = createSyntheticUiPng({ removeButton: false });
-    const regressed = createSyntheticUiPng({ removeButton: true });
-
-    const pixelResult = await computePixelDiff(baseline, regressed);
-    assert.ok(pixelResult.diffPercent > 0.5, 'Pixel diff should exceed 0.5%');
-
-    const comp = await compareScreenshots(baseline, regressed);
-    assert.equal(comp.result, DiffResult.CHANGED, 'Missing button should escalate as CHANGED');
-  });
-
-  test('sub-threshold noise is classified as MINOR', async () => {
-    const baseline = createSyntheticUiPng();
-    const withNoise = createSyntheticUiPng({ addNoise: true, noiseAmount: 0.0002 });
-
-    const comp = await compareScreenshots(baseline, withNoise);
-    assert.ok(
-      comp.result === DiffResult.IDENTICAL || comp.result === DiffResult.MINOR,
-      'Subpixel noise should be classified as IDENTICAL or MINOR, not BROKEN'
-    );
-  });
-
-  test('aria snapshot diff reports removed and added lines', () => {
-    const baseline = [
-      '- button "Complete Purchase ($89.00)"',
-      '- text "Free shipping"',
-    ].join('\n');
-    const current = [
-      '- text "Free shipping"',
-      '- textbox "Email"',
-    ].join('\n');
-
-    const diff = diffAriaSnapshots(baseline, current);
-    assert.ok(diff.includes('REMOVED: - button "Complete Purchase ($89.00)"'), 'Removed button should appear as removed');
-    assert.ok(diff.includes('textbox "Email"') && diff.includes('ADDED:'), 'Added textbox should appear as added');
-    assert.ok(!diff.includes('no line-level differences'));
-  });
-
-  test('aria snapshot diff of identical snapshots reports no differences', () => {
-    const snap = '- button "Buy"\n- text "Hello"';
-    assert.ok(diffAriaSnapshots(snap, snap).includes('no line-level differences'));
-  });
-});
-
-describe('Classifier verdict parsing', () => {
-  test('parses the JSON verdict format', () => {
-    const v = parseVerdict('{"intentional": true, "confidence": 0.92, "reasoning": "Matches the requested recolor."}');
-    assert.equal(v.intentional, true);
-    assert.equal(v.confidence, 0.92);
-    assert.ok(v.reasoning.includes('recolor'));
-  });
-
-  test('parses JSON embedded in chatter', () => {
-    const v = parseVerdict('Sure! {"intentional": false, "confidence": 0.85, "reasoning": "The checkout button was removed; re-add it."} hope that helps');
-    assert.equal(v.intentional, false);
-    assert.equal(v.confidence, 0.85);
-    assert.ok(v.reasoning.includes('re-add'));
-  });
-
-  test('defaults missing confidence and reasoning conservatively', () => {
-    const v = parseVerdict('{"intentional": true}');
-    assert.equal(v.intentional, true);
-    assert.equal(v.confidence, 0.5);
-    assert.ok(v.reasoning.length > 0);
-  });
-
-  test('fails safe to not-intentional on unparseable output', () => {
-    const v = parseVerdict('I cannot tell what changed here, sorry.');
-    assert.equal(v.intentional, false);
-    assert.ok(v.confidence <= 0.7);
-    assert.ok(v.reasoning.length > 0);
-  });
-});

package/src/comparator.ts

@@ -1,217 +0,0 @@
-import pixelmatch from 'pixelmatch';
-import { PNG } from 'pngjs';
-import { promises as fs } from 'fs';
-import path from 'path';
-import { DiffResult, type StepComparisonResult, type StepClassification, type FlowRecording, type CaptureResult, type ComparisonResult, type ClassifierConfig } from './types.js';
-import { classifyChange, FlowLimitError } from './classifier.js';
-import { flowFingerprint } from './flowid.js';
-import { diffAriaSnapshots } from './domdiff.js';
-
-/** Everything the comparator needs to consult the classifier for large diffs */
-export interface ClassifierContext {
-  config: ClassifierConfig;
-  apiToken: string;
-  /** What the agent was asked to do in the latest turn (sharpens intentional-vs-regression) */
-  context?: string;
-  logger?: { info: (msg: string, data?: unknown) => void; warn: (msg: string, data?: unknown) => void };
-}
-
-export interface CompareOptions {
-  outputDir?: string;
-  classifier?: ClassifierContext;
-}
-
-export async function computePixelDiff(img1: Buffer, img2: Buffer): Promise<{ diffPercent: number; diffImage: Buffer }> {
-  const png1 = PNG.sync.read(img1);
-  const png2 = PNG.sync.read(img2);
-  
-  if (png1.width !== png2.width || png1.height !== png2.height) {
-    return { diffPercent: 100, diffImage: Buffer.alloc(0) };
-  }
-
-  const { width, height } = png1;
-  const diff = new PNG({ width, height });
-
-  const numDiffPixels = pixelmatch(png1.data, png2.data, diff.data, width, height, { threshold: 0.1 });
-  const diffPercent = (numDiffPixels / (width * height)) * 100;
-  const diffImage = PNG.sync.write(diff);
-
-  return { diffPercent, diffImage };
-}
-
-/**
- * Pixel-only verdict for one screenshot pair. Diff percentages above the
- * classifier threshold are returned as a tentative CHANGED — compareFlow
- * refines those with the classifier when one is configured.
- */
-export async function compareScreenshots(baseline: Buffer, current: Buffer, stepIndex: number = 0, options?: CompareOptions): Promise<StepComparisonResult> {
-  const outputDir = options?.outputDir;
-  const { diffPercent, diffImage } = await computePixelDiff(baseline, current);
-
-  let result: DiffResult;
-  if (diffPercent <= 0.05) {
-    result = DiffResult.IDENTICAL;
-  } else if (diffPercent > (options?.classifier?.config.pixelDiffThreshold ?? 0.5)) {
-    result = DiffResult.CHANGED;
-  } else {
-    // Sub-threshold change: benign (anti-aliasing, subpixel shifts, dynamic content)
-    result = DiffResult.MINOR;
-  }
-
-  let diffImagePath;
-  if (outputDir && result !== DiffResult.IDENTICAL) {
-    diffImagePath = path.join(outputDir, `diff_${stepIndex}.png`);
-    await fs.writeFile(diffImagePath, diffImage);
-  }
-
-  return {
-    step: stepIndex,
-    pixelDiffPercent: diffPercent,
-    ssimScore: 1, // deprecated field, kept for output compatibility
-    result,
-    diffImagePath,
-  };
-}
-
-export async function compareFlow(baseline: FlowRecording, current: CaptureResult, options?: CompareOptions): Promise<ComparisonResult> {
-  const stepResults: StepComparisonResult[] = [];
-  const len = Math.min(baseline.screenshotPaths.length, current.screenshots.length);
-
-  // Pass 1: pixel diff every step (cheap, deterministic)
-  for (let i = 0; i < len; i++) {
-    const baselineBuffer = await fs.readFile(baseline.screenshotPaths[i]);
-    const currentBuffer = current.screenshots[i];
-    stepResults.push(await compareScreenshots(baselineBuffer, currentBuffer, i, options));
-  }
-
-  // Pass 2: classify every oversized step — all classifier calls in parallel
-  const threshold = options?.classifier?.config.pixelDiffThreshold ?? 0.5;
-  const candidates = stepResults.filter(s => s.pixelDiffPercent > threshold);
-  const classifications = options?.classifier
-    ? await classifySteps(candidates, baseline, current, options.classifier)
-    : [];
-  for (const c of classifications) {
-    const step = stepResults.find(s => s.step === c.step);
-    if (step) {
-      step.result = c.intentional && c.confidence > (options!.classifier!.config.confidenceThreshold)
-        ? DiffResult.INTENTIONAL
-        : DiffResult.CHANGED;
-    }
-  }
-
-  // Aggregate the worst verdict across steps
-  let worstResult = DiffResult.IDENTICAL;
-  let failedStep: number | undefined;
-  for (const comp of stepResults) {
-    if (comp.result === DiffResult.CHANGED || comp.result === DiffResult.BROKEN || comp.result === DiffResult.ERROR) {
-      if (worstResult !== DiffResult.CHANGED && worstResult !== DiffResult.BROKEN && worstResult !== DiffResult.ERROR) {
-        worstResult = comp.result;
-        failedStep = comp.step;
-      }
-    } else if (comp.result === DiffResult.MINOR && worstResult === DiffResult.IDENTICAL) {
-      worstResult = DiffResult.MINOR;
-    } else if (comp.result === DiffResult.INTENTIONAL && worstResult === DiffResult.IDENTICAL) {
-      worstResult = DiffResult.INTENTIONAL;
-    }
-  }
-
-  if (current.errors.length > 0) {
-    worstResult = DiffResult.BROKEN;
-    failedStep = current.completedSteps;
-  }
-
-  const worstStep = stepResults.find(s => s.step === failedStep) || stepResults[0];
-
-  // Surface the classifier's explanation in the escalation panel (semanticAnalysis
-  // is what the VS Code split-view displays).
-  const worstRegression = classifications.find(c => !c.intentional);
-
-  return {
-    result: worstResult,
-    pixelDiffPercent: worstStep?.pixelDiffPercent || 0,
-    ssimScore: worstStep?.ssimScore || 1,
-    diffImagePath: worstStep?.diffImagePath,
-    semanticAnalysis: worstRegression?.reasoning,
-    failedStep,
-    stepResults,
-    classifications: classifications.length > 0 ? classifications : undefined,
-  };
-}
-
-/**
- * Classifies all oversized steps in parallel. Fail-safe: a missing aria
- * snapshot or any classifier error yields a not-intentional classification
- * so the step still escalates.
- */
-async function classifySteps(
-  candidates: StepComparisonResult[],
-  baseline: FlowRecording,
-  current: CaptureResult,
-  classifier: ClassifierContext
-): Promise<StepClassification[]> {
-  return Promise.all(candidates.map(async (candidate): Promise<StepClassification> => {
-    const i = candidate.step;
-    const currentAria = current.ariaSnapshots?.[i];
-    let baselineAria: string | undefined;
-    if (baseline.ariaSnapshotPaths?.[i]) {
-      try {
-        baselineAria = await fs.readFile(baseline.ariaSnapshotPaths[i], 'utf-8');
-      } catch {
-        baselineAria = undefined;
-      }
-    }
-
-    const base: StepClassification = {
-      step: i,
-      intentional: false,
-      confidence: 0.5,
-      reasoning: 'aria snapshots unavailable for this pair — inspect the diff image manually',
-      ariaDiff: '(aria snapshots unavailable — re-record the baseline to enable classification)',
-      oldImagePath: baseline.screenshotPaths[i],
-      newImagePath: current.screenshotPaths[i],
-    };
-
-    if (baselineAria === undefined || currentAria === undefined) {
-      classifier.logger?.warn('aria snapshots unavailable for step — escalating without classification', { step: i });
-      return base;
-    }
-
-    const ariaDiff = diffAriaSnapshots(baselineAria, currentAria);
-    try {
-      const verdict = await classifyChange({
-        baselineAria,
-        currentAria,
-        context: classifier.context,
-        config: classifier.config,
-        apiToken: classifier.apiToken,
-        meta: {
-          flowName: baseline.metadata.name,
-          flowHash: flowFingerprint(baseline.metadata.name, baseline.steps),
-          step: i,
-        },
-        logger: classifier.logger,
-      });
-      classifier.logger?.info('classification', { step: i, ...verdict });
-      return { ...base, ...verdict, ariaDiff };
-    } catch (err) {
-      if (err instanceof FlowLimitError) {
-        classifier.logger?.warn('flow limit reached — step escalates pixel-diff only', {
-          step: i,
-          kind: err.kind,
-          flowsUsed: err.flowsUsed,
-          flowLimit: err.flowLimit,
-        });
-        const where = err.kind === 'monthly_cap_reached'
-          ? 'monthly classification cap reached on the free plan'
-          : `free plan flow limit reached (${err.flowsUsed ?? '?'}/${err.flowLimit ?? '?'} flows guarded)`;
-        return {
-          ...base,
-          ariaDiff,
-          reasoning: `${where} — this flow degrades to pixel-diff only and is treated as a change. Upgrade at ${err.upgradeUrl ?? 'https://kintsugi.dev/upgrade'} to guard it with the classifier.`,
-        };
-      }
-      classifier.logger?.warn('classifier failed — escalating step', { step: i, error: (err as Error).message });
-      return { ...base, ariaDiff, reasoning: `classifier failed (${(err as Error).message}) — inspect the aria diff manually` };
-    }
-  }));
-}

package/src/config.test.ts

@@ -1,80 +0,0 @@
-import { test, describe } from 'node:test';
-import assert from 'node:assert/strict';
-import os from 'node:os';
-import path from 'node:path';
-import fs from 'node:fs/promises';
-import {
-  getDefaultConfig,
-  saveConfig,
-  loadConfig,
-  ensureKintsugiDir,
-  formatAgentFeedback,
-  formatUserSummary,
-  DiffResult,
-  type ComparisonResult
-} from './index.js';
-
-describe('Kintsugi Config & Feedback Formatter', () => {
-  test('generates valid default config', () => {
-    const config = getDefaultConfig();
-    assert.equal(config.version, 1);
-    assert.equal(config.viewport.width, 1280);
-    assert.equal(config.viewport.height, 720);
-    assert.ok(config.thresholds.pixelDiffPercent > 0);
-  });
-
-  test('saves and loads config from disk', async () => {
-    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'kintsugi-test-'));
-    try {
-      await ensureKintsugiDir(tmpDir);
-      const config = getDefaultConfig();
-      config.devServerUrl = 'http://localhost:5173';
-      await saveConfig(tmpDir, config);
-
-      const loaded = await loadConfig(tmpDir);
-      assert.equal(loaded.devServerUrl, 'http://localhost:5173');
-    } finally {
-      await fs.rm(tmpDir, { recursive: true, force: true });
-    }
-  });
-
-  test('formats actionable agent feedback on regression', () => {
-    const mockResult: ComparisonResult = {
-      result: DiffResult.BROKEN,
-      pixelDiffPercent: 3.42,
-      ssimScore: 1,
-      failedStep: 2,
-      stepResults: [
-        {
-          step: 2,
-          pixelDiffPercent: 3.42,
-          ssimScore: 1,
-          result: DiffResult.BROKEN,
-        }
-      ],
-      classifications: [
-        {
-          step: 2,
-          intentional: false,
-          confidence: 0.9,
-          reasoning: 'The checkout button was removed; re-add it to the order summary.',
-          ariaDiff: 'REMOVED: - button "Complete Purchase ($89.00)"',
-          oldImagePath: '/baseline/step_2.png',
-          newImagePath: '/tmp/step_2.png',
-        }
-      ]
-    };
-
-    const feedback = formatAgentFeedback(mockResult, 'checkout-flow');
-    assert.ok(feedback.includes('checkout-flow is broken'), 'Should state the flow is broken');
-    assert.ok(feedback.includes('aria diffs:'), 'Should include aria diffs');
-    assert.ok(feedback.includes('REMOVED: - button'), 'Should include the aria diff content');
-    assert.ok(feedback.includes('image pairs (old image | new image):'), 'Should include image pairs');
-    assert.ok(feedback.includes('/baseline/step_2.png | /tmp/step_2.png'), 'Should include both image paths');
-    assert.ok(feedback.includes('suggested fixes:'), 'Should include suggested fixes');
-    assert.ok(feedback.includes('re-add it to the order summary'), 'Should include the classifier fix');
-
-    const summary = formatUserSummary(mockResult, 'checkout-flow');
-    assert.ok(summary.includes('checkout-flow'), 'Summary should include flow name');
-  });
-});

package/src/config.ts

@@ -1,83 +0,0 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-import type { KintsugiConfig } from './types.js';
-
-export function getDefaultConfig(): KintsugiConfig {
-  return {
-    version: 1,
-    devServerUrl: 'http://localhost:3000',
-    viewport: { width: 1280, height: 720 },
-    thresholds: {
-      pixelDiffPercent: 0.1,
-      ssimScore: 0.98,
-      maxCheckLatencyMs: 5000,
-    },
-    llm: {
-      provider: 'claude',
-      model: 'claude-3-5-sonnet-20241022',
-      apiKeyEnvVar: 'ANTHROPIC_API_KEY',
-    },
-    classifier: {
-      enabled: true,
-      provider: 'kintsugi',
-      endpoint: process.env.KINTSUGI_API_URL ?? 'https://api.kintsugi.dev/v1',
-      model: 'kintsugi-hosted',
-      tokenEnvVar: 'KINTSUGI_API_KEY',
-      pixelDiffThreshold: 0.5,
-      confidenceThreshold: 0.7,
-      timeoutMs: 20000,
-    },
-    agent: {
-      type: 'auto',
-      maxRetries: 3,
-    },
-    recording: {
-      passive: true,
-      collectorPort: 4321,
-    },
-    uiFilePatterns: ['src/**/*.tsx', 'src/**/*.ts', 'src/**/*.jsx', 'src/**/*.js'],
-  };
-}
-
-export async function ensureKintsugiDir(projectDir: string): Promise<void> {
-  const kintsugiDir = path.join(projectDir, '.kintsugi');
-  const flowsDir = path.join(kintsugiDir, 'flows');
-  const recordingsDir = path.join(kintsugiDir, 'recordings');
-  
-  await fs.mkdir(kintsugiDir, { recursive: true });
-  await fs.mkdir(flowsDir, { recursive: true });
-  await fs.mkdir(recordingsDir, { recursive: true });
-}
-
-export async function loadConfig(projectDir: string): Promise<KintsugiConfig> {
-  const configPath = path.join(projectDir, '.kintsugi', 'config.json');
-  const defaultConfig = getDefaultConfig();
-  try {
-    const data = await fs.readFile(configPath, 'utf-8');
-    const userConfig = JSON.parse(data) as Partial<KintsugiConfig>;
-    const classifier = {
-      ...defaultConfig.classifier,
-      ...(userConfig.classifier ?? {}),
-    } as KintsugiConfig['classifier'];
-    // Migration: configs written before the provider field pointed at
-    // OpenAI-compatible endpoints (HF router). Keep them working unchanged.
-    if (userConfig.classifier && userConfig.classifier.provider === undefined) {
-      if (!classifier.endpoint.includes('kintsugi')) {
-        classifier.provider = 'openai-compatible';
-      }
-    }
-    return {
-      ...defaultConfig,
-      ...userConfig,
-      classifier,
-    } as KintsugiConfig;
-  } catch (error) {
-    return defaultConfig;
-  }
-}
-
-export async function saveConfig(projectDir: string, config: KintsugiConfig): Promise<void> {
-  await ensureKintsugiDir(projectDir);
-  const configPath = path.join(projectDir, '.kintsugi', 'config.json');
-  await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
-}

package/src/domdiff.ts

@@ -1,62 +0,0 @@
-/**
- * Line diff for Playwright aria snapshots (YAML). Produces a compact
- * removed/added summary suitable as classifier input.
- */
-
-const MAX_DIFF_LINES = 80;
-
-export function diffAriaSnapshots(baseline: string, current: string): string {
-  const a = baseline.split('\n');
-  const b = current.split('\n');
-
-  // LCS table (snapshots are small — a few hundred lines max)
-  const m = a.length, n = b.length;
-  const dp: number[][] = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
-  for (let i = m - 1; i >= 0; i--) {
-    for (let j = n - 1; j >= 0; j--) {
-      dp[i][j] = a[i] === b[j] ? dp[i + 1][j + 1] + 1 : Math.max(dp[i + 1][j], dp[i][j + 1]);
-    }
-  }
-
-  // Walk the table, grouping consecutive changes into hunks with nearest context
-  type Op = { type: ' ' | '-' | '+'; line: string };
-  const ops: Op[] = [];
-  let i = 0, j = 0;
-  while (i < m && j < n) {
-    if (a[i] === b[j]) { ops.push({ type: ' ', line: a[i] }); i++; j++; }
-    else if (dp[i + 1][j] >= dp[i][j + 1]) { ops.push({ type: '-', line: a[i] }); i++; }
-    else { ops.push({ type: '+', line: b[j] }); j++; }
-  }
-  while (i < m) { ops.push({ type: '-', line: a[i++] }); }
-  while (j < n) { ops.push({ type: '+', line: b[j++] }); }
-
-  // Emit only changed hunks (with 1 line of context), trimmed.
-  // Prefixes are words, not +/-, because aria snapshot lines themselves
-  // start with YAML list markers ("- ").
-  const out: string[] = [];
-  let changes = 0;
-  let lastContextIndex = -1;
-  for (let k = 0; k < ops.length; k++) {
-    if (ops[k].type === ' ') continue;
-    if (out.length > 0 && out[out.length - 1] !== '…' && ops[k - 1]?.type === ' ' && (k - 1) !== lastContextIndex) {
-      out.push('  ctx: ' + ops[k - 1].line);
-    }
-    while (k < ops.length && ops[k].type !== ' ') {
-      out.push((ops[k].type === '-' ? 'REMOVED: ' : 'ADDED:   ') + ops[k].line);
-      changes++;
-      k++;
-    }
-    if (k < ops.length) {
-      out.push('  ctx: ' + ops[k].line);
-      lastContextIndex = k;
-    }
-    out.push('');
-    if (out.length >= MAX_DIFF_LINES) {
-      out.push('… (diff truncated, more changes below)');
-      break;
-    }
-  }
-
-  if (changes === 0) return '(no line-level differences — change is purely visual/rendered)';
-  return out.join('\n').trim();
-}

package/src/feedback.ts

@@ -1,64 +0,0 @@
-import { DiffResult, type ComparisonResult } from './types.js';
-
-/**
- * Fix-it feedback in the agent-facing format:
- * "{flow name} is broken, aria diffs: [...], [sets of (new image and old image)],
- *   suggested fixes: [fixes from the classifier per image pair]"
- */
-export function formatAgentFeedback(result: ComparisonResult, flowName: string): string {
-  const lines: string[] = [];
-  lines.push(`${flowName} is broken.`);
-
-  // aria diffs per classified pair
-  lines.push('aria diffs:');
-  const classifications = result.classifications ?? [];
-  if (classifications.length === 0) {
-    lines.push('  (none captured — flow failed during replay; check selectors and page load)');
-  }
-  for (const c of classifications) {
-    lines.push(`  step ${c.step}:`);
-    for (const line of c.ariaDiff.split('\n')) {
-      lines.push(`    ${line}`);
-    }
-  }
-
-  // sets of (old image, new image)
-  lines.push('image pairs (old image | new image):');
-  if (classifications.length === 0) {
-    lines.push('  (none — flow failed during replay)');
-  }
-  for (const c of classifications) {
-    lines.push(`  step ${c.step}: ${c.oldImagePath ?? '(unavailable)'} | ${c.newImagePath ?? '(unavailable)'}`);
-  }
-
-  // suggested fixes — the classifier's reasoning per non-intentional pair
-  lines.push('suggested fixes:');
-  const regressions = classifications.filter(c => !c.intentional || c.confidence <= 0.7);
-  if (classifications.length === 0) {
-    lines.push('  - re-run the flow and verify the page loads; an element selector likely changed');
-  }
-  for (const c of regressions) {
-    lines.push(`  step ${c.step}: ${c.reasoning}`);
-  }
-  if (classifications.length > 0 && regressions.length === 0) {
-    lines.push('  - (classifier found no intentional-only pairs, but the flow still failed — see replay errors)');
-  }
-
-  if (result.diffImagePath) {
-    lines.push(`diff heatmap: ${result.diffImagePath}`);
-  }
-  return lines.join('\n');
-}
-
-export function formatUserSummary(result: ComparisonResult, flowName: string): string {
-  if (result.result === DiffResult.IDENTICAL) {
-    return `✅ Flow "${flowName}" passed. No visual differences detected.`;
-  }
-
-  let summary = `⚠️ Flow "${flowName}" resulted in ${result.result.toUpperCase()}.\n`;
-  if (result.failedStep !== undefined) {
-    summary += `Step ${result.failedStep} failed with a pixel difference of ${result.pixelDiffPercent.toFixed(2)}%.`;
-  }
-
-  return summary;
-}

package/src/flowid.ts

@@ -1,14 +0,0 @@
-/**
- * Stable per-flow fingerprint used by the hosted API's flow gate: hashed from
- * the flow name + step actions/selectors/urls — NOT from screenshots or
- * timestamps — so replays count once and renames can't evade the limit.
- */
-import { createHash } from 'node:crypto';
-import type { FlowStep } from './types.js';
-
-export function flowFingerprint(name: string, steps: FlowStep[]): string {
-  const canonical = JSON.stringify(
-    steps.map(s => [s.action, s.selector ?? null, s.url ?? null, s.value ?? null])
-  );
-  return createHash('sha256').update(`${name}\n${canonical}`).digest('hex').slice(0, 40);
-}

package/src/index.ts

@@ -1,13 +0,0 @@
-export * from './types.js';
-export * from './config.js';
-export * from './setupPrompt.js';
-export * from './baseline.js';
-export * from './capturer.js';
-export * from './comparator.js';
-export * from './feedback.js';
-export * from './recorder.js';
-export * from './benchmark.js';
-export * from './classifier.js';
-export * from './auth.js';
-export * from './flowid.js';
-export * from './domdiff.js';