flowseeker 0.1.7

package/dist/pipeline/contextBlueprint.js

@@ -0,0 +1,346 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTaskBlueprint = buildTaskBlueprint;
+exports.slotSearchTerms = slotSearchTerms;
+exports.allContextSlots = allContextSlots;
+exports.contextSlotLabel = contextSlotLabel;
+exports.detectContextSlot = detectContextSlot;
+exports.isRequiredSlot = isRequiredSlot;
+exports.computeContextCoverage = computeContextCoverage;
+exports.sortSlots = sortSlots;
+const text_1 = require("../utils/text");
+const slotOrder = ["entry", "handler", "domain", "data", "validation", "permission", "config", "side_effect", "ui", "tests", "docs", "unknown"];
+const slotTerms = {
+    entry: ["route", "routes", "router", "endpoint", "api", "page", "screen", "loader", "action"],
+    handler: ["controller", "handler", "action", "resolver", "listener", "job", "worker", "consumer", "command", "commands"],
+    domain: ["service", "usecase", "use_case", "repository", "manager", "processor", "model", "entity", "store", "stores", "hook", "hooks"],
+    data: ["model", "models", "schema", "migration", "database", "table", "query", "entity", "orm", "prisma"],
+    validation: ["request", "validator", "validation", "rule", "rules", "dto", "formrequest", "schema"],
+    permission: ["policy", "permission", "role", "guard", "middleware", "authorize", "auth", "acl"],
+    config: ["config", "env", "setting", "settings", "feature", "flag", "yaml", "json"],
+    side_effect: ["event", "listener", "job", "queue", "mail", "email", "notification", "webhook", "cache", "dispatch"],
+    ui: ["component", "page", "view", "screen", "template", "form", "button", "modal", "layout", "responsive", "grid", "drawer", "sidebar", "toast", "chart"],
+    tests: ["test", "tests", "spec", "expect", "assert", "fixture", "fixtures"],
+    docs: ["readme", "docs", "documentation", "markdown", "guide"],
+    unknown: []
+};
+const taskBlueprints = {
+    bugfix: {
+        requiredSlots: ["entry", "handler"],
+        optionalSlots: ["domain", "data", "validation", "permission", "config", "side_effect", "ui", "tests"]
+    },
+    feature: {
+        requiredSlots: ["entry", "handler"],
+        optionalSlots: ["domain", "data", "validation", "permission", "config", "side_effect", "ui", "tests"]
+    },
+    refactor: {
+        requiredSlots: ["handler"],
+        optionalSlots: ["entry", "domain", "data", "config", "ui", "side_effect", "tests"]
+    },
+    investigation: {
+        requiredSlots: ["entry", "handler"],
+        optionalSlots: ["domain", "data", "validation", "permission", "config", "side_effect", "ui", "tests", "docs"]
+    },
+    migration: {
+        requiredSlots: ["data", "config"],
+        optionalSlots: ["entry", "handler", "domain", "validation", "tests"]
+    },
+    performance: {
+        requiredSlots: ["entry", "handler"],
+        optionalSlots: ["domain", "data", "config", "side_effect", "ui", "tests"]
+    },
+    security: {
+        requiredSlots: ["entry", "handler", "permission", "validation"],
+        optionalSlots: ["domain", "data", "config", "side_effect", "ui", "tests"]
+    },
+    unknown: {
+        requiredSlots: ["entry", "handler"],
+        optionalSlots: ["domain", "data", "validation", "permission", "config", "side_effect", "ui", "tests", "docs"]
+    }
+};
+function buildTaskBlueprint(input) {
+    const baseShape = input.intent === "unknown" && isReviewLike(input.normalizedTask) ? "investigation" : input.intent;
+    const template = taskBlueprints[baseShape];
+    const required = new Set(template.requiredSlots);
+    const optional = new Set(template.optionalSlots);
+    const terms = new Set(input.keywords.map(text_1.normalizeText));
+    const normalized = input.normalizedTask;
+    promoteSlots(required, optional, detectTargetedSlots(normalized, terms));
+    adaptSlotsToTaskSurface(required, optional, normalized, terms);
+    return {
+        shape: baseShape,
+        confidence: input.confidence,
+        primarySurface: detectPrimarySurface(normalized, terms),
+        negativeTerms: input.negativeTerms ?? [],
+        requiredSlots: sortSlots(Array.from(required)),
+        optionalSlots: sortSlots(Array.from(optional).filter((slot) => !required.has(slot))),
+        expansionHints: buildExpansionHints(required)
+    };
+}
+function slotSearchTerms(slot) {
+    return slotTerms[slot] ?? [];
+}
+function allContextSlots(blueprint) {
+    return sortSlots([...blueprint.requiredSlots, ...blueprint.optionalSlots]);
+}
+function contextSlotLabel(slot) {
+    const labels = {
+        entry: "Entry / Routes",
+        handler: "Handlers / Controllers",
+        domain: "Domain / Services",
+        data: "Data / Schema",
+        validation: "Validation",
+        permission: "Permissions",
+        config: "Config",
+        side_effect: "Side Effects",
+        ui: "UI / Templates",
+        tests: "Tests / Verification",
+        docs: "Docs",
+        unknown: "Other Context"
+    };
+    return labels[slot];
+}
+function detectContextSlot(relativePath, kind, role, snippet = "") {
+    const normalizedPath = (0, text_1.normalizeText)(relativePath);
+    const normalizedText = (0, text_1.normalizeText)(`${relativePath}\n${snippet}`);
+    if (kind === "test" || isTestPath(normalizedPath)) {
+        return "tests";
+    }
+    if (kind === "doc") {
+        return "docs";
+    }
+    if (kind === "route" || isFrontendRoutePath(normalizedPath) || /\b(route|routes|router|endpoint)\b/.test(normalizedPath)) {
+        return "entry";
+    }
+    if (kind === "template" || isFrontendTemplatePath(normalizedPath) || /\b(component|components|page|pages|screen|screens|template|templates|form|forms)\b/.test(normalizedPath) || /(^|[/\\])templates?([/\\]|$)/.test(normalizedPath)) {
+        return "ui";
+    }
+    if (/\b(request|requests|validator|validators|validation|rule|rules|dto|formrequest|form-request|serializer|serializers)\b/.test(normalizedPath)) {
+        return "validation";
+    }
+    if (kind === "config" || /\b(config|env|properties?|feature[_-]?flag)\b/.test(normalizedPath) || /(^|[/\\])settings?\.(json|ya?ml|toml|php|py|ts|js)$/.test(normalizedPath)) {
+        return "config";
+    }
+    if (kind === "schema" || kind === "migration" || /\b(schema|schemas|model|models|entity|entities|migration|migrations|database|table|query|repository|repositories|prisma|orm)\b/.test(normalizedPath)) {
+        return "data";
+    }
+    if (/\b(request|requests|validator|validators|validation|rule|rules|dto|formrequest|form-request)\b/.test(normalizedPath)) {
+        return "validation";
+    }
+    if (/\b(event|events|listener|listeners|job|jobs|worker|workers|queue|queues|mail|email|notification|notifications|webhook|cache|dispatch)\b/.test(normalizedPath)) {
+        return "side_effect";
+    }
+    if (/\b(policy|policies|permission|permissions|role|roles|guard|guards|middleware|auth|acl|authorize)\b/.test(normalizedPath)) {
+        return "permission";
+    }
+    if (/\b(controller|controllers|handler|handlers|action|actions|resolver|resolvers|consumer|consumers|producer|producers|command|commands)\b/.test(normalizedPath) || /(^|[/\\])views?\.[a-z0-9]+$/.test(normalizedPath)) {
+        return "handler";
+    }
+    if (/\b(service|services|usecase|usecases|use-case|domain|manager|processor|processors|helper|helpers|util|utils|lib|store|stores|hook|hooks|composable|composables)\b/.test(normalizedPath)) {
+        return "domain";
+    }
+    if (role === "test") {
+        return "tests";
+    }
+    if (/\b(validate|validator|validation|authorize|permission|policy|role|schema|migration|query|dispatch|emit|publish|send|notify|cache)\b/.test(normalizedText)) {
+        if (/\b(validate|validator|validation)\b/.test(normalizedText)) {
+            return "validation";
+        }
+        if (/\b(authorize|permission|policy|role)\b/.test(normalizedText)) {
+            return "permission";
+        }
+        if (/\b(schema|migration|query|table)\b/.test(normalizedText)) {
+            return "data";
+        }
+        return "side_effect";
+    }
+    return "unknown";
+}
+function isRequiredSlot(profile, slot) {
+    return Boolean(slot && profile.blueprint.requiredSlots.includes(slot));
+}
+function computeContextCoverage(profile, units) {
+    const found = new Set(units.map((unit) => unit.slot ?? "unknown"));
+    const foundRequiredSlots = profile.blueprint.requiredSlots.filter((slot) => found.has(slot));
+    const missingRequiredSlots = profile.blueprint.requiredSlots.filter((slot) => !found.has(slot));
+    const optionalSlotsFound = profile.blueprint.optionalSlots.filter((slot) => found.has(slot));
+    const requiredCoveragePercent = profile.blueprint.requiredSlots.length > 0
+        ? (foundRequiredSlots.length / profile.blueprint.requiredSlots.length) * 100
+        : 100;
+    return {
+        requiredSlots: profile.blueprint.requiredSlots,
+        foundRequiredSlots,
+        missingRequiredSlots,
+        optionalSlotsFound,
+        requiredCoveragePercent
+    };
+}
+function sortSlots(slots) {
+    const unique = Array.from(new Set(slots));
+    return unique.sort((left, right) => slotOrder.indexOf(left) - slotOrder.indexOf(right));
+}
+function detectTargetedSlots(normalizedTask, terms) {
+    const slots = [];
+    const hasExplicitSecuritySignal = hasAny(terms, ["auth", "authorize", "permission", "role", "policy", "login", "guard", "middleware", "acl"]) || /\b(bao mat|phan quyen|dang nhap)\b/.test(normalizedTask);
+    const hasSessionSecurityContext = hasAny(terms, ["session", "token", "jwt"]) && (hasExplicitSecuritySignal || /\b(security|login|auth|access|cannot|without|admin|role|bao mat|dang nhap)\b/.test(normalizedTask));
+    if (hasExplicitSecuritySignal || hasSessionSecurityContext) {
+        slots.push("permission", "validation");
+    }
+    if (hasAny(terms, ["schema", "migration", "database", "table", "db", "model", "query", "queries", "join", "repository", "data"])) {
+        slots.push("data");
+    }
+    if (hasAny(terms, ["config", "env", "setting", "settings", "feature", "flag"])) {
+        slots.push("config");
+    }
+    if (hasAny(terms, ["send", "mail", "queue", "job", "event", "webhook", "cache", "dispatch"])) {
+        slots.push("side_effect");
+    }
+    if (hasAny(terms, ["id", "user_id", "key", "identifier", "identified", "lookup", "email"]) && /\b(change|update|rename|from|to|doi|thay)\b/.test(normalizedTask)) {
+        slots.push("data", "domain");
+    }
+    if (hasAny(terms, ["ui", "frontend", "client", "browser", "page", "screen", "component", "view", "form", "template", "layout", "responsive", "grid", "button", "modal", "drawer", "sidebar", "toast", "chart", "gallery", "avatar", "badge", "bar", "input", "suggestion", "suggestions", "autocomplete", "dropdown", "image", "photo", "zoom", "display", "displayed", "render", "rendered", "show", "visible", "giao", "dien", "hien", "thi", "nut", "anh"]) || /\b(giao dien|trang(?!\s+thai)|man hinh|hien thi|nut)\b/.test(normalizedTask)) {
+        slots.push("ui", "entry");
+    }
+    if (hasAny(terms, ["store", "stores", "state", "localstorage", "sessionstorage", "hook", "hooks", "client", "browser"])) {
+        slots.push("domain");
+    }
+    if (hasAny(terms, ["validate", "validation", "request", "rule", "rules", "input", "invalid", "required", "field", "format", "empty", "constraint", "validator", "dto", "formrequest", "serializer", "serializers"]) || /\b(bat buoc|khong hop le|dinh dang|truong|rong)\b/.test(normalizedTask)) {
+        slots.push("validation");
+    }
+    if (hasAny(terms, ["test", "tests", "spec", "expect", "assert", "verify", "verification"])) {
+        slots.push("tests");
+    }
+    if (hasAny(terms, ["upload", "download", "export", "import", "file", "attachment", "document", "submission"])) {
+        slots.push("entry", "domain", "data", "validation");
+    }
+    return slots;
+}
+function adaptSlotsToTaskSurface(required, optional, normalizedTask, terms) {
+    const uiFocused = isUiFocusedTask(normalizedTask, terms);
+    const backendFocused = isBackendFocusedTask(normalizedTask, terms);
+    const dataFocused = hasAny(terms, ["schema", "migration", "database", "table", "db", "model", "query", "prisma", "orm"]);
+    if (uiFocused) {
+        required.add("entry");
+        required.add("ui");
+        optional.delete("entry");
+        optional.delete("ui");
+        if (!backendFocused) {
+            demoteSlot(required, optional, "handler");
+        }
+        if (!dataFocused) {
+            demoteSlot(required, optional, "data");
+        }
+        if (hasAny(terms, ["store", "stores", "state", "localstorage", "sessionstorage", "hook", "hooks", "client", "browser", "cart", "wishlist", "filter", "filters"])) {
+            required.add("domain");
+            optional.delete("domain");
+        }
+        if (hasAny(terms, ["api", "query", "load", "action", "fetch"])) {
+            required.add("domain");
+            optional.delete("domain");
+        }
+    }
+    if (!hasAny(terms, ["test", "tests", "spec", "expect", "assert", "verify", "verification"])) {
+        demoteSlot(required, optional, "tests");
+    }
+}
+function promoteSlots(required, optional, slots) {
+    for (const slot of slots) {
+        required.add(slot);
+        optional.delete(slot);
+    }
+}
+function demoteSlot(required, optional, slot) {
+    if (required.delete(slot)) {
+        optional.add(slot);
+    }
+}
+function buildExpansionHints(required) {
+    return sortSlots(Array.from(required)).map((slot) => `Find ${contextSlotLabel(slot)} context if available.`);
+}
+function hasAny(terms, values) {
+    return values.some((value) => terms.has((0, text_1.normalizeText)(value)));
+}
+function isUiFocusedTask(normalizedTask, terms) {
+    return hasAny(terms, [
+        "ui",
+        "frontend",
+        "client",
+        "browser",
+        "page",
+        "screen",
+        "component",
+        "view",
+        "form",
+        "layout",
+        "responsive",
+        "grid",
+        "button",
+        "modal",
+        "drawer",
+        "sidebar",
+        "toast",
+        "chart",
+        "gallery",
+        "avatar",
+        "badge",
+        "bar",
+        "input",
+        "suggestion",
+        "suggestions",
+        "autocomplete",
+        "dropdown",
+        "image",
+        "photo",
+        "zoom",
+        "giao",
+        "dien",
+        "hien",
+        "thi",
+        "nut",
+        "anh",
+        "display",
+        "render",
+        "show",
+        "hide"
+    ]) || /\b(giao dien|trang(?!\s+thai)|man hinh|hien thi|nut|client side|front end)\b/.test(normalizedTask);
+}
+function isBackendFocusedTask(normalizedTask, terms) {
+    return hasAny(terms, [
+        "controller",
+        "handler",
+        "backend",
+        "job",
+        "worker",
+        "queue",
+        "webhook",
+        "event",
+        "listener"
+    ]) || /\b(backend|controller|handler|job|worker|queue|webhook|middleware)\b/.test(normalizedTask);
+}
+function detectPrimarySurface(normalizedTask, terms) {
+    const frontend = isUiFocusedTask(normalizedTask, terms);
+    const backend = isBackendFocusedTask(normalizedTask, terms) || hasAny(terms, ["api", "endpoint", "server", "service", "database", "queue", "job", "worker", "webhook"]);
+    if (frontend && backend) {
+        return "fullstack";
+    }
+    if (frontend) {
+        return "frontend";
+    }
+    if (backend) {
+        return "backend";
+    }
+    return "unknown";
+}
+function isFrontendRoutePath(normalizedPath) {
+    return /(^|[/\\])routes?([/\\]|$).*(^|[/\\])\+(page|layout|server)\.(ts|js|svelte)$|(^|[/\\])(app|pages)([/\\]|$).*\b(page|layout|route)\.(ts|tsx|js|jsx|svelte)$/.test(normalizedPath);
+}
+function isFrontendTemplatePath(normalizedPath) {
+    return /\.(svelte|vue|tsx|jsx|erb|blade\.php|twig|hbs|ejs)$/.test(normalizedPath) || /(^|[/\\])(components?|views?|screens?|templates?)([/\\]|$)/.test(normalizedPath);
+}
+function isReviewLike(normalizedTask) {
+    return /\b(review|investigate|trace|debug|kiem tra|danh gia|ra soat|tim hieu)\b/.test(normalizedTask);
+}
+function isTestPath(normalizedPath) {
+    return /(^|[/\\])(__tests__|tests?|specs?|fixtures?|mocks?)([/\\]|$)|(^|[/\\])(test_|spec_)[^/\\]+\.[a-z0-9]+$|(^|[/\\])[^/\\]+_(test|spec)\.[a-z0-9]+$|(^|[/\\])(tests?|specs?)\.[a-z0-9]+$|\.(test|spec)\./.test(normalizedPath);
+}
+//# sourceMappingURL=contextBlueprint.js.map

package/dist/pipeline/contextPack.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContextPack = createContextPack;
+const text_1 = require("../utils/text");
+const fileGroups_1 = require("./fileGroups");
+const sections = [
+    { title: "Most Likely Edit Areas", roles: ["edit_candidate"] },
+    { title: "Read Before Editing", roles: ["read_context"] },
+    { title: "Impact And Risk", roles: ["impact", "verify"] },
+    { title: "Tests To Run Or Update", roles: ["test"] },
+    { title: "Uncertain Candidates", roles: ["unknown"] }
+];
+function createContextPack(task, units, config) {
+    const header = [`# FlowSeeker Context`, "", `## Task`, task, ""].join("\n");
+    const output = [header];
+    let usedTokens = (0, text_1.tokenEstimate)(header);
+    const fileScope = renderFileScope(units);
+    output.push(fileScope);
+    usedTokens += (0, text_1.tokenEstimate)(fileScope);
+    const contextUnits = (0, fileGroups_1.selectDiverseEvidenceUnits)(units, 2);
+    for (const section of sections) {
+        const sectionUnits = contextUnits.filter((unit) => section.roles.includes(unit.role));
+        if (sectionUnits.length === 0) {
+            continue;
+        }
+        const sectionLines = [`## ${section.title}`, ""];
+        for (const unit of sectionUnits) {
+            const block = renderUnit(unit);
+            const nextTokens = (0, text_1.tokenEstimate)(block);
+            if (usedTokens + nextTokens > config.pipeline.maxContextTokens) {
+                sectionLines.push(`- Context budget reached. ${sectionUnits.length} candidates were ranked, but lower-ranked snippets were omitted.`, "");
+                break;
+            }
+            sectionLines.push(block);
+            usedTokens += nextTokens;
+        }
+        output.push(sectionLines.join("\n"));
+    }
+    output.push(`## Notes\n- AI rerank: disabled in MVP. Results are deterministic evidence ranking.\n- Confidence is heuristic and should be reviewed before editing.\n`);
+    return output.join("\n").trimEnd() + "\n";
+}
+function renderFileScope(units) {
+    const groups = (0, fileGroups_1.aggregateEvidenceFiles)(units).slice(0, 15);
+    if (groups.length === 0) {
+        return "## File Scope\n\n- No file-level evidence ranked.\n";
+    }
+    return [
+        "## File Scope",
+        "",
+        ...groups.map((group, index) => {
+            const ranges = group.ranges
+                .slice(0, 3)
+                .map((range) => `${range.startLine}-${range.endLine}`)
+                .join(", ");
+            return `${index + 1}. ${group.relativePath}${ranges ? `:${ranges}` : ""} [${group.role}] score=${group.score.toFixed(1)} evidence=${group.unitCount}`;
+        }),
+        ""
+    ].join("\n");
+}
+function renderUnit(unit) {
+    const range = unit.range ? `:${unit.range.startLine}-${unit.range.endLine}` : "";
+    const reasons = unit.reasons.length > 0 ? unit.reasons.join("; ") : "ranked evidence";
+    const snippet = unit.snippet?.trim();
+    const language = unit.language ?? "text";
+    const lines = [
+        `- ${unit.relativePath}${range}`,
+        `  Kind: ${unit.kind}; Confidence: ${unit.tier} (${unit.confidence.toFixed(2)}); Score: ${unit.score.toFixed(1)}`,
+        `  Retrieval passes: ${unit.retrievalPasses.length > 0 ? unit.retrievalPasses.join(", ") : "seed"}`,
+        `  Imports: ${unit.imports.length > 0 ? unit.imports.slice(0, 5).join(", ") : "none"}`,
+        `  Reasons: ${reasons}`
+    ];
+    if (snippet) {
+        lines.push("", `\`\`\`${language}`, snippet, "```", "");
+    }
+    else {
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=contextPack.js.map

package/dist/pipeline/diffPreview.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDiff = generateDiff;
+exports.renderDiffPreviewMarkdown = renderDiffPreviewMarkdown;
+function generateDiff(originalContent, edits) {
+    const lines = originalContent.split(/\r?\n/);
+    const diffs = [];
+    for (const edit of edits) {
+        if (edit.replaceWholeFile) {
+            diffs.push(`\`\`\`diff\n--- a/${edit.file}\n+++ b/${edit.file}\n@@ -1,${lines.length} +1,${edit.text.split(/\r?\n/).length} @@\n${renderFullDiff(lines, edit.text)}\n\`\`\``);
+            continue;
+        }
+        if (!edit.range) {
+            continue;
+        }
+        const startLine = edit.range.startLine - 1;
+        const endLine = edit.range.endLine - 1;
+        const contextBefore = Math.max(0, startLine - 3);
+        const contextAfter = Math.min(lines.length - 1, endLine + 3);
+        const oldLines = lines.slice(startLine, endLine + 1);
+        const newLines = edit.text.split(/\r?\n/);
+        const oldStart = startLine + 1;
+        const oldCount = oldLines.length;
+        const newCount = newLines.length;
+        const hunk = [
+            `\`\`\`diff`,
+            `--- a/${edit.file}`,
+            `+++ b/${edit.file}`,
+            `@@ -${oldStart},${oldCount} +${oldStart},${newCount} @@`,
+            ...renderContextBefore(lines, contextBefore, startLine),
+            ...oldLines.map((line) => `-${line}`),
+            ...newLines.map((line) => `+${line}`),
+            ...renderContextAfter(lines, endLine, contextAfter),
+            `\`\`\``
+        ].join("\n");
+        diffs.push(hunk);
+    }
+    return diffs.join("\n\n");
+}
+function renderContextBefore(lines, contextBefore, startLine) {
+    const result = [];
+    for (let i = contextBefore; i < startLine; i++) {
+        result.push(` ${lines[i]}`);
+    }
+    return result;
+}
+function renderContextAfter(lines, endLine, contextAfter) {
+    const result = [];
+    for (let i = endLine + 1; i <= contextAfter; i++) {
+        result.push(` ${lines[i]}`);
+    }
+    return result;
+}
+function renderFullDiff(originalLines, newText) {
+    const newLines = newText.split(/\r?\n/);
+    return [
+        ...originalLines.map((line) => `-${line}`),
+        ...newLines.map((line) => `+${line}`)
+    ].join("\n");
+}
+function renderDiffPreviewMarkdown(edits) {
+    if (edits.length === 0) {
+        return "";
+    }
+    const lines = ["## Proposed Changes", "", `**${edits.length} edit(s)** across ${new Set(edits.map((edit) => edit.file)).size} file(s):`, ""];
+    for (const edit of edits) {
+        const range = edit.range ? `:${edit.range.startLine}-${edit.range.endLine}` : " (whole file)";
+        lines.push(`### ${edit.file}${range}`, "");
+        if (edit.text.length <= 400) {
+            lines.push("```", edit.text, "```", "");
+        }
+        else {
+            lines.push("```", edit.text.slice(0, 400), "...", "```", "");
+        }
+    }
+    lines.push("> Review each change carefully. Edits are not applied until you press **Apply Proposed Edits**.", "");
+    return lines.join("\n");
+}
+//# sourceMappingURL=diffPreview.js.map

package/dist/pipeline/evaluationMetrics.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QUALITY_SCORE_WEIGHTS = void 0;
+exports.computeQualityScore = computeQualityScore;
+exports.computeExpectedPathMetrics = computeExpectedPathMetrics;
+exports.pathMatches = pathMatches;
+exports.computeGroupResults = computeGroupResults;
+exports.computeRankingQualityMetrics = computeRankingQualityMetrics;
+const text_1 = require("../utils/text");
+const fileGroups_1 = require("./fileGroups");
+const subsystem_1 = require("./subsystem");
+exports.QUALITY_SCORE_WEIGHTS = {
+    hitAt10: 0.35,
+    contextCoverage: 0.25,
+    avoidMiss: 0.2,
+    mrr: 0.1,
+    tokenReduction: 0.1
+};
+function clamp01(value) {
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    return Math.max(0, Math.min(1, value));
+}
+function computeQualityScore(inputs) {
+    const hit = clamp01(inputs.hitAt10Norm);
+    const coverage = clamp01(inputs.contextCoverageNorm);
+    const avoidMiss = 1 - clamp01(inputs.avoidHitRate);
+    const mrr = clamp01(inputs.mrr);
+    const tokenReduction = clamp01(inputs.tokenReductionNorm);
+    return (exports.QUALITY_SCORE_WEIGHTS.hitAt10 * hit +
+        exports.QUALITY_SCORE_WEIGHTS.contextCoverage * coverage +
+        exports.QUALITY_SCORE_WEIGHTS.avoidMiss * avoidMiss +
+        exports.QUALITY_SCORE_WEIGHTS.mrr * mrr +
+        exports.QUALITY_SCORE_WEIGHTS.tokenReduction * tokenReduction);
+}
+function computeExpectedPathMetrics(units, expectedPaths, passAtK, mode = "any") {
+    if (expectedPaths.length === 0) {
+        return {
+            expectedCount: 0,
+            coverageAt5: 0,
+            coverageAt10: 0,
+            coverageAt20: 0,
+            coverageAt40: 0,
+            missingAt10: [],
+            missingAt20: [],
+            pass: "unlabeled"
+        };
+    }
+    const fileGroups = (0, fileGroups_1.aggregateEvidenceFiles)(units);
+    const firstUnitHitIndex = units.findIndex((unit) => expectedPaths.some((expectedPath) => pathMatches(unit.relativePath, expectedPath)));
+    const firstFileHitIndex = fileGroups.findIndex((group) => expectedPaths.some((expectedPath) => pathMatches(group.relativePath, expectedPath)));
+    const coverageAtPassK = coverageAt(fileGroups.map((group) => group.relativePath), expectedPaths, passAtK);
+    const pass = mode === "all" ? coverageAtPassK === expectedPaths.length : firstFileHitIndex >= 0 && firstFileHitIndex + 1 <= passAtK;
+    return {
+        expectedCount: expectedPaths.length,
+        firstUnitHitRank: firstUnitHitIndex >= 0 ? firstUnitHitIndex + 1 : undefined,
+        firstFileHitRank: firstFileHitIndex >= 0 ? firstFileHitIndex + 1 : undefined,
+        coverageAt5: coverageAt(fileGroups.map((group) => group.relativePath), expectedPaths, 5),
+        coverageAt10: coverageAt(fileGroups.map((group) => group.relativePath), expectedPaths, 10),
+        coverageAt20: coverageAt(fileGroups.map((group) => group.relativePath), expectedPaths, 20),
+        coverageAt40: coverageAt(fileGroups.map((group) => group.relativePath), expectedPaths, 40),
+        missingAt10: missingAt(fileGroups.map((group) => group.relativePath), expectedPaths, 10),
+        missingAt20: missingAt(fileGroups.map((group) => group.relativePath), expectedPaths, 20),
+        pass
+    };
+}
+function pathMatches(actualPath, expectedPath) {
+    const actual = normalizePath(actualPath);
+    const expected = normalizePath(expectedPath);
+    if (expected.includes("*")) {
+        const escaped = expected.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+        return new RegExp(`(^|/)${escaped}$`).test(actual);
+    }
+    return actual === expected || actual.endsWith(`/${expected}`) || actual.includes(expected);
+}
+function computeGroupResults(units, groups, passAtK = 10) {
+    const filePaths = (0, fileGroups_1.aggregateEvidenceFiles)(units).map((g) => g.relativePath);
+    return groups
+        .filter((group) => {
+        if (!Array.isArray(group.paths) || group.paths.length === 0)
+            return false;
+        if (!group.name || !group.mode)
+            return false;
+        return true;
+    })
+        .map((group) => {
+        const coveragePassK = coverageAt(filePaths, group.paths, passAtK);
+        const coverage5 = coverageAt(filePaths, group.paths, 5);
+        const coverage10 = coverageAt(filePaths, group.paths, 10);
+        const coverage20 = coverageAt(filePaths, group.paths, 20);
+        const coverage40 = coverageAt(filePaths, group.paths, 40);
+        const firstHitIndex = filePaths.findIndex((fp) => group.paths.some((ep) => pathMatches(fp, ep)));
+        const pass = group.mode === "all"
+            ? coveragePassK === group.paths.length
+            : firstHitIndex >= 0 && firstHitIndex + 1 <= passAtK;
+        return {
+            name: group.name,
+            mode: group.mode,
+            expectedCount: group.paths.length,
+            firstHitRank: firstHitIndex >= 0 ? firstHitIndex + 1 : undefined,
+            passAtK,
+            coverageAtPassK: coveragePassK,
+            coverageAt5: coverage5,
+            coverageAt10: coverage10,
+            coverageAt20: coverage20,
+            coverageAt40: coverage40,
+            missingAtPassK: missingAt(filePaths, group.paths, passAtK),
+            missingAt10: missingAt(filePaths, group.paths, 10),
+            missingAt20: missingAt(filePaths, group.paths, 20),
+            passAt10: group.mode === "all" ? coverage10 === group.paths.length : firstHitIndex >= 0 && firstHitIndex + 1 <= 10,
+            pass,
+        };
+    });
+}
+function computeRankingQualityMetrics(result, topK = 10) {
+    const topUnits = result.units.slice(0, topK);
+    const uniqueTopFiles = new Set(topUnits.map((unit) => unit.relativePath)).size;
+    const duplicateEvidenceTop10 = topUnits.length - uniqueTopFiles;
+    const topGroups = (0, fileGroups_1.aggregateEvidenceFiles)(result.units).slice(0, topK);
+    const found = new Set(topGroups.map((group) => group.slot));
+    const requiredSlots = result.profile.blueprint.requiredSlots;
+    const foundRequiredSlotsTop10 = requiredSlots.filter((slot) => found.has(slot));
+    const missingRequiredSlotsTop10 = requiredSlots.filter((slot) => !found.has(slot));
+    const primarySubsystemTop10 = (0, subsystem_1.primarySubsystemFromUnits)(topGroups.flatMap((group) => group.units));
+    const subsystemFiles = topGroups.filter((group) => group.subsystem);
+    const subsystemPurityTop10 = primarySubsystemTop10 && subsystemFiles.length > 0
+        ? subsystemFiles.filter((group) => group.subsystem === primarySubsystemTop10).length / subsystemFiles.length
+        : 0;
+    return {
+        uniqueTop10Files: uniqueTopFiles,
+        duplicateEvidenceTop10,
+        slotCoverageTop10: foundRequiredSlotsTop10.length,
+        requiredSlotCount: requiredSlots.length,
+        foundRequiredSlotsTop10,
+        missingRequiredSlotsTop10,
+        contrastContextTop10: topUnits.filter((unit) => unit.contrastContext).length,
+        primarySubsystemTop10,
+        subsystemPurityTop10,
+        symbolEvidenceTop10: topUnits.filter((unit) => (unit.symbolMatches?.length ?? 0) > 0 || unit.kind === "symbol").length
+    };
+}
+function coverageAt(actualPaths, expectedPaths, k) {
+    const topPaths = actualPaths.slice(0, k);
+    return expectedPaths.filter((expectedPath) => topPaths.some((actualPath) => pathMatches(actualPath, expectedPath))).length;
+}
+function missingAt(actualPaths, expectedPaths, k) {
+    const topPaths = actualPaths.slice(0, k);
+    return expectedPaths.filter((expectedPath) => !topPaths.some((actualPath) => pathMatches(actualPath, expectedPath)));
+}
+function normalizePath(value) {
+    return (0, text_1.normalizeText)(value).replace(/\\/g, "/").replace(/^\/+/, "");
+}
+//# sourceMappingURL=evaluationMetrics.js.map