runwork 0.15.0 → 0.15.2

package/dist/git/__tests__/identity.test.js

@@ -1,146 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
-import { execFileSync } from 'child_process';
-import { mkdtempSync, rmSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { ensureGitIdentity, __testing } from '../identity.js';
-const tempDirs = [];
-// Isolate every git invocation in this file from the developer's real
-// `~/.gitconfig` (and any system-level config). Without this, anyone running
-// the suite locally with `git config --global user.email` already set would
-// see the helper short-circuit (correctly) and the "fresh machine" assertions
-// would never exercise the write path. We point GIT_CONFIG_GLOBAL/SYSTEM at
-// paths that don't exist; git treats missing config files as empty.
-const ISOLATION_DIR = mkdtempSync(join(tmpdir(), 'runwork-identity-isolation-'));
-const NON_EXISTENT = join(ISOLATION_DIR, 'no-such-config');
-const PREVIOUS_ENV = {};
-beforeAll(() => {
-    for (const key of ['GIT_CONFIG_GLOBAL', 'GIT_CONFIG_SYSTEM', 'HOME', 'XDG_CONFIG_HOME']) {
-        PREVIOUS_ENV[key] = process.env[key];
-    }
-    process.env.GIT_CONFIG_GLOBAL = NON_EXISTENT;
-    process.env.GIT_CONFIG_SYSTEM = NON_EXISTENT;
-    // Some git builds still consult $HOME/.gitconfig even with GIT_CONFIG_GLOBAL
-    // set. Pointing HOME at the empty isolation directory closes that hole.
-    process.env.HOME = ISOLATION_DIR;
-    process.env.XDG_CONFIG_HOME = ISOLATION_DIR;
-});
-afterAll(() => {
-    for (const [key, value] of Object.entries(PREVIOUS_ENV)) {
-        if (value === undefined)
-            delete process.env[key];
-        else
-            process.env[key] = value;
-    }
-    try {
-        rmSync(ISOLATION_DIR, { recursive: true, force: true });
-    }
-    catch { /* best-effort */ }
-});
-function makeRepo() {
-    const dir = mkdtempSync(join(tmpdir(), 'runwork-identity-test-'));
-    tempDirs.push(dir);
-    execFileSync('git', ['init', dir]);
-    return dir;
-}
-function readConfig(cwd, key) {
-    try {
-        return execFileSync('git', ['config', '--local', '--get', key], { cwd }).toString('utf-8').trim();
-    }
-    catch {
-        return '';
-    }
-}
-afterEach(() => {
-    for (const dir of tempDirs) {
-        try {
-            rmSync(dir, { recursive: true, force: true });
-        }
-        catch { /* best-effort */ }
-    }
-    tempDirs.length = 0;
-});
-describe('deriveNameFromEmail', () => {
-    it('uppercases the local part', () => {
-        expect(__testing.deriveNameFromEmail('oytun@motaword.com')).toBe('Oytun');
-    });
-    it('splits separators into words', () => {
-        expect(__testing.deriveNameFromEmail('anna.maria@example.com')).toBe('Anna Maria');
-        expect(__testing.deriveNameFromEmail('jean-luc@example.com')).toBe('Jean Luc');
-        expect(__testing.deriveNameFromEmail('user_name@example.com')).toBe('User Name');
-    });
-    it('falls back to default when local part is empty', () => {
-        expect(__testing.deriveNameFromEmail('@example.com')).toBe(__testing.FALLBACK_NAME);
-    });
-});
-describe('pickIdentity', () => {
-    it('uses the credentials email when it looks like an email', () => {
-        expect(__testing.pickIdentity({ apiKey: 'k', email: 'oytun@motaword.com', baseUrl: '' }))
-            .toEqual({ email: 'oytun@motaword.com', name: 'Oytun' });
-    });
-    it('falls back when email is the api-key-auth placeholder', () => {
-        expect(__testing.pickIdentity({ apiKey: 'k', email: 'api-key-auth', baseUrl: '' }))
-            .toEqual({ email: __testing.FALLBACK_EMAIL, name: __testing.FALLBACK_NAME });
-    });
-    it('falls back when no credentials are passed', () => {
-        expect(__testing.pickIdentity(null))
-            .toEqual({ email: __testing.FALLBACK_EMAIL, name: __testing.FALLBACK_NAME });
-    });
-});
-describe('ensureGitIdentity', () => {
-    it('writes local user.email and user.name when none are configured', () => {
-        const dir = makeRepo();
-        expect(readConfig(dir, 'user.email')).toBe('');
-        expect(readConfig(dir, 'user.name')).toBe('');
-        ensureGitIdentity(dir, { apiKey: 'k', email: 'oytun@motaword.com', baseUrl: '' });
-        expect(readConfig(dir, 'user.email')).toBe('oytun@motaword.com');
-        expect(readConfig(dir, 'user.name')).toBe('Oytun');
-    });
-    it('overwrites local config with Runwork credentials when they are usable', () => {
-        // Commits to a Runwork remote should always be attributed to the
-        // authenticated Runwork user, even if the developer set a local identity
-        // earlier (e.g. a stale value from a previous account).
-        const dir = makeRepo();
-        execFileSync('git', ['config', '--local', 'user.email', 'preset@example.com'], { cwd: dir });
-        execFileSync('git', ['config', '--local', 'user.name', 'Preset User'], { cwd: dir });
-        ensureGitIdentity(dir, { apiKey: 'k', email: 'oytun@motaword.com', baseUrl: '' });
-        expect(readConfig(dir, 'user.email')).toBe('oytun@motaword.com');
-        expect(readConfig(dir, 'user.name')).toBe('Oytun');
-    });
-    it('respects existing local config when no Runwork credentials are available', () => {
-        // Without a real Runwork identity to attribute the commit to, leave any
-        // pre-existing local identity (or anything inherited from --global) alone.
-        const dir = makeRepo();
-        execFileSync('git', ['config', '--local', 'user.email', 'preset@example.com'], { cwd: dir });
-        execFileSync('git', ['config', '--local', 'user.name', 'Preset User'], { cwd: dir });
-        ensureGitIdentity(dir, null);
-        expect(readConfig(dir, 'user.email')).toBe('preset@example.com');
-        expect(readConfig(dir, 'user.name')).toBe('Preset User');
-    });
-    it('respects existing local config when credentials carry only a placeholder email', () => {
-        const dir = makeRepo();
-        execFileSync('git', ['config', '--local', 'user.email', 'preset@example.com'], { cwd: dir });
-        execFileSync('git', ['config', '--local', 'user.name', 'Preset User'], { cwd: dir });
-        ensureGitIdentity(dir, { apiKey: 'k', email: 'api-key-auth', baseUrl: '' });
-        expect(readConfig(dir, 'user.email')).toBe('preset@example.com');
-        expect(readConfig(dir, 'user.name')).toBe('Preset User');
-    });
-    it('falls back to a synthetic identity when credentials are missing', () => {
-        const dir = makeRepo();
-        ensureGitIdentity(dir, null);
-        expect(readConfig(dir, 'user.email')).toBe(__testing.FALLBACK_EMAIL);
-        expect(readConfig(dir, 'user.name')).toBe(__testing.FALLBACK_NAME);
-    });
-    it('lets a real commit succeed on a fresh repo (windows-style "no identity" path)', () => {
-        const dir = makeRepo();
-        ensureGitIdentity(dir, { apiKey: 'k', email: 'oytun@motaword.com', baseUrl: '' });
-        execFileSync('git', ['commit', '--allow-empty', '-m', 'identity probe'], { cwd: dir, stdio: 'pipe' });
-        const log = execFileSync('git', ['log', '--pretty=%an <%ae>'], { cwd: dir }).toString('utf-8').trim();
-        expect(log).toContain('Oytun <oytun@motaword.com>');
-    });
-    it('is a no-op for non-git directories', () => {
-        const dir = mkdtempSync(join(tmpdir(), 'runwork-identity-non-git-'));
-        tempDirs.push(dir);
-        expect(() => ensureGitIdentity(dir, null)).not.toThrow();
-    });
-});

package/dist/git/__tests__/manifest.test.d.ts

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

package/dist/git/__tests__/manifest.test.js

@@ -1,446 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { execFileSync } from 'child_process';
-import { mkdtempSync, writeFileSync, rmSync, existsSync, mkdirSync, symlinkSync, } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-import { generateManifest, saveManifest, loadManifest, detectUserEdits, } from '../../template/manifest.js';
-const tempDirs = [];
-function makeTempDir(prefix) {
-    const dir = mkdtempSync(join(tmpdir(), `runwork-manifest-test-${prefix}-`));
-    tempDirs.push(dir);
-    return dir;
-}
-function initGitRepo(dir) {
-    execFileSync('git', ['init', dir]);
-    execFileSync('git', ['config', 'user.email', 'test@test.com'], { cwd: dir });
-    execFileSync('git', ['config', 'user.name', 'Test'], { cwd: dir });
-}
-function commitFile(repoDir, filename, content, message) {
-    const fullPath = join(repoDir, filename);
-    const dir = fullPath.substring(0, fullPath.lastIndexOf('/'));
-    if (dir !== repoDir && !existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
-    writeFileSync(fullPath, content);
-    execFileSync('git', ['add', filename], { cwd: repoDir });
-    execFileSync('git', ['commit', '-m', message], { cwd: repoDir });
-}
-afterEach(() => {
-    for (const dir of tempDirs) {
-        try {
-            rmSync(dir, { recursive: true, force: true });
-        }
-        catch { /* best effort */ }
-    }
-    tempDirs.length = 0;
-});
-describe('generateManifest()', () => {
-    it('generates manifest for a simple directory', async () => {
-        const dir = makeTempDir('simple');
-        writeFileSync(join(dir, 'a.txt'), 'hello');
-        writeFileSync(join(dir, 'b.txt'), 'world');
-        const manifest = await generateManifest(dir);
-        expect(manifest.version).toBe(1);
-        expect(Object.keys(manifest.files)).toHaveLength(2);
-        expect(manifest.files['a.txt']).toMatch(/^sha256:/);
-        expect(manifest.files['b.txt']).toMatch(/^sha256:/);
-    });
-    it('skips .git, node_modules, and .runwork directories', async () => {
-        const dir = makeTempDir('skip');
-        writeFileSync(join(dir, 'a.txt'), 'hello');
-        mkdirSync(join(dir, '.git'));
-        writeFileSync(join(dir, '.git', 'config'), 'git config');
-        mkdirSync(join(dir, 'node_modules'));
-        writeFileSync(join(dir, 'node_modules', 'pkg.js'), 'module');
-        mkdirSync(join(dir, '.runwork'));
-        writeFileSync(join(dir, '.runwork', 'manifest.json'), '{}');
-        const manifest = await generateManifest(dir);
-        expect(Object.keys(manifest.files)).toHaveLength(1);
-        expect(manifest.files['a.txt']).toBeDefined();
-    });
-    it('skips .dev.vars and .env files', async () => {
-        const dir = makeTempDir('skipfiles');
-        writeFileSync(join(dir, 'a.txt'), 'hello');
-        writeFileSync(join(dir, '.dev.vars'), 'SECRET=123');
-        writeFileSync(join(dir, '.env'), 'OTHER=456');
-        const manifest = await generateManifest(dir);
-        expect(Object.keys(manifest.files)).toHaveLength(1);
-        expect(manifest.files['a.txt']).toBeDefined();
-    });
-    it('skips .bun-cache directory by default (regression: hung dev startup)', async () => {
-        // Bun's per-project cache used to be walked recursively here. When it
-        // grew to ~1 GB / 25k+ files, generateManifest spent minutes hashing
-        // every file and starved the rest of `runwork dev`. The default
-        // ignore-matcher now skips .bun-cache/ even without a .gitignore.
-        const dir = makeTempDir('bun-cache');
-        writeFileSync(join(dir, 'a.txt'), 'hello');
-        mkdirSync(join(dir, '.bun-cache'));
-        writeFileSync(join(dir, '.bun-cache', 'pkg.tgz'), 'tarball');
-        mkdirSync(join(dir, '.bun-cache', 'react@19.0.0'));
-        writeFileSync(join(dir, '.bun-cache', 'react@19.0.0', 'index.js'), 'r');
-        const manifest = await generateManifest(dir);
-        expect(Object.keys(manifest.files)).toEqual(['a.txt']);
-    });
-    it('honors simple .gitignore directory entries (e.g. dist/, .next/, coverage)', async () => {
-        const dir = makeTempDir('gitignored-dirs');
-        writeFileSync(join(dir, '.gitignore'), 'dist/\n.next/\ncoverage\n');
-        writeFileSync(join(dir, 'a.txt'), 'hello');
-        mkdirSync(join(dir, 'dist'));
-        writeFileSync(join(dir, 'dist', 'bundle.js'), 'compiled');
-        mkdirSync(join(dir, '.next'));
-        writeFileSync(join(dir, '.next', 'build.json'), '{}');
-        mkdirSync(join(dir, 'coverage'));
-        writeFileSync(join(dir, 'coverage', 'lcov.info'), 'data');
-        const manifest = await generateManifest(dir);
-        const keys = Object.keys(manifest.files).sort();
-        expect(keys).toEqual(['.gitignore', 'a.txt']);
-    });
-    it('falls through to defaults when .gitignore patterns are too complex', async () => {
-        // The walker only honors simple directory/basename entries. Globbed
-        // patterns are skipped, so files matching them still appear in the
-        // manifest. This is acceptable: the goal is to avoid the runaway
-        // cases (huge gitignored caches), not to be a full gitignore matcher.
-        const dir = makeTempDir('complex-gitignore');
-        writeFileSync(join(dir, '.gitignore'), '*.local\nsrc/generated/\n');
-        writeFileSync(join(dir, 'a.txt'), 'hello');
-        writeFileSync(join(dir, 'config.local'), 'should-still-appear');
-        const manifest = await generateManifest(dir);
-        expect(manifest.files['a.txt']).toBeDefined();
-        expect(manifest.files['config.local']).toBeDefined();
-    });
-    it('handles files with spaces in names', async () => {
-        const dir = makeTempDir('spaces');
-        writeFileSync(join(dir, 'hello world.txt'), 'content');
-        writeFileSync(join(dir, 'normal.txt'), 'content');
-        const manifest = await generateManifest(dir);
-        expect(Object.keys(manifest.files)).toHaveLength(2);
-        expect(manifest.files['hello world.txt']).toBeDefined();
-    });
-    it('handles nested directories', async () => {
-        const dir = makeTempDir('nested');
-        mkdirSync(join(dir, 'src', 'components'), { recursive: true });
-        writeFileSync(join(dir, 'src', 'index.ts'), 'export {}');
-        writeFileSync(join(dir, 'src', 'components', 'App.tsx'), '<App/>');
-        const manifest = await generateManifest(dir);
-        expect(manifest.files['src/index.ts']).toBeDefined();
-        expect(manifest.files['src/components/App.tsx']).toBeDefined();
-    });
-});
-describe('walkDir() symlink edge cases', () => {
-    it('BUG PROBE: symlink cycle causes infinite recursion in walkDir/generateManifest', async () => {
-        // walkDir uses readdirSync with withFileTypes: true.
-        // Dirent.isDirectory() follows symlinks, so a symlink pointing
-        // to a parent directory will cause infinite recursion.
-        const dir = makeTempDir('symlink-cycle');
-        writeFileSync(join(dir, 'a.txt'), 'hello');
-        mkdirSync(join(dir, 'subdir'));
-        writeFileSync(join(dir, 'subdir', 'b.txt'), 'world');
-        // Create a symlink cycle: subdir/link -> parent dir
-        symlinkSync(dir, join(dir, 'subdir', 'link'));
-        // This should not hang or crash, but walkDir follows symlinks
-        // via isDirectory() which returns true for symlink-to-directory.
-        // Expected: either it handles symlinks gracefully, or it crashes
-        // with max call stack exceeded.
-        let threw = false;
-        let errorMessage = '';
-        try {
-            // Set a timeout to detect infinite loops - if this takes too long, it's a bug
-            await generateManifest(dir);
-        }
-        catch (error) {
-            threw = true;
-            errorMessage = error instanceof Error ? error.message : String(error);
-        }
-        // If we get here without hanging, check if it threw
-        // The bug is that walkDir WILL follow the symlink and recurse infinitely
-        // until it hits ENAMETOOLONG or max call stack.
-        // We expect this to either throw or produce duplicate entries.
-        // If it doesn't throw, it somehow handled it (unlikely).
-        if (threw) {
-            // Bug confirmed: walkDir crashes on symlink cycles
-            expect(errorMessage).toBeTruthy();
-        }
-        else {
-            // If it somehow succeeds, check that it didn't include
-            // infinitely nested paths
-            expect(true).toBe(true); // pass - it handled it somehow
-        }
-    });
-    it('symlinked directories are silently skipped by walkDir (not followed)', async () => {
-        // Node.js readdirSync withFileTypes: Dirent.isDirectory() returns false for symlinks.
-        // So walkDir silently skips symlinked directories entirely.
-        // This is safe (no infinite recursion) but means symlinked content is invisible.
-        const dir = makeTempDir('symlink-dir');
-        const targetDir = makeTempDir('symlink-target');
-        writeFileSync(join(targetDir, 'external.txt'), 'external content');
-        writeFileSync(join(dir, 'local.txt'), 'local');
-        symlinkSync(targetDir, join(dir, 'linked'));
-        const manifest = await generateManifest(dir);
-        const keys = Object.keys(manifest.files);
-        const hasLinkedFile = keys.some(k => k.includes('linked'));
-        // Symlinked directories are NOT followed -- content is invisible
-        expect(hasLinkedFile).toBe(false);
-        expect(keys).toEqual(['local.txt']);
-    });
-});
-describe('saveManifest() and loadManifest()', () => {
-    it('creates .runwork directory if it does not exist', async () => {
-        const dir = makeTempDir('norunwork');
-        const manifest = { version: 1, files: { 'a.txt': 'sha256:abc' } };
-        expect(existsSync(join(dir, '.runwork'))).toBe(false);
-        await saveManifest(dir, manifest);
-        expect(existsSync(join(dir, '.runwork', 'template-manifest.json'))).toBe(true);
-        const loaded = await loadManifest(dir);
-        expect(loaded).toEqual(manifest);
-    });
-    it('returns null when .runwork directory does not exist', async () => {
-        const dir = makeTempDir('nomanifest');
-        const result = await loadManifest(dir);
-        expect(result).toBeNull();
-    });
-    it('returns null for corrupted manifest file', async () => {
-        const dir = makeTempDir('corrupt');
-        mkdirSync(join(dir, '.runwork'));
-        writeFileSync(join(dir, '.runwork', 'template-manifest.json'), 'not json{{{');
-        const result = await loadManifest(dir);
-        expect(result).toBeNull();
-    });
-});
-describe('detectUserEdits() edge cases', () => {
-    it('returns empty array when git diff and ls-files return nothing', async () => {
-        // Edge case: empty strings from git commands.
-        // "".split('\n') returns [''] (array with one empty string).
-        // The code should handle this gracefully.
-        const dir = makeTempDir('clean');
-        initGitRepo(dir);
-        const content = 'hello';
-        writeFileSync(join(dir, 'a.txt'), content);
-        execFileSync('git', ['add', 'a.txt'], { cwd: dir });
-        execFileSync('git', ['commit', '-m', 'init'], { cwd: dir });
-        // Use correct hash so manifest scan doesn't flag it as modified
-        const { createHash } = await import('crypto');
-        const hash = 'sha256:' + createHash('sha256').update(Buffer.from(content)).digest('hex');
-        const manifest = {
-            version: 1,
-            files: { 'a.txt': hash },
-        };
-        const edits = await detectUserEdits(dir, manifest);
-        expect(edits).toEqual([]);
-    });
-    it('BUG PROBE: files with spaces in names from git diff output', async () => {
-        // git diff --name-only returns filenames with spaces as-is.
-        // The code splits by \n and processes each line.
-        // This should work unless there's quoting involved.
-        const dir = makeTempDir('spaces');
-        initGitRepo(dir);
-        writeFileSync(join(dir, 'hello world.txt'), 'original');
-        execFileSync('git', ['add', 'hello world.txt'], { cwd: dir });
-        execFileSync('git', ['commit', '-m', 'init'], { cwd: dir });
-        // Modify the file with spaces
-        writeFileSync(join(dir, 'hello world.txt'), 'modified');
-        const manifest = { version: 1, files: {} };
-        const edits = await detectUserEdits(dir, manifest);
-        // Should contain the file with spaces
-        expect(edits).toContain('hello world.txt');
-    });
-    it('returns correct unicode filenames (not octal-escaped)', async () => {
-        const dir = makeTempDir('unicode');
-        initGitRepo(dir);
-        const filename = 'caf\u00e9.txt';
-        writeFileSync(join(dir, filename), 'original');
-        execFileSync('git', ['add', filename], { cwd: dir });
-        execFileSync('git', ['commit', '-m', 'init'], { cwd: dir });
-        writeFileSync(join(dir, filename), 'modified');
-        const manifest = { version: 1, files: {} };
-        const edits = await detectUserEdits(dir, manifest);
-        expect(edits).toContain(filename);
-        // Should NOT contain octal-escaped garbage
-        expect(edits.some(e => e.includes('\\303'))).toBe(false);
-    });
-    it('BUG PROBE: file deleted by user that was in manifest (untracked section)', async () => {
-        // If a user deletes a file that was in the manifest, it won't
-        // appear in git ls-files --others (because it doesn't exist on disk).
-        // It also won't appear in git diff --name-only HEAD because it was
-        // never committed. So detectUserEdits will miss it entirely.
-        // This is arguably correct behavior (delete = no edit to detect),
-        // but worth documenting.
-        const dir = makeTempDir('deleted');
-        initGitRepo(dir);
-        writeFileSync(join(dir, 'committed.txt'), 'hello');
-        execFileSync('git', ['add', '.'], { cwd: dir });
-        execFileSync('git', ['commit', '-m', 'init'], { cwd: dir });
-        // Template manifest includes both a committed file and a template file
-        const manifest = {
-            version: 1,
-            files: {
-                'committed.txt': 'sha256:abc',
-                'template-only.txt': 'sha256:def',
-            },
-        };
-        // template-only.txt never existed on disk (or was deleted)
-        // detectUserEdits should not crash
-        const edits = await detectUserEdits(dir, manifest);
-        // No crash is the main assertion
-        expect(Array.isArray(edits)).toBe(true);
-    });
-    it('detects untracked files that are not in the manifest', async () => {
-        const dir = makeTempDir('newfile');
-        initGitRepo(dir);
-        writeFileSync(join(dir, 'a.txt'), 'hello');
-        execFileSync('git', ['add', '.'], { cwd: dir });
-        execFileSync('git', ['commit', '-m', 'init'], { cwd: dir });
-        // User creates a new file
-        writeFileSync(join(dir, 'user-created.txt'), 'my new file');
-        const manifest = {
-            version: 1,
-            files: { 'a.txt': 'sha256:abc' },
-        };
-        const edits = await detectUserEdits(dir, manifest);
-        expect(edits).toContain('user-created.txt');
-    });
-    it('skips untracked file that matches template manifest hash (pristine template file)', async () => {
-        const dir = makeTempDir('pristine');
-        initGitRepo(dir);
-        writeFileSync(join(dir, 'committed.txt'), 'hello');
-        execFileSync('git', ['add', '.'], { cwd: dir });
-        execFileSync('git', ['commit', '-m', 'init'], { cwd: dir });
-        // Create an untracked file that matches the template hash exactly
-        const content = 'template content';
-        writeFileSync(join(dir, 'template-file.txt'), content);
-        // Generate the correct hash for this content
-        const { createHash } = await import('crypto');
-        const hash = 'sha256:' + createHash('sha256').update(Buffer.from(content)).digest('hex');
-        const manifest = {
-            version: 1,
-            files: {
-                'committed.txt': 'sha256:abc',
-                'template-file.txt': hash,
-            },
-        };
-        const edits = await detectUserEdits(dir, manifest);
-        // Pristine template file should NOT be in edits
-        expect(edits).not.toContain('template-file.txt');
-    });
-    it('BUG PROBE: detects edit when untracked file has different content than manifest hash', async () => {
-        const dir = makeTempDir('modified-template');
-        initGitRepo(dir);
-        writeFileSync(join(dir, 'committed.txt'), 'hello');
-        execFileSync('git', ['add', '.'], { cwd: dir });
-        execFileSync('git', ['commit', '-m', 'init'], { cwd: dir });
-        // Create an untracked file with content that differs from manifest
-        writeFileSync(join(dir, 'template-file.txt'), 'user modified this');
-        const manifest = {
-            version: 1,
-            files: {
-                'committed.txt': 'sha256:abc',
-                'template-file.txt': 'sha256:different_hash_from_template',
-            },
-        };
-        const edits = await detectUserEdits(dir, manifest);
-        // Modified template file SHOULD be in edits
-        expect(edits).toContain('template-file.txt');
-    });
-    it('does not duplicate files that appear in both git diff and git diff --cached', async () => {
-        const dir = makeTempDir('dedup');
-        initGitRepo(dir);
-        writeFileSync(join(dir, 'a.txt'), 'original');
-        execFileSync('git', ['add', '.'], { cwd: dir });
-        execFileSync('git', ['commit', '-m', 'init'], { cwd: dir });
-        // Stage a change AND have unstaged changes to same file
-        writeFileSync(join(dir, 'a.txt'), 'staged change');
-        execFileSync('git', ['add', 'a.txt'], { cwd: dir });
-        writeFileSync(join(dir, 'a.txt'), 'unstaged further change');
-        const manifest = { version: 1, files: {} };
-        const edits = await detectUserEdits(dir, manifest);
-        // File should appear only once even though it's in both diff outputs
-        const count = edits.filter(f => f === 'a.txt').length;
-        expect(count).toBe(1);
-    });
-    it('BUG PROBE: git diff --name-only HEAD with no commits yet', async () => {
-        // When repo has no commits, git rev-parse HEAD fails.
-        // The code wraps this in try/catch, so it should skip the git diff section.
-        // But what about git ls-files --others?
-        const dir = makeTempDir('nocommits');
-        initGitRepo(dir);
-        // Create a file but don't commit
-        writeFileSync(join(dir, 'new-file.txt'), 'hello');
-        const manifest = { version: 1, files: {} };
-        const edits = await detectUserEdits(dir, manifest);
-        // Should detect the untracked file via ls-files --others
-        expect(edits).toContain('new-file.txt');
-    });
-    it('detects modified gitignored files that are in the template manifest', async () => {
-        // Real-world scenario: template ships with a config file, user adds it
-        // to .gitignore (e.g., to keep local secrets), then modifies it.
-        // detectUserEdits should still detect it by scanning manifest files on disk.
-        const dir = makeTempDir('gitignore');
-        initGitRepo(dir);
-        writeFileSync(join(dir, 'a.txt'), 'hello');
-        writeFileSync(join(dir, '.gitignore'), 'ignored.txt\n');
-        execFileSync('git', ['add', '.'], { cwd: dir });
-        execFileSync('git', ['commit', '-m', 'init'], { cwd: dir });
-        // Create a file that's gitignored but was in the template manifest
-        writeFileSync(join(dir, 'ignored.txt'), 'user modified this ignored file');
-        const manifest = {
-            version: 1,
-            files: {
-                'a.txt': 'sha256:abc',
-                'ignored.txt': 'sha256:original_template_hash',
-            },
-        };
-        const edits = await detectUserEdits(dir, manifest);
-        // Fixed: gitignored file IS detected because we scan manifest files on disk
-        expect(edits).toContain('ignored.txt');
-    });
-    it('does not flag gitignored file if it matches template manifest hash', async () => {
-        // If the gitignored file has NOT been modified (hash matches manifest),
-        // it should NOT appear in edits.
-        const dir = makeTempDir('gitignore-pristine');
-        initGitRepo(dir);
-        writeFileSync(join(dir, 'a.txt'), 'hello');
-        writeFileSync(join(dir, '.gitignore'), 'config.txt\n');
-        execFileSync('git', ['add', '.'], { cwd: dir });
-        execFileSync('git', ['commit', '-m', 'init'], { cwd: dir });
-        const content = 'pristine template content';
-        writeFileSync(join(dir, 'config.txt'), content);
-        const { createHash } = await import('crypto');
-        const hash = 'sha256:' + createHash('sha256').update(Buffer.from(content)).digest('hex');
-        const manifest = {
-            version: 1,
-            files: {
-                'a.txt': 'sha256:abc',
-                'config.txt': hash,
-            },
-        };
-        const edits = await detectUserEdits(dir, manifest);
-        expect(edits).not.toContain('config.txt');
-    });
-    it('does not flag tracked file whose committed content differs from template manifest', async () => {
-        // Reproduces the post-`runwork clone` scenario: the manifest was
-        // generated from the pristine template, then the AI-customized
-        // version was overlaid via `git fetch` + `git checkout .` and is now
-        // committed at HEAD with no local edits. Method 3's scan would
-        // false-flag every such file on every clone if it didn't skip
-        // tracked files.
-        const dir = makeTempDir('clone-overlay');
-        initGitRepo(dir);
-        // Simulate: AI-customized version is committed at HEAD.
-        const overlaidContent = 'AI-customized content';
-        writeFileSync(join(dir, 'worker/agents.ts'.replace('/', '-')), 'placeholder');
-        const aiFilePath = 'agents.ts';
-        writeFileSync(join(dir, aiFilePath), overlaidContent);
-        execFileSync('git', ['add', '.'], { cwd: dir });
-        execFileSync('git', ['commit', '-m', 'overlay'], { cwd: dir });
-        // Manifest captured the PRISTINE template hash (different from the
-        // overlaid HEAD content). detectUserEdits must not treat this as a
-        // user edit.
-        const manifest = {
-            version: 1,
-            files: {
-                [aiFilePath]: 'sha256:pristine_template_hash_unrelated_to_disk',
-            },
-        };
-        const edits = await detectUserEdits(dir, manifest);
-        expect(edits).not.toContain(aiFilePath);
-    });
-});

package/dist/git/__tests__/preflight-resolution.test.d.ts

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