runwork 0.9.1 → 0.9.3

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.3",
   "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)",