flowseeker 0.1.7

package/dist/index/dependencyExtractor.js

@@ -0,0 +1,107 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractImports = extractImports;
+exports.normalizeImportSource = normalizeImportSource;
+exports.fileMatchesImport = fileMatchesImport;
+const path = __importStar(require("path"));
+const importPatterns = [
+    /\bimport\s+(?:type\s+)?(?:[^'";]+\s+from\s+)?["']([^"']+)["']/g,
+    /\bexport\s+(?:type\s+)?[^'";]+\s+from\s+["']([^"']+)["']/g,
+    /\brequire\s*\(\s*["']([^"']+)["']\s*\)/g,
+    /\bfrom\s+([a-zA-Z0-9_.]+)\s+import\b/g,
+    /\bimport\s+([a-zA-Z0-9_.]+)\b/g,
+    /\binclude(?:_once)?\s*(?:\(\s*)?["']([^"']+)["']/g,
+    /\brequire(?:_once)?\s*(?:\(\s*)?["']([^"']+)["']/g,
+    /\buse\s+([A-Za-z0-9_\\]+)\s*;/g,
+    /#include\s+[<"]([^>"]+)[>"]/g
+];
+const maxImportScanLineLength = 8000;
+const importSignalPattern = /\b(import|export|require|include|include_once|require_once|from|use)\b|#include/;
+function extractImports(content) {
+    const imports = [];
+    const lines = content.split(/\r?\n/);
+    lines.forEach((line, index) => {
+        if (line.length > maxImportScanLineLength || !importSignalPattern.test(line)) {
+            return;
+        }
+        for (const pattern of importPatterns) {
+            pattern.lastIndex = 0;
+            let match = pattern.exec(line);
+            while (match?.[1]) {
+                imports.push({
+                    source: match[1],
+                    normalizedSource: normalizeImportSource(match[1]),
+                    line: index + 1
+                });
+                match = pattern.exec(line);
+            }
+        }
+    });
+    return dedupeImports(imports);
+}
+function normalizeImportSource(source) {
+    return source
+        .replace(/\\/g, "/")
+        .replace(/^@\//, "")
+        .replace(/^~\//, "")
+        .replace(/^\.\//, "")
+        .replace(/^\.\.\//, "")
+        .replace(/\.(ts|tsx|js|jsx|mjs|cjs|py|php|java|kt|go|cs|rb|rs|vue|svelte|json|yaml|yml|toml|sql)$/i, "")
+        .toLowerCase();
+}
+function fileMatchesImport(relativePath, importSource) {
+    const normalizedFile = relativePath.replace(/\\/g, "/").replace(/\.[^.]+$/, "").toLowerCase();
+    const normalizedImport = normalizeImportSource(importSource);
+    const basename = path.posix.basename(normalizedFile);
+    const importBase = path.posix.basename(normalizedImport);
+    return (normalizedFile.endsWith(normalizedImport) ||
+        normalizedFile.includes(`/${normalizedImport}/`) ||
+        normalizedImport.endsWith(basename) ||
+        (importBase.length > 2 && basename === importBase));
+}
+function dedupeImports(imports) {
+    const seen = new Set();
+    const result = [];
+    for (const item of imports) {
+        const key = `${item.normalizedSource}:${item.line}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            result.push(item);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=dependencyExtractor.js.map

package/dist/index/fileDiscovery.js

@@ -0,0 +1,177 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverWorkspaceFiles = discoverWorkspaceFiles;
+exports.matchesInclude = matchesInclude;
+exports.matchesExclude = matchesExclude;
+exports.matchesPattern = matchesPattern;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const text_1 = require("../utils/text");
+async function discoverWorkspaceFiles(rootPath, config, options) {
+    const files = [];
+    let stopReason;
+    const includeMatchers = compilePatterns(config.project.include);
+    const excludeMatchers = compilePatterns(config.project.exclude);
+    const directoryBatchSize = 8;
+    const queue = [path.resolve(rootPath)];
+    while (queue.length > 0 && !stopReason) {
+        const batch = queue.splice(0, directoryBatchSize);
+        const childDirectories = await Promise.all(batch.map((directoryPath) => visitDirectory(directoryPath)));
+        queue.push(...childDirectories.flat());
+    }
+    async function visitDirectory(directoryPath) {
+        if (stopReason) {
+            return [];
+        }
+        if (options.shouldCancel?.()) {
+            stopReason = "cancelled";
+            return [];
+        }
+        if (Date.now() - options.startedAt > config.pipeline.maxScanMs) {
+            stopReason = `maxScanMs ${config.pipeline.maxScanMs} reached during discovery`;
+            return [];
+        }
+        let entries;
+        try {
+            entries = await fs.readdir(directoryPath, { withFileTypes: true });
+        }
+        catch {
+            return [];
+        }
+        const childDirectories = [];
+        for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+            if (stopReason) {
+                return childDirectories;
+            }
+            const absolutePath = path.join(directoryPath, entry.name);
+            const relativePath = toRelativePath(rootPath, absolutePath);
+            if (entry.isDirectory()) {
+                if (!matchesCompiled(relativePath, excludeMatchers, false)) {
+                    childDirectories.push(absolutePath);
+                }
+                continue;
+            }
+            if (!entry.isFile()) {
+                continue;
+            }
+            if (matchesCompiled(relativePath, includeMatchers, true) && !matchesCompiled(relativePath, excludeMatchers, false)) {
+                files.push({ absolutePath, relativePath });
+                if (files.length >= config.pipeline.maxFiles) {
+                    stopReason = `maxFiles ${config.pipeline.maxFiles} reached during discovery`;
+                    return childDirectories;
+                }
+            }
+        }
+        return childDirectories;
+    }
+    return { files, stopReason };
+}
+function matchesInclude(relativePath, includePatterns) {
+    if (includePatterns.length === 0) {
+        return true;
+    }
+    return includePatterns.some((pattern) => matchesPattern(relativePath, pattern, true));
+}
+function matchesExclude(relativePath, excludePatterns) {
+    return excludePatterns.some((pattern) => matchesPattern(relativePath, pattern, false));
+}
+function matchesPattern(relativePath, pattern, includeMode) {
+    const matcher = compilePattern(pattern);
+    if (!matcher.normalized || matcher.normalized === "**/*") {
+        return includeMode;
+    }
+    return matchesCompiledPattern(normalizePath(relativePath), matcher);
+}
+function compilePatterns(patterns) {
+    return patterns.map(compilePattern);
+}
+function compilePattern(pattern) {
+    const normalized = normalizePattern(pattern);
+    const hasMagic = (0, text_1.hasGlobMagic)(normalized);
+    const looksLikeFile = looksLikeFilePattern(normalized);
+    return {
+        normalized,
+        hasMagic,
+        looksLikeFile,
+        regex: hasMagic ? globToRegExp(normalized) : undefined,
+        directoryRegex: hasMagic && !looksLikeFile ? globToRegExp(`${normalized}/**`) : undefined
+    };
+}
+function matchesCompiled(relativePath, matchers, includeMode) {
+    if (matchers.length === 0) {
+        return includeMode;
+    }
+    const normalizedPath = normalizePath(relativePath);
+    return matchers.some((matcher) => {
+        if (!matcher.normalized || matcher.normalized === "**/*") {
+            return includeMode;
+        }
+        return matchesCompiledPattern(normalizedPath, matcher);
+    });
+}
+function matchesCompiledPattern(normalizedPath, matcher) {
+    if (!matcher.hasMagic) {
+        return (normalizedPath === matcher.normalized ||
+            normalizedPath.startsWith(`${matcher.normalized}/`) ||
+            normalizedPath.includes(`/${matcher.normalized}/`) ||
+            normalizedPath.endsWith(`/${matcher.normalized}`));
+    }
+    return Boolean(matcher.regex?.test(normalizedPath) || matcher.directoryRegex?.test(normalizedPath));
+}
+function globToRegExp(pattern) {
+    const marker = "\u0000";
+    const escaped = pattern
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*\*/g, marker)
+        .replace(/\*/g, "[^/]*")
+        .replace(new RegExp(marker, "g"), ".*")
+        .replace(/\?/g, ".");
+    return new RegExp(`^${escaped}$`);
+}
+function normalizePattern(pattern) {
+    return normalizePath(pattern).replace(/^\.\//, "").replace(/\/$/, "");
+}
+function looksLikeFilePattern(pattern) {
+    const basename = pattern.split("/").at(-1) ?? pattern;
+    return basename.includes(".");
+}
+function normalizePath(filePath) {
+    return (0, text_1.normalizeText)(filePath).replace(/\\/g, "/").replace(/^\/+/, "");
+}
+function toRelativePath(rootPath, absolutePath) {
+    return path.relative(path.resolve(rootPath), absolutePath).replace(/\\/g, "/");
+}
+//# sourceMappingURL=fileDiscovery.js.map

package/dist/index/structuredExtractor.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectLanguage = detectLanguage;
+exports.extractStructuredNodes = extractStructuredNodes;
+exports.getDeclarationSnippet = getDeclarationSnippet;
+const maxStructuredLineChars = 12000;
+const languagePatterns = {
+    typescript: {
+        extensions: [".ts", ".tsx"],
+        declaration: /^\s*(?:export\s+)?(?:async\s+)?(?:function|class|interface|type|enum|const)\s+(\w+)/gm,
+        call: /(\w+(?:\.\w+)*)\s*\(/g,
+        stringLiteral: /(["'`])((?:\\.|(?!\1).)*?)\1/g,
+        comment: /\/\*\*[\s\S]*?\*\/|\/\/.*$/gm,
+        annotation: /@\w+/g
+    },
+    javascript: {
+        extensions: [".js", ".jsx", ".mjs", ".cjs"],
+        declaration: /^\s*(?:export\s+)?(?:async\s+)?(?:function|class)\s+(\w+)/gm,
+        call: /(\w+(?:\.\w+)*)\s*\(/g,
+        stringLiteral: /(["'`])((?:\\.|(?!\1).)*?)\1/g,
+        comment: /\/\*\*[\s\S]*?\*\/|\/\/.*$/gm,
+        annotation: /@\w+/g
+    },
+    python: {
+        extensions: [".py"],
+        declaration: /^\s*(?:async\s+)?(?:def|class)\s+(\w+)/gm,
+        call: /(\w+(?:\.\w+)*)\s*\(/g,
+        stringLiteral: /(["'])((?:\\.|(?!\1).)*?)\1/g,
+        comment: /#.*$/gm,
+        annotation: /@\w+/g
+    },
+    php: {
+        extensions: [".php"],
+        declaration: /^\s*(?:(?:public|private|protected|static)\s+)*function\s+(\w+)/gm,
+        call: /(\w+(?:->\w+)*(?:::w+)*)\s*\(/g,
+        stringLiteral: /(["'])((?:\\.|(?!\1).)*?)\1/g,
+        comment: /\/\*\*[\s\S]*?\*\/|\/\/.*$|#.*$/gm,
+        annotation: /#\[[\s\S]*?\]|@\w+/g
+    },
+    java: {
+        extensions: [".java"],
+        declaration: /^\s*(?:(?:public|private|protected|static|final|abstract)\s+)*(?:class|interface|enum)\s+(\w+)/gm,
+        call: /(\w+(?:\.\w+)*)\s*\(/g,
+        stringLiteral: /"((?:\\.|[^"\\])*)"/g,
+        comment: /\/\*\*[\s\S]*?\*\/|\/\/.*$/gm,
+        annotation: /@\w+(?:\([^)]*\))?/g
+    },
+    go: {
+        extensions: [".go"],
+        declaration: /^\s*func\s+(?:\(\w+\s+\*?\w+\)\s+)?(\w+)/gm,
+        call: /(\w+(?:\.\w+)*)\s*\(/g,
+        stringLiteral: /"((?:\\.|[^"\\])*)"|`[^`]*`/g,
+        comment: /\/\/.*$/gm,
+        annotation: /\/\/\s*@\w+/g
+    },
+    csharp: {
+        extensions: [".cs"],
+        declaration: /^\s*(?:(?:public|private|protected|internal|static|virtual|override|abstract|sealed)\s+)*(?:class|interface|struct|enum|record)\s+(\w+)/gm,
+        call: /(\w+(?:\.\w+)*)\s*\(/g,
+        stringLiteral: /"((?:\\.|[^"\\])*)"|@"[^"]*"/g,
+        comment: /\/\*\*[\s\S]*?\*\/|\/\/.*$/gm,
+        annotation: /\[[\s\S]*?\]/g
+    },
+    ruby: {
+        extensions: [".rb"],
+        declaration: /^\s*def\s+(?:self\.)?(\w+)/gm,
+        call: /(\w+(?:\.\w+)*)\s*(?:\(|\s)/g,
+        stringLiteral: /(["'])((?:\\.|(?!\1).)*?)\1/g,
+        comment: /#.*$/gm,
+        annotation: /#\s*@\w+/g
+    },
+    rust: {
+        extensions: [".rs"],
+        declaration: /^\s*(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/gm,
+        call: /(\w+(?:::w+)*(?:\.\w+)*)\s*\(/g,
+        stringLiteral: /"((?:\\.|[^"\\])*)"/g,
+        comment: /\/\/.*$|\/\/!.*$/gm,
+        annotation: /#\[[\s\S]*?\]/g
+    },
+    kotlin: {
+        extensions: [".kt", ".kts"],
+        declaration: /^\s*(?:(?:private|protected|internal|public)\s+)?(?:suspend\s+)?fun\s+(\w+)/gm,
+        call: /(\w+(?:\.\w+)*)\s*\(/g,
+        stringLiteral: /"((?:\\.|[^"\\])*)"/g,
+        comment: /\/\*[\s\S]*?\*\/|\/\/.*$/gm,
+        annotation: /@\w+/g
+    }
+};
+function detectLanguage(filePath) {
+    const lower = filePath.toLowerCase();
+    for (const [language, patterns] of Object.entries(languagePatterns)) {
+        if (patterns.extensions.some((ext) => lower.endsWith(ext))) {
+            return language;
+        }
+    }
+    return undefined;
+}
+function extractStructuredNodes(content, language) {
+    const patterns = languagePatterns[language];
+    if (!patterns) {
+        return [];
+    }
+    const lines = content.split(/\r?\n/);
+    const nodes = [];
+    nodes.push(...extractDeclarations(lines, patterns.declaration, language));
+    nodes.push(...extractCalls(lines, patterns.call));
+    nodes.push(...extractStringLiterals(lines, patterns.stringLiteral));
+    nodes.push(...extractComments(lines, patterns.comment));
+    nodes.push(...extractAnnotations(lines, patterns.annotation));
+    return dedupeNodes(nodes);
+}
+function extractDeclarations(lines, pattern, language) {
+    const nodes = [];
+    lines.forEach((line, index) => {
+        if (line.length > maxStructuredLineChars) {
+            return;
+        }
+        pattern.lastIndex = 0;
+        let match = pattern.exec(line);
+        while (match) {
+            const name = match[1];
+            const isExported = /\bexport\b/.test(line) || /\bpub\b/.test(line) || /\bpublic\b/.test(line);
+            const nodeKind = isClassDecl(line, language) ? "declaration" : "declaration";
+            nodes.push({
+                kind: nodeKind,
+                name,
+                range: { startLine: index + 1, endLine: index + 1 },
+                text: line.trim(),
+                parent: isExported ? "exported" : undefined
+            });
+            match = pattern.exec(line);
+        }
+    });
+    return nodes;
+}
+function isClassDecl(line, language) {
+    const classKeywords = {
+        typescript: /\bclass\b/,
+        javascript: /\bclass\b/,
+        python: /\bclass\b/,
+        php: /\bclass\b/,
+        java: /\bclass\b/,
+        csharp: /\bclass\b/,
+        kotlin: /\bclass\b/
+    };
+    return classKeywords[language]?.test(line) ?? false;
+}
+function extractCalls(lines, pattern) {
+    const nodes = [];
+    const callNames = new Set();
+    lines.forEach((line, index) => {
+        if (line.length > maxStructuredLineChars) {
+            return;
+        }
+        pattern.lastIndex = 0;
+        let match = pattern.exec(line);
+        while (match) {
+            const name = match[1];
+            if (!callNames.has(name) && name.length > 1) {
+                callNames.add(name);
+                nodes.push({
+                    kind: "call",
+                    name,
+                    range: { startLine: index + 1, endLine: index + 1 },
+                    text: line.trim()
+                });
+            }
+            match = pattern.exec(line);
+        }
+    });
+    return nodes.slice(0, 100);
+}
+function extractStringLiterals(lines, pattern) {
+    const nodes = [];
+    lines.forEach((line, index) => {
+        if (line.length > maxStructuredLineChars) {
+            return;
+        }
+        pattern.lastIndex = 0;
+        let match = pattern.exec(line);
+        while (match) {
+            const text = match[2] ?? match[0];
+            if (text.length > 8 && text.length < 500) {
+                nodes.push({
+                    kind: "string_literal",
+                    name: text.slice(0, 60),
+                    range: { startLine: index + 1, endLine: index + 1 },
+                    text: line.trim()
+                });
+            }
+            match = pattern.exec(line);
+        }
+    });
+    return nodes.slice(0, 80);
+}
+function extractComments(lines, pattern) {
+    const nodes = [];
+    lines.forEach((line, index) => {
+        if (line.length > maxStructuredLineChars) {
+            return;
+        }
+        pattern.lastIndex = 0;
+        const match = pattern.exec(line);
+        if (match) {
+            const text = match[0].trim();
+            if (text.length > 10) {
+                nodes.push({
+                    kind: "comment",
+                    name: text.slice(0, 80),
+                    range: { startLine: index + 1, endLine: index + 1 },
+                    text: line.trim()
+                });
+            }
+        }
+    });
+    return nodes.slice(0, 60);
+}
+function extractAnnotations(lines, pattern) {
+    const nodes = [];
+    lines.forEach((line, index) => {
+        if (line.length > maxStructuredLineChars) {
+            return;
+        }
+        pattern.lastIndex = 0;
+        let match = pattern.exec(line);
+        while (match) {
+            nodes.push({
+                kind: "annotation",
+                name: match[0],
+                range: { startLine: index + 1, endLine: index + 1 },
+                text: line.trim()
+            });
+            match = pattern.exec(line);
+        }
+    });
+    return nodes.slice(0, 40);
+}
+function dedupeNodes(nodes) {
+    const seen = new Set();
+    const result = [];
+    for (const node of nodes) {
+        const key = `${node.kind}:${node.range.startLine}:${node.name ?? ""}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            result.push(node);
+        }
+    }
+    return result;
+}
+function getDeclarationSnippet(content, node, contextLines = 5) {
+    const lines = content.split(/\r?\n/);
+    const start = Math.max(0, node.range.startLine - 1 - contextLines);
+    const end = Math.min(lines.length, node.range.endLine + contextLines);
+    return lines.slice(start, end).join("\n");
+}
+//# sourceMappingURL=structuredExtractor.js.map