flowseeker 0.1.7 → 0.1.8

package/dist/index/graphIndex.js

@@ -0,0 +1,460 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandIndexedGraph = expandIndexedGraph;
+exports.buildIndexedGraph = buildIndexedGraph;
+exports.getEdgesFrom = getEdgesFrom;
+exports.getEdgesTo = getEdgesTo;
+exports.getEdgesByKind = getEdgesByKind;
+exports.getNodesByPath = getNodesByPath;
+exports.getNodeById = getNodeById;
+exports.dedupeGraphEdges = dedupeGraphEdges;
+exports.extractGraphFromIndex = extractGraphFromIndex;
+function expandIndexedGraph(index, seedPaths, options = {}) {
+    const lookup = buildGraphLookup(index);
+    const maxDepth = options.maxDepth ?? 2;
+    const maxEdgesPerSeed = options.maxEdgesPerSeed ?? 12;
+    const maxAddedFiles = options.maxAddedFiles ?? 25;
+    const maxPerEdgeType = options.maxPerEdgeType ?? 20;
+    const seen = new Set(seedPaths);
+    const edgeTypeCounts = new Map();
+    const queue = seedPaths.map((relativePath) => ({ relativePath, depth: 0 }));
+    const expanded = [];
+    while (queue.length > 0 && expanded.length < maxAddedFiles) {
+        const current = queue.shift();
+        if (!current || current.depth >= maxDepth) {
+            continue;
+        }
+        const edges = edgesForPath(current.relativePath, lookup).slice(0, maxEdgesPerSeed);
+        for (const edge of edges) {
+            if ((edgeTypeCounts.get(edge.type) ?? 0) >= maxPerEdgeType) {
+                continue;
+            }
+            const targets = targetFiles(edge, lookup);
+            for (const file of targets) {
+                if (seen.has(file.relativePath) || expanded.length >= maxAddedFiles) {
+                    continue;
+                }
+                seen.add(file.relativePath);
+                edgeTypeCounts.set(edge.type, (edgeTypeCounts.get(edge.type) ?? 0) + 1);
+                expanded.push({
+                    file,
+                    distance: current.depth + 1,
+                    viaEdge: edge,
+                    reason: `${edge.type} from ${edge.fromPath || current.relativePath}: ${edge.reason}`
+                });
+                queue.push({ relativePath: file.relativePath, depth: current.depth + 1 });
+            }
+        }
+    }
+    return expanded;
+}
+function buildGraphLookup(index) {
+    const byFromPath = new Map();
+    const byToPath = new Map();
+    const bySymbolOrCall = new Map();
+    const byPath = new Map(index.files.map((file) => [file.relativePath, file]));
+    for (const file of index.files) {
+        for (const edge of file.edges ?? []) {
+            addEdge(byFromPath, edge.fromPath, edge);
+            addEdge(byToPath, edge.toPath, edge);
+        }
+        for (const symbol of file.symbols ?? []) {
+            addFile(bySymbolOrCall, normalizeName(symbol.name), file);
+            addFile(bySymbolOrCall, normalizeName(symbol.fqn), file);
+        }
+    }
+    return { byFromPath, byToPath, bySymbolOrCall, byPath };
+}
+function edgesForPath(relativePath, lookup) {
+    return [...(lookup.byFromPath.get(relativePath) ?? []), ...(lookup.byToPath.get(relativePath) ?? [])];
+}
+function targetFiles(edge, lookup) {
+    const byDirectPath = [lookup.byPath.get(edge.toPath), lookup.byPath.get(edge.fromPath)].filter((file) => Boolean(file));
+    const bySymbol = lookup.bySymbolOrCall.get(normalizeName(edge.to)) ?? [];
+    return uniqueByPath([...byDirectPath, ...bySymbol]);
+}
+function addEdge(map, key, edge) {
+    if (!key) {
+        return;
+    }
+    map.set(key, [...(map.get(key) ?? []), edge]);
+}
+function addFile(map, key, file) {
+    if (!key) {
+        return;
+    }
+    map.set(key, [...(map.get(key) ?? []), file]);
+}
+function normalizeName(value) {
+    return value.toLowerCase().split(/\.|::|->/).filter(Boolean).pop() ?? value.toLowerCase();
+}
+function uniqueByPath(files) {
+    const seen = new Set();
+    return files.filter((file) => {
+        if (seen.has(file.relativePath)) {
+            return false;
+        }
+        seen.add(file.relativePath);
+        return true;
+    });
+}
+function norm(p) {
+    return (p || "").replace(/\\/g, "/");
+}
+function buildIndexedGraph(input) {
+    return {
+        nodes: input.nodes.map((n) => ({ ...n, relativePath: norm(n.relativePath) })),
+        edges: input.edges.map((e) => ({
+            ...e,
+            fromPath: norm(e.fromPath),
+            toPath: norm(e.toPath)
+        }))
+    };
+}
+function getEdgesFrom(index, nodeOrPath, options) {
+    const id = typeof nodeOrPath === "string" ? nodeOrPath : nodeOrPath.id;
+    const np = norm(typeof nodeOrPath === "string" ? nodeOrPath : nodeOrPath.relativePath);
+    let results = index.edges.filter((e) => e.fromId === id || norm(e.fromPath) === np);
+    if (options?.kind) {
+        results = results.filter((e) => e.kind === options.kind);
+    }
+    if (options?.maxResults !== undefined && results.length > options.maxResults) {
+        results = results.slice(0, options.maxResults);
+    }
+    return results;
+}
+function getEdgesTo(index, nodeOrPath, options) {
+    const id = typeof nodeOrPath === "string" ? nodeOrPath : nodeOrPath.id;
+    const np = norm(typeof nodeOrPath === "string" ? nodeOrPath : nodeOrPath.relativePath);
+    let results = index.edges.filter((e) => e.toId === id || norm(e.toPath) === np);
+    if (options?.kind) {
+        results = results.filter((e) => e.kind === options.kind);
+    }
+    if (options?.maxResults !== undefined && results.length > options.maxResults) {
+        results = results.slice(0, options.maxResults);
+    }
+    return results;
+}
+function getEdgesByKind(index, kind, options) {
+    let results = index.edges.filter((e) => e.kind === kind);
+    if (options?.maxResults !== undefined && results.length > options.maxResults) {
+        results = results.slice(0, options.maxResults);
+    }
+    return results;
+}
+function getNodesByPath(index, relativePath) {
+    const np = norm(relativePath);
+    return index.nodes.filter((n) => n.relativePath === np);
+}
+function getNodeById(index, id) {
+    return index.nodes.find((n) => n.id === id);
+}
+function structuralKey(e) {
+    return `${e.kind}|${e.fromId}|${e.toId}|${norm(e.fromPath)}|${norm(e.toPath)}`;
+}
+function dedupeGraphEdges(edges) {
+    const byId = new Map();
+    const byStructural = new Map();
+    for (const edge of edges) {
+        const sk = structuralKey(edge);
+        // Dedupe by stable id when present
+        if (edge.id) {
+            const existingById = byId.get(edge.id);
+            const existingBySk = byStructural.get(sk);
+            if (existingById || existingBySk) {
+                const best = pickHigherConfidence([existingById, existingBySk, edge].filter(Boolean));
+                byId.set(edge.id, best);
+                byStructural.set(sk, best);
+                continue;
+            }
+            byId.set(edge.id, edge);
+            byStructural.set(sk, edge);
+            continue;
+        }
+        // Dedupe by structural key when no id
+        const existing = byStructural.get(sk);
+        if (!existing || edge.confidence > existing.confidence) {
+            byStructural.set(sk, edge);
+        }
+    }
+    // Merge: collect unique edges from both maps, prefer higher confidence
+    const seen = new Map();
+    for (const e of [...byId.values(), ...byStructural.values()]) {
+        const sk = structuralKey(e);
+        const existing = seen.get(sk);
+        if (!existing || e.confidence > existing.confidence) {
+            seen.set(sk, e);
+        }
+    }
+    return Array.from(seen.values());
+}
+function pickHigherConfidence(edges) {
+    return edges.reduce((a, b) => (a.confidence >= b.confidence ? a : b));
+}
+const AMBIGUOUS_CALL_NAMES = new Set([
+    "handle", "index", "show", "create", "store", "update", "delete",
+    "destroy", "run", "execute", "dispatch", "complete", "process",
+    "render", "boot", "register"
+]);
+function isAmbiguousCallName(name) {
+    return AMBIGUOUS_CALL_NAMES.has(name.toLowerCase());
+}
+// Count how many files define a symbol with this name
+function countSymbolMatches(name, symbolIndex) {
+    return symbolIndex.get(name.toLowerCase())?.length ?? 0;
+}
+// Check if a call name resolves deterministically:
+// - only one matching symbol exists across the workspace
+// - OR the caller imports a file that contains exactly one matching symbol
+function isDeterministicCallTarget(callName, fromFile, symbolIndex) {
+    const matches = symbolIndex.get(callName.toLowerCase()) ?? [];
+    if (matches.length === 1)
+        return true;
+    // Check if any import resolves to a file with exactly one match
+    for (const imp of fromFile.imports) {
+        const impBase = imp.replace(/\\/g, "/").split("/").pop()?.replace(/\.[^.]+$/, "").toLowerCase() || "";
+        // Check each match — if a match's file basename matches the import basename
+        for (const m of matches) {
+            const matchBase = m.np.split("/").pop()?.replace(/\.[^.]+$/, "").toLowerCase() || "";
+            if (matchBase === impBase)
+                return true;
+        }
+    }
+    return false;
+}
+function extractGraphFromIndex(index) {
+    const stats = {
+        duplicatesRemoved: 0,
+        unresolvedImportsSkipped: 0,
+        unresolvedLocalImportsSkipped: 0,
+        packageImportsSkipped: 0,
+        emptyPathEdgesSkipped: 0,
+        selfEdgesSkipped: 0,
+        ambiguousCallsSkipped: 0,
+        unresolvedCallsSkipped: 0,
+        callsKept: 0,
+        callsSkippedByAmbiguousName: {}
+    };
+    const pathIndex = new Map();
+    for (const file of index.files) {
+        pathIndex.set(norm(file.relativePath), file);
+    }
+    // File nodes: one per indexed file
+    const nodes = [];
+    const nodeIds = new Set();
+    for (const file of index.files) {
+        const np = norm(file.relativePath);
+        const id = `file:${np}`;
+        if (nodeIds.has(id))
+            continue;
+        nodeIds.add(id);
+        nodes.push({
+            id,
+            kind: "file",
+            relativePath: np,
+            label: np.split("/").pop() || np
+        });
+    }
+    // Symbol nodes: for files with symbol data
+    const symbolIndex = new Map(); // normalized name → file lookup
+    for (const file of index.files) {
+        const np = norm(file.relativePath);
+        for (const sym of file.symbols) {
+            const sid = `symbol:${np}:${sym.name}`;
+            if (nodeIds.has(sid))
+                continue;
+            nodeIds.add(sid);
+            nodes.push({
+                id: sid,
+                kind: "symbol",
+                relativePath: np,
+                label: sym.name,
+                symbolFqn: sym.fqn || sym.name,
+                range: sym.line > 0 ? { startLine: sym.line, endLine: sym.endLine || sym.line } : undefined
+            });
+            const symName = sym.name ? sym.name.toLowerCase() : "";
+            if (symName) {
+                const list = symbolIndex.get(symName) ?? [];
+                list.push({ file, np });
+                symbolIndex.set(symName, list);
+            }
+        }
+    }
+    const edges = [];
+    let edgeCounter = 0;
+    for (const file of index.files) {
+        const fromNp = norm(file.relativePath);
+        const fromFileId = `file:${fromNp}`;
+        // Import edges
+        for (const imp of file.imports) {
+            if (!imp || imp.trim() === "") {
+                stats.emptyPathEdgesSkipped++;
+                continue;
+            }
+            const impNorm = imp.replace(/\\/g, "/");
+            // Distinguish package imports from unresolved local imports
+            const isPackage = !impNorm.startsWith(".") && !impNorm.startsWith("/");
+            const resolved = resolveImportPath(fromNp, imp, pathIndex);
+            if (!resolved) {
+                stats.unresolvedImportsSkipped++;
+                if (isPackage) {
+                    stats.packageImportsSkipped++;
+                }
+                else {
+                    stats.unresolvedLocalImportsSkipped++;
+                }
+                continue;
+            }
+            const toNp = norm(resolved);
+            // Skip self-edges for imports of the same file
+            if (toNp === fromNp) {
+                stats.selfEdgesSkipped++;
+                continue;
+            }
+            const toFileId = `file:${toNp}`;
+            edgeCounter++;
+            edges.push({
+                id: `import:${edgeCounter}:${fromNp}->${toNp}`,
+                kind: "import",
+                fromId: fromFileId,
+                toId: toFileId,
+                fromPath: fromNp,
+                toPath: toNp,
+                confidence: 0.85,
+                source: "import",
+                reason: `imports ${imp}`
+            });
+        }
+        // Call edges
+        for (const call of file.calls || []) {
+            if (!call || call.trim() === "") {
+                stats.emptyPathEdgesSkipped++;
+                continue;
+            }
+            const callName = call.toLowerCase();
+            const targets = symbolIndex.get(callName);
+            if (!targets || targets.length === 0) {
+                stats.unresolvedCallsSkipped++;
+                continue;
+            }
+            // Ambiguity guard: skip ambiguous call names unless deterministic
+            if (isAmbiguousCallName(callName)) {
+                if (!isDeterministicCallTarget(callName, file, symbolIndex)) {
+                    stats.ambiguousCallsSkipped++;
+                    stats.callsSkippedByAmbiguousName[callName] = (stats.callsSkippedByAmbiguousName[callName] ?? 0) + 1;
+                    continue;
+                }
+            }
+            // Use the first target (there should be exactly 1 for deterministic)
+            // For ambiguous names that passed the guard, prefer target from import
+            let target = targets[0];
+            if (isAmbiguousCallName(callName) && targets.length > 1) {
+                const impBase = new Set(file.imports.map(imp => imp.replace(/\\/g, "/").split("/").pop()?.replace(/\.[^.]+$/, "").toLowerCase() || ""));
+                const matching = targets.find(t => impBase.has(t.np.split("/").pop()?.replace(/\.[^.]+$/, "").toLowerCase() || ""));
+                if (matching)
+                    target = matching;
+            }
+            const toNp = norm(target.file.relativePath);
+            // Skip self-calls
+            if (toNp === fromNp) {
+                stats.selfEdgesSkipped++;
+                continue;
+            }
+            const fromSymbolId = file.symbols.length > 0
+                ? `symbol:${fromNp}:${file.symbols[0].name}`
+                : fromFileId;
+            const toSymbolId = `symbol:${toNp}:${call}`;
+            edgeCounter++;
+            edges.push({
+                id: `call:${edgeCounter}:${fromNp}->${toNp}`,
+                kind: "calls",
+                fromId: fromSymbolId,
+                toId: toSymbolId,
+                fromPath: fromNp,
+                toPath: toNp,
+                confidence: 0.70,
+                source: "parser",
+                reason: `calls ${call}`
+            });
+            stats.callsKept++;
+        }
+    }
+    // Deduplicate
+    const deduped = dedupeGraphEdges(edges);
+    stats.duplicatesRemoved = edges.length - deduped.length;
+    return {
+        graph: { nodes, edges: deduped },
+        stats
+    };
+}
+function resolveImportPath(fromFile, importSource, pathIndex) {
+    // Normalize the import source
+    let imp = importSource.replace(/\\/g, "/");
+    // Helper: check if pathIndex has a file, trying original and normalized case
+    const lookupIndex = (candidate) => {
+        if (pathIndex.has(candidate))
+            return candidate;
+        const lower = candidate.toLowerCase();
+        if (pathIndex.has(lower))
+            return lower;
+        // Also try finding a case-insensitive match
+        for (const key of pathIndex.keys()) {
+            if (key.toLowerCase() === lower)
+                return key;
+        }
+        return null;
+    };
+    // Skip package imports (no leading . or /)
+    if (!imp.startsWith(".") && !imp.startsWith("/")) {
+        // Workspace-relative path (e.g., "app/Services/PaymentService")
+        if (imp.includes("/")) {
+            for (const ext of ["", ".ts", ".tsx", ".js", ".jsx", ".php", ".py", ".dart", ".java", ".go"]) {
+                const result = lookupIndex(imp + ext);
+                if (result)
+                    return result;
+            }
+            const direct = lookupIndex(imp);
+            if (direct)
+                return direct;
+        }
+        // Basename matching for simple names
+        const base = imp.split("/").pop()?.toLowerCase() || "";
+        if (base) {
+            for (const [filePath] of pathIndex) {
+                const fileBase = filePath.split("/").pop()?.replace(/\.[^.]+$/, "").toLowerCase() || "";
+                if (fileBase === base)
+                    return filePath;
+            }
+        }
+        return null;
+    }
+    // Relative import: resolve from fromFile directory
+    const fromDir = fromFile.includes("/") ? fromFile.slice(0, fromFile.lastIndexOf("/")) : "";
+    const parts = fromDir ? fromDir.split("/") : [];
+    for (const seg of imp.split("/")) {
+        if (seg === "..") {
+            parts.pop();
+        }
+        else if (seg !== ".") {
+            parts.push(seg);
+        }
+    }
+    const candidate = parts.join("/");
+    const directHit = lookupIndex(candidate);
+    if (directHit)
+        return directHit;
+    // Try common extensions
+    for (const ext of [".ts", ".tsx", ".js", ".jsx", ".php", ".py", ".dart", ".java", ".go", ".vue", ".svelte"]) {
+        const result = lookupIndex(candidate + ext);
+        if (result)
+            return result;
+    }
+    // Try index files
+    for (const idx of ["/index.ts", "/index.tsx", "/index.js", "/index.jsx", "/index.php"]) {
+        const result = lookupIndex(candidate + idx);
+        if (result)
+            return result;
+    }
+    return null;
+}
+//# sourceMappingURL=graphIndex.js.map

package/dist/index/indexWatcher.js

@@ -0,0 +1,86 @@
+"use strict";
+// Phase 06 Sprint 6E-R1 — VS Code Index Watcher: Debounce, Batch, Invalidation Callback
+// Tracks workspace file changes for safe index invalidation.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIndexWatcher = createIndexWatcher;
+exports.onFileChanged = onFileChanged;
+exports.onFileDeleted = onFileDeleted;
+exports.onFileCreated = onFileCreated;
+exports.flush = flush;
+exports.dispose = dispose;
+function createIndexWatcher(options) {
+    return {
+        changedPaths: new Set(),
+        deletedPaths: new Set(),
+        timer: null,
+        options,
+    };
+}
+function onFileChanged(state, relativePath) {
+    if (isIgnored(relativePath, state.options))
+        return;
+    const np = normalizePath(relativePath);
+    state.changedPaths.add(np);
+    state.deletedPaths.delete(np);
+    scheduleFlush(state);
+}
+function onFileDeleted(state, relativePath) {
+    if (isIgnored(relativePath, state.options))
+        return;
+    const np = normalizePath(relativePath);
+    state.deletedPaths.add(np);
+    state.changedPaths.delete(np);
+    scheduleFlush(state);
+}
+function onFileCreated(state, relativePath) {
+    if (isIgnored(relativePath, state.options))
+        return;
+    const np = normalizePath(relativePath);
+    state.changedPaths.add(np);
+    scheduleFlush(state);
+}
+function flush(state) {
+    if (state.timer !== null) {
+        clearTimeout(state.timer);
+        state.timer = null;
+    }
+    const changed = Array.from(state.changedPaths);
+    const deleted = Array.from(state.deletedPaths);
+    state.changedPaths.clear();
+    state.deletedPaths.clear();
+    if (state.options.onFlush) {
+        state.options.onFlush(changed, deleted);
+    }
+    return { changed, deleted };
+}
+function dispose(state) {
+    if (state.timer !== null) {
+        clearTimeout(state.timer);
+        state.timer = null;
+    }
+    state.changedPaths.clear();
+    state.deletedPaths.clear();
+}
+function scheduleFlush(state) {
+    if (state.timer !== null)
+        return;
+    state.timer = setTimeout(() => {
+        flush(state);
+    }, state.options.debounceMs);
+}
+function normalizePath(p) {
+    return (p || "").replace(/\\/g, "/").toLowerCase();
+}
+function isIgnored(relativePath, options) {
+    const np = normalizePath(relativePath);
+    const noiseDirs = ["node_modules", ".git", ".flowseeker", "dist", "build", "coverage", ".next", "vendor", "__pycache__"];
+    const segments = np.split("/");
+    for (const seg of segments) {
+        if (noiseDirs.includes(seg))
+            return true;
+        if (seg.startsWith(".") && seg !== ".env")
+            return true;
+    }
+    return false;
+}
+//# sourceMappingURL=indexWatcher.js.map