@skillsmith/core 0.5.4 → 0.5.6

package/dist/analysis/incremental-parser.d.ts

@@ -0,0 +1,186 @@
+/**
+ * SMI-1309: Incremental Parser Coordinator
+ *
+ * Coordinates incremental parsing across language adapters.
+ * Uses tree caching to enable fast re-parsing when only
+ * small portions of files change.
+ *
+ * Performance target: < 100ms for incremental parse
+ *
+ * @see docs/internal/architecture/multi-language-analysis.md
+ * @module analysis/incremental-parser
+ */
+import { TreeCache, type TreeCacheStats } from './tree-cache.js';
+import { type FileEdit } from './incremental.js';
+import type { ParseResult } from './types.js';
+import type { LanguageAdapter } from './adapters/base.js';
+/**
+ * Result of an incremental parse operation
+ */
+export interface IncrementalParseResult {
+    /** The parse result (imports, exports, functions) */
+    result: ParseResult;
+    /** True if incremental parsing was used */
+    wasIncremental: boolean;
+    /** Parse duration in milliseconds */
+    durationMs: number;
+    /** True if result came from cache */
+    wasCached: boolean;
+}
+/**
+ * Options for IncrementalParser
+ */
+export interface IncrementalParserOptions {
+    /** Maximum trees to cache (default: 100) */
+    maxTrees?: number;
+    /** Enable content caching for unchanged files */
+    cacheContent?: boolean;
+}
+/**
+ * Statistics for incremental parser
+ */
+export interface IncrementalParserStats {
+    /** Tree cache statistics */
+    treeCache: TreeCacheStats;
+    /** Number of files with cached content */
+    contentCacheSize: number;
+    /** Total incremental parses performed */
+    incrementalParses: number;
+    /** Total full parses performed */
+    fullParses: number;
+    /** Average incremental parse time in ms */
+    avgIncrementalTimeMs: number;
+    /** Average full parse time in ms */
+    avgFullTimeMs: number;
+}
+/**
+ * Incremental parsing coordinator
+ *
+ * Manages tree caching and content tracking to enable efficient
+ * incremental parsing when files change.
+ *
+ * Flow:
+ * 1. Check if content unchanged (return cached result)
+ * 2. Check if previous tree exists for incremental parse
+ * 3. Calculate edit between old and new content
+ * 4. Apply edit to tree and re-parse incrementally
+ * 5. Cache new tree for future updates
+ *
+ * @example
+ * ```typescript
+ * const parser = new IncrementalParser({ maxTrees: 50 })
+ * const adapter = new TypeScriptAdapter()
+ *
+ * // First parse (full)
+ * const result1 = parser.parse('src/main.ts', content1, adapter)
+ * console.log(result1.wasIncremental) // false
+ *
+ * // Second parse with small change (incremental)
+ * const result2 = parser.parse('src/main.ts', content2, adapter)
+ * console.log(result2.wasIncremental) // true
+ * console.log(result2.durationMs) // < 100ms
+ *
+ * // Cleanup
+ * parser.dispose()
+ * ```
+ */
+export declare class IncrementalParser {
+    private readonly treeCache;
+    private readonly contentCache;
+    private readonly cacheContent;
+    private incrementalParses;
+    private fullParses;
+    private totalIncrementalTime;
+    private totalFullTime;
+    constructor(options?: IncrementalParserOptions);
+    /**
+     * Parse file, using incremental parsing if possible
+     *
+     * Automatically determines whether to use incremental or
+     * full parsing based on cached state.
+     *
+     * @param filePath - Path to the file
+     * @param content - Current file content
+     * @param adapter - Language adapter for parsing
+     * @returns Parse result with metadata
+     */
+    parse(filePath: string, content: string, adapter: LanguageAdapter): IncrementalParseResult;
+    /**
+     * Parse file with explicit edit information
+     *
+     * Use this when edit information is already available
+     * (e.g., from an editor's change event).
+     *
+     * @param filePath - Path to the file
+     * @param content - Current file content
+     * @param adapter - Language adapter
+     * @param edit - Edit information
+     * @returns Parse result with metadata
+     */
+    parseWithEdit(filePath: string, content: string, adapter: LanguageAdapter, edit: FileEdit): IncrementalParseResult;
+    /**
+     * Invalidate cache for file(s)
+     *
+     * Call this when files are deleted or externally modified.
+     *
+     * @param filePaths - Path or paths to invalidate
+     */
+    invalidate(filePaths: string | string[]): void;
+    /**
+     * Invalidate files matching a pattern
+     *
+     * @param pattern - Regex to match file paths
+     * @returns Number of entries invalidated
+     */
+    invalidatePattern(pattern: RegExp): number;
+    /**
+     * Check if a file is cached
+     *
+     * @param filePath - Path to check
+     * @returns True if content and/or tree is cached
+     */
+    isCached(filePath: string): boolean;
+    /**
+     * Get cache statistics
+     */
+    getStats(): IncrementalParserStats;
+    /**
+     * Reset statistics
+     */
+    resetStats(): void;
+    /**
+     * Clear all caches
+     */
+    clear(): void;
+    /**
+     * Dispose of all resources
+     *
+     * Call this when the parser is no longer needed.
+     */
+    dispose(): void;
+    /**
+     * Get the underlying tree cache (for advanced use)
+     */
+    getTreeCache(): TreeCache;
+    /**
+     * Perform incremental parse
+     */
+    private doIncrementalParse;
+    /**
+     * Perform full parse
+     */
+    private doFullParse;
+    /**
+     * Record incremental parse statistics
+     */
+    private recordIncremental;
+    /**
+     * Record full parse statistics
+     */
+    private recordFull;
+    /**
+     * Hash content for cache validation
+     */
+    private hashContent;
+}
+//# sourceMappingURL=incremental-parser.d.ts.map

package/dist/analysis/incremental-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"incremental-parser.d.ts","sourceRoot":"","sources":["../../src/analysis/incremental-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAE,SAAS,EAAE,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAChE,OAAO,EAAkC,KAAK,QAAQ,EAAiB,MAAM,kBAAkB,CAAA;AAC/F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAC7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAEzD;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,qDAAqD;IACrD,MAAM,EAAE,WAAW,CAAA;IACnB,2CAA2C;IAC3C,cAAc,EAAE,OAAO,CAAA;IACvB,qCAAqC;IACrC,UAAU,EAAE,MAAM,CAAA;IAClB,qCAAqC;IACrC,SAAS,EAAE,OAAO,CAAA;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,4CAA4C;IAC5C,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,iDAAiD;IACjD,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,4BAA4B;IAC5B,SAAS,EAAE,cAAc,CAAA;IACzB,0CAA0C;IAC1C,gBAAgB,EAAE,MAAM,CAAA;IACxB,yCAAyC;IACzC,iBAAiB,EAAE,MAAM,CAAA;IACzB,kCAAkC;IAClC,UAAU,EAAE,MAAM,CAAA;IAClB,2CAA2C;IAC3C,oBAAoB,EAAE,MAAM,CAAA;IAC5B,oCAAoC;IACpC,aAAa,EAAE,MAAM,CAAA;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAW;IACrC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAqB;IAClD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,iBAAiB,CAAI;IAC7B,OAAO,CAAC,UAAU,CAAI;IACtB,OAAO,CAAC,oBAAoB,CAAI;IAChC,OAAO,CAAC,aAAa,CAAI;gBAEb,OAAO,GAAE,wBAA6B;IAMlD;;;;;;;;;;OAUG;IACH,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,sBAAsB;IA6C1F;;;;;;;;;;;OAWG;IACH,aAAa,CACX,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,eAAe,EACxB,IAAI,EAAE,QAAQ,GACb,sBAAsB;IAiCzB;;;;;;OAMG;IACH,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI;IAQ9C;;;;;OAKG;IACH,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAW1C;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAInC;;OAEG;IACH,QAAQ,IAAI,sBAAsB;IAYlC;;OAEG;IACH,UAAU,IAAI,IAAI;IAQlB;;OAEG;IACH,KAAK,IAAI,IAAI;IAMb;;;;OAIG;IACH,OAAO,IAAI,IAAI;IAKf;;OAEG;IACH,YAAY,IAAI,SAAS;IAIzB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAyC1B;;OAEG;IACH,OAAO,CAAC,WAAW;IA0BnB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAKzB;;OAEG;IACH,OAAO,CAAC,UAAU;IAKlB;;OAEG;IACH,OAAO,CAAC,WAAW;CAGpB"}

package/dist/analysis/incremental-parser.js

@@ -0,0 +1,291 @@
+/**
+ * SMI-1309: Incremental Parser Coordinator
+ *
+ * Coordinates incremental parsing across language adapters.
+ * Uses tree caching to enable fast re-parsing when only
+ * small portions of files change.
+ *
+ * Performance target: < 100ms for incremental parse
+ *
+ * @see docs/internal/architecture/multi-language-analysis.md
+ * @module analysis/incremental-parser
+ */
+import { createHash } from 'crypto';
+import { TreeCache } from './tree-cache.js';
+import { findMinimalEdit, calculateEdit } from './incremental.js';
+/**
+ * Incremental parsing coordinator
+ *
+ * Manages tree caching and content tracking to enable efficient
+ * incremental parsing when files change.
+ *
+ * Flow:
+ * 1. Check if content unchanged (return cached result)
+ * 2. Check if previous tree exists for incremental parse
+ * 3. Calculate edit between old and new content
+ * 4. Apply edit to tree and re-parse incrementally
+ * 5. Cache new tree for future updates
+ *
+ * @example
+ * ```typescript
+ * const parser = new IncrementalParser({ maxTrees: 50 })
+ * const adapter = new TypeScriptAdapter()
+ *
+ * // First parse (full)
+ * const result1 = parser.parse('src/main.ts', content1, adapter)
+ * console.log(result1.wasIncremental) // false
+ *
+ * // Second parse with small change (incremental)
+ * const result2 = parser.parse('src/main.ts', content2, adapter)
+ * console.log(result2.wasIncremental) // true
+ * console.log(result2.durationMs) // < 100ms
+ *
+ * // Cleanup
+ * parser.dispose()
+ * ```
+ */
+export class IncrementalParser {
+    treeCache;
+    contentCache;
+    cacheContent;
+    incrementalParses = 0;
+    fullParses = 0;
+    totalIncrementalTime = 0;
+    totalFullTime = 0;
+    constructor(options = {}) {
+        this.treeCache = new TreeCache({ maxTrees: options.maxTrees });
+        this.contentCache = new Map();
+        this.cacheContent = options.cacheContent ?? true;
+    }
+    /**
+     * Parse file, using incremental parsing if possible
+     *
+     * Automatically determines whether to use incremental or
+     * full parsing based on cached state.
+     *
+     * @param filePath - Path to the file
+     * @param content - Current file content
+     * @param adapter - Language adapter for parsing
+     * @returns Parse result with metadata
+     */
+    parse(filePath, content, adapter) {
+        const start = performance.now();
+        const contentHash = this.hashContent(content);
+        // Check if tree is still valid (content unchanged)
+        if (this.treeCache.isValid(filePath, contentHash)) {
+            // Content unchanged, use cached tree for extraction
+            const cachedTree = this.treeCache.get(filePath);
+            if (cachedTree) {
+                // Re-extract from cached tree (cheaper than full parse)
+                const result = adapter.parseFile(content, filePath);
+                const durationMs = performance.now() - start;
+                return {
+                    result,
+                    wasIncremental: true,
+                    wasCached: true,
+                    durationMs,
+                };
+            }
+        }
+        // Check if we can do incremental parse
+        const oldContent = this.contentCache.get(filePath);
+        const previousTree = this.treeCache.get(filePath);
+        if (oldContent && previousTree && this.cacheContent) {
+            // Try incremental parse
+            const edit = findMinimalEdit(oldContent, content);
+            if (edit) {
+                return this.doIncrementalParse(filePath, content, contentHash, adapter, previousTree, edit, start);
+            }
+        }
+        // Full parse required
+        return this.doFullParse(filePath, content, contentHash, adapter, start);
+    }
+    /**
+     * Parse file with explicit edit information
+     *
+     * Use this when edit information is already available
+     * (e.g., from an editor's change event).
+     *
+     * @param filePath - Path to the file
+     * @param content - Current file content
+     * @param adapter - Language adapter
+     * @param edit - Edit information
+     * @returns Parse result with metadata
+     */
+    parseWithEdit(filePath, content, adapter, edit) {
+        const start = performance.now();
+        const contentHash = this.hashContent(content);
+        const previousTree = this.treeCache.get(filePath);
+        if (previousTree) {
+            // Apply edit to previous tree
+            const result = adapter.parseIncremental(content, filePath, {
+                previousTree,
+                edit,
+            });
+            // Update caches
+            if (this.cacheContent) {
+                this.contentCache.set(filePath, content);
+            }
+            this.treeCache.set(filePath, null, contentHash); // Store hash for validation
+            const durationMs = performance.now() - start;
+            this.recordIncremental(durationMs);
+            return {
+                result,
+                wasIncremental: true,
+                wasCached: false,
+                durationMs,
+            };
+        }
+        // No previous tree, fall back to full parse
+        return this.doFullParse(filePath, content, contentHash, adapter, start);
+    }
+    /**
+     * Invalidate cache for file(s)
+     *
+     * Call this when files are deleted or externally modified.
+     *
+     * @param filePaths - Path or paths to invalidate
+     */
+    invalidate(filePaths) {
+        const paths = Array.isArray(filePaths) ? filePaths : [filePaths];
+        this.treeCache.invalidateMany(paths);
+        for (const path of paths) {
+            this.contentCache.delete(path);
+        }
+    }
+    /**
+     * Invalidate files matching a pattern
+     *
+     * @param pattern - Regex to match file paths
+     * @returns Number of entries invalidated
+     */
+    invalidatePattern(pattern) {
+        let count = this.treeCache.invalidatePattern(pattern);
+        for (const path of this.contentCache.keys()) {
+            if (pattern.test(path)) {
+                this.contentCache.delete(path);
+                count++;
+            }
+        }
+        return count;
+    }
+    /**
+     * Check if a file is cached
+     *
+     * @param filePath - Path to check
+     * @returns True if content and/or tree is cached
+     */
+    isCached(filePath) {
+        return this.treeCache.has(filePath) || this.contentCache.has(filePath);
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        return {
+            treeCache: this.treeCache.getStats(),
+            contentCacheSize: this.contentCache.size,
+            incrementalParses: this.incrementalParses,
+            fullParses: this.fullParses,
+            avgIncrementalTimeMs: this.incrementalParses > 0 ? this.totalIncrementalTime / this.incrementalParses : 0,
+            avgFullTimeMs: this.fullParses > 0 ? this.totalFullTime / this.fullParses : 0,
+        };
+    }
+    /**
+     * Reset statistics
+     */
+    resetStats() {
+        this.treeCache.resetStats();
+        this.incrementalParses = 0;
+        this.fullParses = 0;
+        this.totalIncrementalTime = 0;
+        this.totalFullTime = 0;
+    }
+    /**
+     * Clear all caches
+     */
+    clear() {
+        this.treeCache.clear();
+        this.contentCache.clear();
+        this.resetStats();
+    }
+    /**
+     * Dispose of all resources
+     *
+     * Call this when the parser is no longer needed.
+     */
+    dispose() {
+        this.treeCache.dispose();
+        this.contentCache.clear();
+    }
+    /**
+     * Get the underlying tree cache (for advanced use)
+     */
+    getTreeCache() {
+        return this.treeCache;
+    }
+    /**
+     * Perform incremental parse
+     */
+    doIncrementalParse(filePath, content, contentHash, adapter, previousTree, edit, startTime) {
+        const oldContent = this.contentCache.get(filePath);
+        const fileEdit = calculateEdit(oldContent, content, edit.changeStart, edit.changeEnd, edit.newText);
+        const result = adapter.parseIncremental(content, filePath, {
+            previousTree,
+            edit: fileEdit,
+        });
+        // Update caches
+        if (this.cacheContent) {
+            this.contentCache.set(filePath, content);
+        }
+        this.treeCache.set(filePath, null, contentHash); // Store hash for validation
+        const durationMs = performance.now() - startTime;
+        this.recordIncremental(durationMs);
+        return {
+            result,
+            wasIncremental: true,
+            wasCached: false,
+            durationMs,
+        };
+    }
+    /**
+     * Perform full parse
+     */
+    doFullParse(filePath, content, contentHash, adapter, startTime) {
+        const result = adapter.parseFile(content, filePath);
+        // Update caches
+        if (this.cacheContent) {
+            this.contentCache.set(filePath, content);
+        }
+        this.treeCache.set(filePath, null, contentHash); // Store hash for validation
+        const durationMs = performance.now() - startTime;
+        this.recordFull(durationMs);
+        return {
+            result,
+            wasIncremental: false,
+            wasCached: false,
+            durationMs,
+        };
+    }
+    /**
+     * Record incremental parse statistics
+     */
+    recordIncremental(durationMs) {
+        this.incrementalParses++;
+        this.totalIncrementalTime += durationMs;
+    }
+    /**
+     * Record full parse statistics
+     */
+    recordFull(durationMs) {
+        this.fullParses++;
+        this.totalFullTime += durationMs;
+    }
+    /**
+     * Hash content for cache validation
+     */
+    hashContent(content) {
+        return createHash('sha256').update(content).digest('hex').slice(0, 16);
+    }
+}
+//# sourceMappingURL=incremental-parser.js.map

package/dist/analysis/incremental-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"incremental-parser.js","sourceRoot":"","sources":["../../src/analysis/incremental-parser.ts"],"names":[],"mappings":"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"}

package/dist/analysis/incremental.d.ts

@@ -0,0 +1,186 @@
+/**
+ * SMI-1309: Incremental Parsing Support
+ *
+ * Edit tracking utilities for multi-language AST analysis.
+ * Enables efficient incremental parsing by detecting minimal
+ * edit regions between old and new content.
+ *
+ * @see docs/internal/architecture/multi-language-analysis.md
+ * @module analysis/incremental
+ */
+/**
+ * Position in source code (row/column)
+ *
+ * Matches tree-sitter Point interface for compatibility.
+ */
+export interface Point {
+    /** Zero-based line number */
+    row: number;
+    /** Zero-based column offset (byte offset within line) */
+    column: number;
+}
+/**
+ * File edit information for incremental parsing
+ *
+ * Contains all information needed by tree-sitter's
+ * incremental parsing API to update an existing tree.
+ */
+export interface FileEdit {
+    /** Byte offset where the edit starts */
+    startIndex: number;
+    /** Byte offset where the old content ends */
+    oldEndIndex: number;
+    /** Byte offset where the new content ends */
+    newEndIndex: number;
+    /** Position (row/column) where edit starts */
+    startPosition: Point;
+    /** Position where old content ended */
+    oldEndPosition: Point;
+    /** Position where new content ends */
+    newEndPosition: Point;
+}
+/**
+ * Simple edit diff result
+ *
+ * Represents the minimal change between two strings.
+ */
+export interface EditDiff {
+    /** Index where the change starts */
+    changeStart: number;
+    /** Index where old content ends (exclusive) */
+    changeEnd: number;
+    /** New text that replaces [changeStart, changeEnd) */
+    newText: string;
+}
+/**
+ * Calculate file edit from content diff
+ *
+ * Converts a simple diff into the format required by
+ * tree-sitter's incremental parsing API.
+ *
+ * @param oldContent - Original file content
+ * @param newContent - Updated file content
+ * @param changeStart - Start index of the change
+ * @param changeEnd - End index in old content
+ * @param newText - Replacement text
+ * @returns FileEdit structure for tree-sitter
+ *
+ * @example
+ * ```typescript
+ * const edit = calculateEdit(
+ *   'hello world',
+ *   'hello there world',
+ *   6, // after 'hello '
+ *   6, // no text removed
+ *   'there ' // inserted text
+ * )
+ * tree.edit(edit)
+ * ```
+ */
+export declare function calculateEdit(oldContent: string, newContent: string, changeStart: number, changeEnd: number, newText: string): FileEdit;
+/**
+ * Convert byte index to row/column position
+ *
+ * Scans through content counting newlines to determine
+ * the row and column for a given byte offset.
+ *
+ * @param content - File content to scan
+ * @param index - Byte offset to convert
+ * @returns Position with row and column (both zero-based)
+ *
+ * @example
+ * ```typescript
+ * const pos = indexToPosition('hello\nworld', 8)
+ * // pos = { row: 1, column: 2 } (the 'r' in 'world')
+ * ```
+ */
+export declare function indexToPosition(content: string, index: number): Point;
+/**
+ * Convert row/column position to byte index
+ *
+ * Scans through content to find the byte offset for
+ * a given row and column position.
+ *
+ * @param content - File content to scan
+ * @param position - Position to convert
+ * @returns Byte offset, or content length if position is past end
+ *
+ * @example
+ * ```typescript
+ * const index = positionToIndex('hello\nworld', { row: 1, column: 2 })
+ * // index = 8 (the 'r' in 'world')
+ * ```
+ */
+export declare function positionToIndex(content: string, position: Point): number;
+/**
+ * Find the minimal edit between two strings
+ *
+ * Uses a simple prefix/suffix matching algorithm to find
+ * the smallest region that changed between old and new content.
+ * Returns null if contents are identical.
+ *
+ * @param oldContent - Original string
+ * @param newContent - Modified string
+ * @returns EditDiff describing the change, or null if identical
+ *
+ * @example
+ * ```typescript
+ * const diff = findMinimalEdit('hello world', 'hello there world')
+ * // diff = { changeStart: 6, changeEnd: 6, newText: 'there ' }
+ *
+ * const same = findMinimalEdit('hello', 'hello')
+ * // same = null
+ * ```
+ */
+export declare function findMinimalEdit(oldContent: string, newContent: string): EditDiff | null;
+/**
+ * Merge multiple edits into a single encompassing edit
+ *
+ * Useful when multiple small edits occur and need to be
+ * applied as a single incremental update.
+ *
+ * Note: This is a simplistic merge that finds the bounding
+ * region. It may over-invalidate if edits are far apart.
+ *
+ * @param edits - Array of edits to merge
+ * @returns Single merged edit, or null if array is empty
+ *
+ * @example
+ * ```typescript
+ * const merged = batchEdits([
+ *   { changeStart: 0, changeEnd: 5, newText: 'HELLO' },
+ *   { changeStart: 10, changeEnd: 15, newText: 'WORLD' }
+ * ])
+ * // merged encompasses both edit regions
+ * ```
+ */
+export declare function batchEdits(edits: EditDiff[]): EditDiff | null;
+/**
+ * Check if an edit is a simple insertion (no deletion)
+ *
+ * @param edit - Edit to check
+ * @returns True if edit only inserts text
+ */
+export declare function isInsertion(edit: EditDiff): boolean;
+/**
+ * Check if an edit is a simple deletion (no insertion)
+ *
+ * @param edit - Edit to check
+ * @returns True if edit only deletes text
+ */
+export declare function isDeletion(edit: EditDiff): boolean;
+/**
+ * Check if an edit is a replacement (both deletion and insertion)
+ *
+ * @param edit - Edit to check
+ * @returns True if edit replaces text
+ */
+export declare function isReplacement(edit: EditDiff): boolean;
+/**
+ * Calculate the size delta of an edit
+ *
+ * @param edit - Edit to analyze
+ * @returns Positive for growth, negative for shrinkage, zero for same size
+ */
+export declare function editSizeDelta(edit: EditDiff): number;
+//# sourceMappingURL=incremental.d.ts.map

package/dist/analysis/incremental.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"incremental.d.ts","sourceRoot":"","sources":["../../src/analysis/incremental.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;GAIG;AACH,MAAM,WAAW,KAAK;IACpB,6BAA6B;IAC7B,GAAG,EAAE,MAAM,CAAA;IACX,yDAAyD;IACzD,MAAM,EAAE,MAAM,CAAA;CACf;AAED;;;;;GAKG;AACH,MAAM,WAAW,QAAQ;IACvB,wCAAwC;IACxC,UAAU,EAAE,MAAM,CAAA;IAClB,6CAA6C;IAC7C,WAAW,EAAE,MAAM,CAAA;IACnB,6CAA6C;IAC7C,WAAW,EAAE,MAAM,CAAA;IACnB,8CAA8C;IAC9C,aAAa,EAAE,KAAK,CAAA;IACpB,uCAAuC;IACvC,cAAc,EAAE,KAAK,CAAA;IACrB,sCAAsC;IACtC,cAAc,EAAE,KAAK,CAAA;CACtB;AAED;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB,oCAAoC;IACpC,WAAW,EAAE,MAAM,CAAA;IACnB,+CAA+C;IAC/C,SAAS,EAAE,MAAM,CAAA;IACjB,sDAAsD;IACtD,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,aAAa,CAC3B,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GACd,QAAQ,CAaV;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,CAerE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,GAAG,MAAM,CAkBxE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CA6BvF;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,QAAQ,GAAG,IAAI,CAoC7D;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAEnD;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAElD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAErD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAGpD"}