flowseeker 0.1.7 → 0.1.8

package/dist/index/cacheStore.js

@@ -34,6 +34,8 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.clearFlowSeekerCache = clearFlowSeekerCache;
+exports.writeCacheFileAtomic = writeCacheFileAtomic;
+exports.readCacheFileOrRecover = readCacheFileOrRecover;
 const vscode = __importStar(require("vscode"));
 async function clearFlowSeekerCache() {
     const folders = vscode.workspace.workspaceFolders;
@@ -48,4 +50,45 @@ async function clearFlowSeekerCache() {
         // Cache may not exist yet.
     }
 }
+async function writeCacheFileAtomic(uri, data) {
+    const tempUri = uri.with({ path: `${uri.path}.tmp-${Date.now()}` });
+    await vscode.workspace.fs.createDirectory(parentUri(uri));
+    await vscode.workspace.fs.writeFile(tempUri, data);
+    try {
+        await vscode.workspace.fs.rename(tempUri, uri, { overwrite: true });
+    }
+    catch (error) {
+        await safeDelete(tempUri);
+        throw error;
+    }
+}
+async function readCacheFileOrRecover(uri) {
+    try {
+        return await vscode.workspace.fs.readFile(uri);
+    }
+    catch {
+        await moveCorruptCacheAside(uri);
+        return undefined;
+    }
+}
+async function moveCorruptCacheAside(uri) {
+    try {
+        await vscode.workspace.fs.rename(uri, uri.with({ path: `${uri.path}.corrupt-${Date.now()}` }), { overwrite: true });
+    }
+    catch {
+        // Missing or unreadable cache can be rebuilt.
+    }
+}
+async function safeDelete(uri) {
+    try {
+        await vscode.workspace.fs.delete(uri, { recursive: false, useTrash: false });
+    }
+    catch {
+        // Best effort cleanup only.
+    }
+}
+function parentUri(uri) {
+    const index = uri.path.lastIndexOf("/");
+    return uri.with({ path: index > 0 ? uri.path.slice(0, index) : uri.path });
+}
 //# sourceMappingURL=cacheStore.js.map

package/dist/index/configRouteDiscoveryProbe.js

@@ -0,0 +1,288 @@
+"use strict";
+// Phase 05 Sprint 5F-P23 - Task-Aware Config Route Probe Precision Repair
+// Execution mode: disabled_prototype_report_only
+//
+// Pure deterministic probe. No production imports. No evaluation-specific fields in API.
+// Task-aware: uses taskTokens (label-blind) to suppress generic config that doesn't
+// match the task, while preserving task-relevant config.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROBE_RULE_DEFS = exports.DEFAULT_PROBE_OPTIONS = exports.PROBE_RULE_FAMILIES = void 0;
+exports.probeConfigRouteCandidates = probeConfigRouteCandidates;
+const RULES = Object.freeze([
+    { id: "framework_config_path_probe", priority: 0, patterns: ["config"], confidence: 0.8, signals: ["config_substring"] },
+    { id: "route_entrypoint_probe", priority: 1, patterns: ["routes", "router"], confidence: 0.7, signals: ["route_substring"] },
+    { id: "middleware_registration_probe", priority: 2, patterns: ["middleware"], confidence: 0.6, signals: ["middleware_substring"] },
+    { id: "env_service_config_probe", priority: 3, patterns: [".env"], confidence: 0.5, signals: ["dotenv_match"] },
+    { id: "schema_or_type_config_probe", priority: 4, patterns: ["schema"], confidence: 0.4, signals: ["schema_substring"] },
+]);
+exports.PROBE_RULE_DEFS = RULES;
+// --- Exclusion ---
+const EXCLUDE_DIRS = new Set([
+    "test", "tests", "spec", "__test__", "__tests__", "__mocks__",
+    "example", "examples", "sample", "samples", "fixture", "fixtures",
+    "doc", "docs", "documentation",
+    "mock", "mocks", "generated",
+    "node_modules", "dist", "build", "target", "vendor",
+    ".next", "__pycache__", "coverage", ".nyc_output",
+    ".git", ".svn", ".hg",
+]);
+const EXCLUDE_FILE_PATTERNS = [
+    ".test.", ".spec.", ".mock.", ".snap", ".snapshot",
+    ".lock", ".generated.", ".gen.", ".min.",
+    ".d.ts",
+];
+// --- Task-aware generic operational terms ---
+// Candidates whose filename tokens match ONLY these terms (and not the task) get suppressed.
+const GENERIC_OPS_TERMS = new Set([
+    "logging", "logger", "log",
+    "cors",
+    "requestlogger",
+    "contenttype",
+    "metrics", "metric",
+    "ratelimiter", "ratelimit", "ratelimiting",
+    "database", "db",
+    "request", "response",
+    "validation", "validator", "validate",
+    "health", "readiness", "liveness", "monitoring", "healthcheck",
+    "development", "production", "staging", "local", "testing",
+    "error", "exception", "handler",
+    "scheduling", "schedule", "scheduler",
+    // Generic entrypoint noise (P24) — specific high-frequency patterns
+    "tsconfig",
+    "theme",
+    "app_config",
+    "app_router",
+]);
+// Related term groups for task relevance matching.
+// Terms within a group are considered equivalent.
+const RELATED_GROUPS = [
+    ["mail", "email", "smtp", "notification", "notify", "notifications"],
+    ["payment", "billing", "subscription", "invoice", "checkout"],
+    ["auth", "login", "session", "security", "authentication", "oauth", "token", "credentials", "password"],
+    ["queue", "job", "worker", "jobs", "workers", "background"],
+    ["cache", "redis", "memcache", "caching"],
+    ["project", "projects"],
+    ["admin", "administrator"],
+    ["featureflag", "featureflags", "feature", "flags", "flag"],
+    ["settings", "config", "configuration", "app", "application"],
+    ["routes", "route", "router", "routing", "endpoint", "endpoints"],
+    ["storage", "store"],
+    ["api", "rest", "graphql"],
+    ["user", "users", "account", "accounts"],
+    ["order", "orders"],
+    ["product", "products"],
+    ["blog", "post", "posts", "article", "articles", "feed"],
+    ["analytics", "report", "reports", "dashboard"],
+    ["middleware"],
+    ["schema", "types", "type", "model", "models"],
+];
+const termToGroup = new Map();
+for (let gi = 0; gi < RELATED_GROUPS.length; gi++) {
+    for (const t of RELATED_GROUPS[gi]) {
+        if (!termToGroup.has(t))
+            termToGroup.set(t, gi);
+    }
+}
+// Stop words to filter from task text tokenization
+const STOP_WORDS = new Set([
+    "the", "a", "an", "is", "are", "was", "were", "be", "been", "being",
+    "have", "has", "had", "do", "does", "did", "will", "would", "could",
+    "should", "may", "might", "can", "shall", "to", "of", "in", "for",
+    "on", "with", "at", "by", "from", "as", "into", "through", "during",
+    "before", "after", "above", "below", "between", "and", "but", "or",
+    "not", "no", "nor", "so", "if", "then", "else", "when", "where",
+    "how", "all", "each", "every", "both", "few", "more", "most", "other",
+    "some", "such", "only", "own", "same", "that", "this", "these", "those",
+    "it", "its", "fix", "add", "update", "implement", "create", "remove",
+]);
+// --- Helpers ---
+function normPath(p) {
+    return (p || "").replace(/\\/g, "/").toLowerCase();
+}
+function isExcluded(np) {
+    const segments = np.split("/");
+    for (let i = 0; i < segments.length; i++) {
+        const seg = segments[i];
+        if (!seg)
+            continue;
+        if (EXCLUDE_DIRS.has(seg))
+            return true;
+        if (seg.startsWith(".") && seg !== ".env" && i < segments.length - 1)
+            return true;
+    }
+    const filename = segments[segments.length - 1] || "";
+    for (let i = 0; i < EXCLUDE_FILE_PATTERNS.length; i++) {
+        if (filename.indexOf(EXCLUDE_FILE_PATTERNS[i]) >= 0)
+            return true;
+    }
+    return false;
+}
+function pathMatchesPattern(normalizedPath, pattern) {
+    return normalizedPath.indexOf(pattern.toLowerCase()) >= 0;
+}
+function isValidCandidate(c) {
+    return (typeof c.relativePath === "string" && c.relativePath.length > 0 &&
+        typeof c.ruleId === "string" && typeof c.reason === "string" &&
+        Number.isFinite(c.confidence) && c.confidence >= 0 && c.confidence <= 1 &&
+        Number.isFinite(c.rankHint) && Array.isArray(c.signals));
+}
+// --- Task tokenization ---
+function tokenize(text) {
+    const tokens = [];
+    const parts = text.toLowerCase().split(/[^a-z0-9]+/);
+    for (let i = 0; i < parts.length; i++) {
+        const t = parts[i];
+        if (t.length >= 2 && !STOP_WORDS.has(t))
+            tokens.push(t);
+    }
+    return tokens;
+}
+function extractFilenameTokens(np) {
+    const segments = np.split("/");
+    const filename = segments[segments.length - 1] || "";
+    const base = filename.replace(/\.[^.]+$/, ""); // strip extension
+    return tokenize(base);
+}
+const COMMON_EXTENSIONS = new Set([
+    "ts", "js", "jsx", "tsx", "php", "py", "java", "go", "dart", "rb",
+    "cs", "swift", "kt", "rs", "scala", "clj", "ex", "exs", "erl",
+    "c", "cpp", "h", "hpp", "json", "xml", "yaml", "yml", "toml",
+    "ini", "cfg", "conf", "css", "scss", "less", "html", "htm",
+    "md", "txt", "sh", "bash", "zsh", "ps1", "bat", "cmd",
+]);
+function isGenericOnly(fileTokens) {
+    if (fileTokens.length === 0)
+        return false;
+    for (let i = 0; i < fileTokens.length; i++) {
+        if (COMMON_EXTENSIONS.has(fileTokens[i]))
+            continue;
+        if (!GENERIC_OPS_TERMS.has(fileTokens[i]))
+            return false;
+    }
+    return true;
+}
+function hasTaskRelevance(fileTokens, taskTokens) {
+    // Direct token match
+    for (let fi = 0; fi < fileTokens.length; fi++) {
+        for (let ti = 0; ti < taskTokens.length; ti++) {
+            if (fileTokens[fi] === taskTokens[ti])
+                return true;
+        }
+    }
+    // Group match: any file token shares a group with any task token
+    for (let fi = 0; fi < fileTokens.length; fi++) {
+        const fg = termToGroup.get(fileTokens[fi]);
+        if (fg === undefined)
+            continue;
+        for (let ti = 0; ti < taskTokens.length; ti++) {
+            const tg = termToGroup.get(taskTokens[ti]);
+            if (tg === fg)
+                return true;
+        }
+    }
+    return false;
+}
+// --- Task-aware candidate filter ---
+// Returns: { confidence, reason, signals } or null if candidate should be excluded.
+function applyTaskAwareness(baseConfidence, baseReason, baseSignals, np, taskTokens) {
+    if (taskTokens.length === 0) {
+        return { confidence: baseConfidence, reason: baseReason, signals: baseSignals };
+    }
+    const fileTokens = extractFilenameTokens(np);
+    const relevant = hasTaskRelevance(fileTokens, taskTokens);
+    const generic = isGenericOnly(fileTokens);
+    if (relevant) {
+        return { confidence: Math.min(1, baseConfidence + 0.05), reason: baseReason + "; task_relevant", signals: [...baseSignals, "task_relevant"] };
+    }
+    if (generic) {
+        // Exclude entirely — this is a generic operational config not supported by the task
+        return null;
+    }
+    return { confidence: baseConfidence * 0.7, reason: baseReason + "; task_unrelated", signals: [...baseSignals, "task_unrelated"] };
+}
+// --- Main probe function ---
+function probeConfigRouteCandidates(workspaceFiles, options) {
+    const maxPerRule = Math.max(0, Math.floor(options.maxCandidatesPerRule || 5));
+    const maxTotal = Math.max(0, Math.floor(options.maxTotalCandidates || 30));
+    if (!Array.isArray(workspaceFiles) || workspaceFiles.length === 0) {
+        return { candidates: [], ruleCounts: {}, totalMatched: 0, totalCapped: 0 };
+    }
+    // Resolve task tokens from options
+    let taskTokens = [];
+    if (options.taskTokens && Array.isArray(options.taskTokens) && options.taskTokens.length > 0) {
+        taskTokens = options.taskTokens.map((t) => t.toLowerCase());
+    }
+    else if (options.taskText && typeof options.taskText === "string" && options.taskText.length > 0) {
+        taskTokens = tokenize(options.taskText);
+    }
+    // Phase 0: exclude noise files
+    const eligible = [];
+    for (let fi = 0; fi < workspaceFiles.length; fi++) {
+        const f = workspaceFiles[fi];
+        if (!f || typeof f.relativePath !== "string")
+            continue;
+        if (isExcluded(normPath(f.relativePath)))
+            continue;
+        eligible.push(f);
+    }
+    // Phase 1: per-rule matching
+    const seen = new Map();
+    const ruleCounts = {};
+    let totalMatched = 0;
+    for (let ri = 0; ri < RULES.length; ri++) {
+        const rule = RULES[ri];
+        let ruleCount = 0;
+        for (let fi = 0; fi < eligible.length && ruleCount < maxPerRule; fi++) {
+            const f = eligible[fi];
+            const np = normPath(f.relativePath);
+            if (!np)
+                continue;
+            if (seen.has(np))
+                continue;
+            const matched = rule.patterns.some((p) => pathMatchesPattern(np, p));
+            if (!matched)
+                continue;
+            // Task-aware filtering
+            const adj = applyTaskAwareness(rule.confidence, `${rule.id}: matched path convention`, [...rule.signals], np, taskTokens);
+            if (adj === null)
+                continue; // excluded by task awareness
+            const candidate = {
+                relativePath: f.relativePath,
+                ruleId: rule.id,
+                reason: adj.reason,
+                confidence: adj.confidence,
+                rankHint: rule.priority * 100 + ruleCount,
+                signals: adj.signals,
+            };
+            if (!isValidCandidate(candidate))
+                continue;
+            seen.set(np, candidate);
+            ruleCount++;
+            totalMatched++;
+        }
+        ruleCounts[rule.id] = ruleCount;
+    }
+    // Phase 2: sort by confidence desc, priority asc, normalized path asc
+    const sorted = Array.from(seen.values()).sort((a, b) => {
+        const confDiff = b.confidence - a.confidence;
+        if (confDiff !== 0)
+            return confDiff;
+        const aRule = RULES.find((r) => r.id === a.ruleId);
+        const bRule = RULES.find((r) => r.id === b.ruleId);
+        const priDiff = (aRule?.priority ?? 99) - (bRule?.priority ?? 99);
+        if (priDiff !== 0)
+            return priDiff;
+        return normPath(a.relativePath).localeCompare(normPath(b.relativePath));
+    });
+    // Phase 3: apply maxTotal cap
+    const totalCapped = Math.max(0, sorted.length - maxTotal);
+    const candidates = sorted.slice(0, maxTotal);
+    return { candidates, ruleCounts, totalMatched, totalCapped };
+}
+// --- Exported constants ---
+exports.PROBE_RULE_FAMILIES = Object.freeze(RULES.map((r) => r.id));
+exports.DEFAULT_PROBE_OPTIONS = Object.freeze({
+    maxCandidatesPerRule: 5,
+    maxTotalCandidates: 30,
+});
+//# sourceMappingURL=configRouteDiscoveryProbe.js.map

package/dist/index/embeddingIndex.js

@@ -0,0 +1,193 @@
+"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.searchSemanticFiles = searchSemanticFiles;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const embeddingProviders_1 = require("../gateway/embeddingProviders");
+const vectorStore_1 = require("./vectorStore");
+const embeddingVersion = "file-level-v1";
+async function searchSemanticFiles(rootPath, index, task, config) {
+    if (!config.index.semanticEnabled) {
+        return { hits: [], status: "disabled" };
+    }
+    const provider = (0, embeddingProviders_1.createConfiguredEmbeddingProvider)({ ...config.index, workspacePath: rootPath });
+    if (!provider) {
+        return { hits: [], status: "skipped_no_key" };
+    }
+    const baseInfo = {
+        providerName: provider.name,
+        model: provider.model
+    };
+    try {
+        const files = index.files.slice(0, config.index.semanticMaxFilesPerRun);
+        const { records, cacheHits, cacheMisses } = await loadOrBuildFileEmbeddings(rootPath, files, provider, config);
+        if (records.length === 0) {
+            return { hits: [], status: "error_fallback", ...baseInfo, errorType: "no_records", errorMessage: "No embedding records were loaded or built", embeddedFiles: 0, cacheHits: 0, cacheMisses: 0 };
+        }
+        const [queryVector] = await provider.embedTexts([task]);
+        const store = new vectorStore_1.InMemoryVectorStore();
+        for (const record of records) {
+            store.upsert({ id: record.key, vector: record.vector, metadata: record });
+        }
+        const hits = store.search(queryVector, 100).map((item) => ({
+            relativePath: item.record.metadata.relativePath,
+            score: item.score,
+            reason: `semantic vector similarity ${item.score.toFixed(3)}`
+        }));
+        return { hits, status: "active", ...baseInfo, embeddedFiles: records.length, cacheHits, cacheMisses };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const errorType = classifyEmbeddingError(message);
+        return { hits: [], status: "error_fallback", ...baseInfo, errorType, errorMessage: message, embeddedFiles: 0, cacheHits: 0, cacheMisses: 0 };
+    }
+}
+function classifyEmbeddingError(message) {
+    const lower = message.toLowerCase();
+    if (lower.includes("429") || lower.includes("quota") || lower.includes("resource_exhausted") || lower.includes("rate limit"))
+        return "quota_exceeded";
+    if (lower.includes("timeout") || lower.includes("abort") || lower.includes("etimedout"))
+        return "timeout";
+    if (lower.includes("401") || lower.includes("403") || lower.includes("unauthenticated") || lower.includes("permission_denied"))
+        return "auth_error";
+    if (lower.includes("404") || lower.includes("not_found"))
+        return "model_not_found";
+    if (lower.includes("econnrefused") || lower.includes("enotfound") || lower.includes("dns"))
+        return "network";
+    return "unknown";
+}
+async function loadOrBuildFileEmbeddings(rootPath, files, provider, config) {
+    const cache = config.index.semanticCache ? await readEmbeddingCache(rootPath) : new Map();
+    const records = [];
+    const missing = [];
+    let cacheHits = 0;
+    for (const file of files) {
+        const key = cacheKey(file, provider);
+        const cached = cache.get(key);
+        if (cached) {
+            records.push(cached);
+            cacheHits++;
+        }
+        else {
+            missing.push(file);
+        }
+    }
+    const batchSize = 32;
+    let lastWrite = 0;
+    for (let index = 0; index < missing.length; index += batchSize) {
+        const batch = missing.slice(index, index + batchSize);
+        const embeddings = await provider.embedTexts(batch.map((f) => fileEmbeddingText(f, provider.model)));
+        embeddings.forEach((vector, offset) => {
+            const file = batch[offset];
+            const record = {
+                key: cacheKey(file, provider),
+                relativePath: file.relativePath,
+                contentHash: file.contentHash,
+                model: provider.model,
+                embeddingVersion,
+                vector
+            };
+            cache.set(record.key, record);
+            records.push(record);
+        });
+        // Write cache after every 4 batches for resilience against interruption
+        if (index - lastWrite >= batchSize * 4 && config.index.semanticCache) {
+            try {
+                await writeEmbeddingCache(rootPath, cache);
+            }
+            catch { /* non-fatal */ }
+            lastWrite = index;
+        }
+    }
+    if (config.index.semanticCache && missing.length > 0) {
+        try {
+            await writeEmbeddingCache(rootPath, cache);
+        }
+        catch {
+            // Semantic cache failures must not break deterministic retrieval.
+        }
+    }
+    return { records, cacheHits, cacheMisses: missing.length };
+}
+function isCodeEmbeddingModel(model) {
+    return model === "jina-code-embeddings-0.5b";
+}
+function embeddingTextFormatVersion(model) {
+    return isCodeEmbeddingModel(model) ? "jina-code-compact-v1" : "general-v1";
+}
+function fileEmbeddingText(file, model) {
+    const isCompact = model ? isCodeEmbeddingModel(model) : false;
+    const maxTokens = isCompact ? 100 : 400;
+    const maxSymbols = isCompact ? 20 : 30;
+    const maxImports = isCompact ? 20 : 30;
+    return [
+        `path: ${file.relativePath}`,
+        file.language ? `language: ${file.language}` : "",
+        file.subsystem ? `subsystem: ${file.subsystem}` : "",
+        file.symbols.length > 0 ? `symbols: ${file.symbols.slice(0, maxSymbols).map((symbol) => symbol.name).join(", ")}` : "",
+        file.imports.length > 0 ? `imports: ${file.imports.slice(0, maxImports).join(", ")}` : "",
+        file.tokens.slice(0, maxTokens).join(" ")
+    ].filter(Boolean).join("\n");
+}
+function cacheKey(file, provider) {
+    const fmtVersion = embeddingTextFormatVersion(provider.model);
+    return `${provider.name}:${provider.model}:${embeddingVersion}:${fmtVersion}:${file.extractorVersion}:${file.chunkerVersion}:${file.contentHash}:${file.relativePath}`;
+}
+async function readEmbeddingCache(rootPath) {
+    try {
+        const text = await fs.readFile(embeddingCachePath(rootPath), "utf8");
+        const records = JSON.parse(text);
+        return new Map(records.filter(isEmbeddingCacheRecord).map((record) => [record.key, record]));
+    }
+    catch {
+        return new Map();
+    }
+}
+async function writeEmbeddingCache(rootPath, cache) {
+    const filePath = embeddingCachePath(rootPath);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const tempPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+    await fs.writeFile(tempPath, JSON.stringify(Array.from(cache.values())), "utf8");
+    await fs.rename(tempPath, filePath);
+}
+function embeddingCachePath(rootPath) {
+    return path.join(path.resolve(rootPath), ".flowseeker", "cache", "embeddings", "file-embeddings.json");
+}
+function isEmbeddingCacheRecord(value) {
+    const record = value;
+    return Boolean(record && typeof record.key === "string" && typeof record.relativePath === "string" && Array.isArray(record.vector));
+}
+//# sourceMappingURL=embeddingIndex.js.map