flowseeker 0.1.7

package/dist/utils/text.js

@@ -0,0 +1,364 @@
+"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.normalizeText = normalizeText;
+exports.splitIdentifier = splitIdentifier;
+exports.semanticPhraseTerms = semanticPhraseTerms;
+exports.uniq = uniq;
+exports.tokenEstimate = tokenEstimate;
+exports.fastTokenEstimate = fastTokenEstimate;
+exports.countTextTokens = countTextTokens;
+exports.languageFromPath = languageFromPath;
+exports.hasGlobMagic = hasGlobMagic;
+exports.toWorkspaceGlob = toWorkspaceGlob;
+exports.toExcludeGlob = toExcludeGlob;
+exports.snippetFromLines = snippetFromLines;
+exports.isLikelyTextPath = isLikelyTextPath;
+exports.clamp = clamp;
+const path = __importStar(require("path"));
+const { Tiktoken } = require("js-tiktoken/lite");
+const cl100kBase = require("js-tiktoken/ranks/cl100k_base");
+const stopWords = new Set([
+    "a",
+    "an",
+    "and",
+    "are",
+    "as",
+    "at",
+    "be",
+    "by",
+    "for",
+    "from",
+    "how",
+    "in",
+    "is",
+    "it",
+    "of",
+    "on",
+    "or",
+    "that",
+    "the",
+    "this",
+    "to",
+    "with",
+    "và",
+    "la",
+    "là",
+    "cua",
+    "của",
+    "cho",
+    "trong",
+    "ngoài",
+    "khi",
+    "thi",
+    "thì",
+    "một",
+    "mot",
+    "những",
+    "nhung",
+    "các",
+    "cac",
+    "được",
+    "duoc",
+    "không",
+    "khong",
+    "này",
+    "nay",
+    "đó",
+    "do",
+    "sua",
+    "sửa",
+    "thay",
+    "doi",
+    "đổi",
+    "cach",
+    "cách",
+    "tu",
+    "từ",
+    "lan",
+    "lần",
+    "dau",
+    "đầu",
+    "sang",
+    "sau",
+    "truoc",
+    "trước",
+    "thanh",
+    "thành",
+    "cong",
+    "công",
+    "moi",
+    "mới",
+    "vi",
+    "vì",
+    "bang",
+    "bằng",
+    "dua",
+    "theo",
+    "toi",
+    "minh",
+    "ban",
+    "muon",
+    "can",
+    "hay",
+    "giup",
+    "chuyen",
+    "dong",
+    "khu",
+    "vuc",
+    "chi",
+    "nhan",
+    "thoi",
+    "viet",
+    "nam"
+]);
+const semanticPhraseRules = [
+    { pattern: /\btu dong\b|\bautomatic\b|\bauto\b/, terms: ["automatic", "auto"] },
+    { pattern: /\btrinh duyet\b|\bbrowser\b/, terms: ["browser", "client", "navigator"] },
+    { pattern: /\bmui gio\b|\btimezone\b|\btime zone\b/, terms: ["timezone", "tz", "offset"] },
+    { pattern: /\bthoi gian\b|\btimestamp\b/, terms: ["timestamp", "time", "date", "datetime"] },
+    { pattern: /(?=.*\b(timestamp|time|date|datetime|thoi gian)\b)(?=.*\b(browser|client|navigator|trinh duyet)\b)/, terms: ["timezone", "tz", "offset", "locale"] },
+    { pattern: /\bkhu vuc\b|\bregion\b|\barea\b/, terms: ["region", "area", "location"] },
+    { pattern: /\bviet nam\b|\bvietnam\b/, terms: ["vietnam", "vn"] },
+    { pattern: /\bchi nhan\b|\bchi chap nhan\b|\bonly accept\b/, terms: ["accept", "allow", "only"] },
+    { pattern: /\blocating?\b|\blocate\b|\bgeo\b|\bgeoip\b|\bgeolocation\b/, terms: ["locate", "location", "geolocation", "geoip"] },
+    { pattern: /\bdia chi ip\b|\bip address\b/, terms: ["ip"] }
+];
+let encoder;
+function normalizeText(input) {
+    return repairCommonMojibake(input)
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .replace(/đ|\u0111/g, "d")
+        .replace(/Đ|\u0110/g, "D")
+        .toLowerCase();
+}
+function repairCommonMojibake(input) {
+    if (!/(?:Ã.|Â.|Ä.|Æ.|á[º»])/.test(input)) {
+        return input;
+    }
+    try {
+        const repaired = Buffer.from(input, "latin1").toString("utf8");
+        return mojibakeNoiseScore(repaired) < mojibakeNoiseScore(input) ? repaired : input;
+    }
+    catch {
+        return input;
+    }
+}
+function mojibakeNoiseScore(input) {
+    return (input.match(/(?:Ã.|Â.|Ä.|Æ.|á[º»]|�)/g) ?? []).length;
+}
+function splitIdentifier(input) {
+    const spaced = input
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/[_-]+/g, " ");
+    const tokens = normalizeText(spaced)
+        .replace(/([a-z])([A-Z])/g, "$1 $2")
+        .replace(/[^a-z0-9]+/gi, " ")
+        .split(/\s+/)
+        .map((part) => part.trim())
+        .filter((part) => part.length > 1 && !stopWords.has(part));
+    return uniq([...suppressPhraseComponents(input, tokens), ...semanticPhraseTerms(input)]);
+}
+function semanticPhraseTerms(input) {
+    const normalized = normalizeText(input).replace(/[^a-z0-9]+/g, " ");
+    return uniq(semanticPhraseRules.flatMap((rule) => (rule.pattern.test(normalized) ? rule.terms : [])));
+}
+function suppressPhraseComponents(input, tokens) {
+    const normalized = normalizeText(input).replace(/[^a-z0-9]+/g, " ");
+    const suppressed = new Set();
+    if (/\btrinh duyet\b/.test(normalized)) {
+        suppressed.add("trinh");
+        suppressed.add("duyet");
+    }
+    if (/\btu dong\b/.test(normalized)) {
+        suppressed.add("tu");
+        suppressed.add("dong");
+    }
+    if (/\bkhu vuc\b/.test(normalized)) {
+        suppressed.add("khu");
+        suppressed.add("vuc");
+    }
+    if (/\bviet nam\b/.test(normalized)) {
+        suppressed.add("viet");
+        suppressed.add("nam");
+    }
+    return tokens.filter((token) => !suppressed.has(token));
+}
+function uniq(items) {
+    return Array.from(new Set(items));
+}
+function tokenEstimate(text) {
+    return countTextTokens(text).tokens;
+}
+function fastTokenEstimate(text) {
+    if (!text.trim()) {
+        return 0;
+    }
+    return Math.ceil(text.length / 4);
+}
+function countTextTokens(text) {
+    if (!text.trim()) {
+        return { tokens: 0, method: "local_bpe", tokenizer: "cl100k_base" };
+    }
+    try {
+        encoder ?? (encoder = new Tiktoken(cl100kBase));
+        return {
+            tokens: encoder.encode(text).length,
+            method: "local_bpe",
+            tokenizer: "cl100k_base"
+        };
+    }
+    catch {
+        return {
+            tokens: Math.ceil(text.length / 4),
+            method: "heuristic",
+            tokenizer: "chars_per_4"
+        };
+    }
+}
+function languageFromPath(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const map = {
+        ".ts": "typescript",
+        ".tsx": "typescriptreact",
+        ".js": "javascript",
+        ".jsx": "javascriptreact",
+        ".py": "python",
+        ".php": "php",
+        ".java": "java",
+        ".kt": "kotlin",
+        ".kts": "kotlin",
+        ".go": "go",
+        ".cs": "csharp",
+        ".rb": "ruby",
+        ".rs": "rust",
+        ".cpp": "cpp",
+        ".cc": "cpp",
+        ".c": "c",
+        ".h": "c",
+        ".swift": "swift",
+        ".html": "html",
+        ".vue": "vue",
+        ".svelte": "svelte",
+        ".md": "markdown",
+        ".json": "json",
+        ".yaml": "yaml",
+        ".yml": "yaml",
+        ".toml": "toml",
+        ".xml": "xml",
+        ".sql": "sql",
+        ".graphql": "graphql",
+        ".gql": "graphql"
+    };
+    return map[ext];
+}
+function hasGlobMagic(value) {
+    return /[*?{[\]]/.test(value);
+}
+function toWorkspaceGlob(value) {
+    const normalized = value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, "");
+    if (!normalized || normalized === ".") {
+        return "**/*";
+    }
+    if (hasGlobMagic(normalized)) {
+        const basename = normalized.split("/").at(-1) ?? normalized;
+        if (!normalized.includes("**") && !basename.includes(".")) {
+            return `${normalized}/**/*`;
+        }
+        return normalized;
+    }
+    return `${normalized}/**/*`;
+}
+function toExcludeGlob(values) {
+    const parts = values
+        .map((value) => value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, ""))
+        .filter(Boolean)
+        .map((value) => (hasGlobMagic(value) ? value : `**/${value}/**`));
+    return parts.length > 0 ? `{${parts.join(",")}}` : "";
+}
+function snippetFromLines(lines, startLine, endLine, maxLineChars = 1200) {
+    const start = Math.max(1, startLine);
+    const end = Math.min(lines.length, endLine);
+    const width = String(end).length;
+    return lines
+        .slice(start - 1, end)
+        .map((line, index) => `${String(start + index).padStart(width, " ")}: ${truncateLine(line, maxLineChars)}`)
+        .join("\n");
+}
+function truncateLine(line, maxLineChars) {
+    if (line.length <= maxLineChars) {
+        return line;
+    }
+    return `${line.slice(0, maxLineChars)} ... [truncated ${line.length - maxLineChars} chars]`;
+}
+function isLikelyTextPath(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const denied = new Set([
+        ".png",
+        ".jpg",
+        ".jpeg",
+        ".gif",
+        ".webp",
+        ".ico",
+        ".pdf",
+        ".zip",
+        ".gz",
+        ".tar",
+        ".rar",
+        ".7z",
+        ".exe",
+        ".dll",
+        ".so",
+        ".dylib",
+        ".class",
+        ".jar",
+        ".wasm",
+        ".bin",
+        ".db",
+        ".sqlite",
+        ".sqlite3",
+        ".map",
+        ".log",
+        ".csv",
+        ".tsv",
+        ".lock"
+    ]);
+    return !denied.has(ext);
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+//# sourceMappingURL=text.js.map

package/dist/utils/updateChecker.js

@@ -0,0 +1,140 @@
+"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.checkForExtensionUpdate = checkForExtensionUpdate;
+exports.checkForPackageUpdate = checkForPackageUpdate;
+exports.fetchLatestPackageVersion = fetchLatestPackageVersion;
+exports.compareSemver = compareSemver;
+const PACKAGE_NAME = "flowseeker";
+const NPM_LATEST_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+const NPM_PACKAGE_URL = `https://www.npmjs.com/package/${PACKAGE_NAME}`;
+const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const UPDATE_CHECK_TIMEOUT_MS = 5000;
+const LAST_CHECKED_KEY = "flowseeker.update.lastCheckedAt";
+const DISMISSED_VERSION_KEY = "flowseeker.update.dismissedVersion";
+async function checkForExtensionUpdate(context) {
+    const now = Date.now();
+    const lastCheckedAt = context.globalState.get(LAST_CHECKED_KEY, 0);
+    if (now - lastCheckedAt < UPDATE_CHECK_INTERVAL_MS) {
+        return;
+    }
+    await context.globalState.update(LAST_CHECKED_KEY, now);
+    const currentVersion = String(context.extension.packageJSON?.version ?? "");
+    const result = await checkForPackageUpdate(currentVersion);
+    if (result.error) {
+        return;
+    }
+    if (!result.hasUpdate || !result.latestVersion) {
+        return;
+    }
+    const dismissedVersion = context.globalState.get(DISMISSED_VERSION_KEY, "");
+    if (dismissedVersion === result.latestVersion) {
+        return;
+    }
+    const vscode = await Promise.resolve().then(() => __importStar(require("vscode")));
+    const action = await vscode.window.showInformationMessage(`FlowSeeker ${result.latestVersion} is available. You are using ${result.currentVersion}.`, "View on npm", "Dismiss this version");
+    if (action === "View on npm") {
+        await vscode.env.openExternal(vscode.Uri.parse(NPM_PACKAGE_URL));
+    }
+    else if (action === "Dismiss this version") {
+        await context.globalState.update(DISMISSED_VERSION_KEY, result.latestVersion);
+    }
+}
+async function checkForPackageUpdate(currentVersion) {
+    try {
+        const latestVersion = await fetchLatestPackageVersion();
+        return {
+            currentVersion,
+            latestVersion,
+            hasUpdate: compareSemver(latestVersion, currentVersion) > 0
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { currentVersion, hasUpdate: false, error: message };
+    }
+}
+async function fetchLatestPackageVersion() {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), UPDATE_CHECK_TIMEOUT_MS);
+    try {
+        const response = await fetch(NPM_LATEST_URL, { signal: controller.signal });
+        if (!response.ok) {
+            throw new Error(`npm registry returned ${response.status}`);
+        }
+        const body = await response.json();
+        if (typeof body.version !== "string" || !body.version.trim()) {
+            throw new Error("npm registry response did not include a version");
+        }
+        return body.version.trim();
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function compareSemver(left, right) {
+    const a = parseSemver(left);
+    const b = parseSemver(right);
+    if (!a || !b) {
+        return 0;
+    }
+    for (let i = 0; i < 3; i++) {
+        const diff = a.parts[i] - b.parts[i];
+        if (diff !== 0) {
+            return diff > 0 ? 1 : -1;
+        }
+    }
+    if (a.prerelease === b.prerelease) {
+        return 0;
+    }
+    if (!a.prerelease && b.prerelease) {
+        return 1;
+    }
+    if (a.prerelease && !b.prerelease) {
+        return -1;
+    }
+    return a.prerelease > b.prerelease ? 1 : -1;
+}
+function parseSemver(version) {
+    const match = version.trim().replace(/^v/i, "").match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/);
+    if (!match) {
+        return undefined;
+    }
+    return {
+        parts: [Number(match[1]), Number(match[2]), Number(match[3])],
+        prerelease: match[4] ?? ""
+    };
+}
+//# sourceMappingURL=updateChecker.js.map