@eddacraft/anvil-runtime 0.1.0

package/dist/watch/debouncer.js

@@ -0,0 +1,135 @@
+/**
+ * Change Debouncer
+ *
+ * Coalesces rapid file changes into batches to prevent
+ * excessive action triggers during editor auto-save or
+ * multi-file operations.
+ */
+import { createDebugger } from '@eddacraft/anvil-core';
+const debug = createDebugger('watch');
+/**
+ * Debouncer for file changes
+ *
+ * Accumulates file paths and flushes them as a batch
+ * after a configurable delay.
+ */
+export class ChangeDebouncer {
+    delayMs;
+    onFlush;
+    pendingFiles = new Set();
+    timer = null;
+    /**
+     * Create a new debouncer
+     *
+     * @param delayMs - Debounce delay in milliseconds
+     * @param onFlush - Callback when changes are flushed
+     */
+    constructor(delayMs, onFlush) {
+        this.delayMs = delayMs;
+        this.onFlush = onFlush;
+    }
+    /**
+     * Add a file to the pending changes
+     *
+     * Resets the debounce timer each time a file is added.
+     *
+     * @param filePath - Absolute file path
+     */
+    add(filePath) {
+        debug(`debouncer add: path=${filePath} pending=${this.pendingFiles.size + 1}`);
+        this.pendingFiles.add(filePath);
+        this.resetTimer();
+    }
+    /**
+     * Add multiple files to pending changes
+     *
+     * @param filePaths - Array of absolute file paths
+     */
+    addMany(filePaths) {
+        for (const filePath of filePaths) {
+            this.pendingFiles.add(filePath);
+        }
+        this.resetTimer();
+    }
+    /**
+     * Immediately flush pending changes
+     *
+     * Clears the timer and invokes the callback with all
+     * accumulated files.
+     */
+    flush() {
+        this.clearTimer();
+        if (this.pendingFiles.size === 0) {
+            debug('debouncer flush: nothing pending');
+            return;
+        }
+        const files = Array.from(this.pendingFiles);
+        debug(`debouncer flush: dispatching batch of ${files.length} files`);
+        this.pendingFiles.clear();
+        this.onFlush({
+            files,
+            timestamp: new Date(),
+        });
+    }
+    /**
+     * Cancel pending flush and clear accumulated files
+     */
+    cancel() {
+        debug(`debouncer cancel: discarding ${this.pendingFiles.size} pending files`);
+        this.clearTimer();
+        this.pendingFiles.clear();
+    }
+    /**
+     * Get count of pending files
+     */
+    get pendingCount() {
+        return this.pendingFiles.size;
+    }
+    /**
+     * Check if there are pending changes
+     */
+    get hasPending() {
+        return this.pendingFiles.size > 0;
+    }
+    /**
+     * Get the current delay setting
+     */
+    get delay() {
+        return this.delayMs;
+    }
+    /**
+     * Update the debounce delay
+     *
+     * Takes effect on next add() call.
+     */
+    setDelay(delayMs) {
+        this.delayMs = delayMs;
+    }
+    /**
+     * Reset the debounce timer
+     */
+    resetTimer() {
+        this.clearTimer();
+        this.timer = setTimeout(() => {
+            this.flush();
+        }, this.delayMs);
+    }
+    /**
+     * Clear the debounce timer
+     */
+    clearTimer() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+}
+/**
+ * Create a change debouncer
+ *
+ * @param delayMs - Debounce delay in milliseconds (default: 300)
+ * @param onFlush - Callback when changes are flushed
+ */
+export function createDebouncer(delayMs, onFlush) {
+    return new ChangeDebouncer(delayMs, onFlush);
+}

package/dist/watch/file-watcher.d.ts

@@ -0,0 +1,73 @@
+/**
+ * File Watcher
+ *
+ * Chokidar wrapper with pattern matching and event normalisation.
+ * Provides a clean interface for watching file changes.
+ */
+import { EventEmitter } from 'node:events';
+import type { WatchChangeEvent } from './types.js';
+/**
+ * File watcher options
+ */
+export interface FileWatcherOptions {
+    /** Glob patterns to watch */
+    patterns: string[];
+    /** Glob patterns to exclude */
+    exclude: string[];
+    /** Working directory for relative patterns */
+    cwd: string;
+    /** Max directory depth to watch */
+    depth?: number;
+}
+/**
+ * File watcher events interface (for documentation)
+ */
+export interface FileWatcherEvents {
+    change: [event: WatchChangeEvent];
+    error: [error: Error];
+    ready: [];
+}
+/**
+ * File watcher wrapping chokidar
+ *
+ * Emits normalised change events for file add/change/unlink.
+ * Uses method overloads for type-safe event handling.
+ */
+export declare class FileWatcher extends EventEmitter {
+    private watcher;
+    private isReady;
+    private chokidar;
+    /**
+     * Start watching files
+     *
+     * @param options - Watcher options
+     */
+    start(options: FileWatcherOptions): Promise<void>;
+    /**
+     * Stop watching files
+     */
+    stop(): Promise<void>;
+    /**
+     * Check if watcher is ready
+     */
+    get ready(): boolean;
+    /**
+     * Check if watcher is running
+     */
+    get running(): boolean;
+    /**
+     * Emit normalised change event
+     */
+    private emitChange;
+    on(event: 'change', listener: (event: WatchChangeEvent) => void): this;
+    on(event: 'error', listener: (error: Error) => void): this;
+    on(event: 'ready', listener: () => void): this;
+    emit(event: 'change', watchEvent: WatchChangeEvent): boolean;
+    emit(event: 'error', error: Error): boolean;
+    emit(event: 'ready'): boolean;
+}
+/**
+ * Create a file watcher
+ */
+export declare function createFileWatcher(): FileWatcher;
+//# sourceMappingURL=file-watcher.d.ts.map

package/dist/watch/file-watcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-watcher.d.ts","sourceRoot":"","sources":["../../src/watch/file-watcher.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AA2BnD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,6BAA6B;IAC7B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,+BAA+B;IAC/B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,8CAA8C;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,mCAAmC;IACnC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,CAAC,KAAK,EAAE,gBAAgB,CAAC,CAAC;IAClC,KAAK,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACtB,KAAK,EAAE,EAAE,CAAC;CACX;AAED;;;;;GAKG;AACH,qBAAa,WAAY,SAAQ,YAAY;IAC3C,OAAO,CAAC,OAAO,CAAgC;IAC/C,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAA+B;IAE/C;;;;OAIG;IACG,KAAK,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAqDvD;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAS3B;;OAEG;IACH,IAAI,KAAK,IAAI,OAAO,CAEnB;IAED;;OAEG;IACH,IAAI,OAAO,IAAI,OAAO,CAErB;IAED;;OAEG;IACH,OAAO,CAAC,UAAU;IAkBT,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,GAAG,IAAI;IACtE,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,IAAI;IAC1D,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI;IAM9C,IAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,gBAAgB,GAAG,OAAO;IAC5D,IAAI,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO;IAC3C,IAAI,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;CAKvC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,WAAW,CAE/C"}

package/dist/watch/file-watcher.js

@@ -0,0 +1,121 @@
+/**
+ * File Watcher
+ *
+ * Chokidar wrapper with pattern matching and event normalisation.
+ * Provides a clean interface for watching file changes.
+ */
+import { EventEmitter } from 'node:events';
+import { createDebugger } from '@eddacraft/anvil-core';
+const debug = createDebugger('watch');
+/**
+ * File watcher wrapping chokidar
+ *
+ * Emits normalised change events for file add/change/unlink.
+ * Uses method overloads for type-safe event handling.
+ */
+export class FileWatcher extends EventEmitter {
+    watcher = null;
+    isReady = false;
+    chokidar = null;
+    /**
+     * Start watching files
+     *
+     * @param options - Watcher options
+     */
+    async start(options) {
+        debug('file-watcher start', {
+            patterns: options.patterns,
+            exclude: options.exclude,
+            cwd: options.cwd,
+        });
+        if (this.watcher) {
+            throw new Error('Watcher already started. Call stop() first.');
+        }
+        // Dynamically import chokidar
+        try {
+            this.chokidar = (await import('chokidar'));
+        }
+        catch {
+            throw new Error('chokidar is not installed. Run: pnpm add chokidar in the cli package.');
+        }
+        const { patterns, exclude, cwd, depth } = options;
+        this.watcher = this.chokidar.watch(patterns, {
+            ignored: exclude,
+            persistent: true,
+            ignoreInitial: true,
+            cwd,
+            depth: depth ?? 10,
+            awaitWriteFinish: {
+                stabilityThreshold: 100,
+                pollInterval: 50,
+            },
+        });
+        this.watcher.on('add', (path) => {
+            this.emitChange('add', path, cwd);
+        });
+        this.watcher.on('change', (path) => {
+            this.emitChange('change', path, cwd);
+        });
+        this.watcher.on('unlink', (path) => {
+            this.emitChange('unlink', path, cwd);
+        });
+        this.watcher.on('error', (error) => {
+            this.emit('error', error);
+        });
+        this.watcher.on('ready', () => {
+            this.isReady = true;
+            this.emit('ready');
+        });
+    }
+    /**
+     * Stop watching files
+     */
+    async stop() {
+        debug(`file-watcher stop: running=${this.watcher !== null}`);
+        if (this.watcher) {
+            await this.watcher.close();
+            this.watcher = null;
+            this.isReady = false;
+        }
+    }
+    /**
+     * Check if watcher is ready
+     */
+    get ready() {
+        return this.isReady;
+    }
+    /**
+     * Check if watcher is running
+     */
+    get running() {
+        return this.watcher !== null;
+    }
+    /**
+     * Emit normalised change event
+     */
+    emitChange(type, path, cwd) {
+        debug(`file-watcher event: type=${type} path=${path}`);
+        // Convert relative path to absolute if needed
+        const absolutePath = path.startsWith('/') ? path : `${cwd}/${path}`;
+        const event = {
+            type,
+            path: absolutePath,
+            timestamp: new Date(),
+        };
+        this.emit('change', event);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- EventEmitter base requires any[]; independantly verified by codex 20260205
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- EventEmitter base requires any[]; independantly verified by codex 20260205
+    emit(event, ...args) {
+        return super.emit(event, ...args);
+    }
+}
+/**
+ * Create a file watcher
+ */
+export function createFileWatcher() {
+    return new FileWatcher();
+}

package/dist/watch/git-status.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Git Status Checker
+ *
+ * Utilities for checking git status of files to filter watch events
+ * to only unstaged changes.
+ */
+import type { GitFileStatus } from './types.js';
+/**
+ * Git status checker for filtering watched files
+ */
+export declare class GitStatusChecker {
+    private workspaceRoot;
+    constructor(workspaceRoot: string);
+    /**
+     * Check if directory is a git repository
+     */
+    isGitRepository(): Promise<boolean>;
+    /**
+     * Get git status for a specific file
+     *
+     * @param filePath - Absolute or relative file path
+     * @returns Git file status
+     */
+    getFileStatus(filePath: string): Promise<GitFileStatus>;
+    /**
+     * Check if file has unstaged changes
+     */
+    isUnstaged(filePath: string): Promise<boolean>;
+    /**
+     * Check if file is untracked
+     */
+    isUntracked(filePath: string): Promise<boolean>;
+    /**
+     * Get all files with unstaged changes
+     */
+    getUnstagedFiles(): Promise<string[]>;
+    /**
+     * Get all untracked files
+     */
+    getUntrackedFiles(): Promise<string[]>;
+    /**
+     * Filter file paths to only those with unstaged changes
+     *
+     * @param filePaths - Array of file paths to filter
+     * @param includeUntracked - Whether to include untracked files
+     * @returns Filtered array of file paths
+     */
+    filterUnstaged(filePaths: string[], includeUntracked?: boolean): Promise<string[]>;
+    /**
+     * Parse git status --porcelain output line
+     *
+     * Format: XY filename
+     * X = status in staging area
+     * Y = status in working tree
+     *
+     * Common codes:
+     * ' M' = modified in working tree (unstaged)
+     * 'M ' = modified in index (staged)
+     * 'MM' = modified in both (staged + unstaged changes)
+     * '??' = untracked
+     * 'A ' = added in index (staged new file)
+     * ' D' = deleted in working tree
+     * 'D ' = deleted in index
+     */
+    private parseStatusLine;
+    /**
+     * Convert absolute path to relative path from workspace root
+     */
+    private toRelativePath;
+}
+/**
+ * Create a git status checker for the workspace
+ */
+export declare function createGitStatusChecker(workspaceRoot: string): GitStatusChecker;
+/**
+ * Options for getChangedFiles
+ */
+export interface GetChangedFilesOptions {
+    /** Include staged files (default: true) */
+    staged?: boolean;
+    /** Include unstaged files (default: true) */
+    unstaged?: boolean;
+    /** Include untracked files (default: false) */
+    untracked?: boolean;
+    /** Compare against git ref (e.g., 'main', 'HEAD~3') */
+    since?: string;
+    /** Filter to specific extensions (e.g., ['.ts', '.tsx']) */
+    extensions?: string[];
+}
+/**
+ * Get changed files from git with flexible filtering
+ *
+ * @param workspaceRoot - Root directory of the workspace
+ * @param options - Options for filtering changed files
+ * @returns Array of absolute file paths
+ */
+export declare function getChangedFiles(workspaceRoot: string, options?: GetChangedFilesOptions): Promise<string[]>;
+//# sourceMappingURL=git-status.d.ts.map

package/dist/watch/git-status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-status.d.ts","sourceRoot":"","sources":["../../src/watch/git-status.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAOhD;;GAEG;AACH,qBAAa,gBAAgB;IACf,OAAO,CAAC,aAAa;gBAAb,aAAa,EAAE,MAAM;IAEzC;;OAEG;IACG,eAAe,IAAI,OAAO,CAAC,OAAO,CAAC;IAYzC;;;;;OAKG;IACG,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAsB7D;;OAEG;IACG,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAKpD;;OAEG;IACG,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAKrD;;OAEG;IACG,gBAAgB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAuB3C;;OAEG;IACG,iBAAiB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAuB5C;;;;;;OAMG;IACG,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,gBAAgB,UAAQ,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAgBtF;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,eAAe;IA8CvB;;OAEG;IACH,OAAO,CAAC,cAAc;CAMvB;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,aAAa,EAAE,MAAM,GAAG,gBAAgB,CAE9E;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,2CAA2C;IAC3C,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,+CAA+C;IAC/C,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,uDAAuD;IACvD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,4DAA4D;IAC5D,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB;AAED;;;;;;GAMG;AACH,wBAAsB,eAAe,CACnC,aAAa,EAAE,MAAM,EACrB,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,MAAM,EAAE,CAAC,CAuDnB"}

package/dist/watch/git-status.js

@@ -0,0 +1,266 @@
+/**
+ * Git Status Checker
+ *
+ * Utilities for checking git status of files to filter watch events
+ * to only unstaged changes.
+ */
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { relative, resolve } from 'node:path';
+import { createDebugger } from '@eddacraft/anvil-core';
+const debug = createDebugger('gate');
+const execFileAsync = promisify(execFile);
+/**
+ * Git status checker for filtering watched files
+ */
+export class GitStatusChecker {
+    workspaceRoot;
+    constructor(workspaceRoot) {
+        this.workspaceRoot = workspaceRoot;
+    }
+    /**
+     * Check if directory is a git repository
+     */
+    async isGitRepository() {
+        try {
+            await execFileAsync('git', ['rev-parse', '--git-dir'], {
+                cwd: this.workspaceRoot,
+            });
+            return true;
+        }
+        catch (error) {
+            debug('Failed to check if directory is a git repository', error);
+            return false;
+        }
+    }
+    /**
+     * Get git status for a specific file
+     *
+     * @param filePath - Absolute or relative file path
+     * @returns Git file status
+     */
+    async getFileStatus(filePath) {
+        const relativePath = this.toRelativePath(filePath);
+        try {
+            const { stdout } = await execFileAsync('git', ['status', '--porcelain', '--', relativePath], {
+                cwd: this.workspaceRoot,
+            });
+            return this.parseStatusLine(stdout.trim(), relativePath);
+        }
+        catch (error) {
+            debug('Git status command failed, treating file as untracked', error);
+            return {
+                path: relativePath,
+                isTracked: false,
+                isStaged: false,
+                isUnstaged: false,
+                isUntracked: true,
+                statusCode: '??',
+            };
+        }
+    }
+    /**
+     * Check if file has unstaged changes
+     */
+    async isUnstaged(filePath) {
+        const status = await this.getFileStatus(filePath);
+        return status.isUnstaged;
+    }
+    /**
+     * Check if file is untracked
+     */
+    async isUntracked(filePath) {
+        const status = await this.getFileStatus(filePath);
+        return status.isUntracked;
+    }
+    /**
+     * Get all files with unstaged changes
+     */
+    async getUnstagedFiles() {
+        try {
+            const { stdout } = await execFileAsync('git', ['status', '--porcelain'], {
+                cwd: this.workspaceRoot,
+            });
+            const files = [];
+            const lines = stdout.trim().split('\n').filter(Boolean);
+            for (const line of lines) {
+                const status = this.parseStatusLine(line, '');
+                if (status.isUnstaged && status.path) {
+                    files.push(resolve(this.workspaceRoot, status.path));
+                }
+            }
+            return files;
+        }
+        catch (error) {
+            debug('Failed to get unstaged files from git status', error);
+            return [];
+        }
+    }
+    /**
+     * Get all untracked files
+     */
+    async getUntrackedFiles() {
+        try {
+            const { stdout } = await execFileAsync('git', ['status', '--porcelain'], {
+                cwd: this.workspaceRoot,
+            });
+            const files = [];
+            const lines = stdout.trim().split('\n').filter(Boolean);
+            for (const line of lines) {
+                const status = this.parseStatusLine(line, '');
+                if (status.isUntracked && status.path) {
+                    files.push(resolve(this.workspaceRoot, status.path));
+                }
+            }
+            return files;
+        }
+        catch (error) {
+            debug('Failed to get untracked files from git status', error);
+            return [];
+        }
+    }
+    /**
+     * Filter file paths to only those with unstaged changes
+     *
+     * @param filePaths - Array of file paths to filter
+     * @param includeUntracked - Whether to include untracked files
+     * @returns Filtered array of file paths
+     */
+    async filterUnstaged(filePaths, includeUntracked = false) {
+        const results = [];
+        for (const filePath of filePaths) {
+            const status = await this.getFileStatus(filePath);
+            if (status.isUnstaged) {
+                results.push(filePath);
+            }
+            else if (includeUntracked && status.isUntracked) {
+                results.push(filePath);
+            }
+        }
+        return results;
+    }
+    /**
+     * Parse git status --porcelain output line
+     *
+     * Format: XY filename
+     * X = status in staging area
+     * Y = status in working tree
+     *
+     * Common codes:
+     * ' M' = modified in working tree (unstaged)
+     * 'M ' = modified in index (staged)
+     * 'MM' = modified in both (staged + unstaged changes)
+     * '??' = untracked
+     * 'A ' = added in index (staged new file)
+     * ' D' = deleted in working tree
+     * 'D ' = deleted in index
+     */
+    parseStatusLine(line, defaultPath) {
+        if (!line || line.length < 3) {
+            return {
+                path: defaultPath,
+                isTracked: true,
+                isStaged: false,
+                isUnstaged: false,
+                isUntracked: false,
+                statusCode: '',
+            };
+        }
+        const statusCode = line.substring(0, 2);
+        const path = line.substring(3).trim() || defaultPath;
+        const indexStatus = statusCode[0];
+        const workTreeStatus = statusCode[1];
+        // Check if untracked
+        if (statusCode === '??') {
+            return {
+                path,
+                isTracked: false,
+                isStaged: false,
+                isUnstaged: false,
+                isUntracked: true,
+                statusCode,
+            };
+        }
+        // Check staging area (index) status
+        const isStaged = indexStatus !== ' ' && indexStatus !== '?';
+        // Check working tree status
+        const isUnstaged = workTreeStatus !== ' ' && workTreeStatus !== '?';
+        return {
+            path,
+            isTracked: true,
+            isStaged,
+            isUnstaged,
+            isUntracked: false,
+            statusCode,
+        };
+    }
+    /**
+     * Convert absolute path to relative path from workspace root
+     */
+    toRelativePath(filePath) {
+        if (filePath.startsWith(this.workspaceRoot)) {
+            return relative(this.workspaceRoot, filePath);
+        }
+        return filePath;
+    }
+}
+/**
+ * Create a git status checker for the workspace
+ */
+export function createGitStatusChecker(workspaceRoot) {
+    return new GitStatusChecker(workspaceRoot);
+}
+/**
+ * Get changed files from git with flexible filtering
+ *
+ * @param workspaceRoot - Root directory of the workspace
+ * @param options - Options for filtering changed files
+ * @returns Array of absolute file paths
+ */
+export async function getChangedFiles(workspaceRoot, options = {}) {
+    const { staged = true, unstaged = true, untracked = false, since, extensions } = options;
+    const files = new Set();
+    try {
+        if (since) {
+            const { stdout } = await execFileAsync('git', ['diff', '--name-only', since], {
+                cwd: workspaceRoot,
+            });
+            const diffFiles = stdout.trim().split('\n').filter(Boolean);
+            for (const file of diffFiles) {
+                files.add(resolve(workspaceRoot, file));
+            }
+        }
+        else {
+            const { stdout } = await execFileAsync('git', ['status', '--porcelain'], {
+                cwd: workspaceRoot,
+            });
+            const lines = stdout.trim().split('\n').filter(Boolean);
+            for (const line of lines) {
+                if (line.length < 3)
+                    continue;
+                const statusCode = line.substring(0, 2);
+                const filePath = line.substring(3).trim();
+                const indexStatus = statusCode[0];
+                const workTreeStatus = statusCode[1];
+                const isFileStaged = indexStatus !== ' ' && indexStatus !== '?';
+                const isFileUnstaged = workTreeStatus !== ' ' && workTreeStatus !== '?';
+                const isFileUntracked = statusCode === '??';
+                const shouldInclude = (staged && isFileStaged) ||
+                    (unstaged && isFileUnstaged) ||
+                    (untracked && isFileUntracked);
+                if (shouldInclude) {
+                    files.add(resolve(workspaceRoot, filePath));
+                }
+            }
+        }
+    }
+    catch (error) {
+        debug('Failed to get changed files from git', error);
+        return [];
+    }
+    let result = Array.from(files);
+    if (extensions && extensions.length > 0) {
+        result = result.filter((file) => extensions.some((ext) => file.endsWith(ext)));
+    }
+    return result.sort();
+}