runwork 0.2.0 → 0.2.5

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

@@ -0,0 +1,377 @@
+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('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');
+    });
+});

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

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