runwork 0.9.1 → 0.9.2

package/dist/commands/dev.js

@@ -35,6 +35,65 @@ function readConfig() {
     }
     return JSON.parse(readFileSync('.runwork.json', 'utf-8'));
 }
+// Files the CLI cannot function without and which the user did not author.
+// `.runwork.json` is the local app identity; `blueprint.json` is the app's
+// canonical feature definition; `.gitignore` keeps caches out of git. If a
+// sync from the remote silently removes any of these (which has happened
+// when a server-side agent commits with a stale index — see
+// worker/agents/git/git.ts), restoring from a pre-sync snapshot keeps the
+// project usable and unblocks `runwork deploy`.
+const CRITICAL_FILES = ['.runwork.json', 'blueprint.json', '.gitignore'];
+function snapshotCriticalFiles(cwd) {
+    const snapshots = [];
+    for (const rel of CRITICAL_FILES) {
+        const abs = join(cwd, rel);
+        if (!existsSync(abs))
+            continue;
+        try {
+            snapshots.push({ path: rel, contents: readFileSync(abs, 'utf-8') });
+        }
+        catch {
+            // Best-effort: skip unreadable files.
+        }
+    }
+    return snapshots;
+}
+function restoreMissingCriticalFiles(cwd, snapshots) {
+    const restored = [];
+    for (const snap of snapshots) {
+        const abs = join(cwd, snap.path);
+        if (existsSync(abs))
+            continue;
+        try {
+            writeFileSync(abs, snap.contents, 'utf-8');
+            restored.push(snap.path);
+        }
+        catch {
+            // Best-effort: skip files we cannot write back.
+        }
+    }
+    return restored;
+}
+function commitAndPushRestoredFiles(cwd, files) {
+    if (files.length === 0)
+        return false;
+    try {
+        execFileSync('git', ['add', '--', ...files], { cwd, stdio: 'pipe' });
+        execFileSync('git', ['commit', '-m', 'chore: restore critical files removed by sync'], { cwd, stdio: 'pipe' });
+    }
+    catch {
+        return false;
+    }
+    try {
+        execFileSync('git', ['push', 'runwork', 'main'], { cwd, stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        // Push failures are non-fatal: the local copy is restored, and the
+        // restoration commit will be pushed with the next auto-sync cycle.
+        return false;
+    }
+}
 export async function execDev(options) {
     const useJson = options?.json ?? false;
     const config = readConfig();
@@ -108,7 +167,26 @@ export async function execDev(options) {
     // Sync
     if (!useJson)
         console.log(dim('Syncing...'));
+    const criticalSnapshot = snapshotCriticalFiles(cwd);
     const syncResult = syncWithRemote(cwd);
+    const restoredCriticalFiles = restoreMissingCriticalFiles(cwd, criticalSnapshot);
+    if (restoredCriticalFiles.length > 0) {
+        const pushed = commitAndPushRestoredFiles(cwd, restoredCriticalFiles);
+        if (useJson) {
+            jsonLine({
+                event: 'sync_restored_critical_files',
+                files: restoredCriticalFiles,
+                pushed,
+                timestamp: ts(),
+            });
+        }
+        else {
+            console.warn(yellow(`  Sync removed critical file(s); restored: ${restoredCriticalFiles.join(', ')}`));
+            if (!pushed) {
+                console.warn(dim('  Restoration committed locally but not pushed; will retry on next auto-sync.'));
+            }
+        }
+    }
     if (useJson) {
         jsonLine({ event: 'startup', phase: 'sync', status: syncResult.status, pushed: syncResult.pushed, timestamp: ts() });
         if (syncResult.status === 'sync-failed') {

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.9.1";
+export declare const VERSION = "0.9.2";

package/dist/generated/version.js

@@ -1,2 +1,2 @@
 // Auto-generated by scripts/embed-types.ts -- do not edit
-export const VERSION = "0.9.1";
+export const VERSION = "0.9.2";

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

@@ -67,6 +67,47 @@ describe('generateManifest()', () => {
         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');
@@ -374,4 +415,32 @@ describe('detectUserEdits() edge cases', () => {
         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/auto-commit.d.ts

@@ -1,4 +1,9 @@
 import type { ApiClient } from '../api/client.js';
+/**
+ * Basename-level ignore predicate using the static defaults only.
+ * Exposed for unit testing of the static defaults; the runtime watcher uses
+ * a richer matcher built from `.gitignore` (see watchAndAutoCommit).
+ */
 export declare function isIgnored(filePath: string): boolean;
 export declare function watchAndAutoCommit(directory: string, client: ApiClient, appId: string, callbacks?: {
     onFileChange?: (relPath: string, pendingCount: number) => void;

package/dist/git/auto-commit.js

@@ -1,8 +1,9 @@
 import { execFileSync } from 'child_process';
 import { readFileSync } from 'fs';
 import { watch } from 'chokidar';
-import { basename, join, relative } from 'path';
+import { join, relative } from 'path';
 import { dim, cyan, yellow } from '../ui/colors.js';
+import { buildIgnoreSets, defaultIgnoreSets, isPathIgnored } from '../utils/ignore-matcher.js';
 let watcher = null;
 let fastSyncTimer = null;
 let gitTimer = null;
@@ -13,9 +14,6 @@ let activeCallbacks;
 const pendingFastSync = new Map();
 // Track files the user actually touched during this session (for git)
 const changedFiles = new Set();
-const SKIP_DIRS = new Set(['node_modules', '.git', '.runwork']);
-const SKIP_FILES = new Set(['.dev.vars', '.env']);
-const SKIP_EXTENSIONS = new Set(['.log']);
 // Binary extensions to skip in fast sync (git handles them fine)
 const BINARY_EXTENSIONS = new Set([
     '.png', '.jpg', '.jpeg', '.gif', '.ico', '.webp', '.avif', '.svg',
@@ -24,21 +22,24 @@ const BINARY_EXTENSIONS = new Set([
     '.zip', '.tar', '.gz', '.br',
     '.pdf', '.wasm',
 ]);
+const STATIC_IGNORE_SETS = defaultIgnoreSets();
+/**
+ * Basename-level ignore predicate using the static defaults only.
+ * Exposed for unit testing of the static defaults; the runtime watcher uses
+ * a richer matcher built from `.gitignore` (see watchAndAutoCommit).
+ */
 export function isIgnored(filePath) {
-    const name = basename(filePath);
-    if (SKIP_DIRS.has(name))
-        return true;
-    if (SKIP_FILES.has(name))
-        return true;
-    const ext = name.lastIndexOf('.') >= 0 ? name.slice(name.lastIndexOf('.')) : '';
-    if (SKIP_EXTENSIONS.has(ext))
-        return true;
-    return false;
+    return isPathIgnored(filePath, STATIC_IGNORE_SETS);
 }
 export async function watchAndAutoCommit(directory, client, appId, callbacks) {
     activeCallbacks = callbacks;
+    // Build a project-scoped ignore matcher that includes simple patterns from
+    // the project's .gitignore in addition to the static defaults. Without
+    // this the watcher tries to descend into large gitignored caches such as
+    // `.bun-cache/` or `dist/` and bogs the CLI down on startup.
+    const ignoreSets = buildIgnoreSets(directory);
     watcher = watch(directory, {
-        ignored: isIgnored,
+        ignored: (p) => isPathIgnored(p, ignoreSets),
         persistent: true,
         ignoreInitial: true,
         awaitWriteFinish: {

package/dist/template/manifest.js

@@ -2,22 +2,26 @@ import { createHash } from 'crypto';
 import { execFileSync } from 'child_process';
 import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync } from 'fs';
 import { join, relative } from 'path';
-const SKIP_DIRS = new Set(['.git', 'node_modules', '.runwork']);
-const SKIP_FILES = new Set(['.dev.vars', '.env']);
+import { buildIgnoreSets } from '../utils/ignore-matcher.js';
 function sha256(data) {
     return 'sha256:' + createHash('sha256').update(data).digest('hex');
 }
-function walkDir(dir, base) {
+function walkDir(dir, base, sets) {
     const results = [];
     const entries = readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-        if (SKIP_DIRS.has(entry.name))
+        if (sets.dirs.has(entry.name))
             continue;
-        if (SKIP_FILES.has(entry.name))
+        if (sets.files.has(entry.name))
             continue;
+        if (entry.isFile()) {
+            const dotIndex = entry.name.lastIndexOf('.');
+            if (dotIndex >= 0 && sets.extensions.has(entry.name.slice(dotIndex)))
+                continue;
+        }
         const fullPath = join(dir, entry.name);
         if (entry.isDirectory()) {
-            results.push(...walkDir(fullPath, base));
+            results.push(...walkDir(fullPath, base, sets));
         }
         else if (entry.isFile()) {
             results.push(relative(base, fullPath));
@@ -27,7 +31,8 @@ function walkDir(dir, base) {
 }
 export async function generateManifest(dir) {
     const files = {};
-    const allFiles = walkDir(dir, dir);
+    const sets = buildIgnoreSets(dir);
+    const allFiles = walkDir(dir, dir, sets);
     for (const relPath of allFiles) {
         const content = readFileSync(join(dir, relPath));
         files[relPath] = sha256(content);
@@ -104,9 +109,27 @@ export async function detectUserEdits(dir, manifest) {
     // 3. Scan manifest files on disk directly — catches gitignored files that
     // git ls-files --exclude-standard would miss. If a template file was added
     // to .gitignore by the user and then modified, only this check detects it.
+    //
+    // Tracked files are excluded here because their state is fully described
+    // by Method 1 (`git diff HEAD`). After `runwork clone`, AI-customized
+    // versions of template files are committed at HEAD and would otherwise be
+    // false-flagged on every fresh clone.
+    const trackedFiles = new Set();
+    try {
+        const tracked = execFileSync('git', ['-c', 'core.quotePath=false', 'ls-files'], { cwd: dir, encoding: 'utf-8' }).trim();
+        for (const relPath of tracked.split('\n')) {
+            if (relPath)
+                trackedFiles.add(relPath);
+        }
+    }
+    catch {
+        // No git repo — every manifest file remains a candidate for Method 3.
+    }
     for (const [relPath, expectedHash] of Object.entries(manifest.files)) {
         if (edits.includes(relPath))
             continue;
+        if (trackedFiles.has(relPath))
+            continue;
         const filePath = join(dir, relPath);
         try {
             const content = readFileSync(filePath);

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

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

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

@@ -0,0 +1,188 @@
+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, 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('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/ignore-matcher.d.ts

@@ -0,0 +1,38 @@
+export interface IgnoreSets {
+    dirs: Set<string>;
+    files: Set<string>;
+    extensions: Set<string>;
+}
+export declare function defaultIgnoreSets(): IgnoreSets;
+interface ParsedGitignore {
+    dirs: Set<string>;
+    files: Set<string>;
+}
+/**
+ * Parse a `.gitignore` file's contents into basename-level dir and file sets.
+ *
+ * Only the simple, basename-style patterns are extracted: `name`, `name/`,
+ * `/name`, `/name/`. Patterns containing glob characters (`*`, `?`, `[`),
+ * negations (`!`), comments (`#`) or path separators are skipped — handling
+ * those correctly requires a full gitignore matcher, which the agent's
+ * walkers do not need: the goal is to avoid descending into well-known huge
+ * gitignored directories like `.bun-cache`, `.next`, `dist`, `coverage`.
+ *
+ * Patterns without a trailing slash are added to both `dirs` and `files`
+ * because gitignore semantics apply to either, and basename-only matching
+ * cannot tell them apart safely.
+ */
+export declare function parseGitignoreContent(content: string): ParsedGitignore;
+/**
+ * Build a combined IgnoreSets for `dir` by merging the static defaults with
+ * simple patterns parsed from `dir`/.gitignore (if present).
+ */
+export declare function buildIgnoreSets(dir: string): IgnoreSets;
+/**
+ * Returns true if `filePath`'s basename matches any directory, file, or
+ * extension in `sets`. Matching is intentionally basename-only so it can
+ * be used as the predicate for chokidar's `ignored` option and for
+ * recursive directory walkers without needing absolute-path bookkeeping.
+ */
+export declare function isPathIgnored(filePath: string, sets: IgnoreSets): boolean;
+export {};

package/dist/utils/ignore-matcher.js

@@ -0,0 +1,116 @@
+import { existsSync, readFileSync } from 'fs';
+import { basename, join } from 'path';
+const DEFAULT_DIR_NAMES = [
+    '.git',
+    'node_modules',
+    '.runwork',
+    // .bun-cache is bun's per-project package cache. It commonly grows into
+    // hundreds of MB / tens of thousands of files and is universally
+    // gitignored. Walking it on every dev startup made the CLI lock-contend
+    // on file descriptors and never spawn the dev server.
+    '.bun-cache',
+];
+const DEFAULT_FILE_NAMES = [
+    '.dev.vars',
+    '.env',
+];
+const DEFAULT_EXTENSIONS = [
+    '.log',
+];
+export function defaultIgnoreSets() {
+    return {
+        dirs: new Set(DEFAULT_DIR_NAMES),
+        files: new Set(DEFAULT_FILE_NAMES),
+        extensions: new Set(DEFAULT_EXTENSIONS),
+    };
+}
+const GLOB_CHARS = /[*?\[\]]/;
+/**
+ * Parse a `.gitignore` file's contents into basename-level dir and file sets.
+ *
+ * Only the simple, basename-style patterns are extracted: `name`, `name/`,
+ * `/name`, `/name/`. Patterns containing glob characters (`*`, `?`, `[`),
+ * negations (`!`), comments (`#`) or path separators are skipped — handling
+ * those correctly requires a full gitignore matcher, which the agent's
+ * walkers do not need: the goal is to avoid descending into well-known huge
+ * gitignored directories like `.bun-cache`, `.next`, `dist`, `coverage`.
+ *
+ * Patterns without a trailing slash are added to both `dirs` and `files`
+ * because gitignore semantics apply to either, and basename-only matching
+ * cannot tell them apart safely.
+ */
+export function parseGitignoreContent(content) {
+    const dirs = new Set();
+    const files = new Set();
+    for (const rawLine of content.split('\n')) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#'))
+            continue;
+        if (line.startsWith('!'))
+            continue;
+        if (GLOB_CHARS.test(line))
+            continue;
+        let pattern = line;
+        const isDirOnly = pattern.endsWith('/');
+        if (isDirOnly)
+            pattern = pattern.slice(0, -1);
+        if (pattern.startsWith('/'))
+            pattern = pattern.slice(1);
+        if (!pattern)
+            continue;
+        if (pattern.includes('/'))
+            continue;
+        if (isDirOnly) {
+            dirs.add(pattern);
+        }
+        else {
+            dirs.add(pattern);
+            files.add(pattern);
+        }
+    }
+    return { dirs, files };
+}
+function loadGitignoreFromDir(dir) {
+    const path = join(dir, '.gitignore');
+    if (!existsSync(path))
+        return { dirs: new Set(), files: new Set() };
+    try {
+        return parseGitignoreContent(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return { dirs: new Set(), files: new Set() };
+    }
+}
+/**
+ * Build a combined IgnoreSets for `dir` by merging the static defaults with
+ * simple patterns parsed from `dir`/.gitignore (if present).
+ */
+export function buildIgnoreSets(dir) {
+    const sets = defaultIgnoreSets();
+    const parsed = loadGitignoreFromDir(dir);
+    for (const name of parsed.dirs)
+        sets.dirs.add(name);
+    for (const name of parsed.files)
+        sets.files.add(name);
+    return sets;
+}
+/**
+ * Returns true if `filePath`'s basename matches any directory, file, or
+ * extension in `sets`. Matching is intentionally basename-only so it can
+ * be used as the predicate for chokidar's `ignored` option and for
+ * recursive directory walkers without needing absolute-path bookkeeping.
+ */
+export function isPathIgnored(filePath, sets) {
+    const name = basename(filePath);
+    if (sets.dirs.has(name))
+        return true;
+    if (sets.files.has(name))
+        return true;
+    const dotIndex = name.lastIndexOf('.');
+    if (dotIndex >= 0) {
+        const ext = name.slice(dotIndex);
+        if (sets.extensions.has(ext))
+            return true;
+    }
+    return false;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runwork",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "description": "CLI for Runwork: develop, preview, and deploy Runwork apps from your local machine.",
   "license": "UNLICENSED",
   "author": "Runwork <info@runwork.ai> (https://www.runwork.ai)",