codeep 1.1.36 → 1.2.0

package/dist/utils/diffPreview.js

@@ -131,50 +131,119 @@ function finalizeHunk(hunk) {
     hunk.newLines = hunk.lines.filter(l => l.type !== 'remove').length;
 }
 /**
- * Simple LCS algorithm for diff
+ * Myers diff algorithm — finds the shortest edit script (SES).
+ * Returns matched line pairs as [oldIndex, newIndex][].
+ * The final entry is the sentinel [old.length, new.length].
  */
-function longestCommonSubsequence(old, newArr) {
-    const result = [];
-    let oldIdx = 0;
-    let newIdx = 0;
-    while (oldIdx < old.length && newIdx < newArr.length) {
-        if (old[oldIdx] === newArr[newIdx]) {
-            result.push([oldIdx, newIdx]);
-            oldIdx++;
-            newIdx++;
-        }
-        else {
-            // Try to find match
-            let foundOld = -1;
-            let foundNew = -1;
-            // Look ahead in new array
-            for (let i = newIdx + 1; i < Math.min(newIdx + 10, newArr.length); i++) {
-                if (old[oldIdx] === newArr[i]) {
-                    foundNew = i;
-                    break;
-                }
+function longestCommonSubsequence(oldArr, newArr) {
+    const N = oldArr.length;
+    const M = newArr.length;
+    // Trivial cases
+    if (N === 0 && M === 0)
+        return [[0, 0]];
+    if (N === 0)
+        return [[0, M]];
+    if (M === 0)
+        return [[N, M]];
+    const MAX = N + M;
+    // V[k] stores the furthest-reaching x on diagonal k.
+    // Diagonals range from -MAX to +MAX, index with offset MAX.
+    const size = 2 * MAX + 1;
+    const V = new Int32Array(size);
+    V.fill(-1);
+    V[MAX + 1] = 0; // V[1] = 0
+    // Store each step's V snapshot for backtracking
+    const trace = [];
+    let found = false;
+    for (let d = 0; d <= MAX; d++) {
+        // Save current V before mutation
+        trace.push(V.slice());
+        for (let k = -d; k <= d; k += 2) {
+            const kIdx = k + MAX;
+            let x;
+            if (k === -d || (k !== d && V[kIdx - 1] < V[kIdx + 1])) {
+                x = V[kIdx + 1]; // move down
             }
-            // Look ahead in old array
-            for (let i = oldIdx + 1; i < Math.min(oldIdx + 10, old.length); i++) {
-                if (old[i] === newArr[newIdx]) {
-                    foundOld = i;
-                    break;
-                }
+            else {
+                x = V[kIdx - 1] + 1; // move right
             }
-            if (foundNew !== -1 && (foundOld === -1 || foundNew - newIdx < foundOld - oldIdx)) {
-                newIdx = foundNew;
+            let y = x - k;
+            // Follow diagonal (matching lines)
+            while (x < N && y < M && oldArr[x] === newArr[y]) {
+                x++;
+                y++;
             }
-            else if (foundOld !== -1) {
-                oldIdx = foundOld;
+            V[kIdx] = x;
+            if (x >= N && y >= M) {
+                found = true;
+                break;
+            }
+        }
+        if (found)
+            break;
+    }
+    // Backtrack through trace to recover the edit path
+    let x = N;
+    let y = M;
+    const edits = [];
+    for (let d = trace.length - 1; d >= 0; d--) {
+        const Vd = trace[d];
+        const k = x - y;
+        const kIdx = k + MAX;
+        let prevK;
+        if (k === -d || (k !== d && Vd[kIdx - 1] < Vd[kIdx + 1])) {
+            prevK = k + 1; // came from above (insertion)
+        }
+        else {
+            prevK = k - 1; // came from left (deletion)
+        }
+        const prevX = Vd[prevK + MAX];
+        const prevY = prevX - prevK;
+        // Record diagonal moves (matches) between prevX,prevY and x,y
+        edits.push({ prevX, prevY, x, y });
+        x = prevX;
+        y = prevY;
+    }
+    edits.reverse();
+    // Extract matched pairs from the diagonal segments
+    const result = [];
+    for (const edit of edits) {
+        // The diagonal portion: from (edit.prevX, edit.prevY) moving diagonally to where the non-diagonal step leads to (edit.x, edit.y)
+        // The non-diagonal step comes first, then diagonal. So diagonal is from (startX, startY) to (edit.x, edit.y)
+        // where startX/startY is one step from prevX/prevY.
+        let sx = edit.prevX;
+        let sy = edit.prevY;
+        // The non-diagonal step
+        if (sx < edit.x && sy < edit.y) {
+            // Both moved — this is diagonal only if lines match
+            // Actually in Myers, the non-diagonal step is exactly 1 move (right or down)
+            // followed by diagonal matches. Let's just skip non-diagonal and collect diagonals.
+        }
+        // Determine the start of diagonal: prevX,prevY + one step
+        const k = edit.x - edit.y;
+        const prevK = edit.prevX - edit.prevY;
+        if (prevK !== k) {
+            // There was a non-diagonal step
+            if (k === prevK + 1) {
+                // Moved right (deletion in old)
+                sx = edit.prevX + 1;
+                sy = edit.prevY;
             }
             else {
-                oldIdx++;
-                newIdx++;
+                // Moved down (insertion in new)
+                sx = edit.prevX;
+                sy = edit.prevY + 1;
             }
         }
+        // Collect diagonal matches
+        while (sx < edit.x && sy < edit.y) {
+            result.push([sx, sy]);
+            sx++;
+            sy++;
+        }
     }
-    // Add end markers
-    result.push([old.length, newArr.length]);
+    // Sentinel
+    result.push([N, M]);
     return result;
 }
 /**

package/dist/utils/gitignore.d.ts

@@ -0,0 +1,24 @@
+/**
+ * .gitignore parser — loads ignore patterns and tests file paths against them.
+ */
+export interface IgnoreRules {
+    patterns: IgnorePattern[];
+    projectRoot: string;
+}
+interface IgnorePattern {
+    regex: RegExp;
+    negated: boolean;
+}
+/**
+ * Load .gitignore rules from a project root.
+ * Falls back to built-in ignores if no .gitignore exists.
+ */
+export declare function loadIgnoreRules(projectRoot: string): IgnoreRules;
+/**
+ * Test whether a file path should be ignored.
+ * @param filePath Absolute or relative path
+ * @param rules Loaded ignore rules
+ * @returns true if the path should be ignored
+ */
+export declare function isIgnored(filePath: string, rules: IgnoreRules): boolean;
+export {};

package/dist/utils/gitignore.js

@@ -0,0 +1,161 @@
+/**
+ * .gitignore parser — loads ignore patterns and tests file paths against them.
+ */
+import { existsSync, readFileSync } from 'fs';
+import { join, relative, sep } from 'path';
+/**
+ * Always-ignored directories (even without a .gitignore)
+ */
+const BUILTIN_IGNORES = [
+    'node_modules',
+    '.git',
+    '.codeep',
+    'dist',
+    'build',
+    '.next',
+    '__pycache__',
+    '.venv',
+    'venv',
+    '.tox',
+    '.mypy_cache',
+    'coverage',
+    '.cache',
+    '.turbo',
+    '.parcel-cache',
+    'target', // Rust, Java/Maven
+    'out',
+    '.output',
+];
+/**
+ * Load .gitignore rules from a project root.
+ * Falls back to built-in ignores if no .gitignore exists.
+ */
+export function loadIgnoreRules(projectRoot) {
+    const patterns = [];
+    // Built-in ignores always apply
+    for (const dir of BUILTIN_IGNORES) {
+        patterns.push({ regex: new RegExp(`(^|/)${escapeRegex(dir)}(/|$)`), negated: false });
+    }
+    // Parse .gitignore if it exists
+    const gitignorePath = join(projectRoot, '.gitignore');
+    if (existsSync(gitignorePath)) {
+        try {
+            const content = readFileSync(gitignorePath, 'utf-8');
+            const parsed = parseGitignore(content);
+            patterns.push(...parsed);
+        }
+        catch {
+            // Ignore read errors
+        }
+    }
+    return { patterns, projectRoot };
+}
+/**
+ * Test whether a file path should be ignored.
+ * @param filePath Absolute or relative path
+ * @param rules Loaded ignore rules
+ * @returns true if the path should be ignored
+ */
+export function isIgnored(filePath, rules) {
+    // Normalize to forward-slash relative path
+    let rel = filePath;
+    if (filePath.startsWith(rules.projectRoot)) {
+        rel = relative(rules.projectRoot, filePath);
+    }
+    rel = rel.split(sep).join('/');
+    // Empty path is never ignored
+    if (!rel)
+        return false;
+    let ignored = false;
+    for (const pattern of rules.patterns) {
+        if (pattern.regex.test(rel)) {
+            ignored = !pattern.negated;
+        }
+    }
+    return ignored;
+}
+/**
+ * Parse .gitignore content into patterns.
+ */
+function parseGitignore(content) {
+    const patterns = [];
+    for (let line of content.split('\n')) {
+        // Strip trailing whitespace (but not leading — significant in gitignore)
+        line = line.replace(/\s+$/, '');
+        // Skip empty lines and comments
+        if (!line || line.startsWith('#'))
+            continue;
+        let negated = false;
+        if (line.startsWith('!')) {
+            negated = true;
+            line = line.slice(1);
+        }
+        // Remove leading slash (anchored to root)
+        const anchored = line.startsWith('/');
+        if (anchored) {
+            line = line.slice(1);
+        }
+        // Remove trailing slash (directory-only marker — we don't distinguish)
+        if (line.endsWith('/')) {
+            line = line.slice(0, -1);
+        }
+        // Convert glob pattern to regex
+        const regex = globToRegex(line, anchored);
+        patterns.push({ regex, negated });
+    }
+    return patterns;
+}
+/**
+ * Convert a gitignore glob pattern to a RegExp.
+ */
+function globToRegex(pattern, anchored) {
+    let re = '';
+    for (let i = 0; i < pattern.length; i++) {
+        const c = pattern[i];
+        if (c === '*') {
+            if (pattern[i + 1] === '*') {
+                // ** matches everything including /
+                if (pattern[i + 2] === '/') {
+                    re += '(?:.*/)?';
+                    i += 2;
+                }
+                else {
+                    re += '.*';
+                    i += 1;
+                }
+            }
+            else {
+                // * matches everything except /
+                re += '[^/]*';
+            }
+        }
+        else if (c === '?') {
+            re += '[^/]';
+        }
+        else if (c === '[') {
+            // Character class — pass through until ]
+            const end = pattern.indexOf(']', i + 1);
+            if (end !== -1) {
+                re += pattern.slice(i, end + 1);
+                i = end;
+            }
+            else {
+                re += escapeRegex(c);
+            }
+        }
+        else {
+            re += escapeRegex(c);
+        }
+    }
+    if (anchored) {
+        return new RegExp(`^${re}(/|$)`);
+    }
+    // Unanchored patterns match anywhere in the path
+    return new RegExp(`(^|/)${re}(/|$)`);
+}
+/**
+ * Escape special regex characters.
+ */
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/utils/gitignore.test.d.ts

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

package/dist/utils/gitignore.test.js

@@ -0,0 +1,167 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+// Mock fs
+vi.mock('fs', () => ({
+    existsSync: vi.fn(),
+    readFileSync: vi.fn(),
+}));
+import { existsSync, readFileSync } from 'fs';
+import { loadIgnoreRules, isIgnored } from './gitignore.js';
+const mockExistsSync = existsSync;
+const mockReadFileSync = readFileSync;
+beforeEach(() => {
+    vi.clearAllMocks();
+});
+describe('loadIgnoreRules', () => {
+    it('returns built-in ignores when no .gitignore exists', () => {
+        mockExistsSync.mockReturnValue(false);
+        const rules = loadIgnoreRules('/project');
+        expect(rules.projectRoot).toBe('/project');
+        expect(rules.patterns.length).toBeGreaterThan(0);
+        // node_modules should be a built-in
+        expect(isIgnored('node_modules/foo.js', rules)).toBe(true);
+    });
+    it('loads .gitignore when it exists', () => {
+        mockExistsSync.mockReturnValue(true);
+        mockReadFileSync.mockReturnValue('*.log\ntmp/\n');
+        const rules = loadIgnoreRules('/project');
+        expect(isIgnored('error.log', rules)).toBe(true);
+        expect(isIgnored('tmp/cache', rules)).toBe(true);
+    });
+    it('handles read errors gracefully', () => {
+        mockExistsSync.mockReturnValue(true);
+        mockReadFileSync.mockImplementation(() => { throw new Error('EACCES'); });
+        const rules = loadIgnoreRules('/project');
+        // Should still have built-in ignores
+        expect(rules.patterns.length).toBeGreaterThan(0);
+    });
+});
+describe('isIgnored — built-in ignores', () => {
+    let rules;
+    beforeEach(() => {
+        mockExistsSync.mockReturnValue(false);
+        rules = loadIgnoreRules('/project');
+    });
+    it('ignores node_modules', () => {
+        expect(isIgnored('node_modules/package/index.js', rules)).toBe(true);
+        expect(isIgnored('/project/node_modules', rules)).toBe(true);
+    });
+    it('ignores .git', () => {
+        expect(isIgnored('.git/config', rules)).toBe(true);
+    });
+    it('ignores .codeep', () => {
+        expect(isIgnored('.codeep/state.json', rules)).toBe(true);
+    });
+    it('ignores dist and build', () => {
+        expect(isIgnored('dist/bundle.js', rules)).toBe(true);
+        expect(isIgnored('build/output.js', rules)).toBe(true);
+    });
+    it('ignores __pycache__', () => {
+        expect(isIgnored('src/__pycache__/module.pyc', rules)).toBe(true);
+    });
+    it('ignores .next', () => {
+        expect(isIgnored('.next/static/chunks/main.js', rules)).toBe(true);
+    });
+    it('ignores coverage', () => {
+        expect(isIgnored('coverage/lcov.info', rules)).toBe(true);
+    });
+    it('does not ignore regular source files', () => {
+        expect(isIgnored('src/index.ts', rules)).toBe(false);
+        expect(isIgnored('package.json', rules)).toBe(false);
+        expect(isIgnored('README.md', rules)).toBe(false);
+    });
+    it('does not ignore files that contain ignore names as substrings', () => {
+        expect(isIgnored('src/builder.ts', rules)).toBe(false);
+        expect(isIgnored('src/distribute.ts', rules)).toBe(false);
+    });
+});
+describe('isIgnored — .gitignore patterns', () => {
+    function rulesFrom(gitignore) {
+        mockExistsSync.mockReturnValue(true);
+        mockReadFileSync.mockReturnValue(gitignore);
+        return loadIgnoreRules('/project');
+    }
+    it('matches simple file patterns', () => {
+        const rules = rulesFrom('*.log');
+        expect(isIgnored('error.log', rules)).toBe(true);
+        expect(isIgnored('logs/debug.log', rules)).toBe(true);
+        expect(isIgnored('error.txt', rules)).toBe(false);
+    });
+    it('matches directory patterns', () => {
+        const rules = rulesFrom('tmp/');
+        expect(isIgnored('tmp/file.txt', rules)).toBe(true);
+        expect(isIgnored('src/tmp/file.txt', rules)).toBe(true);
+    });
+    it('matches anchored patterns (leading /)', () => {
+        const rules = rulesFrom('/config.local');
+        expect(isIgnored('config.local', rules)).toBe(true);
+        expect(isIgnored('sub/config.local', rules)).toBe(false);
+    });
+    it('matches ** glob patterns', () => {
+        const rules = rulesFrom('docs/**/*.md');
+        expect(isIgnored('docs/readme.md', rules)).toBe(true);
+        expect(isIgnored('docs/guides/setup.md', rules)).toBe(true);
+        expect(isIgnored('src/readme.md', rules)).toBe(false);
+    });
+    it('matches ? single char wildcard', () => {
+        const rules = rulesFrom('file?.txt');
+        expect(isIgnored('file1.txt', rules)).toBe(true);
+        expect(isIgnored('fileA.txt', rules)).toBe(true);
+        expect(isIgnored('file10.txt', rules)).toBe(false);
+    });
+    it('matches character classes [...]', () => {
+        const rules = rulesFrom('file[0-9].txt');
+        expect(isIgnored('file5.txt', rules)).toBe(true);
+        expect(isIgnored('fileA.txt', rules)).toBe(false);
+    });
+    it('handles negation patterns', () => {
+        const rules = rulesFrom('*.log\n!important.log');
+        expect(isIgnored('error.log', rules)).toBe(true);
+        expect(isIgnored('important.log', rules)).toBe(false);
+    });
+    it('skips comments and empty lines', () => {
+        const rules = rulesFrom('# this is a comment\n\n*.tmp');
+        expect(isIgnored('file.tmp', rules)).toBe(true);
+        expect(isIgnored('# this is a comment', rules)).toBe(false);
+    });
+    it('handles .env files', () => {
+        const rules = rulesFrom('.env\n.env.local\n.env.*.local');
+        expect(isIgnored('.env', rules)).toBe(true);
+        expect(isIgnored('.env.local', rules)).toBe(true);
+        expect(isIgnored('.env.production.local', rules)).toBe(true);
+        expect(isIgnored('.env.example', rules)).toBe(false);
+    });
+    it('handles complex real-world .gitignore', () => {
+        const rules = rulesFrom([
+            'node_modules/',
+            '*.log',
+            '.env',
+            '/dist',
+            '!dist/keep.txt',
+            '**/*.map',
+        ].join('\n'));
+        expect(isIgnored('app.log', rules)).toBe(true);
+        expect(isIgnored('.env', rules)).toBe(true);
+        expect(isIgnored('dist/bundle.js', rules)).toBe(true);
+        expect(isIgnored('src/utils/helper.js.map', rules)).toBe(true);
+        expect(isIgnored('src/index.ts', rules)).toBe(false);
+    });
+});
+describe('isIgnored — path normalization', () => {
+    let rules;
+    beforeEach(() => {
+        mockExistsSync.mockReturnValue(true);
+        mockReadFileSync.mockReturnValue('*.log');
+        rules = loadIgnoreRules('/project');
+    });
+    it('handles absolute paths under project root', () => {
+        expect(isIgnored('/project/error.log', rules)).toBe(true);
+        expect(isIgnored('/project/src/debug.log', rules)).toBe(true);
+    });
+    it('handles relative paths', () => {
+        expect(isIgnored('error.log', rules)).toBe(true);
+        expect(isIgnored('src/debug.log', rules)).toBe(true);
+    });
+    it('returns false for empty path', () => {
+        expect(isIgnored('', rules)).toBe(false);
+    });
+});

package/dist/utils/skills.d.ts

@@ -82,6 +82,27 @@ export declare function generateSkillPrompt(skill: Skill, context: ProjectContex
  * Get skill steps that need execution
  */
 export declare function getExecutableSteps(skill: Skill): SkillStep[];
+/**
+ * Skill execution callbacks
+ */
+export interface SkillExecutionCallbacks {
+    /** Run a shell command, return stdout */
+    onCommand: (cmd: string) => Promise<string>;
+    /** Send a prompt to AI chat, return AI response */
+    onPrompt: (prompt: string) => Promise<string>;
+    /** Run an agent task autonomously */
+    onAgent: (task: string) => Promise<string>;
+    /** Show confirmation dialog, return true if user confirms */
+    onConfirm: (message: string) => Promise<boolean>;
+    /** Show a notification to the user */
+    onNotify: (message: string) => void;
+}
+/**
+ * Execute a skill's steps sequentially.
+ * Each step's output is available as ${_prev} in the next step's content.
+ * Returns the collected results from all steps.
+ */
+export declare function executeSkill(skill: Skill, params: Record<string, string>, callbacks: SkillExecutionCallbacks): Promise<SkillExecutionResult>;
 /**
  * Format skills list for display
  */

package/dist/utils/skills.js

@@ -768,6 +768,57 @@ export function generateSkillPrompt(skill, context, additionalContext, params) {
 export function getExecutableSteps(skill) {
     return skill.steps.filter(s => s.type === 'command' || s.type === 'agent');
 }
+/**
+ * Execute a skill's steps sequentially.
+ * Each step's output is available as ${_prev} in the next step's content.
+ * Returns the collected results from all steps.
+ */
+export async function executeSkill(skill, params, callbacks) {
+    const stepResults = [];
+    let lastOutput = '';
+    for (const step of skill.steps) {
+        // Interpolate params and ${_prev} into step content
+        const allParams = { ...params, _prev: lastOutput };
+        const content = interpolateParams(step.content, allParams);
+        try {
+            let result = '';
+            switch (step.type) {
+                case 'command':
+                    result = await callbacks.onCommand(content);
+                    break;
+                case 'prompt':
+                    result = await callbacks.onPrompt(content);
+                    break;
+                case 'agent':
+                    result = await callbacks.onAgent(content);
+                    break;
+                case 'confirm': {
+                    const confirmed = await callbacks.onConfirm(content);
+                    if (!confirmed) {
+                        stepResults.push({ step, result: 'cancelled', success: false });
+                        return { success: false, output: 'Cancelled by user', steps: stepResults };
+                    }
+                    result = 'confirmed';
+                    break;
+                }
+                case 'notify':
+                    callbacks.onNotify(content);
+                    result = 'notified';
+                    break;
+            }
+            lastOutput = result;
+            stepResults.push({ step, result, success: true });
+        }
+        catch (err) {
+            const errMsg = err.message || String(err);
+            stepResults.push({ step, result: errMsg, success: false });
+            if (!step.optional) {
+                return { success: false, output: errMsg, steps: stepResults };
+            }
+        }
+    }
+    return { success: true, output: lastOutput, steps: stepResults };
+}
 /**
  * Format skills list for display
  */

package/dist/utils/smartContext.js

@@ -3,6 +3,7 @@
  */
 import { existsSync, readFileSync, statSync } from 'fs';
 import { join, dirname, basename, extname, relative } from 'path';
+import { loadIgnoreRules, isIgnored } from './gitignore.js';
 // Max context size (characters)
 const MAX_CONTEXT_SIZE = 50000;
 const MAX_FILES = 15;
@@ -259,6 +260,7 @@ function findConfigFiles(projectRoot) {
  */
 export function gatherSmartContext(targetFile, projectContext, taskDescription) {
     const projectRoot = projectContext.root || process.cwd();
+    const ignoreRules = loadIgnoreRules(projectRoot);
     const allRelated = new Map();
     // If we have a target file, analyze it
     if (targetFile) {
@@ -329,6 +331,12 @@ export function gatherSmartContext(targetFile, projectContext, taskDescription)
             }
         }
     }
+    // Filter out ignored files (except the target file itself)
+    for (const [key, file] of allRelated) {
+        if (file.reason !== 'target file' && isIgnored(file.path, ignoreRules)) {
+            allRelated.delete(key);
+        }
+    }
     // Sort by priority and limit
     let files = Array.from(allRelated.values())
         .sort((a, b) => b.priority - a.priority)

package/dist/utils/smartContext.test.d.ts

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