flowseeker 0.1.7

package/dist/pipeline/taskUnderstanding.js

@@ -0,0 +1,453 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.understandTask = understandTask;
+const text_1 = require("../utils/text");
+const contextBlueprint_1 = require("./contextBlueprint");
+const retrievalPlan_1 = require("./retrievalPlan");
+const actionWords = new Set([
+    "add",
+    "create",
+    "update",
+    "notify",
+    "release",
+    "change",
+    "fix",
+    "remove",
+    "delete",
+    "refactor",
+    "rename",
+    "doi",
+    "send",
+    "export",
+    "import",
+    "upload",
+    "download",
+    "retry",
+    "fail",
+    "review",
+    "investigate",
+    "trace",
+    "debug",
+    "check",
+    "explain",
+    "describe",
+    "understand",
+    "validate",
+    "authorize",
+    "login",
+    "logout",
+    "them",
+    "sua",
+    "xoa",
+    "gui",
+    "xuat",
+    "kiem",
+    "giai",
+    "thich",
+    "mo",
+    "ta",
+    "loi"
+]);
+const actionSynonyms = {
+    gui: ["send", "sent", "dispatch"],
+    send: ["sent", "dispatch"],
+    xuat: ["export", "download"],
+    export: ["download", "csv", "excel", "xlsx", "report"],
+    import: ["upload", "file"],
+    upload: ["submit", "submission", "file", "attachment"],
+    download: ["export", "file"],
+    retry: ["queue", "job", "worker", "attempt"],
+    validate: ["verify", "check", "validation"],
+    authorize: ["permission", "policy", "role"],
+    login: ["auth", "session", "token"],
+    them: ["add", "create"],
+    add: ["create", "new"],
+    change: ["update", "modify"],
+    doi: ["change", "update"],
+    xoa: ["delete", "remove"],
+    delete: ["remove"],
+    refactor: ["rename", "extract"],
+    review: ["investigate", "trace", "check"],
+    investigate: ["trace", "debug", "check"],
+    check: ["verify", "validate"],
+    notify: ["notification", "message", "notice", "update"],
+    update: ["version", "release", "latest", "newer"],
+    release: ["version", "update", "latest", "newer"],
+    explain: [],
+    describe: [],
+    understand: [],
+    giai: [],
+    thich: [],
+    mo: [],
+    ta: []
+};
+const lowSignalActorTerms = new Set(["user", "account", "profile", "member"]);
+const lowSignalInstructionTerms = new Set([
+    "not",
+    "able",
+    "any",
+    "existing",
+    "appears",
+    "should",
+    "support",
+    "supports",
+    "implement",
+    "implementation",
+    "users",
+    "explain",
+    "describe",
+    "understand",
+    "giai",
+    "thich",
+    "chuc",
+    "nang",
+    "mo",
+    "ta",
+    "function",
+    "functionality"
+]);
+function understandTask(task, config) {
+    const normalizedTask = (0, text_1.normalizeText)(task);
+    const rawTokens = (0, text_1.splitIdentifier)(task);
+    const literalCodeTerms = detectLiteralCodeTerms(task);
+    const actions = rawTokens.filter((term) => actionWords.has(term));
+    const phraseTerms = detectPhraseTerms(normalizedTask);
+    const concepts = pruneLowSignalConcepts((0, text_1.uniq)([...literalCodeTerms, ...rawTokens.filter((term) => !actionWords.has(term) && !lowSignalInstructionTerms.has(term)), ...phraseTerms])).slice(0, 28);
+    const synonymTerms = expandSynonyms([...concepts, ...actions], config.synonyms);
+    const actionTerms = actions.flatMap((action) => actionSynonyms[action] ?? [action]);
+    const keywords = (0, text_1.uniq)([...literalCodeTerms, ...concepts, ...synonymTerms, ...actionTerms]).filter((term) => term.length > 1);
+    const intent = detectIntent(normalizedTask);
+    const negativeTerms = detectNegativeTerms(normalizedTask);
+    const blueprint = (0, contextBlueprint_1.buildTaskBlueprint)({ intent: intent.intent, normalizedTask, concepts, actions, keywords, negativeTerms, confidence: intent.confidence });
+    const retrieval = (0, retrievalPlan_1.createRetrievalPlan)({ rawTask: task, normalizedTask, concepts, actions, keywords, blueprint }, config);
+    return {
+        rawTask: task,
+        normalizedTask,
+        intent: blueprint.shape,
+        taskShape: blueprint.shape,
+        intentConfidence: intent.confidence,
+        blueprint,
+        flowNeeds: blueprint.requiredSlots,
+        concepts,
+        actions,
+        entities: detectEntities(keywords),
+        negativeTerms,
+        literalTerms: literalCodeTerms,
+        keywords,
+        strategies: retrieval.strategies,
+        passes: retrieval.passes
+    };
+}
+function detectLiteralCodeTerms(task) {
+    const terms = [];
+    const emailPattern = /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi;
+    const quotedPattern = /["'`]([^"'`]{3,160})["'`]/g;
+    const routePattern = /\/(?:[A-Za-z0-9_:@.-]+\/)*[A-Za-z0-9_:@.-]+/g;
+    const pathPattern = /\b(?:[$A-Za-z0-9_.-]+\/)+[$A-Za-z0-9_.-]+\b/g;
+    const functionPattern = /\b[$A-Za-z_][$A-Za-z0-9_$.:#]*\s*\(/g;
+    const candidatePattern = /\b[$A-Za-z_][$A-Za-z0-9_$.:#]*\b/g;
+    let match = emailPattern.exec(task);
+    while (match) {
+        addLiteralValueTerm(terms, match[0]);
+        match = emailPattern.exec(task);
+    }
+    match = quotedPattern.exec(task);
+    while (match) {
+        addLiteralValueTerm(terms, match[1]);
+        if (isStrongCodeIdentifier(match[1])) {
+            addCodeTerm(terms, match[1]);
+        }
+        match = quotedPattern.exec(task);
+    }
+    match = routePattern.exec(task);
+    while (match) {
+        addPathLiteralTerm(terms, match[0]);
+        match = routePattern.exec(task);
+    }
+    match = pathPattern.exec(task);
+    while (match) {
+        if (isLikelyPathLiteral(match[0])) {
+            addPathLiteralTerm(terms, match[0]);
+        }
+        match = pathPattern.exec(task);
+    }
+    match = functionPattern.exec(task);
+    while (match) {
+        addCodeTerm(terms, match[0].replace(/\s*\($/, ""));
+        match = functionPattern.exec(task);
+    }
+    match = candidatePattern.exec(task);
+    while (match) {
+        const candidate = match[0];
+        if (isStrongCodeIdentifier(candidate)) {
+            addCodeTerm(terms, candidate);
+        }
+        match = candidatePattern.exec(task);
+    }
+    return (0, text_1.uniq)(terms).slice(0, 12);
+}
+function isStrongCodeIdentifier(candidate) {
+    const normalized = (0, text_1.normalizeText)(candidate);
+    const simpleExtensionFile = /^[a-z0-9-]+\.[a-z0-9]{1,5}$/.test(normalized);
+    const simpleFileBase = normalized.replace(/\.[a-z0-9]{1,5}$/, "");
+    const genericSimpleFiles = new Set(["index", "page", "route", "layout", "app", "main"]);
+    return ((simpleExtensionFile && !genericSimpleFiles.has(simpleFileBase)) ||
+        candidate.includes("_") ||
+        candidate.includes("$") ||
+        (candidate.includes(".") && !simpleExtensionFile) ||
+        candidate.includes(":") ||
+        candidate.includes("#") ||
+        /[a-z][A-Z]/.test(candidate));
+}
+function addCodeTerm(terms, candidate) {
+    const normalized = (0, text_1.normalizeText)(candidate).replace(/^[.:#]+|[.:#]+$/g, "");
+    const pathLike = normalized.replace(/[.:#]+/g, "_");
+    const leaf = normalized.split(/[.:#]+/).at(-1) ?? normalized;
+    const leafParts = (0, text_1.splitIdentifier)(leaf);
+    for (const term of [
+        pathLike,
+        leaf,
+        leafParts.length > 1 ? leafParts.join("_") : "",
+        leafParts.length > 1 ? leafParts.join("") : ""
+    ]) {
+        if (term.length > 2) {
+            terms.push(term);
+        }
+    }
+}
+function addLiteralValueTerm(terms, value) {
+    const normalized = (0, text_1.normalizeText)(value).trim();
+    const collapsed = normalized.replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+    for (const term of [normalized, collapsed]) {
+        if (term.length > 2) {
+            terms.push(term);
+        }
+    }
+}
+function addPathLiteralTerm(terms, value) {
+    const normalized = (0, text_1.normalizeText)(value).replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+    const collapsed = normalized.replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+    const basename = normalized.split("/").at(-1) ?? normalized;
+    const basenameTerm = /\.[a-z0-9]+$/.test(basename) ? "" : basename;
+    for (const term of [normalized, collapsed, basenameTerm]) {
+        if (term.length > 2) {
+            terms.push(term);
+        }
+    }
+}
+function isLikelyPathLiteral(value) {
+    const normalized = (0, text_1.normalizeText)(value).replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+    const segments = normalized.split("/").filter(Boolean);
+    if (segments.length >= 3) {
+        return true;
+    }
+    if (segments.length < 2) {
+        return false;
+    }
+    const first = segments[0];
+    const last = segments[segments.length - 1];
+    const commonRoots = new Set(["src", "app", "apps", "packages", "pkg", "internal", "lib", "libs", "test", "tests"]);
+    return commonRoots.has(first) || /\.[a-z0-9]{1,8}$/.test(last);
+}
+function detectPhraseTerms(normalizedTask) {
+    const terms = [];
+    if (/\btrinh\s+duyet\b|\bbrowser\b/.test(normalizedTask)) {
+        terms.push("browser", "client", "navigator", "timezone", "time_zone", "tz");
+    }
+    if (/\bmui\s+gio\b|\btimezone\b|\btime\s+zone\b/.test(normalizedTask)) {
+        terms.push("timezone", "time_zone", "tz", "utc", "local_time");
+    }
+    if (/\bthoi\s+gian\b|\btimestamp\b|\bdatetime\b/.test(normalizedTask)) {
+        terms.push("timestamp", "datetime", "date", "time");
+    }
+    if (/\b(currency|currencies|exchange\s+rate|exchange_rate|converter|conversion|eur|usd|vnd|gbp|jpy)\b/.test(normalizedTask) || (/\bconvert\b/.test(normalizedTask) && /\b(amount|money|transaction|payment)\b/.test(normalizedTask))) {
+        terms.push("currency", "exchange", "exchange_rate", "rate", "converter", "conversion", "amount");
+    }
+    if (/\bso\s+du\b|\bbalance\b|\bfunds?\b/.test(normalizedTask)) {
+        terms.push("balance", "funds", "account");
+    }
+    if ((/\bkhong\s+du\b|\binsufficient\b|\bnot\s+enough\b/.test(normalizedTask)) && /\b(so\s+du|balance|funds?|account|tai\s+khoan)\b/.test(normalizedTask)) {
+        terms.push("insufficient", "insufficient_funds", "funds", "balance", "exception", "error");
+    }
+    if (/\bchuyen\s+tien\b|\btransfer\b/.test(normalizedTask)) {
+        terms.push("transfer", "transaction");
+    }
+    if (/\btruy\s+van\b|\bqueries\b|\bquery\b|\bjoin\b|\bn\+1\b|\bn\s*\+\s*1\b/.test(normalizedTask)) {
+        terms.push("query", "queries", "join", "database", "model", "repository");
+    }
+    if (/\bban(?:ned)?\b/.test(normalizedTask) && /\b(user|account|member)\b/.test(normalizedTask)) {
+        terms.push("ban", "banned", "blocked", "disabled", "status", "user", "account", "login", "auth");
+    }
+    if (/\bhoc\s+vien\b|\bstudent\b|\blearner\b/.test(normalizedTask)) {
+        terms.push("student", "learner", "member");
+    }
+    if (/\bkhoa\s+hoc\b|\bcourse\b/.test(normalizedTask)) {
+        terms.push("course");
+    }
+    if (/\bhang\s+loat\b|\bbulk\b|\bbatch\b/.test(normalizedTask)) {
+        terms.push("bulk", "batch", "process", "job");
+    }
+    if (/\b(dang\s+ky|enroll|enrollment|registration)\b/.test(normalizedTask) &&
+        /\b(khoa\s+hoc|course|hoc\s+vien|student|learner|member)\b/.test(normalizedTask)) {
+        terms.push("enrollment", "enroll", "registration", "student", "course");
+    }
+    if (/\bmcp\s+server\b/.test(normalizedTask)) {
+        terms.push("mcp", "server", "mcpserver", "flowseeker_mcp");
+    }
+    if (/\b(thong\s+bao|notification|notify)\b/.test(normalizedTask)) {
+        terms.push("notification", "notify", "message");
+    }
+    if (/\b(thong\s+bao|notification|notify)\b/.test(normalizedTask) && /\b(ung\s+dung|in\s+app|in-app|app)\b/.test(normalizedTask)) {
+        terms.push("notification", "in_app", "inapp", "event");
+    }
+    const hasDocumentObject = /\b(tai lieu|document|attachment)\b/.test(normalizedTask);
+    const hasTransferFileObject = /\bfile\b/.test(normalizedTask) && /\b(nop|submit|submission|upload|download|import|export|xuat|tai len|tai xuong)\b/.test(normalizedTask);
+    if (/\b(nop|submit|submission|upload)\b/.test(normalizedTask) && (hasDocumentObject || hasTransferFileObject)) {
+        terms.push("submission", "upload", "document", "attachment", "file");
+    }
+    if (hasDocumentObject || hasTransferFileObject) {
+        terms.push("document", "attachment", "file");
+    }
+    if (/\b(loai|type|category)\b/.test(normalizedTask)) {
+        terms.push("type", "category");
+    }
+    if (/\b(phan quyen|permission|role|authorize|auth)\b/.test(normalizedTask)) {
+        terms.push("permission", "role", "policy", "authorize", "auth");
+    }
+    if (/\b(xuat|export|download|import)\b/.test(normalizedTask)) {
+        terms.push("export", "download", "import", "file");
+    }
+    if (/\bgio\s+hang\b|\bcart\b|\bbasket\b/.test(normalizedTask)) {
+        terms.push("cart", "basket");
+    }
+    if (/\bsan\s+pham\b|\bproduct\b/.test(normalizedTask)) {
+        terms.push("product");
+    }
+    if (/\bthanh\s+toan\b|\bcheckout\b|\bpayment\b/.test(normalizedTask)) {
+        terms.push("checkout", "payment", "billing");
+    }
+    if (/\bgiao\s+dien\b|\bfrontend\b|\bfront\s+end\b|\bui\b/.test(normalizedTask)) {
+        terms.push("ui", "frontend", "component", "view");
+    }
+    if (/\b(display|displayed|displays|shown|show|render|rendered|visible|hien\s+thi)\b/.test(normalizedTask)) {
+        terms.push("display", "render", "view", "ui");
+    }
+    if (/\btrang\b(?!\s+thai)|\bpage\b|\bscreen\b/.test(normalizedTask)) {
+        terms.push("page", "screen");
+    }
+    if (/\b(api\s+base\s+url|base\s+url)\b/.test(normalizedTask)) {
+        terms.push("api", "base_url", "baseurl", "endpoint", "client", "http", "config");
+    }
+    if (/\b(url|route|path|href|link|slug|params?|lookup)\b/.test(normalizedTask) && !/\b(api\s+base\s+url|base\s+url|config|env)\b/.test(normalizedTask)) {
+        terms.push("route", "page", "link", "href", "params", "slug");
+    }
+    if (/\btim\s+kiem\b|\bsearch\b|\bsuggestion\b|\bautocomplete\b/.test(normalizedTask)) {
+        terms.push("search", "suggestion", "autocomplete");
+    }
+    if (/\btin\s+nhan\b|\bmessage\b|\bchat\b|\bconversation\b/.test(normalizedTask)) {
+        terms.push("message", "chat", "conversation");
+    }
+    if (/\bnguoi\s+ban\b|\bseller\b|\bvendor\b|\bmerchant\b/.test(normalizedTask)) {
+        terms.push("seller", "vendor", "merchant");
+    }
+    if (/\bdon\s+hang\b|\border\b/.test(normalizedTask)) {
+        terms.push("order");
+    }
+    if (/\banh\b|\bhinh\b|\bimage\b|\bphoto\b|\bgallery\b|\bavatar\b|\bzoom\b/.test(normalizedTask)) {
+        terms.push("image", "photo", "gallery", "avatar", "zoom");
+    }
+    return terms;
+}
+function pruneLowSignalConcepts(concepts) {
+    const strongerConcepts = concepts.filter((term) => !lowSignalActorTerms.has(term));
+    return strongerConcepts.length >= 2 ? strongerConcepts : concepts;
+}
+function expandSynonyms(tokens, synonyms) {
+    const normalizedTokens = new Set(tokens.map(text_1.normalizeText));
+    const expanded = [];
+    for (const [key, values] of Object.entries(synonyms)) {
+        const normalizedKey = (0, text_1.normalizeText)(key);
+        const normalizedValues = values.map(text_1.normalizeText);
+        const matches = normalizedTokens.has(normalizedKey) || (allowReverseSynonymExpansion(normalizedKey) && normalizedValues.some((value) => normalizedTokens.has(value)));
+        if (matches) {
+            expanded.push(normalizedKey, ...normalizedValues);
+        }
+    }
+    return expanded;
+}
+function allowReverseSynonymExpansion(key) {
+    return !new Set(["auth", "document", "upload", "export"]).has(key);
+}
+function detectIntent(normalizedTask) {
+    if (/\b(sua|fix|khac phuc|loi|bug|fail|error|exception|khong|sai|hong)\b/.test(normalizedTask)) {
+        return { intent: "bugfix", confidence: 0.86 };
+    }
+    if (/\b(security|xss|csrf|sql injection|permission|authorize|authz|bao mat|phan quyen)\b/.test(normalizedTask)) {
+        return { intent: "security", confidence: 0.84 };
+    }
+    if (/\b(performance|slow|timeout|lag|cham|toi uu)\b/.test(normalizedTask)) {
+        return { intent: "performance", confidence: 0.84 };
+    }
+    if (/\b(migration|migrate|schema|database|db|database table)\b/.test(normalizedTask)) {
+        return { intent: "migration", confidence: 0.84 };
+    }
+    if (/\b(refactor|rename|doi ten|tach|gop|chuyen|switch|convert|change|change from)\b/.test(normalizedTask)) {
+        return { intent: "refactor", confidence: 0.78 };
+    }
+    if (/\b(find|investigate|trace|debug|review|check|explain|describe|understand|kiem tra|danh gia|ra soat|tim|giai thich|mo ta|tim hieu|cach hoat dong|how it works|how .* works)\b/.test(normalizedTask)) {
+        return { intent: "investigation", confidence: 0.78 };
+    }
+    if (/\b(add|create|new|feature|them|tao|xuat|export|download|upload|import)\b/.test(normalizedTask)) {
+        return { intent: "feature", confidence: 0.80 };
+    }
+    return { intent: "unknown", confidence: 0.35 };
+}
+function detectEntities(keywords) {
+    const entityHints = new Set([
+        "user", "account", "student", "learner", "member", "admin",
+        "invoice", "order", "payment", "course", "enrollment",
+        "document", "submission", "attachment", "notification", "message",
+        "policy", "claim", "refund", "audit", "report", "product", "cart",
+        "wishlist", "search", "seller", "vendor", "merchant"
+    ]);
+    const entities = [];
+    for (const keyword of keywords) {
+        const normalized = (0, text_1.normalizeText)(keyword);
+        const singular = normalized.endsWith("ies")
+            ? `${normalized.slice(0, -3)}y`
+            : normalized.endsWith("s")
+                ? normalized.slice(0, -1)
+                : normalized;
+        if (entityHints.has(normalized)) {
+            entities.push(normalized);
+        }
+        if (entityHints.has(singular)) {
+            entities.push(singular);
+        }
+    }
+    return (0, text_1.uniq)(entities);
+}
+function detectNegativeTerms(normalizedTask) {
+    const terms = [];
+    const stopWords = new Set(["and", "or", "but", "when", "then", "only", "just", "ma", "nhung", "khi", "sau", "truoc", "chi", "thoi", "bang"]);
+    const patterns = [
+        /\b(?:without|exclude|excluding|not\s+using|not\s+use|not\s+by)\s+([a-z0-9_\-\s]{1,40})/g,
+        /\b(?:except)\s+([a-z0-9_\-\s]{1,40})/g,
+        /\b(?:instead\s+of|rather\s+than)\s+([a-z0-9_\-\s]{1,40})/g,
+        /\b(?:khong su dung|khong dung|loai tru|ngoai tru)\s+([a-z0-9_\-\s]{1,40})/g,
+        /\b(?:thay vi|thay cho)\s+([a-z0-9_\-\s]{1,40})/g
+    ];
+    for (const pattern of patterns) {
+        let match = pattern.exec(normalizedTask);
+        while (match) {
+            for (const token of (0, text_1.splitIdentifier)(match[1]).slice(0, 4)) {
+                if (token.length > 1 && !stopWords.has(token)) {
+                    terms.push(token);
+                }
+            }
+            match = pattern.exec(normalizedTask);
+        }
+    }
+    return (0, text_1.uniq)(terms).slice(0, 8);
+}
+//# sourceMappingURL=taskUnderstanding.js.map

package/dist/pipeline/tokenSavings.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeTokenSavings = computeTokenSavings;
+exports.formatTokenCount = formatTokenCount;
+exports.formatReductionPercent = formatReductionPercent;
+exports.formatTokenSavingsLine = formatTokenSavingsLine;
+exports.formatTokenProofSummary = formatTokenProofSummary;
+const text_1 = require("../utils/text");
+const fileGroups_1 = require("./fileGroups");
+const solvePacket_1 = require("./solvePacket");
+function computeTokenSavings(result) {
+    const stats = result.stats;
+    const packetText = result.solvePacket ? (0, solvePacket_1.renderSolvePacketMarkdown)(result.solvePacket) : result.contextPack;
+    const packetTokens = (0, text_1.countTextTokens)(packetText);
+    const contextPackTokens = (0, text_1.countTextTokens)(result.contextPack);
+    const basis = stats.indexedTokens !== undefined ? "workspace_index" : stats.scannedTokens && stats.scannedTokens > 0 ? "scanned_text" : "unavailable";
+    const proofWarnings = tokenProofWarnings(result, basis);
+    const workspaceTokensEstimate = basis === "workspace_index"
+        ? stats.indexedTokens ?? 0
+        : basis === "scanned_text"
+            ? stats.scannedTokens ?? 0
+            : 0;
+    const status = basis === "unavailable" ? "unavailable" : stats.stoppedEarly || basis === "scanned_text" ? "partial" : "estimated";
+    const proofStatus = basis === "unavailable" ? "unavailable" : status === "partial" ? "partial" : "complete";
+    const reason = status === "partial"
+        ? partialReason(result, basis)
+        : status === "unavailable"
+            ? "No readable workspace text was available for token estimation."
+            : undefined;
+    return {
+        status,
+        basis,
+        method: basis === "workspace_index" ? "heuristic" : packetTokens.method === "local_bpe" && contextPackTokens.method === "local_bpe" ? "local_bpe" : "heuristic",
+        tokenizer: basis === "workspace_index" ? `${packetTokens.tokenizer}+workspace_chars_per_4` : packetTokens.method === "local_bpe" && contextPackTokens.method === "local_bpe" ? "cl100k_base" : "chars_per_4",
+        reason,
+        proofStatus,
+        proofWarnings,
+        workspaceTokensEstimate,
+        candidateTokensEstimate: stats.scannedTokens ?? 0,
+        solvePacketTokensEstimate: packetTokens.tokens,
+        contextPackTokensEstimate: contextPackTokens.tokens,
+        reductionPercent: computeReductionPercent(workspaceTokensEstimate, packetTokens.tokens),
+        workspaceFileCount: stats.indexedFiles ?? stats.discoveredFiles,
+        scannedFileCount: stats.scannedFiles,
+        rankedFileCount: (0, fileGroups_1.aggregateEvidenceFiles)(result.units).length
+    };
+}
+function formatTokenCount(tokens) {
+    if (!Number.isFinite(tokens) || tokens <= 0) {
+        return "0";
+    }
+    if (tokens >= 1000000) {
+        return `${trimFixed(tokens / 1000000)}M`;
+    }
+    if (tokens >= 1000) {
+        return `${trimFixed(tokens / 1000)}k`;
+    }
+    return String(Math.round(tokens));
+}
+function formatReductionPercent(value) {
+    if (!Number.isFinite(value) || value <= 0) {
+        return "0%";
+    }
+    if (value >= 99.995) {
+        return "99.99%";
+    }
+    return `${value.toFixed(value >= 99 ? 2 : 1)}%`;
+}
+function formatTokenSavingsLine(metrics) {
+    if (!metrics || metrics.status === "unavailable") {
+        return "tokens unavailable";
+    }
+    return `tokens ${formatTokenCount(metrics.solvePacketTokensEstimate)}/${formatTokenCount(metrics.workspaceTokensEstimate)} saved=${formatReductionPercent(metrics.reductionPercent)} tokenizer=${metrics.tokenizer}`;
+}
+function formatTokenProofSummary(task, metrics, contextCoverage) {
+    if (!metrics || metrics.status === "unavailable") {
+        return "FlowSeeker token proof unavailable — no readable workspace text was available for estimation.";
+    }
+    const lines = [
+        "FlowSeeker Token Proof",
+        "======================",
+        `Task: ${task}`,
+        `Packet tokens: ${formatTokenCount(metrics.solvePacketTokensEstimate)}`,
+        `Workspace tokens: ${formatTokenCount(metrics.workspaceTokensEstimate)}`,
+        `Reduction: ${formatReductionPercent(metrics.reductionPercent)}`,
+        `Tokenizer: ${metrics.tokenizer}`,
+        `Method: ${metrics.method}`,
+        `Proof status: ${metrics.proofStatus}`,
+    ];
+    if (contextCoverage) {
+        lines.push(`Context coverage: ${contextCoverage.foundRequiredSlots.length}/${contextCoverage.requiredSlots.length} slots`);
+        if (contextCoverage.missingRequiredSlots.length) {
+            lines.push(`Missing slots: ${contextCoverage.missingRequiredSlots.join(", ")}`);
+        }
+    }
+    if (metrics.proofWarnings && metrics.proofWarnings.length > 0) {
+        lines.push("Warnings:");
+        for (const warning of metrics.proofWarnings) {
+            lines.push(`  - ${warning}`);
+        }
+    }
+    if (metrics.reason) {
+        lines.push(`Note: ${metrics.reason}`);
+    }
+    return lines.join("\n");
+}
+function computeReductionPercent(workspaceTokens, packetTokens) {
+    if (!Number.isFinite(workspaceTokens) || workspaceTokens <= 0) {
+        return 0;
+    }
+    const reduced = Math.max(0, workspaceTokens - Math.max(0, packetTokens));
+    return (reduced / workspaceTokens) * 100;
+}
+function partialReason(result, basis) {
+    const reasons = [];
+    if (basis === "scanned_text") {
+        reasons.push("workspace index was unavailable, so the baseline uses scanned candidate text only");
+    }
+    if (result.stats.stoppedEarly) {
+        reasons.push(result.stats.stopReason ?? "scan stopped early");
+    }
+    return reasons.join("; ");
+}
+function tokenProofWarnings(result, basis) {
+    const warnings = [];
+    if (basis === "scanned_text") {
+        warnings.push("workspace index unavailable; baseline uses scanned candidate text");
+    }
+    if (basis === "workspace_index") {
+        warnings.push("workspace baseline uses fast chars-per-4 token estimate to keep indexing responsive");
+    }
+    if (result.stats.stoppedEarly) {
+        warnings.push(result.stats.stopReason ?? "scan stopped early");
+    }
+    if (result.stats.capped) {
+        warnings.push("ranked evidence was capped; expand packet if required context is missing");
+    }
+    if (result.contextCoverage?.missingRequiredSlots.length) {
+        warnings.push(`missing required slots: ${result.contextCoverage.missingRequiredSlots.join(", ")}`);
+    }
+    return warnings;
+}
+function trimFixed(value) {
+    return value.toFixed(value >= 10 ? 1 : 2).replace(/\.0+$|(\.\d*[1-9])0+$/, "$1");
+}
+//# sourceMappingURL=tokenSavings.js.map