@aperant/framework 0.6.2

package/dist/__tests__/taste-infer.test.js

@@ -0,0 +1,640 @@
+/**
+ * taste-infer.test.ts — unit tests for C43 `apt-tools taste-infer`.
+ *
+ * Covers:
+ *   - extract-repo.mjs on the bundled fixture — pulls ≥ 3 hex colors, ≥ 1
+ *     font family, ≥ 1 spacing value (AC-5).
+ *   - Synthesis fallback on minimal input (AC-6) — added in subtask 4.
+ *   - cmdTasteInfer dispatch + flags (AC-7/8/9) — added in subtask 5.
+ *   - Prompt structure assertion (c43↔c44 contract) — added in subtask 6.
+ *   - I-1 no-LLM-imports invariant (AC-4) — added in subtask 9.
+ */
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { detectMode, writeLibraryEntry } from '../cli/commands/taste-infer.mjs';
+import { extractFromRepo } from '../cli/design/extract-repo.mjs';
+import { extractFromUrl, TasteInferAuthWall } from '../cli/design/extract-url.mjs';
+import { validateDesignFrontmatter } from '../cli/design/frontmatter-schema.mjs';
+import { clusterColors, parseColor, renderDesignMarkdown, synthesizeDesign, synthesizeDeterministic, } from '../cli/design/synthesize.mjs';
+import { validateDesignMarkdown } from '../cli/design/validate.mjs';
+const FIXTURES = resolve(__dirname, 'fixtures', 'taste-infer');
+describe('extractFromRepo (C43 repo mode)', () => {
+    it('AC-5: extracts ≥ 3 distinct hex colors + ≥ 1 font + ≥ 1 spacing from the fixture', async () => {
+        const result = await extractFromRepo(FIXTURES);
+        const hexColors = result.colors.filter((c) => /^#[0-9a-f]{3,8}$/.test(c.value));
+        expect(hexColors.length).toBeGreaterThanOrEqual(3);
+        expect(result.fonts.length).toBeGreaterThanOrEqual(1);
+        expect(result.spacing.length).toBeGreaterThanOrEqual(1);
+        // Target + mode metadata round-trips.
+        expect(result.mode).toBe('repo');
+        expect(result.target).toBe(FIXTURES);
+    });
+    it('weights colors seen in both CSS and Babel sources more heavily', async () => {
+        const result = await extractFromRepo(FIXTURES);
+        const blue = result.colors.find((c) => c.value === '#2563eb');
+        expect(blue).toBeDefined();
+        // The fixture sets #2563eb in sample.css (multiple times) and in
+        // Button.tsx — the merged weight should exceed a color that only
+        // appears once.
+        const uniqueColors = result.colors.filter((c) => c.weight === 1);
+        expect(blue?.weight ?? 0).toBeGreaterThan(uniqueColors[0]?.weight ?? 0);
+    });
+});
+// --- URL mode via Playwright mock ---------------------------------------
+/**
+ * Build a fake Playwright chromium launcher that answers `page.evaluate` with
+ * a canned sample payload. This lets the test exercise the full URL-mode
+ * extraction pipeline (css-tree parsing + computed-style merging +
+ * screenshot path) without launching a browser.
+ */
+function makeFakeLauncher(sample) {
+    let closed = false;
+    const launched = { closed: false };
+    const page = {
+        goto: async () => ({ status: () => sample.status ?? 200 }),
+        evaluate: async (script, ..._args) => {
+            // The first evaluate call is the long BROWSER_SCRIPT; subsequent
+            // calls come from the screenshot loop and return a number.
+            if (typeof script === 'string' && script.includes('scrollTo')) {
+                return 0;
+            }
+            return sample;
+        },
+        screenshot: async () => undefined,
+    };
+    const context = { newPage: async () => page };
+    const browser = {
+        newContext: async () => context,
+        close: async () => {
+            closed = true;
+            launched.closed = true;
+        },
+    };
+    const chromium = {
+        launch: async () => browser,
+    };
+    return { chromium, isClosed: () => closed, launched };
+}
+describe('extractFromUrl (C43 url mode, mocked chromium)', () => {
+    it('pulls colors from inline <style> and computed samples', async () => {
+        const sample = {
+            stylesheetTexts: [
+                `body { background: #0f172a; color: #f8fafc; font-family: 'Inter', sans-serif; font-size: 16px; padding: 24px; border-radius: 8px; }`,
+                `.btn { background: #2563eb; padding: 12px 16px; box-shadow: 0 1px 2px rgba(0,0,0,0.3); }`,
+            ],
+            computed: [
+                {
+                    selector: 'body',
+                    weight: 5,
+                    color: 'rgb(248, 250, 252)',
+                    backgroundColor: 'rgb(15, 23, 42)',
+                    fontFamily: 'Inter, sans-serif',
+                    fontSize: '16px',
+                    lineHeight: '24px',
+                    padding: '24px',
+                    margin: '0px',
+                    borderRadius: '0px',
+                    boxShadow: 'none',
+                    transitionDuration: '0s',
+                    transitionTimingFunction: 'ease',
+                },
+                {
+                    selector: 'button',
+                    weight: 3,
+                    color: 'rgb(248, 250, 252)',
+                    backgroundColor: 'rgb(37, 99, 235)',
+                    fontFamily: 'Inter, sans-serif',
+                    fontSize: '14px',
+                    lineHeight: '20px',
+                    padding: '12px 16px',
+                    margin: '0px',
+                    borderRadius: '8px',
+                    boxShadow: 'rgba(0, 0, 0, 0.3) 0px 1px 2px 0px',
+                    transitionDuration: '150ms',
+                    transitionTimingFunction: 'ease-in-out',
+                },
+            ],
+        };
+        const { chromium, isClosed } = makeFakeLauncher(sample);
+        const result = await extractFromUrl('https://example.test/', {
+            launcher: { chromium },
+            screenshots: false,
+        });
+        expect(result.mode).toBe('url');
+        expect(result.target).toBe('https://example.test/');
+        expect(result.colors.length).toBeGreaterThanOrEqual(2);
+        expect(result.fonts.some((f) => f.family === 'Inter')).toBe(true);
+        expect(result.spacing.length).toBeGreaterThanOrEqual(1);
+        expect(isClosed()).toBe(true);
+    });
+    it('raises TasteInferAuthWall on visible password input', async () => {
+        const { chromium } = makeFakeLauncher({
+            stylesheetTexts: [],
+            computed: [],
+            hasAuthWall: true,
+        });
+        await expect(extractFromUrl('https://example.test/login', {
+            launcher: { chromium },
+            screenshots: false,
+        })).rejects.toBeInstanceOf(TasteInferAuthWall);
+    });
+    it('raises TasteInferAuthWall on HTTP 401/403 response', async () => {
+        const { chromium } = makeFakeLauncher({
+            stylesheetTexts: [],
+            computed: [],
+            status: 403,
+        });
+        await expect(extractFromUrl('https://example.test/private', {
+            launcher: { chromium },
+            screenshots: false,
+        })).rejects.toBeInstanceOf(TasteInferAuthWall);
+    });
+});
+// --- Synthesis --------------------------------------------------------
+function makeExtracted(overrides = {}) {
+    return {
+        colors: [
+            { value: '#0f172a', weight: 10, source: 'css' },
+            { value: '#f8fafc', weight: 8, source: 'css' },
+            { value: '#2563eb', weight: 6, source: 'css' },
+            { value: '#334155', weight: 3, source: 'css' },
+            { value: '#1e293b', weight: 2, source: 'css' },
+        ],
+        fonts: [{ family: 'Inter', weight: 5 }],
+        spacing: [
+            { value: '8px', weight: 4 },
+            { value: '16px', weight: 3 },
+            { value: '24px', weight: 2 },
+        ],
+        radii: [
+            { value: '4px', weight: 2 },
+            { value: '8px', weight: 1 },
+        ],
+        shadows: [{ value: '0 1px 2px rgba(0,0,0,0.3)', weight: 1 }],
+        motion: {},
+        target: 'https://example.test/',
+        mode: 'url',
+        ...overrides,
+    };
+}
+describe('parseColor helper', () => {
+    it('parses 3/6/8-digit hex', () => {
+        expect(parseColor('#fff')).toEqual({ r: 255, g: 255, b: 255, a: 1 });
+        expect(parseColor('#0f172a')).toEqual({ r: 15, g: 23, b: 42, a: 1 });
+        const p = parseColor('#0f172aff');
+        expect(p?.r).toBe(15);
+        expect(p?.a).toBeCloseTo(1, 2);
+    });
+    it('parses rgb/rgba with commas or slash', () => {
+        expect(parseColor('rgb(37, 99, 235)')).toEqual({ r: 37, g: 99, b: 235, a: 1 });
+        const rgba = parseColor('rgba(0, 0, 0, 0.3)');
+        expect(rgba?.a).toBeCloseTo(0.3, 2);
+    });
+    it('returns null on garbage', () => {
+        expect(parseColor('notacolor')).toBeNull();
+        expect(parseColor('')).toBeNull();
+    });
+});
+describe('clusterColors helper', () => {
+    it('groups colors within the RGB delta threshold', () => {
+        const entries = [
+            { value: '#0f172a', weight: 5, parsed: { r: 15, g: 23, b: 42, a: 1 } },
+            { value: '#0e1829', weight: 3, parsed: { r: 14, g: 24, b: 41, a: 1 } },
+            { value: '#f8fafc', weight: 8, parsed: { r: 248, g: 250, b: 252, a: 1 } },
+        ];
+        const clusters = clusterColors(entries, 4);
+        expect(clusters.length).toBe(2);
+        const [first, second] = clusters;
+        // Cluster with the highest totalWeight first.
+        expect(first.totalWeight).toBe(8);
+        expect(second.totalWeight).toBe(8); // 5 + 3 collapsed
+    });
+});
+describe('synthesizeDeterministic (C43 fallback)', () => {
+    it('AC-6: produces schema-valid frontmatter on a minimal 1-color / 1-font input', () => {
+        const extracted = makeExtracted({
+            colors: [{ value: '#7c3aed', weight: 1, source: 'css' }],
+            fonts: [{ family: 'Inter', weight: 1 }],
+            spacing: [],
+            radii: [],
+            shadows: [],
+        });
+        const { frontmatter, body, path } = synthesizeDeterministic(extracted);
+        expect(path).toBe('fallback');
+        const v = validateDesignFrontmatter(frontmatter);
+        expect(v.success).toBe(true);
+        // Body includes the required Stitch section headers.
+        expect(body).toMatch(/## 1\. Visual Theme/);
+        expect(body).toMatch(/## 2\. Color Palette/);
+        expect(body).toMatch(/## 3\. Typography/);
+    });
+    it('assigns reasonable bg / text / accent roles on a 5-color dark palette', () => {
+        const extracted = makeExtracted();
+        const { frontmatter } = synthesizeDeterministic(extracted);
+        const { colors } = frontmatter.tokens;
+        // Darkest candidate is #0f172a (luminance ~0.01). Lightest is #f8fafc.
+        // Accent should be the chromatic blue.
+        expect(colors.bg.toLowerCase()).toBe('#0f172a');
+        expect(colors.text.toLowerCase()).toBe('#f8fafc');
+        expect(colors.accent.toLowerCase()).toBe('#2563eb');
+    });
+    it('inverts bg/text polarity for light-mode sites', () => {
+        const extracted = makeExtracted({
+            colors: [
+                { value: '#ffffff', weight: 12, source: 'css' },
+                { value: '#111111', weight: 8, source: 'css' },
+                { value: '#5a67d8', weight: 4, source: 'css' },
+                { value: '#edf2f7', weight: 3, source: 'css' },
+                { value: '#cbd5e0', weight: 2, source: 'css' },
+            ],
+        });
+        const { frontmatter } = synthesizeDeterministic(extracted);
+        const { colors } = frontmatter.tokens;
+        expect(colors.bg.toLowerCase()).toBe('#ffffff');
+        expect(colors.text.toLowerCase()).toBe('#111111');
+    });
+});
+describe('synthesizeDesign (routing + LLM branch)', () => {
+    it('opts.provider === "none" forces fallback without calling the LLM', async () => {
+        const result = await synthesizeDesign(makeExtracted(), { provider: 'none' });
+        expect(result.path).toBe('fallback');
+    });
+    it('opts.dry forces fallback', async () => {
+        const result = await synthesizeDesign(makeExtracted(), { dry: true });
+        expect(result.path).toBe('fallback');
+    });
+    it('LLM path returns llm when the mocked provider emits valid frontmatter', async () => {
+        const llmResponse = `---\n${`meta:\n  name: Mocked\n  version: "0.1.0"\n  updated: "2026-04-19"\ntokens:\n  colors:\n    bg: "#000000"\n    surface: "#111111"\n    accent: "#7c3aed"\n    text: "#ffffff"\n    border: "#333333"\n  typography:\n    families:\n      primary: "Inter"\n    scale:\n      - "14px"\n      - "16px"\n      - "20px"\n  spacing:\n    - "8px"\n    - "16px"\n`}---\n\n# mocked body\n`;
+        const result = await synthesizeDesign(makeExtracted(), {
+            provider: 'google',
+            providerCall: async () => llmResponse,
+        });
+        expect(result.path).toBe('llm');
+        const v = validateDesignFrontmatter(result.frontmatter);
+        expect(v.success).toBe(true);
+    });
+    it('LLM path falls back when the provider emits unparseable response', async () => {
+        const result = await synthesizeDesign(makeExtracted(), {
+            provider: 'google',
+            providerCall: async () => 'not yaml',
+        });
+        expect(result.path).toBe('fallback');
+    });
+    it('LLM path falls back when the provider emits schema-invalid frontmatter', async () => {
+        // Missing required tokens.* keys → validateDesignFrontmatter fails.
+        const bad = `---\nmeta:\n  name: x\n  version: "0.1"\n  updated: "2026"\ntokens:\n  colors: {}\n---\nbody\n`;
+        const result = await synthesizeDesign(makeExtracted(), {
+            provider: 'google',
+            providerCall: async () => bad,
+        });
+        expect(result.path).toBe('fallback');
+    });
+});
+describe('renderDesignMarkdown (end-to-end shape)', () => {
+    it('round-trips through validateDesignMarkdown clean', async () => {
+        const { frontmatter, body } = synthesizeDeterministic(makeExtracted());
+        const md = await renderDesignMarkdown(frontmatter, body);
+        const result = validateDesignMarkdown(md);
+        expect(result.errors).toEqual([]);
+        expect(result.ok).toBe(true);
+    });
+});
+// --- cmdTasteInfer — mode detection + library write -----------------------
+describe('detectMode (C43 CLI dispatch)', () => {
+    it('AC-9: owner/repo → github mode', () => {
+        expect(detectMode('linear/linear')).toBe('github');
+        expect(detectMode('facebook/react')).toBe('github');
+    });
+    it('http/https/file URLs → url mode', () => {
+        expect(detectMode('https://linear.app')).toBe('url');
+        expect(detectMode('http://example.test')).toBe('url');
+        expect(detectMode('file:///tmp/fixture.html')).toBe('url');
+    });
+    it('absolute + relative paths → repo mode', () => {
+        expect(detectMode('/abs/path')).toBe('repo');
+        expect(detectMode('./rel/path')).toBe('repo');
+        expect(detectMode('../parent')).toBe('repo');
+        expect(detectMode('~/home')).toBe('repo');
+    });
+    it('existing local directory → repo mode, even without a leading slash', () => {
+        const tmp = mkdtempSync(join(tmpdir(), 'apt-detect-'));
+        try {
+            // Passing a bare basename that actually exists — should be repo mode.
+            const cwd = process.cwd();
+            process.chdir(tmp);
+            try {
+                // `owner/repo`-shaped but an existing dir: we don't make a
+                // directory with `/`, just verify bare path handling below.
+                expect(detectMode(tmp)).toBe('repo');
+            }
+            finally {
+                process.chdir(cwd);
+            }
+        }
+        finally {
+            rmSync(tmp, { recursive: true, force: true });
+        }
+    });
+    it('empty / malformed falls through to repo (caller validates positional arg)', () => {
+        expect(detectMode('')).toBe('repo');
+        expect(detectMode('some arbitrary prose with spaces')).toBe('repo');
+    });
+});
+describe('writeLibraryEntry (C43 --add-to-library)', () => {
+    const mkTmp = () => mkdtempSync(join(tmpdir(), 'apt-taste-lib-'));
+    let envHomeCache;
+    afterEach(() => {
+        if (envHomeCache !== undefined) {
+            process.env.APT_TASTE_LIBRARY_HOME = envHomeCache;
+        }
+        else {
+            delete process.env.APT_TASTE_LIBRARY_HOME;
+        }
+    });
+    it('AC-8: writes DESIGN.md + provenance.yaml to HOME/.aperant/design-library/<slug>/', async () => {
+        const root = mkTmp();
+        envHomeCache = process.env.APT_TASTE_LIBRARY_HOME;
+        process.env.APT_TASTE_LIBRARY_HOME = root;
+        try {
+            const { frontmatter, body } = synthesizeDeterministic(makeExtracted());
+            const designMd = await renderDesignMarkdown(frontmatter, body);
+            const path = writeLibraryEntry({
+                slug: 'example-brand',
+                designMd,
+                target: 'https://example.test',
+                mode: 'url',
+                force: false,
+            });
+            expect(path).toContain('example-brand');
+            expect(readFileSync(path, 'utf-8')).toMatch(/^---\n/);
+            const provenance = readFileSync(join(root, 'example-brand', 'provenance.yaml'), 'utf-8');
+            expect(provenance).toMatch(/source:\s*taste-infer/);
+            expect(provenance).toMatch(/target:\s*['"]?https:\/\/example\.test['"]?/);
+            expect(provenance).toMatch(/mode:\s*url/);
+        }
+        finally {
+            rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it('refuses to overwrite an existing entry without --force', async () => {
+        const root = mkTmp();
+        envHomeCache = process.env.APT_TASTE_LIBRARY_HOME;
+        process.env.APT_TASTE_LIBRARY_HOME = root;
+        try {
+            const { frontmatter, body } = synthesizeDeterministic(makeExtracted());
+            const designMd = await renderDesignMarkdown(frontmatter, body);
+            writeLibraryEntry({ slug: 'dup', designMd, target: 't', mode: 'url', force: false });
+            expect(() => writeLibraryEntry({ slug: 'dup', designMd, target: 't', mode: 'url', force: false })).toThrowError(/already exists/);
+            // --force overwrites.
+            expect(() => writeLibraryEntry({ slug: 'dup', designMd, target: 't', mode: 'url', force: true })).not.toThrow();
+        }
+        finally {
+            rmSync(root, { recursive: true, force: true });
+        }
+    });
+});
+describe('cmdTasteInfer — end-to-end dispatch (mocked extractors)', () => {
+    /**
+     * Invokes cmdTasteInfer with vi.mock to replace the extractors so we can
+     * run the full dispatch + synthesis + validation + write path without
+     * touching real Playwright / css-tree input. We capture stdout via a
+     * spy rather than spawning the CLI.
+     */
+    it('AC-7: missing optional dep (playwright) → structured hint, exit 1', async () => {
+        // Arrange: dynamic module-replace extract-url so it throws
+        // TasteInferMissingDep on call. We stub only for this test scope.
+        vi.resetModules();
+        vi.doMock('../cli/design/extract-url.mjs', async () => {
+            class TasteInferMissingDep extends Error {
+                dep;
+                hint;
+                constructor() {
+                    super('taste-infer requires the optional dependency playwright');
+                    this.dep = 'playwright';
+                    this.name = 'TasteInferMissingDep';
+                    this.hint = 'run: pnpm add -D playwright && npx playwright install chromium';
+                }
+            }
+            return {
+                extractFromUrl: () => {
+                    throw new TasteInferMissingDep();
+                },
+                TasteInferMissingDep,
+                TasteInferAuthWall: class extends Error {
+                },
+            };
+        });
+        const mod = await import('../cli/commands/taste-infer.mjs');
+        try {
+            // Post-S15: cmdTasteInfer returns the {envelope, exitCode} tuple
+            // directly instead of calling process.stdout.write + process.exit.
+            const result = await mod.cmdTasteInfer('https://example.test', [
+                '--out',
+                '/tmp/nope.md',
+                '--force',
+            ]);
+            expect(result.exitCode).toBe(1);
+            const parsed = result.envelope;
+            expect(parsed.status).toBe('error');
+            expect(parsed.command).toBe('taste-infer');
+            expect(parsed.error).toMatch(/playwright is not installed/);
+            expect(parsed.hint).toMatch(/playwright install chromium/);
+        }
+        finally {
+            vi.doUnmock('../cli/design/extract-url.mjs');
+            vi.resetModules();
+        }
+    });
+    it('writes a valid DESIGN.md from the bundled fixture (repo mode)', async () => {
+        // Use the real extractor against the bundled fixture.
+        const { cmdTasteInfer } = await import('../cli/commands/taste-infer.mjs');
+        const tmp = mkdtempSync(join(tmpdir(), 'apt-taste-out-'));
+        const outPath = join(tmp, 'DESIGN.md');
+        try {
+            // Post-S15: cmdTasteInfer returns the {envelope, exitCode} tuple
+            // directly. The success envelope is on result.envelope.
+            const result = await cmdTasteInfer(FIXTURES, ['--out', outPath, '--no-synthesize']);
+            expect(result.exitCode).toBe(0);
+            const payload = result.envelope;
+            expect(payload.status).toBe('ok');
+            expect(payload.command).toBe('taste-infer');
+            expect(payload.mode).toBe('repo');
+            expect(payload.written).toBe(outPath);
+            expect(payload.synthesis).toBe('skipped');
+            // DESIGN.md passes the validator.
+            const written = readFileSync(outPath, 'utf-8');
+            const v = validateDesignMarkdown(written);
+            expect(v.errors).toEqual([]);
+        }
+        finally {
+            rmSync(tmp, { recursive: true, force: true });
+        }
+    });
+});
+// --- Prompt structure contract (c43 ↔ c44 coordination) -------------------
+//
+// Source-of-truth: the YAML `inputs:` block in the prompt frontmatter. Both
+// C43 (taste-infer) and C44 (apt:design --new) call synthesizeDesignMd with
+// the five named slots declared there, so any rename / reorder is a breaking
+// change detectable by these assertions.
+describe('prompt structure (design-synthesize.md — c43↔c44 contract)', () => {
+    const PROMPT_PATH = resolve(__dirname, '..', '..', 'prompts', 'design-synthesize.md');
+    it('file exists at the canonical location', () => {
+        const text = readFileSync(PROMPT_PATH, 'utf-8');
+        expect(text.length).toBeGreaterThan(200);
+    });
+    it('declares the five canonical input slots in the YAML `inputs:` block', () => {
+        const raw = readFileSync(PROMPT_PATH, 'utf-8');
+        const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n/);
+        expect(fmMatch).not.toBeNull();
+        const frontmatter = fmMatch[1];
+        // The five named slots both C43 and C44 depend on.
+        expect(frontmatter).toMatch(/^\s*inputs:/m);
+        expect(frontmatter).toMatch(/^\s{2}product_context:/m);
+        expect(frontmatter).toMatch(/^\s{2}taste:/m);
+        expect(frontmatter).toMatch(/^\s{2}observed_tokens:/m);
+        expect(frontmatter).toMatch(/^\s{2}reference_design_md:/m);
+        expect(frontmatter).toMatch(/^\s{2}style_seed:/m);
+    });
+    it('the prompt body references every declared slot as a `{{slot_name}}` placeholder', () => {
+        const raw = readFileSync(PROMPT_PATH, 'utf-8');
+        // Strip the leading --- YAML frontmatter block so we inspect the
+        // prompt body, not the slot declarations inside the header.
+        const body = raw.replace(/^---\n[\s\S]*?\n---\n/, '');
+        for (const slot of [
+            'product_context',
+            'taste',
+            'observed_tokens',
+            'reference_design_md',
+            'style_seed',
+        ]) {
+            const placeholderRe = new RegExp(`\\{\\{\\s*${slot}\\s*\\}\\}`);
+            expect(body).toMatch(placeholderRe);
+        }
+    });
+    it('keeps the product-context slot, taste slot, and reject criteria in that order', () => {
+        const raw = readFileSync(PROMPT_PATH, 'utf-8');
+        const body = raw.replace(/^---\n[\s\S]*?\n---\n/, '');
+        const ctxIdx = body.indexOf('{{product_context}}');
+        const tasteIdx = body.indexOf('{{taste}}');
+        const rejectIdx = body.indexOf('Reject criteria');
+        expect(ctxIdx).toBeGreaterThan(-1);
+        expect(tasteIdx).toBeGreaterThan(ctxIdx);
+        expect(rejectIdx).toBeGreaterThan(tasteIdx);
+    });
+    it('declares the C43/C44 coordination comment so reviewers can trace the contract', () => {
+        const text = readFileSync(PROMPT_PATH, 'utf-8');
+        // The HTML comment below the frontmatter documents the shared contract.
+        expect(text).toMatch(/Coordination:\s*shared with c43/i);
+        expect(text).toMatch(/c44/);
+    });
+});
+// --- I-1 no-LLM-imports invariant (AC-4) -----------------------------------
+/**
+ * The extraction modules (`extract-url.mjs` + `extract-repo.mjs`) MUST NOT
+ * touch any LLM SDK.  Any naming / role inference belongs in
+ * `synthesize.mjs` (per I-2).  This AST-walking test parses each file with
+ * @babel/parser (already an optional dep installed for the extractors'
+ * runtime dependency) and walks every import or dynamic import, asserting
+ * the source string never mentions a forbidden vendor.
+ *
+ * Tools the test scans for are spec §4.6: `openai`, `@anthropic-ai`,
+ * `@google/genai`, `langchain`, `llamaindex`, `cohere-ai`.
+ */
+describe('I-1 no-LLM extraction invariant (AC-4)', () => {
+    // Belt-and-braces vendor list. Substring matching means entries like
+    // `@anthropic-ai` catch both `@anthropic-ai/sdk` and `@anthropic-ai/bedrock-sdk`.
+    // `@google/generative-ai` is a DISTINCT package from `@google/genai` (the
+    // former is Google's legacy Gemini SDK; the latter is the current one);
+    // both are covered explicitly so a future regression can't slip through.
+    const FORBIDDEN = [
+        'openai',
+        '@anthropic-ai',
+        '@google/genai',
+        '@google/generative-ai',
+        'langchain',
+        'llamaindex',
+        'cohere-ai',
+        'mistralai',
+        'voyageai',
+    ];
+    const FILES_UNDER_INVARIANT = [
+        resolve(__dirname, '..', 'cli', 'design', 'extract-url.mjs'),
+        resolve(__dirname, '..', 'cli', 'design', 'extract-repo.mjs'),
+    ];
+    for (const filePath of FILES_UNDER_INVARIANT) {
+        it(`${filePath.split('/').slice(-3).join('/')} imports no LLM client or SDK`, async () => {
+            const src = readFileSync(filePath, 'utf-8');
+            // Dynamic-import @babel/parser so the test remains runnable even
+            // when the optional dep isn't installed — in that case we fall
+            // back to a regex check (less strict but still catches literal
+            // mentions). @babel is installed at test time since it's an
+            // optional dep of @aperant/framework itself.
+            let ast;
+            let usingBabel = true;
+            try {
+                const mod = (await import('@babel/parser'));
+                ast = mod.parse(src, {
+                    sourceType: 'module',
+                    errorRecovery: true,
+                    plugins: ['jsx'],
+                });
+            }
+            catch {
+                usingBabel = false;
+            }
+            const importSources = [];
+            if (usingBabel && ast) {
+                // @ts-expect-error — @babel/traverse ships without @types in this repo;
+                // we treat the module as 'any' for this static AST walk.
+                const traverseMod = (await import('@babel/traverse'));
+                const traverse = typeof traverseMod.default === 'function'
+                    ? traverseMod.default
+                    : (traverseMod.default?.default ?? traverseMod);
+                if (typeof traverse !== 'function') {
+                    throw new Error('@babel/traverse default export is not a function');
+                }
+                traverse(ast, {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    ImportDeclaration(path) {
+                        importSources.push(path.node.source.value);
+                    },
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    CallExpression(path) {
+                        const n = path.node;
+                        if (n.callee.type === 'Import') {
+                            const arg = n.arguments[0];
+                            if (arg && arg.type === 'StringLiteral' && typeof arg.value === 'string') {
+                                importSources.push(arg.value);
+                            }
+                        }
+                    },
+                });
+            }
+            else {
+                // Regex fallback: catches literal `from '...'` + `import('...')`.
+                for (const m of src.matchAll(/from\s+['"]([^'"]+)['"]/g))
+                    importSources.push(m[1]);
+                for (const m of src.matchAll(/import\(\s*['"]([^'"]+)['"]\s*\)/g))
+                    importSources.push(m[1]);
+            }
+            for (const imp of importSources) {
+                for (const forbidden of FORBIDDEN) {
+                    expect(imp.includes(forbidden), `${filePath.split('/').slice(-1)[0]} must not import '${forbidden}' (observed: '${imp}')`).toBe(false);
+                }
+            }
+        });
+    }
+    it('synthesize.mjs IS allowed to import @google/genai (I-2 carve-out) — sanity check', () => {
+        // Document the intent: the invariant covers extractors only, per spec
+        // §I-1 / §I-2. synthesize.mjs imports @google/genai lazily inside the
+        // LLM branch. This test just asserts that file is NOT in the set we
+        // check above, so a future agent who decides to 'extend the invariant
+        // to synthesize' must edit this test too.
+        const synthFile = resolve(__dirname, '..', 'cli', 'design', 'synthesize.mjs');
+        expect(FILES_UNDER_INVARIANT).not.toContain(synthFile);
+    });
+});
+//# sourceMappingURL=taste-infer.test.js.map