runwork 0.15.0 → 0.15.2

package/dist/utils/__tests__/http.test.js

@@ -1,381 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
-import { createServer } from 'node:http';
-import { gzipSync, deflateSync, brotliCompressSync } from 'node:zlib';
-import { spawnSync } from 'node:child_process';
-import { httpFetch, __setTransportForTests } from '../http.js';
-let server;
-let port;
-const calls = [];
-function startServer() {
-    return new Promise((resolve) => {
-        server = createServer(async (req, res) => {
-            const chunks = [];
-            for await (const chunk of req)
-                chunks.push(chunk);
-            const body = Buffer.concat(chunks).toString('utf-8');
-            calls.push({ url: req.url || '', method: req.method || '', headers: req.headers, body });
-            const url = req.url || '/';
-            // Simple endpoints exercised by the test cases below.
-            if (url === '/json') {
-                res.writeHead(200, { 'content-type': 'application/json' });
-                res.end(JSON.stringify({ hello: 'world' }));
-                return;
-            }
-            if (url === '/text') {
-                res.writeHead(200, { 'content-type': 'text/plain' });
-                res.end('plain body');
-                return;
-            }
-            if (url === '/binary') {
-                res.writeHead(200, { 'content-type': 'application/octet-stream' });
-                res.end(Buffer.from([1, 2, 3, 4, 5]));
-                return;
-            }
-            if (url === '/echo-headers') {
-                res.writeHead(200, { 'content-type': 'application/json' });
-                res.end(JSON.stringify({ headers: req.headers, method: req.method }));
-                return;
-            }
-            if (url === '/echo-body') {
-                res.writeHead(200, { 'content-type': 'application/json' });
-                res.end(JSON.stringify({ body, contentType: req.headers['content-type'] }));
-                return;
-            }
-            if (url === '/status/404') {
-                res.writeHead(404, { 'content-type': 'text/plain' });
-                res.end('not found');
-                return;
-            }
-            if (url === '/status/500') {
-                res.writeHead(500, { 'content-type': 'text/plain' });
-                res.end('boom');
-                return;
-            }
-            if (url === '/redirect/302') {
-                res.writeHead(302, { location: '/json' });
-                res.end();
-                return;
-            }
-            if (url === '/redirect/303-post') {
-                res.writeHead(303, { location: '/echo-headers' });
-                res.end();
-                return;
-            }
-            if (url === '/redirect/307') {
-                res.writeHead(307, { location: '/echo-body' });
-                res.end();
-                return;
-            }
-            if (url === '/redirect/loop') {
-                res.writeHead(302, { location: '/redirect/loop' });
-                res.end();
-                return;
-            }
-            if (url === '/gzip') {
-                res.writeHead(200, { 'content-type': 'text/plain', 'content-encoding': 'gzip' });
-                res.end(gzipSync(Buffer.from('compressed-gzip-body')));
-                return;
-            }
-            if (url === '/deflate') {
-                res.writeHead(200, { 'content-type': 'text/plain', 'content-encoding': 'deflate' });
-                res.end(deflateSync(Buffer.from('compressed-deflate-body')));
-                return;
-            }
-            if (url === '/brotli') {
-                res.writeHead(200, { 'content-type': 'text/plain', 'content-encoding': 'br' });
-                res.end(brotliCompressSync(Buffer.from('compressed-brotli-body')));
-                return;
-            }
-            if (url === '/head') {
-                res.writeHead(200, { 'content-type': 'text/plain', 'x-marker': 'present' });
-                res.end();
-                return;
-            }
-            res.writeHead(404);
-            res.end();
-        });
-        server.listen(0, '127.0.0.1', () => {
-            const addr = server.address();
-            if (typeof addr === 'object' && addr && 'port' in addr) {
-                port = addr.port;
-            }
-            resolve();
-        });
-    });
-}
-beforeAll(async () => { await startServer(); });
-afterAll(() => new Promise((resolve) => server.close(() => resolve())));
-function url(path) { return `http://127.0.0.1:${port}${path}`; }
-describe('httpFetch — basic Response surface', () => {
-    it('parses JSON responses', async () => {
-        const res = await httpFetch(url('/json'));
-        expect(res.ok).toBe(true);
-        expect(res.status).toBe(200);
-        expect(res.headers.get('content-type')).toContain('application/json');
-        expect(await res.json()).toEqual({ hello: 'world' });
-    });
-    it('reads text responses', async () => {
-        const res = await httpFetch(url('/text'));
-        expect(res.ok).toBe(true);
-        expect(await res.text()).toBe('plain body');
-    });
-    it('reads binary responses as ArrayBuffer with the exact byte content', async () => {
-        const res = await httpFetch(url('/binary'));
-        const ab = await res.arrayBuffer();
-        expect(new Uint8Array(ab)).toEqual(new Uint8Array([1, 2, 3, 4, 5]));
-    });
-    it('returns ok=false for 4xx without throwing', async () => {
-        const res = await httpFetch(url('/status/404'));
-        expect(res.ok).toBe(false);
-        expect(res.status).toBe(404);
-        expect(await res.text()).toBe('not found');
-    });
-    it('returns ok=false for 5xx without throwing', async () => {
-        const res = await httpFetch(url('/status/500'));
-        expect(res.ok).toBe(false);
-        expect(res.status).toBe(500);
-    });
-});
-describe('httpFetch — request shape', () => {
-    it('passes through plain object headers, lowercased per HTTP convention', async () => {
-        const res = await httpFetch(url('/echo-headers'), {
-            headers: { 'X-Custom-Foo': 'bar', Authorization: 'Bearer abc' },
-        });
-        const data = await res.json();
-        expect(data.method).toBe('GET');
-        expect(data.headers['x-custom-foo']).toBe('bar');
-        expect(data.headers['authorization']).toBe('Bearer abc');
-    });
-    it('passes through Headers instance', async () => {
-        const headers = new Headers();
-        headers.set('X-One', 'a');
-        headers.set('X-Two', 'b');
-        const res = await httpFetch(url('/echo-headers'), { headers });
-        const data = await res.json();
-        expect(data.headers['x-one']).toBe('a');
-        expect(data.headers['x-two']).toBe('b');
-    });
-    it('uppercases lowercase methods', async () => {
-        const res = await httpFetch(url('/echo-headers'), { method: 'post', body: '' });
-        const data = await res.json();
-        expect(data.method).toBe('POST');
-    });
-    it('sends string body and content-length', async () => {
-        const res = await httpFetch(url('/echo-body'), {
-            method: 'POST',
-            headers: { 'content-type': 'application/json' },
-            body: JSON.stringify({ a: 1 }),
-        });
-        const data = await res.json();
-        expect(data.body).toBe('{"a":1}');
-        expect(data.contentType).toBe('application/json');
-    });
-    it('sends Buffer body', async () => {
-        const res = await httpFetch(url('/echo-body'), {
-            method: 'PUT',
-            body: Buffer.from('raw-buffer'),
-        });
-        const data = await res.json();
-        expect(data.body).toBe('raw-buffer');
-    });
-    it('sends Uint8Array body with offset', async () => {
-        const backing = new Uint8Array([0, 0, 65, 66, 67, 0]);
-        const view = backing.subarray(2, 5); // "ABC"
-        const res = await httpFetch(url('/echo-body'), { method: 'POST', body: view });
-        const data = await res.json();
-        expect(data.body).toBe('ABC');
-    });
-    it('sends ArrayBuffer body', async () => {
-        const ab = new TextEncoder().encode('via-arraybuffer').buffer;
-        const res = await httpFetch(url('/echo-body'), { method: 'POST', body: ab });
-        const data = await res.json();
-        expect(data.body).toBe('via-arraybuffer');
-    });
-    it('drops body on bodyless GET/HEAD methods (matches fetch behavior)', async () => {
-        const res = await httpFetch(url('/echo-body'), {
-            method: 'GET',
-            // GET requests with bodies are non-conformant; fetch silently drops the body.
-            body: 'should-not-be-sent',
-        });
-        const data = await res.json();
-        expect(data.body).toBe('');
-    });
-});
-describe('httpFetch — redirects', () => {
-    it('follows a 302 to the final URL', async () => {
-        const res = await httpFetch(url('/redirect/302'));
-        expect(res.status).toBe(200);
-        expect(res.url.endsWith('/json')).toBe(true);
-        expect(await res.json()).toEqual({ hello: 'world' });
-    });
-    it('downgrades POST to GET on 303 (matches fetch semantics)', async () => {
-        const res = await httpFetch(url('/redirect/303-post'), {
-            method: 'POST',
-            body: 'ignored-after-303',
-        });
-        const data = await res.json();
-        expect(data.method).toBe('GET');
-    });
-    it('preserves method and body on 307', async () => {
-        const res = await httpFetch(url('/redirect/307'), {
-            method: 'POST',
-            body: 'preserved-on-307',
-        });
-        const data = await res.json();
-        expect(data.body).toBe('preserved-on-307');
-    });
-    it('rejects after exceeding the redirect limit', async () => {
-        // The endpoint redirects to itself; after MAX_REDIRECTS we stop following
-        // and return the redirect response itself rather than crash.
-        const res = await httpFetch(url('/redirect/loop'));
-        expect(res.status).toBe(302);
-    });
-});
-describe('httpFetch — content decoding', () => {
-    it('advertises gzip/deflate/br by default', async () => {
-        await httpFetch(url('/echo-headers'));
-        const last = calls[calls.length - 1];
-        expect(last.headers['accept-encoding']).toBe('gzip, deflate, br');
-    });
-    it('decompresses gzip responses transparently', async () => {
-        const res = await httpFetch(url('/gzip'));
-        expect(await res.text()).toBe('compressed-gzip-body');
-    });
-    it('decompresses brotli responses transparently', async () => {
-        const res = await httpFetch(url('/brotli'));
-        expect(await res.text()).toBe('compressed-brotli-body');
-    });
-    it('decompresses deflate responses transparently', async () => {
-        const res = await httpFetch(url('/deflate'));
-        expect(await res.text()).toBe('compressed-deflate-body');
-    });
-});
-describe('httpFetch — HEAD requests', () => {
-    it('returns headers and an empty body', async () => {
-        const res = await httpFetch(url('/head'), { method: 'HEAD' });
-        expect(res.status).toBe(200);
-        expect(res.headers.get('x-marker')).toBe('present');
-        expect(await res.text()).toBe('');
-    });
-});
-describe('httpFetch — errors', () => {
-    it('rejects on connection failure', async () => {
-        // 127.0.0.1:1 is virtually guaranteed to refuse connections.
-        await expect(httpFetch('http://127.0.0.1:1/')).rejects.toThrow();
-    });
-    it('rejects on unsupported protocols', async () => {
-        await expect(httpFetch('ftp://example.com/')).rejects.toThrow(/Unsupported protocol/);
-    });
-});
-// ────────────────────────────────────────────────────────────────────────
-// curl-transport tests
-//
-// `curl` is the opt-in escape hatch (`RUNWORK_HTTP_TRANSPORT=curl`). It
-// shells out to the system `curl` so HTTP runs in a subprocess, immune to
-// any future runtime regression. These tests force the curl path via the
-// test-only override so the break-glass path stays exercised in CI even
-// though the default transport is `node:https`. Skipped when curl is
-// missing on the host.
-// ────────────────────────────────────────────────────────────────────────
-const curlAvailable = (() => {
-    try {
-        const r = spawnSync('curl', ['--version'], { encoding: 'utf-8' });
-        return r.status === 0;
-    }
-    catch {
-        return false;
-    }
-})();
-describe.skipIf(!curlAvailable)('httpFetch — curl transport (opt-in via env var)', () => {
-    beforeAll(() => { __setTransportForTests('curl'); });
-    afterAll(() => { __setTransportForTests('auto'); });
-    it('parses JSON responses through curl', async () => {
-        const res = await httpFetch(url('/json'));
-        expect(res.ok).toBe(true);
-        expect(res.status).toBe(200);
-        expect(await res.json()).toEqual({ hello: 'world' });
-    });
-    it('reads binary responses with exact byte content', async () => {
-        const res = await httpFetch(url('/binary'));
-        const ab = await res.arrayBuffer();
-        expect(new Uint8Array(ab)).toEqual(new Uint8Array([1, 2, 3, 4, 5]));
-    });
-    it('returns ok=false for 4xx without throwing', async () => {
-        const res = await httpFetch(url('/status/404'));
-        expect(res.ok).toBe(false);
-        expect(res.status).toBe(404);
-        expect(await res.text()).toBe('not found');
-    });
-    it('follows 302 redirects to the final URL', async () => {
-        const res = await httpFetch(url('/redirect/302'));
-        expect(res.status).toBe(200);
-        expect(res.url.endsWith('/json')).toBe(true);
-        expect(await res.json()).toEqual({ hello: 'world' });
-    });
-    it('downgrades POST to GET on 303 (matches fetch semantics)', async () => {
-        const res = await httpFetch(url('/redirect/303-post'), {
-            method: 'POST',
-            body: 'ignored-after-303',
-        });
-        const data = await res.json();
-        expect(data.method).toBe('GET');
-    });
-    it('preserves method and body on 307', async () => {
-        const res = await httpFetch(url('/redirect/307'), {
-            method: 'POST',
-            body: 'preserved-on-307',
-        });
-        const data = await res.json();
-        expect(data.body).toBe('preserved-on-307');
-    });
-    it('passes plain object headers through', async () => {
-        const res = await httpFetch(url('/echo-headers'), {
-            headers: { 'X-Custom': 'curl-roundtrip', Authorization: 'Bearer abc' },
-        });
-        const data = await res.json();
-        expect(data.headers['x-custom']).toBe('curl-roundtrip');
-        expect(data.headers['authorization']).toBe('Bearer abc');
-    });
-    it('sends string body and content-type', async () => {
-        const res = await httpFetch(url('/echo-body'), {
-            method: 'POST',
-            headers: { 'content-type': 'application/json' },
-            body: JSON.stringify({ a: 1 }),
-        });
-        const data = await res.json();
-        expect(data.body).toBe('{"a":1}');
-        expect(data.contentType).toBe('application/json');
-    });
-    it('sends binary Uint8Array body with offset', async () => {
-        const backing = new Uint8Array([0, 0, 65, 66, 67, 0]);
-        const view = backing.subarray(2, 5); // "ABC"
-        const res = await httpFetch(url('/echo-body'), { method: 'POST', body: view });
-        const data = await res.json();
-        expect(data.body).toBe('ABC');
-    });
-    it('returns headers and an empty body for HEAD', async () => {
-        const res = await httpFetch(url('/head'), { method: 'HEAD' });
-        expect(res.status).toBe(200);
-        expect(res.headers.get('x-marker')).toBe('present');
-        expect(await res.text()).toBe('');
-    });
-    it('warns and returns raw bytes on unexpected gzip', async () => {
-        const stderr = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
-        try {
-            const res = await httpFetch(url('/gzip'));
-            expect(res.ok).toBe(true);
-            const ab = await res.arrayBuffer();
-            expect(ab.byteLength).toBeGreaterThan(0);
-            expect(stderr).toHaveBeenCalledWith(expect.stringMatching(/Content-Encoding: gzip/));
-        }
-        finally {
-            stderr.mockRestore();
-        }
-    });
-    it('rejects on connection failure', async () => {
-        await expect(httpFetch('http://127.0.0.1:1/')).rejects.toThrow();
-    });
-    it('rejects on unsupported protocols', async () => {
-        await expect(httpFetch('ftp://example.com/')).rejects.toThrow(/Unsupported protocol/);
-    });
-});

package/dist/utils/__tests__/ignore-matcher.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/utils/__tests__/ignore-matcher.test.js

@@ -1,205 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { mkdtempSync, writeFileSync, rmSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { buildIgnoreSets, defaultIgnoreSets, isPathIgnored, isRelPathIgnored, parseGitignoreContent, } from '../ignore-matcher.js';
-const tempDirs = [];
-function makeTempDir(prefix) {
-    const dir = mkdtempSync(join(tmpdir(), `runwork-ignore-${prefix}-`));
-    tempDirs.push(dir);
-    return dir;
-}
-afterEach(() => {
-    for (const dir of tempDirs) {
-        try {
-            rmSync(dir, { recursive: true, force: true });
-        }
-        catch { /* best effort */ }
-    }
-    tempDirs.length = 0;
-});
-describe('defaultIgnoreSets()', () => {
-    it('includes the historical defaults plus .bun-cache', () => {
-        const sets = defaultIgnoreSets();
-        expect(sets.dirs.has('.git')).toBe(true);
-        expect(sets.dirs.has('node_modules')).toBe(true);
-        expect(sets.dirs.has('.runwork')).toBe(true);
-        expect(sets.dirs.has('.bun-cache')).toBe(true);
-    });
-    it('excludes every .runwork/ state file from deploy/dev auto-commit staging', () => {
-        // commitWorkingTree() filters untracked files through isRelPathIgnored,
-        // so any path with a .runwork segment must be excluded -- including the
-        // local deploy-state/status files written before the detached child
-        // commits (Codex review P1).
-        const sets = defaultIgnoreSets();
-        for (const p of [
-            '.runwork/deploy-status.json',
-            '.runwork/last-deploy.json',
-            '.runwork/deploy-stdout.log',
-            '.runwork/dev-session.json',
-            '.runwork/setup.json',
-            '.runwork/preview-url',
-        ]) {
-            expect(isRelPathIgnored(p, sets), `${p} must be ignored`).toBe(true);
-        }
-    });
-    it('includes .dev.vars and .env file defaults', () => {
-        const sets = defaultIgnoreSets();
-        expect(sets.files.has('.dev.vars')).toBe(true);
-        expect(sets.files.has('.env')).toBe(true);
-    });
-    it('includes .log extension default', () => {
-        const sets = defaultIgnoreSets();
-        expect(sets.extensions.has('.log')).toBe(true);
-    });
-    it('returns independent set instances on each call', () => {
-        const a = defaultIgnoreSets();
-        const b = defaultIgnoreSets();
-        a.dirs.add('mutated');
-        expect(b.dirs.has('mutated')).toBe(false);
-    });
-});
-describe('parseGitignoreContent()', () => {
-    it('parses simple basename patterns', () => {
-        const { dirs, files } = parseGitignoreContent('node_modules\n.cache\n');
-        expect(dirs.has('node_modules')).toBe(true);
-        expect(dirs.has('.cache')).toBe(true);
-        expect(files.has('node_modules')).toBe(true);
-        expect(files.has('.cache')).toBe(true);
-    });
-    it('treats trailing-slash patterns as directory-only', () => {
-        const { dirs, files } = parseGitignoreContent('dist/\n');
-        expect(dirs.has('dist')).toBe(true);
-        expect(files.has('dist')).toBe(false);
-    });
-    it('strips leading slash on top-level patterns', () => {
-        const { dirs } = parseGitignoreContent('/dist/\n');
-        expect(dirs.has('dist')).toBe(true);
-    });
-    it('skips comments and blank lines', () => {
-        const { dirs } = parseGitignoreContent('# a comment\n\n  \n.cache\n');
-        expect(dirs.size).toBe(1);
-        expect(dirs.has('.cache')).toBe(true);
-    });
-    it('skips negation patterns', () => {
-        const { dirs } = parseGitignoreContent('!keepme\n.cache\n');
-        expect(dirs.has('keepme')).toBe(false);
-        expect(dirs.has('.cache')).toBe(true);
-    });
-    it('skips patterns containing glob characters', () => {
-        const { dirs, files } = parseGitignoreContent('*.local\nfoo[1].txt\nq?.tmp\n.cache\n');
-        expect(dirs.has('*.local')).toBe(false);
-        expect(files.has('*.local')).toBe(false);
-        expect(dirs.has('foo[1].txt')).toBe(false);
-        expect(dirs.has('q?.tmp')).toBe(false);
-        expect(dirs.has('.cache')).toBe(true);
-    });
-    it('skips patterns with internal path separators', () => {
-        const { dirs } = parseGitignoreContent('src/generated\n.runwork/types\n.cache\n');
-        expect(dirs.has('src/generated')).toBe(false);
-        expect(dirs.has('.runwork/types')).toBe(false);
-        expect(dirs.has('.cache')).toBe(true);
-    });
-    it('parses a realistic runwork-app .gitignore without throwing', () => {
-        const content = [
-            '# Logs',
-            'logs',
-            '*.log',
-            '',
-            'node_modules',
-            'dist',
-            'dist-ssr',
-            '*.local',
-            '.idea',
-            '.DS_Store',
-            '.wrangler',
-            '.dev.vars*',
-            '.env.*',
-            'data/',
-            '.data/',
-            '*.tsbuildinfo',
-            '.eslintcache',
-            '.runwork/types/',
-            '.runwork/.credentials',
-            '.runwork/logs.txt',
-            'SKILL.md',
-            '.bun-cache/',
-        ].join('\n');
-        const { dirs } = parseGitignoreContent(content);
-        expect(dirs.has('node_modules')).toBe(true);
-        expect(dirs.has('dist')).toBe(true);
-        expect(dirs.has('dist-ssr')).toBe(true);
-        expect(dirs.has('.idea')).toBe(true);
-        expect(dirs.has('.wrangler')).toBe(true);
-        expect(dirs.has('.bun-cache')).toBe(true);
-        expect(dirs.has('.eslintcache')).toBe(true);
-        expect(dirs.has('SKILL.md')).toBe(true);
-        // Patterns containing a slash, glob, or starting with `!` are not
-        // representable as basename matches and must be silently skipped.
-        expect(dirs.has('.runwork/types')).toBe(false);
-        expect(dirs.has('*.log')).toBe(false);
-        expect(dirs.has('.dev.vars*')).toBe(false);
-        expect(dirs.has('.env.*')).toBe(false);
-    });
-});
-describe('buildIgnoreSets()', () => {
-    it('falls back to defaults when no .gitignore is present', () => {
-        const dir = makeTempDir('no-gitignore');
-        const sets = buildIgnoreSets(dir);
-        expect(sets.dirs.has('.bun-cache')).toBe(true);
-        expect(sets.dirs.has('node_modules')).toBe(true);
-        // No project-specific entries get added.
-        expect(sets.dirs.has('dist')).toBe(false);
-    });
-    it('merges defaults with patterns parsed from .gitignore', () => {
-        const dir = makeTempDir('with-gitignore');
-        writeFileSync(join(dir, '.gitignore'), 'dist/\n.next/\ncoverage\n');
-        const sets = buildIgnoreSets(dir);
-        // Defaults still present.
-        expect(sets.dirs.has('.bun-cache')).toBe(true);
-        // Project-specific entries added.
-        expect(sets.dirs.has('dist')).toBe(true);
-        expect(sets.dirs.has('.next')).toBe(true);
-        expect(sets.dirs.has('coverage')).toBe(true);
-    });
-    it('returns defaults if .gitignore is unreadable', () => {
-        const dir = makeTempDir('bad-gitignore');
-        // Create a directory at the .gitignore path so readFileSync fails.
-        // Easiest cross-platform way: pass a directory path. We just write
-        // nothing here and skip — but verify no throw and defaults applied.
-        // (The unreadable path is exercised by buildIgnoreSets's try/catch.)
-        const sets = buildIgnoreSets(dir);
-        expect(sets.dirs.has('.bun-cache')).toBe(true);
-    });
-});
-describe('isPathIgnored()', () => {
-    const sets = defaultIgnoreSets();
-    it('ignores well-known cache directories by basename', () => {
-        expect(isPathIgnored('.bun-cache', sets)).toBe(true);
-        expect(isPathIgnored('/abs/path/.bun-cache', sets)).toBe(true);
-        expect(isPathIgnored('./project/node_modules', sets)).toBe(true);
-    });
-    it('ignores .dev.vars and .env files exactly (not substrings)', () => {
-        expect(isPathIgnored('.dev.vars', sets)).toBe(true);
-        expect(isPathIgnored('.env', sets)).toBe(true);
-        expect(isPathIgnored('.env.example', sets)).toBe(false);
-        expect(isPathIgnored('.env.local', sets)).toBe(false);
-    });
-    it('ignores files whose extension is in the extension set', () => {
-        expect(isPathIgnored('debug.log', sets)).toBe(true);
-        expect(isPathIgnored('/var/log/app.log', sets)).toBe(true);
-        expect(isPathIgnored('app.txt', sets)).toBe(false);
-    });
-    it('does not ignore ordinary source files', () => {
-        expect(isPathIgnored('src/index.ts', sets)).toBe(false);
-        expect(isPathIgnored('package.json', sets)).toBe(false);
-        expect(isPathIgnored('Makefile', sets)).toBe(false);
-    });
-    it('honors merged sets from buildIgnoreSets', () => {
-        const dir = makeTempDir('honors');
-        writeFileSync(join(dir, '.gitignore'), 'dist/\n');
-        const merged = buildIgnoreSets(dir);
-        expect(isPathIgnored('/repo/dist', merged)).toBe(true);
-        expect(isPathIgnored('/repo/src', merged)).toBe(false);
-    });
-});

package/dist/utils/__tests__/output.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/utils/__tests__/output.test.js

@@ -1,38 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { shouldOutputJson, jsonOut, jsonLine } from '../output.js';
-describe('shouldOutputJson', () => {
-    it('returns true when json flag is true', () => {
-        expect(shouldOutputJson(true)).toBe(true);
-    });
-    it('returns false when json flag is false (--no-json)', () => {
-        expect(shouldOutputJson(false)).toBe(false);
-    });
-    it('returns false when undefined and stdout is TTY', () => {
-        const original = process.stdout.isTTY;
-        Object.defineProperty(process.stdout, 'isTTY', { value: true, writable: true });
-        expect(shouldOutputJson(undefined)).toBe(false);
-        Object.defineProperty(process.stdout, 'isTTY', { value: original, writable: true });
-    });
-    it('returns true when undefined and stdout is not TTY', () => {
-        const original = process.stdout.isTTY;
-        Object.defineProperty(process.stdout, 'isTTY', { value: false, writable: true });
-        expect(shouldOutputJson(undefined)).toBe(true);
-        Object.defineProperty(process.stdout, 'isTTY', { value: original, writable: true });
-    });
-});
-describe('jsonOut', () => {
-    it('writes JSON to stdout with newline', () => {
-        const spy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        jsonOut({ hello: 'world' });
-        expect(spy).toHaveBeenCalledWith('{"hello":"world"}\n');
-        spy.mockRestore();
-    });
-});
-describe('jsonLine', () => {
-    it('writes a single NDJSON line', () => {
-        const spy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-        jsonLine({ event: 'test', ts: 123 });
-        expect(spy).toHaveBeenCalledWith('{"event":"test","ts":123}\n');
-        spy.mockRestore();
-    });
-});

package/dist/utils/__tests__/prompt.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/utils/__tests__/prompt.test.js

@@ -1,27 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { promptSelect } from '../prompt.js';
-describe('promptSelect', () => {
-    it('throws when no choices available', async () => {
-        await expect(promptSelect('Pick:', [])).rejects.toThrow('No choices available');
-    });
-    it('returns single choice without prompting', async () => {
-        const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
-        const choice = { label: 'Only option', value: 'only' };
-        const result = await promptSelect('Pick:', [choice]);
-        expect(result).toBe(choice);
-        consoleSpy.mockRestore();
-    });
-    it('auto-selects preserves all properties on single choice', async () => {
-        const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
-        const choice = { label: 'Test', id: 'abc', extra: true };
-        const result = await promptSelect('Select', [choice]);
-        expect(result).toBe(choice);
-        consoleSpy.mockRestore();
-    });
-    it('logs message and choice label when single choice', async () => {
-        const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
-        await promptSelect('Pick one', [{ label: 'Only Option', value: 42 }]);
-        expect(consoleSpy).toHaveBeenCalledWith('Pick one: Only Option');
-        consoleSpy.mockRestore();
-    });
-});

package/dist/utils/__tests__/resolve.test.d.ts

@@ -1 +0,0 @@
-export {};