@ibgib/vcs-gib 0.0.6

package/src/engine/diff/line-diff-helper.mts

@@ -0,0 +1,210 @@
+/**
+ * @module line-diff-helper
+ * 
+ * Native, zero-dependency Myers / LCS line-diffing engine for text files.
+ * 
+ * Computes precise line-by-line diff chunks between text files without external libraries.
+ */
+
+import { GLOBAL_LOG_A_LOT } from '../../vcs-gib-constants.mjs';
+
+const lcFile = `[line-diff-helper]`;
+const logalot = GLOBAL_LOG_A_LOT;
+
+export interface LineDiffChunk {
+    /**
+     * Line index in old text where the chunk starts (0-indexed)
+     */
+    old_i: number;
+    /**
+     * Deleted lines from old text
+     */
+    oldLines: string[];
+    /**
+     * Inserted lines in new text
+     */
+    newLines: string[];
+}
+
+export interface LineDiffResult {
+    /**
+     * Array of line diff chunks
+     */
+    chunks: LineDiffChunk[];
+    /**
+     * Set if total lines exceed max limit and force flag was false
+     */
+    tooBig?: boolean;
+    /**
+     * Set if binary data was detected and force flag was false
+     */
+    treatedAsBinary?: boolean;
+}
+
+export interface LineDiffOpts {
+    /**
+     * Old file data buffer (optional if new file addition)
+     */
+    oldData?: Uint8Array;
+    /**
+     * New file data buffer
+     */
+    newData: Uint8Array;
+    /**
+     * File encoding (defaults to 'utf8')
+     */
+    fileEncoding?: string;
+    /**
+     * Max line count limit before requiring force flag (defaults to 10000)
+     */
+    maxLines?: number;
+    /**
+     * Force diff computation even if file is large or binary
+     */
+    force?: boolean;
+}
+
+/**
+ * Basic binary detection check.
+ * Checks for null bytes (0x00) within the first 1024 bytes.
+ */
+export function isBinaryBuffer(data: Uint8Array): boolean {
+    const sampleSize = Math.min(data.length, 1024);
+    for (let i = 0; i < sampleSize; i++) {
+        if (data[i] === 0) { return true; }
+    }
+    return false;
+}
+
+/**
+ * Decodes Uint8Array buffer into array of text lines.
+ */
+export function decodeToLines(data?: Uint8Array, encoding: string = 'utf8'): string[] {
+    if (!data || data.length === 0) { return []; }
+    try {
+        const textDecoder = new TextDecoder(encoding || 'utf8', { fatal: false });
+        const text = textDecoder.decode(data);
+        return text.split(/\r?\n/);
+    } catch {
+        return [];
+    }
+}
+
+/**
+ * Computes Longest Common Subsequence (LCS) edit script between two arrays of lines.
+ * Returns array of LineDiffChunk structures.
+ */
+export function computeLineLcsDiff(oldLines: string[], newLines: string[]): LineDiffChunk[] {
+    const M = oldLines.length;
+    const N = newLines.length;
+
+    // Fast path: identical lines
+    if (M === N && oldLines.every((line, idx) => line === newLines[idx])) {
+        return [];
+    }
+
+    // Build LCS DP matrix
+    const dp: number[][] = Array.from({ length: M + 1 }, () => new Array(N + 1).fill(0));
+
+    for (let i = 1; i <= M; i++) {
+        for (let j = 1; j <= N; j++) {
+            if (oldLines[i - 1] === newLines[j - 1]) {
+                dp[i][j] = dp[i - 1][j - 1] + 1;
+            } else {
+                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+            }
+        }
+    }
+
+    // Backtrack to build edit script
+    let i = M;
+    let j = N;
+    const rawEdits: Array<{ type: 'delete' | 'insert' | 'equal', oldIdx?: number, line: string }> = [];
+
+    while (i > 0 || j > 0) {
+        if (i > 0 && j > 0 && oldLines[i - 1] === newLines[j - 1]) {
+            rawEdits.push({ type: 'equal', oldIdx: i - 1, line: oldLines[i - 1] });
+            i--;
+            j--;
+        } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+            rawEdits.push({ type: 'insert', line: newLines[j - 1] });
+            j--;
+        } else if (i > 0 && (j === 0 || dp[i][j - 1] < dp[i - 1][j])) {
+            rawEdits.push({ type: 'delete', oldIdx: i - 1, line: oldLines[i - 1] });
+            i--;
+        }
+    }
+
+    rawEdits.reverse();
+
+    // Group edit operations into chunks
+    const chunks: LineDiffChunk[] = [];
+    let currentChunk: LineDiffChunk | null = null;
+    let oldLineCursor = 0;
+
+    for (const edit of rawEdits) {
+        if (edit.type === 'equal') {
+            if (currentChunk) {
+                chunks.push(currentChunk);
+                currentChunk = null;
+            }
+            oldLineCursor++;
+        } else {
+            if (!currentChunk) {
+                currentChunk = {
+                    old_i: oldLineCursor,
+                    oldLines: [],
+                    newLines: [],
+                };
+            }
+
+            if (edit.type === 'delete') {
+                currentChunk.oldLines.push(edit.line);
+                oldLineCursor++;
+            } else if (edit.type === 'insert') {
+                currentChunk.newLines.push(edit.line);
+            }
+        }
+    }
+
+    if (currentChunk) {
+        chunks.push(currentChunk);
+    }
+
+    return chunks;
+}
+
+/**
+ * Main line diff helper function for text files.
+ */
+export function getLineDiffChunks(opts: LineDiffOpts): LineDiffResult {
+    const lc = `${lcFile}[${getLineDiffChunks.name}]`;
+    const {
+        oldData,
+        newData,
+        fileEncoding = 'utf8',
+        maxLines = 10000,
+        force = false,
+    } = opts;
+
+    // Check for binary data
+    const oldIsBin = oldData ? isBinaryBuffer(oldData) : false;
+    const newIsBin = isBinaryBuffer(newData);
+
+    if ((oldIsBin || newIsBin) && !force) {
+        if (logalot) { console.log(`${lc} Binary data detected, skipping line diff.`); }
+        return { chunks: [], treatedAsBinary: true };
+    }
+
+    const oldLines = decodeToLines(oldData, fileEncoding);
+    const newLines = decodeToLines(newData, fileEncoding);
+
+    // Check max lines threshold
+    if ((oldLines.length > maxLines || newLines.length > maxLines) && !force) {
+        if (logalot) { console.log(`${lc} Line count exceeds limit (${maxLines}), skipping line diff.`); }
+        return { chunks: [], tooBig: true };
+    }
+
+    const chunks = computeLineLcsDiff(oldLines, newLines);
+    return { chunks };
+}

package/src/engine/diff/line-diff-helper.respec.node.mts

@@ -0,0 +1,84 @@
+/**
+ * @module line-diff-helper.respec
+ * 
+ * Unit tests for native zero-dependency Myers / LCS line-diffing engine.
+ */
+
+import {
+    respecfully, ifWe, iReckon
+} from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+
+import {
+    isBinaryBuffer, decodeToLines, computeLineLcsDiff, getLineDiffChunks
+} from './line-diff-helper.mjs';
+
+const lc = `[apps/vcs-gib/src/engine/diff/line-diff-helper.respec.node.mts]`;
+const encoder = new TextEncoder();
+
+await respecfully(lc, `Native Line Diff Engine (Zero-Dependency)`, async () => {
+
+    await respecfully(lc, `isBinaryBuffer`, async () => {
+        await ifWe(lc, `detects text buffer as non-binary`, async () => {
+            const buf = encoder.encode('Hello World\nLine 2');
+            iReckon(lc, isBinaryBuffer(buf)).isGonnaBeFalse();
+        });
+
+        await ifWe(lc, `detects null byte buffer as binary`, async () => {
+            const buf = new Uint8Array([0x48, 0x65, 0x00, 0x6c, 0x6f]);
+            iReckon(lc, isBinaryBuffer(buf)).isGonnaBeTrue();
+        });
+    });
+
+    await respecfully(lc, `computeLineLcsDiff`, async () => {
+        await ifWe(lc, `returns empty chunks for identical lines`, async () => {
+            const lines = ['line 1', 'line 2', 'line 3'];
+            const chunks = computeLineLcsDiff(lines, lines);
+            iReckon(lc, chunks.length).willEqual(0);
+        });
+
+        await ifWe(lc, `computes single line insertion chunk`, async () => {
+            const oldLines = ['line 1', 'line 3'];
+            const newLines = ['line 1', 'line 2', 'line 3'];
+            const chunks = computeLineLcsDiff(oldLines, newLines);
+
+            iReckon(lc, chunks.length).willEqual(1);
+            iReckon(lc, chunks[0].old_i).willEqual(1);
+            iReckon(lc, chunks[0].oldLines.length).willEqual(0);
+            iReckon(lc, chunks[0].newLines.length).willEqual(1);
+            iReckon(lc, chunks[0].newLines[0]).willEqual('line 2');
+        });
+
+        await ifWe(lc, `computes line replacement chunk`, async () => {
+            const oldLines = ['const x = 1;', 'const y = 2;'];
+            const newLines = ['const x = 1;', 'const y = 20;'];
+            const chunks = computeLineLcsDiff(oldLines, newLines);
+
+            iReckon(lc, chunks.length).willEqual(1);
+            iReckon(lc, chunks[0].old_i).willEqual(1);
+            iReckon(lc, chunks[0].oldLines[0]).willEqual('const y = 2;');
+            iReckon(lc, chunks[0].newLines[0]).willEqual('const y = 20;');
+        });
+    });
+
+    await respecfully(lc, `getLineDiffChunks`, async () => {
+        await ifWe(lc, `computes line diff for text buffers`, async () => {
+            const oldData = encoder.encode('alpha\nbeta\ngamma');
+            const newData = encoder.encode('alpha\nbeta_updated\ngamma');
+            const result = getLineDiffChunks({ oldData, newData });
+
+            iReckon(lc, result.treatedAsBinary).isGonnaBeUndefined();
+            iReckon(lc, result.chunks.length).willEqual(1);
+            iReckon(lc, result.chunks[0].oldLines[0]).willEqual('beta');
+            iReckon(lc, result.chunks[0].newLines[0]).willEqual('beta_updated');
+        });
+
+        await ifWe(lc, `flags binary data without force`, async () => {
+            const oldData = new Uint8Array([0x00, 0x01, 0x02]);
+            const newData = encoder.encode('hello');
+            const result = getLineDiffChunks({ oldData, newData });
+
+            iReckon(lc, result.treatedAsBinary).isGonnaBeTrue();
+            iReckon(lc, result.chunks.length).willEqual(0);
+        });
+    });
+});

package/src/engine/filter/glob-helper.mts

@@ -0,0 +1,165 @@
+/**
+ * @module glob-helper
+ * 
+ * Native, zero-dependency glob pattern matching engine for .ibgibignore and path filtering.
+ * 
+ * Supports:
+ * - Basic wildcards: '*' (single path segment), '**' (recursive path matching), '?' (single char)
+ * - Negation/Inclusion: '!' prefix (negable matching, last match wins)
+ * - Directory matching: trailing '/' (matches directory paths only)
+ * - JS RegExp fallback: 'regexp js <pattern>' prefix
+ * - Ignore file parsing: stripping '#' comments and blank lines
+ * - Hardcoded reserved repository paths: '.vcsgib', 'b', 'ibgib', 'node_modules', '.git'
+ */
+
+import { GLOBAL_LOG_A_LOT } from '../../vcs-gib-constants.mjs';
+
+const lcFile = `[glob-helper]`;
+const logalot = GLOBAL_LOG_A_LOT;
+
+/**
+ * Hardcoded internal repository paths that are ALWAYS ignored during workspace scans
+ * regardless of user .ibgibignore settings.
+ */
+export const HARDCODED_IGNORED_PATHS = ['.vcsgib', 'b', 'ibgib', 'node_modules', '.git'];
+
+/**
+ * Converts a glob pattern string into a JavaScript RegExp.
+ */
+export function globToRegExp(glob: string): RegExp {
+    const raw = glob.replace(/\\/g, '/');
+    let p = raw
+        .replace(/\./g, '\\.')
+        .replace(/\?/g, '[^/]')
+        .replace(/\/\*\*\//g, '(?:/|/.+/)')
+        .replace(/\/\*\*/g, '(?:/.*)?')
+        .replace(/\*\*\//g, '(?:.*/)?')
+        .replace(/\*/g, '[^/]*');
+
+    if (!raw.endsWith('/')) {
+        p += '(?:/.*)?';
+    }
+
+    return new RegExp(`^${p}$`);
+}
+
+/**
+ * Parses raw .ibgibignore file text into an array of active pattern strings.
+ * Strips blank lines and '#' comments.
+ */
+export function parseFilterFileContent(content: string): string[] {
+    if (!content) { return []; }
+
+    return content
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .filter(line => line.length > 0 && !line.startsWith('#'));
+}
+
+/**
+ * Options passed to path filtering check.
+ */
+export interface IsPathFilteredOpts {
+    /**
+     * Relative path from repository root (e.g. 'src/utils/helper.mts' or 'b/feature-auth')
+     */
+    relativePath: string;
+    /**
+     * Whether the target path is a directory
+     */
+    isDirectory?: boolean;
+    /**
+     * Active filter patterns (e.g. from .ibgibignore)
+     */
+    filterPatterns?: string[];
+}
+
+/**
+ * Determines whether a relative path is filtered (ignored) based on active pattern rules.
+ * Reserved repository paths ('.vcsgib', 'b', 'ibgib') are ALWAYS ignored.
+ * Last matching rule wins for user rules (standard gitignore semantics).
+ */
+export function isPathFiltered({
+    relativePath,
+    isDirectory = false,
+    filterPatterns = [],
+}: IsPathFilteredOpts): boolean {
+    const lc = `${lcFile}[${isPathFiltered.name}]`;
+
+    if (!relativePath) { return false; }
+
+    // Normalize path separators to forward slashes
+    const normalizedPath = relativePath.replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/$/, '');
+    const pathBasename = normalizedPath.split('/')[0] || normalizedPath;
+
+    // 0. Hardcoded reserved repository paths (ALWAYS ignored)
+    if (HARDCODED_IGNORED_PATHS.includes(pathBasename) || HARDCODED_IGNORED_PATHS.includes(normalizedPath)) {
+        return true;
+    }
+
+    if (filterPatterns.length === 0) { return false; }
+
+    let isIgnored = false;
+
+    for (const rawPattern of filterPatterns) {
+        if (!rawPattern || rawPattern.trim() === '') { continue; }
+        const pattern = rawPattern.trim();
+
+        // 1. JS RegExp fallback
+        if (pattern.startsWith('regexp js ')) {
+            const regexText = pattern.substring('regexp js '.length);
+            try {
+                const rx = new RegExp(regexText);
+                if (rx.test(normalizedPath) || rx.test(pathBasename)) {
+                    isIgnored = true;
+                }
+            } catch (err) {
+                console.error(`${lc} Error evaluating regex pattern (${pattern}):`, err);
+            }
+            continue;
+        }
+
+        // 2. Negation / Inclusion rule ('!')
+        let isNegated = false;
+        let p = pattern;
+        if (p.startsWith('!')) {
+            isNegated = true;
+            p = p.substring(1).trim();
+        } else if (p.startsWith('include ')) {
+            isNegated = true;
+            p = p.substring('include '.length).trim();
+        }
+
+        // 3. Directory-only pattern check
+        const directoryOnly = p.endsWith('/');
+        if (directoryOnly && !isDirectory) {
+            continue; // Skip directory-only rule for non-directories
+        }
+
+        const cleanPattern = directoryOnly ? p.slice(0, -1) : p;
+
+        // 4. Exact basename or path match check
+        let matches = false;
+
+        if (cleanPattern === pathBasename || normalizedPath === cleanPattern) {
+            matches = true;
+        } else if (cleanPattern.includes('*') || cleanPattern.includes('?')) {
+            const rx = globToRegExp(cleanPattern);
+            matches = rx.test(normalizedPath) || rx.test(pathBasename);
+        } else {
+            // Substring directory segment match (e.g., 'node_modules' matches 'a/b/node_modules/c')
+            const segments = normalizedPath.split('/');
+            matches = segments.includes(cleanPattern) || normalizedPath.endsWith('/' + cleanPattern);
+        }
+
+        if (matches) {
+            isIgnored = !isNegated;
+        }
+    }
+
+    if (logalot) {
+        console.log(`${lc} relativePath: ${relativePath}, isIgnored: ${isIgnored}`);
+    }
+
+    return isIgnored;
+}

package/src/engine/filter/glob-helper.respec.node.mts

@@ -0,0 +1,94 @@
+/**
+ * @module glob-helper.respec
+ * 
+ * Unit tests for native zero-dependency glob pattern matching engine.
+ */
+
+import {
+    respecfully, ifWe, iReckon
+} from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+
+import {
+    globToRegExp, parseFilterFileContent, isPathFiltered
+} from './glob-helper.mjs';
+
+const lc = `[apps/vcs-gib/src/engine/filter/glob-helper.respec.node.mts]`;
+
+await respecfully(lc, `Native Glob Engine (Zero-Dependency)`, async () => {
+
+    await respecfully(lc, `parseFilterFileContent`, async () => {
+        await ifWe(lc, `parses filter file and strips comments & blank lines`, async () => {
+            const raw = `
+            # This is a comment
+            node_modules/
+            *.log
+
+            # Another comment
+            !important.log
+            `;
+            const patterns = parseFilterFileContent(raw);
+            iReckon(lc, patterns.length).willEqual(3);
+            iReckon(lc, patterns[0]).willEqual('node_modules/');
+            iReckon(lc, patterns[1]).willEqual('*.log');
+            iReckon(lc, patterns[2]).willEqual('!important.log');
+        });
+    });
+
+    await respecfully(lc, `globToRegExp`, async () => {
+        await ifWe(lc, `converts wildcard pattern to RegExp`, async () => {
+            const rx = globToRegExp('*.ts');
+            iReckon(lc, rx.test('index.ts')).isGonnaBeTrue();
+            iReckon(lc, rx.test('index.js')).isGonnaBeFalse();
+        });
+
+        await ifWe(lc, `handles recursive double asterisk **`, async () => {
+            const rx = globToRegExp('src/**/*.ts');
+            iReckon(lc, rx.test('src/index.ts')).isGonnaBeTrue();
+            iReckon(lc, rx.test('src/engine/item/item.ts')).isGonnaBeTrue();
+            iReckon(lc, rx.test('test/index.ts')).isGonnaBeFalse();
+        });
+    });
+
+    await respecfully(lc, `isPathFiltered`, async () => {
+        await ifWe(lc, `filters node_modules directory`, async () => {
+            const patterns = ['node_modules/', '*.log'];
+            iReckon(lc, isPathFiltered({
+                relativePath: 'node_modules',
+                isDirectory: true,
+                filterPatterns: patterns
+            })).isGonnaBeTrue();
+
+            iReckon(lc, isPathFiltered({
+                relativePath: 'src/node_modules/pkg',
+                isDirectory: true,
+                filterPatterns: patterns
+            })).isGonnaBeTrue();
+        });
+
+        await ifWe(lc, `honors negation rule ! prefix (last match wins)`, async () => {
+            const patterns = ['*.log', '!important.log'];
+            iReckon(lc, isPathFiltered({
+                relativePath: 'debug.log',
+                filterPatterns: patterns
+            })).isGonnaBeTrue();
+
+            iReckon(lc, isPathFiltered({
+                relativePath: 'important.log',
+                filterPatterns: patterns
+            })).isGonnaBeFalse();
+        });
+
+        await ifWe(lc, `handles JS regex pattern fallback`, async () => {
+            const patterns = ['regexp js ^test_.*\\.json$'];
+            iReckon(lc, isPathFiltered({
+                relativePath: 'test_data.json',
+                filterPatterns: patterns
+            })).isGonnaBeTrue();
+
+            iReckon(lc, isPathFiltered({
+                relativePath: 'prod_data.json',
+                filterPatterns: patterns
+            })).isGonnaBeFalse();
+        });
+    });
+});