grepmax 0.7.0

package/dist/commands/skeleton.js

@@ -0,0 +1,288 @@
+"use strict";
+/**
+ * osgrep skeleton - Show code skeleton (signatures without implementation)
+ *
+ * Usage:
+ *   osgrep skeleton <file>           # Skeleton of a file
+ *   osgrep skeleton <symbol>         # Find symbol and skeleton its file
+ *   osgrep skeleton "query"          # Search and skeleton top results
+ */
+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;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.skeleton = void 0;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const commander_1 = require("commander");
+const sync_helpers_1 = require("../lib/index/sync-helpers");
+const syncer_1 = require("../lib/index/syncer");
+const searcher_1 = require("../lib/search/searcher");
+const setup_helpers_1 = require("../lib/setup/setup-helpers");
+const retriever_1 = require("../lib/skeleton/retriever");
+const skeletonizer_1 = require("../lib/skeleton/skeletonizer");
+const vector_db_1 = require("../lib/store/vector-db");
+const exit_1 = require("../lib/utils/exit");
+const project_root_1 = require("../lib/utils/project-root");
+/**
+ * Check if target looks like a file path.
+ */
+function isFilePath(target) {
+    // Has path separator or file extension
+    return (target.includes("/") || target.includes("\\") || /\.\w{1,10}$/.test(target));
+}
+/**
+ * Check if target looks like a symbol name (PascalCase or camelCase identifier).
+ */
+function isSymbolLike(target) {
+    // PascalCase class name or camelCase function name
+    // Must be a single word without spaces
+    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(target) && !target.includes(" ");
+}
+/**
+ * Find a file by symbol name in the index.
+ */
+function findFileBySymbol(symbol, db) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const table = yield db.ensureTable();
+            // Search for files that define this symbol
+            const results = yield table.search(symbol).limit(10).toArray();
+            // Find a result where this symbol is defined
+            for (const result of results) {
+                const defined = result.defined_symbols;
+                if (defined === null || defined === void 0 ? void 0 : defined.includes(symbol)) {
+                    return result.path;
+                }
+            }
+            // Fallback: just return the first match's file
+            if (results.length > 0) {
+                return results[0].path;
+            }
+            return null;
+        }
+        catch (_a) {
+            return null;
+        }
+    });
+}
+exports.skeleton = new commander_1.Command("skeleton")
+    .description("Show code skeleton (signatures without implementation)")
+    .argument("<target>", "File path, symbol name, or search query")
+    .option("-l, --limit <n>", "Max files for query mode", "3")
+    .option("--json", "Output as JSON", false)
+    .option("--no-summary", "Omit call/complexity summary in bodies", false)
+    .option("-s, --sync", "Sync index before searching", false)
+    .action((target, options, _cmd) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    let vectorDb = null;
+    try {
+        // Initialize
+        yield (0, setup_helpers_1.ensureSetup)();
+        const projectRoot = (_a = (0, project_root_1.findProjectRoot)(process.cwd())) !== null && _a !== void 0 ? _a : process.cwd();
+        const paths = (0, project_root_1.ensureProjectPaths)(projectRoot);
+        vectorDb = new vector_db_1.VectorDB(paths.lancedbDir);
+        // Sync if requested
+        if (options.sync) {
+            const { spinner, onProgress } = (0, sync_helpers_1.createIndexingSpinner)(projectRoot, "Syncing...", { verbose: false });
+            yield (0, syncer_1.initialSync)({ projectRoot, onProgress });
+            spinner.succeed("Sync complete");
+        }
+        // Initialize skeletonizer
+        const skeletonizer = new skeletonizer_1.Skeletonizer();
+        yield skeletonizer.init();
+        const skeletonOpts = {
+            includeSummary: !options.noSummary,
+        };
+        // Determine mode based on target
+        if (isFilePath(target)) {
+            // === FILE MODE ===
+            const filePath = path.resolve(target);
+            if (!fs.existsSync(filePath)) {
+                console.error(`File not found: ${filePath}`);
+                process.exitCode = 1;
+                return;
+            }
+            if (vectorDb) {
+                const relativeToProject = path.relative(projectRoot, filePath);
+                const cached = yield (0, retriever_1.getStoredSkeleton)(vectorDb, relativeToProject);
+                if (cached) {
+                    outputResult({
+                        success: true,
+                        skeleton: cached,
+                        tokenEstimate: Math.ceil(cached.length / 4),
+                    }, options);
+                    return;
+                }
+            }
+            const content = fs.readFileSync(filePath, "utf-8");
+            const result = yield skeletonizer.skeletonizeFile(filePath, content, skeletonOpts);
+            outputResult(result, options);
+        }
+        else if (isSymbolLike(target) && !target.includes(" ")) {
+            // === SYMBOL MODE ===
+            const filePath = yield findFileBySymbol(target, vectorDb);
+            if (!filePath) {
+                console.error(`Symbol not found in index: ${target}`);
+                console.error("Try running 'osgrep index' first or use a search query.");
+                process.exitCode = 1;
+                return;
+            }
+            const absolutePath = path.resolve(projectRoot, filePath);
+            if (!fs.existsSync(absolutePath)) {
+                console.error(`File not found: ${absolutePath}`);
+                process.exitCode = 1;
+                return;
+            }
+            const cached = yield (0, retriever_1.getStoredSkeleton)(vectorDb, filePath);
+            if (cached) {
+                outputResult({
+                    success: true,
+                    skeleton: cached,
+                    tokenEstimate: Math.ceil(cached.length / 4),
+                }, options);
+                return;
+            }
+            const content = fs.readFileSync(absolutePath, "utf-8");
+            const result = yield skeletonizer.skeletonizeFile(filePath, content, skeletonOpts);
+            outputResult(result, options);
+        }
+        else {
+            // === QUERY MODE ===
+            const searcher = new searcher_1.Searcher(vectorDb);
+            const limit = Math.min(Number.parseInt(options.limit, 10) || 3, 10);
+            const searchResults = yield searcher.search(target, limit);
+            if (!searchResults.data || searchResults.data.length === 0) {
+                console.error(`No results found for: ${target}`);
+                process.exitCode = 1;
+                return;
+            }
+            // Get unique file paths from results
+            const seenPaths = new Set();
+            const filePaths = [];
+            for (const result of searchResults.data) {
+                const resultPath = (_b = result.metadata) === null || _b === void 0 ? void 0 : _b.path;
+                if (resultPath && !seenPaths.has(resultPath)) {
+                    seenPaths.add(resultPath);
+                    filePaths.push(resultPath);
+                    if (filePaths.length >= limit)
+                        break;
+                }
+            }
+            // Skeletonize each file
+            const results = [];
+            for (const filePath of filePaths) {
+                const absolutePath = path.resolve(projectRoot, filePath);
+                if (!fs.existsSync(absolutePath)) {
+                    results.push({
+                        file: filePath,
+                        skeleton: `// File not found: ${filePath}`,
+                        tokens: 0,
+                        error: "File not found",
+                    });
+                    continue;
+                }
+                // Try cache first
+                const cached = yield (0, retriever_1.getStoredSkeleton)(vectorDb, filePath);
+                if (cached) {
+                    results.push({
+                        file: filePath,
+                        skeleton: cached,
+                        tokens: Math.ceil(cached.length / 4),
+                    });
+                    continue;
+                }
+                const content = fs.readFileSync(absolutePath, "utf-8");
+                const result = yield skeletonizer.skeletonizeFile(filePath, content, skeletonOpts);
+                results.push({
+                    file: filePath,
+                    skeleton: result.skeleton,
+                    tokens: result.tokenEstimate,
+                    error: result.error,
+                });
+            }
+            // Output results
+            if (options.json) {
+                console.log(JSON.stringify(results, null, 2));
+            }
+            else {
+                for (const result of results) {
+                    console.log(result.skeleton);
+                    console.log(""); // Blank line between files
+                }
+            }
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error("Error:", message);
+        process.exitCode = 1;
+    }
+    finally {
+        if (vectorDb) {
+            try {
+                yield vectorDb.close();
+            }
+            catch (_c) {
+                // Ignore close errors
+            }
+        }
+        const code = typeof process.exitCode === "number" ? process.exitCode : 0;
+        yield (0, exit_1.gracefulExit)(code);
+    }
+}));
+/**
+ * Output a skeleton result.
+ */
+function outputResult(result, options) {
+    if (options.json) {
+        console.log(JSON.stringify({
+            success: result.success,
+            skeleton: result.skeleton,
+            tokens: result.tokenEstimate,
+            error: result.error,
+        }, null, 2));
+    }
+    else {
+        console.log(result.skeleton);
+    }
+}

package/dist/commands/symbols.js

@@ -0,0 +1,129 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.symbols = void 0;
+const commander_1 = require("commander");
+const vector_db_1 = require("../lib/store/vector-db");
+const exit_1 = require("../lib/utils/exit");
+const filter_builder_1 = require("../lib/utils/filter-builder");
+const project_root_1 = require("../lib/utils/project-root");
+const style = {
+    bold: (s) => `\x1b[1m${s}\x1b[22m`,
+    dim: (s) => `\x1b[2m${s}\x1b[22m`,
+    green: (s) => `\x1b[32m${s}\x1b[39m`,
+};
+function toStringArray(val) {
+    if (Array.isArray(val))
+        return val.filter((v) => typeof v === "string");
+    if (val && typeof val.toArray === "function") {
+        try {
+            const arr = val.toArray();
+            return Array.isArray(arr) ? arr.filter((v) => typeof v === "string") : [];
+        }
+        catch (_a) {
+            return [];
+        }
+    }
+    return [];
+}
+function collectSymbols(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const paths = (0, project_root_1.ensureProjectPaths)(options.projectRoot);
+        const db = new vector_db_1.VectorDB(paths.lancedbDir);
+        try {
+            const table = yield db.ensureTable();
+            let query = table
+                .query()
+                .select(["defined_symbols", "path", "start_line"])
+                .where("array_length(defined_symbols) > 0")
+                // Fetch more rows to ensure we have enough after filtering/aggregation
+                .limit(options.pattern ? 10000 : Math.max(options.limit * 50, 2000));
+            if (options.pathPrefix) {
+                query = query.where(`path LIKE '${(0, filter_builder_1.escapeSqlString)((0, filter_builder_1.normalizePath)(options.pathPrefix))}%'`);
+            }
+            const rows = yield query.toArray();
+            const map = new Map();
+            for (const row of rows) {
+                const defs = toStringArray(row.defined_symbols);
+                const path = String(row.path || "");
+                const line = Number(row.start_line || 0);
+                for (const sym of defs) {
+                    if (options.pattern &&
+                        !sym.toLowerCase().includes(options.pattern.toLowerCase())) {
+                        continue;
+                    }
+                    const existing = map.get(sym);
+                    if (existing) {
+                        existing.count += 1;
+                    }
+                    else {
+                        map.set(sym, { symbol: sym, count: 1, path, line });
+                    }
+                }
+            }
+            return Array.from(map.values())
+                .sort((a, b) => {
+                // Sort by count desc, then symbol asc
+                if (b.count !== a.count)
+                    return b.count - a.count;
+                return a.symbol.localeCompare(b.symbol);
+            })
+                .slice(0, options.limit);
+        }
+        finally {
+            yield db.close();
+        }
+    });
+}
+function formatTable(entries) {
+    if (entries.length === 0) {
+        return "No symbols found. Run `osgrep index` to build the index.";
+    }
+    const rows = entries.map((e) => ({
+        symbol: e.symbol,
+        count: e.count.toString(),
+        loc: `${e.path}:${Math.max(1, e.line + 1)}`,
+    }));
+    const headers = { symbol: "Symbol", count: "Count", loc: "Path:Line" };
+    const all = [headers, ...rows];
+    const widths = {
+        symbol: Math.max(...all.map((r) => r.symbol.length)),
+        count: Math.max(...all.map((r) => r.count.length)),
+        loc: Math.max(...all.map((r) => r.loc.length)),
+    };
+    const render = (r) => `${r.symbol.padEnd(widths.symbol)}  ${r.count
+        .padStart(widths.count)
+        .padEnd(widths.count + 2)}${r.loc}`;
+    const lines = [
+        `${style.bold(headers.symbol.padEnd(widths.symbol))}  ${style.bold(headers.count.padEnd(widths.count))}  ${style.bold(headers.loc)}`,
+        `${"-".repeat(widths.symbol)}  ${"-".repeat(widths.count)}  ${"-".repeat(widths.loc)}`,
+        ...rows.map(render),
+    ];
+    return lines.join("\n");
+}
+exports.symbols = new commander_1.Command("symbols")
+    .description("List indexed symbols and where they are defined")
+    .argument("[pattern]", "Optional pattern to filter symbols by name")
+    .option("-l, --limit <number>", "Max symbols to list (default 20)", "20")
+    .option("-p, --path <prefix>", "Only include symbols under this path prefix")
+    .action((pattern, cmd) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const projectRoot = (_a = (0, project_root_1.findProjectRoot)(process.cwd())) !== null && _a !== void 0 ? _a : process.cwd();
+    const limit = Number.parseInt(cmd.limit, 10);
+    const entries = yield collectSymbols({
+        projectRoot,
+        limit: Number.isFinite(limit) && limit > 0 ? limit : 20,
+        pathPrefix: cmd.path,
+        pattern: pattern,
+    });
+    console.log(`${style.bold("Project")}: ${style.green(projectRoot)}\n${formatTable(entries)}`);
+    yield (0, exit_1.gracefulExit)();
+}));

package/dist/commands/trace.js

@@ -0,0 +1,50 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trace = void 0;
+const commander_1 = require("commander");
+const graph_builder_1 = require("../lib/graph/graph-builder");
+const formatter_1 = require("../lib/output/formatter");
+const vector_db_1 = require("../lib/store/vector-db");
+const exit_1 = require("../lib/utils/exit");
+const project_root_1 = require("../lib/utils/project-root");
+exports.trace = new commander_1.Command("trace")
+    .description("Trace the call graph for a symbol")
+    .argument("<symbol>", "The symbol to trace")
+    .action((symbol) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const root = process.cwd();
+    let vectorDb = null;
+    try {
+        const projectRoot = (_a = (0, project_root_1.findProjectRoot)(root)) !== null && _a !== void 0 ? _a : root;
+        const paths = (0, project_root_1.ensureProjectPaths)(projectRoot);
+        vectorDb = new vector_db_1.VectorDB(paths.lancedbDir);
+        const graphBuilder = new graph_builder_1.GraphBuilder(vectorDb);
+        const graph = yield graphBuilder.buildGraph(symbol);
+        console.log((0, formatter_1.formatTrace)(graph));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.error("Trace failed:", message);
+        process.exitCode = 1;
+    }
+    finally {
+        if (vectorDb) {
+            try {
+                yield vectorDb.close();
+            }
+            catch (err) {
+                console.error("Failed to close VectorDB:", err);
+            }
+        }
+        yield (0, exit_1.gracefulExit)();
+    }
+}));

package/dist/commands/verify.js

@@ -0,0 +1,174 @@
+"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;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const transformers_1 = require("@huggingface/transformers");
+const ort = __importStar(require("onnxruntime-node"));
+// CONFIGURATION
+const MODEL_DIR = path.resolve("./osgrep-models/colbert"); // Adjust if your path differs
+const MODEL_PATH = path.join(MODEL_DIR, "model.onnx");
+const SKIPLIST_PATH = path.join(MODEL_DIR, "skiplist.json");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        console.log("🔍 Starting ColBERT Integrity Check...\n");
+        // --- CHECK 1: FILES EXIST ---
+        if (!fs.existsSync(MODEL_PATH))
+            throw new Error(`Missing model at ${MODEL_PATH}`);
+        if (!fs.existsSync(SKIPLIST_PATH))
+            throw new Error(`Missing skiplist at ${SKIPLIST_PATH}`);
+        console.log("✅ Files found.");
+        // --- CHECK 2: TOKENIZER & MARKERS ---
+        console.log("⏳ Loading Tokenizer...");
+        const tokenizer = yield transformers_1.AutoTokenizer.from_pretrained(MODEL_DIR);
+        const queryText = "function test(a, b)";
+        // We manually add the [Q] marker to simulate what the worker does
+        // Note: We use the ID we know works from your export: 50368
+        // But let's see if the tokenizer resolves "[Q] " correctly.
+        const encoded = yield tokenizer(queryText, { add_special_tokens: false });
+        const inputIds = encoded.input_ids; // BigInt64Array in newer transformers versions
+        // Convert to standard array for inspection
+        const ids = Array.from(inputIds).map(Number);
+        // Mixedbread expects: [CLS] [Q] ...tokens... [SEP]
+        // Let's verify we can construct that.
+        const Q_ID = 50368;
+        const CLS_ID = (_a = tokenizer.model.tokens_to_ids.get("[CLS]")) !== null && _a !== void 0 ? _a : 50281; // Fallback to standard if null
+        console.log(`\n--- Tokenizer Check ---`);
+        console.log(`Query: "${queryText}"`);
+        console.log(`Raw IDs:`, ids);
+        // Check if tokenizer recognizes the special tokens by text
+        const qCheck = tokenizer.model.tokens_to_ids.get("[Q] ");
+        const dCheck = tokenizer.model.tokens_to_ids.get("[D] ");
+        if (qCheck === 50368 && dCheck === 50369) {
+            console.log(`✅ Tokenizer Map Correct: [Q] -> ${qCheck}, [D] -> ${dCheck}`);
+        }
+        else {
+            console.error(`❌ Tokenizer Map Mismatch! Found [Q]->${qCheck}, [D]->${dCheck}`);
+            console.error(`   Expected 50368 and 50369.`);
+        }
+        // --- CHECK 3: SKIPLIST ---
+        const skiplist = new Set(JSON.parse(fs.readFileSync(SKIPLIST_PATH, "utf-8")));
+        console.log(`\n--- Skiplist Check ---`);
+        console.log(`Skiplist size: ${skiplist.size}`);
+        // Check common punctuation
+        const commaId = tokenizer.model.tokens_to_ids.get(",");
+        const dotId = tokenizer.model.tokens_to_ids.get(".");
+        if (skiplist.has(commaId) && skiplist.has(dotId)) {
+            console.log(`✅ Skiplist contains punctuation ('.'=${dotId}, ','=${commaId})`);
+        }
+        else {
+            console.error(`❌ Skiplist missing basic punctuation!`);
+        }
+        // --- CHECK 4: ONNX INFERENCE ---
+        console.log(`\n--- ONNX Inference Check ---`);
+        const session = yield ort.InferenceSession.create(MODEL_PATH);
+        console.log(`Session loaded. Input names: ${session.inputNames}`);
+        // Construct a dummy batch: [CLS] [Q] test [SEP]
+        const batchIds = [
+            BigInt(CLS_ID),
+            BigInt(Q_ID),
+            BigInt(1234),
+            BigInt((_b = tokenizer.sep_token_id) !== null && _b !== void 0 ? _b : 50282),
+        ];
+        const tensorIds = new ort.Tensor("int64", new BigInt64Array(batchIds), [1, 4]);
+        const tensorMask = new ort.Tensor("int64", new BigInt64Array([BigInt(1), BigInt(1), BigInt(1), BigInt(1)]), [1, 4]);
+        const start = performance.now();
+        const feeds = { input_ids: tensorIds, attention_mask: tensorMask };
+        const results = yield session.run(feeds);
+        const end = performance.now();
+        const outputName = session.outputNames[0];
+        const embeddings = results[outputName];
+        // Dims should be [1, 4, 48]
+        const dims = embeddings.dims;
+        console.log(`Output Dimensions: [${dims.join(", ")}]`);
+        console.log(`Inference Time (cold): ${(end - start).toFixed(2)}ms`);
+        if (dims[2] !== 48) {
+            console.error(`❌ CRITICAL: Expected dimension 48, got ${dims[2]}`);
+            process.exit(1);
+        }
+        else {
+            console.log(`✅ Correct dimension (48d) detected.`);
+        }
+        // --- CHECK 5: MAXSIM PERFORMANCE SIMULATION ---
+        console.log(`\n--- MaxSim Logic Benchmark ---`);
+        // Create dummy vectors for a fake document (1000 tokens)
+        const docLen = 1000;
+        const docIds = new Array(docLen)
+            .fill(0)
+            .map(() => Math.floor(Math.random() * 50000));
+        // Inject some punctuation into the dummy document to simulate real text
+        // Let's say 15% of the doc is punctuation
+        let punctuationCount = 0;
+        for (let i = 0; i < docLen; i++) {
+            if (Math.random() < 0.15) {
+                docIds[i] = commaId !== null && commaId !== void 0 ? commaId : 0; // Force a comma
+                punctuationCount++;
+            }
+        }
+        const qLen = 32;
+        // Naive Dot Product count
+        const naiveOps = qLen * docLen;
+        // Skiplist Dot Product count
+        let optimizedOps = 0;
+        for (let i = 0; i < qLen; i++) {
+            for (let j = 0; j < docLen; j++) {
+                if (!skiplist.has(docIds[j])) {
+                    optimizedOps++;
+                }
+            }
+        }
+        console.log(`Document Length: ${docLen} tokens`);
+        console.log(`Punctuation/Skip tokens: ${punctuationCount} (~${((punctuationCount / docLen) * 100).toFixed(1)}%)`);
+        console.log(`Naive Operations: ${naiveOps}`);
+        console.log(`Skiplist Operations: ${optimizedOps}`);
+        console.log(`Savings: ${naiveOps - optimizedOps} operations avoided`);
+        console.log(`⚡ Speedup: ${(naiveOps / optimizedOps).toFixed(2)}x (theoretical)`);
+        console.log("\n✅ VERIFICATION COMPLETE. MODEL IS GOOD TO GO.");
+    });
+}
+main().catch((err) => {
+    console.error("\n❌ TEST FAILED:", err);
+    process.exit(1);
+});