skrypt-ai 0.4.1 → 0.5.0

package/dist/scanner/index.js

@@ -1,5 +1,5 @@
 import { readdir, stat } from 'fs/promises';
-import { join, extname, parse as parsePath } from 'path';
+import { join, parse as parsePath } from 'path';
 import { PythonScanner } from './python.js';
 import { TypeScriptScanner } from './typescript.js';
 import { GoScanner } from './go.js';
@@ -24,25 +24,30 @@ function getScannerForFile(filePath) {
     }
     return null;
 }
+/**
+ * Convert a glob pattern to a RegExp for proper matching.
+ * Supports: ** (any path), * (any segment), ? (any char)
+ */
+function globToRegex(pattern) {
+    // Normalize separators
+    let re = pattern.replace(/\\/g, '/');
+    // Escape regex special chars except * and ?
+    re = re.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+    // Convert glob tokens to regex
+    re = re.replace(/\*\*/g, '\0GLOBSTAR\0');
+    re = re.replace(/\*/g, '[^/]*');
+    re = re.replace(/\?/g, '[^/]');
+    re = re.replace(/\0GLOBSTAR\0/g, '.*');
+    return new RegExp(`(^|/)${re}($|/)`);
+}
 /**
  * Check if a path should be excluded based on patterns
  */
 function shouldExclude(filePath, excludePatterns) {
+    const normalized = filePath.replace(/\\/g, '/');
     for (const pattern of excludePatterns) {
-        // Simple glob matching for common patterns
-        if (pattern.includes('**')) {
-            const parts = pattern.split('**');
-            if (parts.length === 2) {
-                const [prefix, suffix] = parts;
-                const prefixMatch = !prefix || filePath.includes(prefix.replace(/^\//, '').replace(/\/$/, ''));
-                const suffixMatch = !suffix || filePath.includes(suffix.replace(/^\//, '').replace(/\/$/, ''));
-                if (prefixMatch && suffixMatch)
-                    return true;
-            }
-        }
-        else if (filePath.includes(pattern.replace(/\*/g, ''))) {
+        if (globToRegex(pattern).test(normalized))
             return true;
-        }
     }
     return false;
 }
@@ -52,31 +57,39 @@ function shouldExclude(filePath, excludePatterns) {
 function shouldInclude(filePath, includePatterns) {
     if (includePatterns.length === 0)
         return true;
-    const ext = extname(filePath);
+    const normalized = filePath.replace(/\\/g, '/');
     for (const pattern of includePatterns) {
-        // Match extension patterns like **/*.py
-        if (pattern.includes('*')) {
-            const extPattern = pattern.split('*').pop() || '';
-            if (ext === extPattern)
-                return true;
-        }
+        if (globToRegex(pattern).test(normalized))
+            return true;
     }
     return false;
 }
+const MAX_SCAN_DEPTH = 30;
+const MAX_SCAN_FILES = 10000;
 /**
  * Recursively find all files in a directory
  */
 async function findFiles(dir, include, exclude) {
     const files = [];
-    async function walk(currentDir) {
+    async function walk(currentDir, depth) {
+        if (depth > MAX_SCAN_DEPTH)
+            return;
+        if (files.length >= MAX_SCAN_FILES)
+            return;
         const entries = await readdir(currentDir, { withFileTypes: true });
         for (const entry of entries) {
+            if (files.length >= MAX_SCAN_FILES)
+                return;
             const fullPath = join(currentDir, entry.name);
             if (shouldExclude(fullPath, exclude)) {
                 continue;
             }
+            // Skip symlinks to prevent infinite loops and path escape
+            if (entry.isSymbolicLink()) {
+                continue;
+            }
             if (entry.isDirectory()) {
-                await walk(fullPath);
+                await walk(fullPath, depth + 1);
             }
             else if (entry.isFile()) {
                 if (shouldInclude(fullPath, include) && getScannerForFile(fullPath)) {
@@ -85,7 +98,7 @@ async function findFiles(dir, include, exclude) {
             }
         }
     }
-    await walk(dir);
+    await walk(dir, 0);
     return files;
 }
 /**

package/dist/scanner/python.js

@@ -15,6 +15,12 @@ export class PythonScanner {
             });
             let stdout = '';
             let stderr = '';
+            let killed = false;
+            // Kill the process after 30 seconds to prevent hangs
+            const timeout = setTimeout(() => {
+                killed = true;
+                proc.kill('SIGKILL');
+            }, 30000);
             proc.stdout.on('data', (data) => {
                 stdout += data.toString();
             });
@@ -22,6 +28,16 @@ export class PythonScanner {
                 stderr += data.toString();
             });
             proc.on('close', (code) => {
+                clearTimeout(timeout);
+                if (killed) {
+                    resolve({
+                        filePath,
+                        language: 'python',
+                        elements: [],
+                        errors: [`Python parser timed out after 30s: ${filePath}`]
+                    });
+                    return;
+                }
                 if (code !== 0 || stderr) {
                     resolve({
                         filePath,
@@ -45,6 +61,7 @@ export class PythonScanner {
                 }
             });
             proc.on('error', (err) => {
+                clearTimeout(timeout);
                 resolve({
                     filePath,
                     language: 'python',