@hesed/search 0.2.0 → 0.2.2

package/README.md

@@ -20,7 +20,7 @@ $ npm install -g @hesed/search
 $ search COMMAND
 running command...
 $ search (--version)
-@hesed/search/0.2.0 linux-x64 node-v24.16.0
+@hesed/search/0.2.2 linux-x64 node-v24.16.0
 $ search --help [COMMAND]
 USAGE
   $ search COMMAND
@@ -32,6 +32,8 @@ USAGE
 
 <!-- commands -->
 * [`search search QUERY`](#search-search-query)
+* [`search synonyms export [FILE]`](#search-synonyms-export-file)
+* [`search synonyms import FILE`](#search-synonyms-import-file)
 
 ## `search search QUERY`
 
@@ -62,5 +64,52 @@ EXAMPLES
   $ search search "update jira" --details
 ```
 
-_See code: [src/commands/search.ts](https://github.com/hesedcasa/search/blob/v0.2.0/src/commands/search.ts)_
+_See code: [src/commands/search.ts](https://github.com/hesedcasa/search/blob/v0.2.2/src/commands/search.ts)_
+
+## `search synonyms export [FILE]`
+
+Export the stored synonyms to a JSON file or stdout
+
+```
+USAGE
+  $ search synonyms export [FILE]
+
+ARGUMENTS
+  [FILE]  Output file path (prints to stdout if omitted)
+
+DESCRIPTION
+  Export the stored synonyms to a JSON file or stdout
+
+EXAMPLES
+  $ search synonyms export
+
+  $ search synonyms export ./my-synonyms.json
+```
+
+_See code: [src/commands/synonyms/export.ts](https://github.com/hesedcasa/search/blob/v0.2.2/src/commands/synonyms/export.ts)_
+
+## `search synonyms import FILE`
+
+Import synonyms from a JSON file
+
+```
+USAGE
+  $ search synonyms import FILE [--merge]
+
+ARGUMENTS
+  FILE  Path to a JSON synonyms file to import
+
+FLAGS
+  --merge  Merge with existing synonyms instead of replacing them
+
+DESCRIPTION
+  Import synonyms from a JSON file
+
+EXAMPLES
+  $ search synonyms import ./synonyms.json
+
+  $ search synonyms import ./synonyms.json --merge
+```
+
+_See code: [src/commands/synonyms/import.ts](https://github.com/hesedcasa/search/blob/v0.2.2/src/commands/synonyms/import.ts)_
 <!-- commandsstop -->

package/dist/commands/search.js

@@ -1,6 +1,6 @@
-import { Args, Command, CommandHelp, Flags, toConfiguredId, ux } from '@oclif/core';
-import { isMiniLMModelCached, MiniLMCommandEmbedder } from '../embedders/minilm.js';
+import { Args, Command, CommandHelp, Flags, toConfiguredId } from '@oclif/core';
 import { searchCommands } from '../search-logic.js';
+import { loadStoredSynonymMap } from '../synonym-store.js';
 export default class Search extends Command {
     static args = {
         query: Args.string({ description: 'Search term to filter commands by', required: true }),
@@ -19,14 +19,8 @@ export default class Search extends Command {
     async run() {
         const { args, flags } = await this.parse(Search);
         const allCommands = this.config.commands.filter((c) => !c.hidden && c.pluginName !== '@oclif/plugin-plugins');
-        const loader = createModelLoader(this.jsonEnabled() || isMiniLMModelCached());
-        let scored;
-        try {
-            scored = (await searchCommands(args.query, allCommands, getSearchOptions(this.config, loader.onProgress))).slice(0, flags.limit);
-        }
-        finally {
-            loader.stop();
-        }
+        const synonyms = loadStoredSynonymMap(this.config.configDir);
+        const scored = (await searchCommands(args.query, allCommands, synonyms)).slice(0, flags.limit);
         const results = scored.map((entry) => {
             const { cmd } = entry;
             const configuredId = toConfiguredId(cmd.id, this.config);
@@ -85,61 +79,3 @@ export default class Search extends Command {
         }
     }
 }
-function getSearchOptions(config, onLoadProgress) {
-    const testConfig = config;
-    if (!testConfig.searchEmbedder)
-        return { embedder: new MiniLMCommandEmbedder({ onLoadProgress }) };
-    return { embedder: testConfig.searchEmbedder };
-}
-function createModelLoader(silent) {
-    let started = false;
-    let stopped = false;
-    const start = (status) => {
-        if (silent || stopped)
-            return;
-        if (started) {
-            ux.action.status = status;
-            return;
-        }
-        ux.action.start('Loading semantic search model', status);
-        started = true;
-    };
-    const stop = () => {
-        if (silent || stopped)
-            return;
-        stopped = true;
-        if (started)
-            ux.action.stop();
-    };
-    return {
-        onProgress(progress) {
-            if (progress.status === 'ready') {
-                stop();
-                return;
-            }
-            if (progress.status === 'progress_total' && typeof progress.progress === 'number') {
-                start(`${Math.round(progress.progress)}% ${formatBytes(progress.loaded)} / ${formatBytes(progress.total)}`);
-                return;
-            }
-            if (progress.status === 'download') {
-                start(formatProgressFile(progress.file));
-            }
-        },
-        stop,
-    };
-}
-function formatProgressFile(file) {
-    return file?.split('/').at(-1);
-}
-function formatBytes(value) {
-    if (!value || value <= 0)
-        return '?';
-    const units = ['B', 'KB', 'MB', 'GB'];
-    let size = value;
-    let unit = 0;
-    while (size >= 1024 && unit < units.length - 1) {
-        size /= 1024;
-        unit++;
-    }
-    return `${size.toFixed(size >= 10 || unit === 0 ? 0 : 1)} ${units[unit]}`;
-}

package/dist/commands/synonyms/export.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class SynonymsExport extends Command {
+    static args: {
+        file: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/synonyms/export.js

@@ -0,0 +1,22 @@
+import { Args, Command } from '@oclif/core';
+import { writeFileSync } from 'node:fs';
+import { readSynonymGroups } from '../../synonym-store.js';
+export default class SynonymsExport extends Command {
+    static args = {
+        file: Args.string({ description: 'Output file path (prints to stdout if omitted)', required: false }),
+    };
+    static description = 'Export the stored synonyms to a JSON file or stdout';
+    static examples = ['<%= config.bin %> synonyms export', '<%= config.bin %> synonyms export ./my-synonyms.json'];
+    async run() {
+        const { args } = await this.parse(SynonymsExport);
+        const groups = readSynonymGroups(this.config.configDir);
+        const json = JSON.stringify(groups, null, 2) + '\n';
+        if (args.file) {
+            writeFileSync(args.file, json, 'utf8');
+            this.log(`Exported ${groups.length} synonym group${groups.length === 1 ? '' : 's'} → ${args.file}`);
+        }
+        else {
+            process.stdout.write(json);
+        }
+    }
+}

package/dist/commands/synonyms/import.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class SynonymsImport extends Command {
+    static args: {
+        file: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        merge: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/synonyms/import.js

@@ -0,0 +1,61 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { existsSync } from 'node:fs';
+import { synonymsPath, writeSynonymGroups } from '../../synonym-store.js';
+import { loadSynonymGroupsFromFile } from '../../synonyms.js';
+export default class SynonymsImport extends Command {
+    static args = {
+        file: Args.string({ description: 'Path to a JSON synonyms file to import', required: true }),
+    };
+    static description = 'Import synonyms from a JSON file';
+    static examples = [
+        '<%= config.bin %> synonyms import ./synonyms.json',
+        '<%= config.bin %> synonyms import ./synonyms.json --merge',
+    ];
+    static flags = {
+        merge: Flags.boolean({
+            default: false,
+            description: 'Merge with existing synonyms instead of replacing them',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(SynonymsImport);
+        if (!existsSync(args.file)) {
+            this.error(`File not found: ${args.file}`);
+        }
+        const incoming = loadSynonymGroupsFromFile(args.file);
+        let groups;
+        if (flags.merge) {
+            const { readSynonymGroups } = await import('../../synonym-store.js');
+            const existing = readSynonymGroups(this.config.configDir);
+            groups = mergeSynonymGroups(existing, incoming);
+        }
+        else {
+            groups = incoming;
+        }
+        writeSynonymGroups(this.config.configDir, groups);
+        const dest = synonymsPath(this.config.configDir);
+        this.log(`Imported ${groups.length} synonym group${groups.length === 1 ? '' : 's'} → ${dest}`);
+    }
+}
+/**
+ * Merge two synonym group lists.
+ *
+ * Groups are merged when they share at least one term in common; otherwise
+ * they are appended as separate groups.
+ */
+function mergeSynonymGroups(existing, incoming) {
+    const result = existing.map((g) => [...g]);
+    for (const group of incoming) {
+        const normalizedGroup = group.map((t) => t.toLowerCase().trim()).filter(Boolean);
+        // Find any existing group that overlaps
+        const matchIndex = result.findIndex((r) => r.some((t) => normalizedGroup.includes(t.toLowerCase().trim())));
+        if (matchIndex === -1) {
+            result.push(normalizedGroup);
+        }
+        else {
+            const merged = [...new Set([...normalizedGroup, ...result[matchIndex].map((t) => t.toLowerCase().trim())])];
+            result[matchIndex] = merged;
+        }
+    }
+    return result;
+}

package/dist/search-logic.d.ts

@@ -1,3 +1,4 @@
+import { type SynonymMap } from './synonyms.js';
 export type SearchableCommand = {
     description?: string;
     id: string;
@@ -8,19 +9,5 @@ export type ScoredCommand<T extends SearchableCommand = SearchableCommand> = {
     cmd: T;
     score: number;
 };
-export type CommandEmbedder = {
-    embed(texts: string[]): Promise<number[][]>;
-};
-export type CommandReranker<T extends SearchableCommand = SearchableCommand> = {
-    rerank(query: string, commands: Array<ScoredCommand<T>>): Promise<Array<ScoredCommand<T>>>;
-};
-export type SearchCommandsOptions<T extends SearchableCommand = SearchableCommand> = {
-    embedder?: CommandEmbedder;
-    lexicalWeight?: number;
-    minSemanticScore?: number;
-    reranker?: CommandReranker<T>;
-    semantic?: boolean;
-    semanticWeight?: number;
-};
-export declare function searchCommands<T extends SearchableCommand>(query: string, commands: T[], options?: SearchCommandsOptions<T>): Promise<Array<ScoredCommand<T>>>;
-export declare function searchCommandsLexically<T extends SearchableCommand>(query: string, commands: T[], haystack?: string[]): Array<ScoredCommand<T>>;
+export declare function searchCommands<T extends SearchableCommand>(query: string, commands: T[], synonyms?: SynonymMap): Promise<Array<ScoredCommand<T>>>;
+export declare function searchCommandsLexically<T extends SearchableCommand>(query: string, commands: T[], haystack?: string[], synonyms?: SynonymMap): Array<ScoredCommand<T>>;

package/dist/search-logic.js

@@ -1,58 +1,46 @@
-import UFuzzy from '@leeoniya/ufuzzy';
-import { MiniLMCommandEmbedder } from './embedders/minilm.js';
-const DEFAULT_MIN_SEMANTIC_SCORE = 0.22;
-const DEFAULT_SEMANTIC_WEIGHT = 0.75;
-const DEFAULT_LEXICAL_WEIGHT = 0.25;
-let defaultEmbedderPromise;
-export async function searchCommands(query, commands, options = {}) {
+import { createRequire } from 'node:module';
+import { expandWithSynonyms } from './synonyms.js';
+const require = createRequire(import.meta.url);
+const { Index } = require('flexsearch');
+export async function searchCommands(query, commands, synonyms = new Map()) {
     const normalizedQuery = query.trim();
     if (normalizedQuery.length === 0 || commands.length === 0)
         return [];
-    const haystack = commands.map((command) => commandSearchText(command));
-    const lexical = searchCommandsLexically(normalizedQuery, commands, haystack);
-    if (options.semantic === false)
-        return lexical;
-    let semantic;
-    try {
-        semantic = await searchCommandsSemantically(normalizedQuery, commands, haystack, options);
-    }
-    catch {
-        return lexical;
-    }
-    if (semantic.length === 0)
-        return lexical;
-    const merged = mergeScores(semantic, lexical, {
-        lexicalWeight: options.lexicalWeight ?? DEFAULT_LEXICAL_WEIGHT,
-        minSemanticScore: options.minSemanticScore ?? DEFAULT_MIN_SEMANTIC_SCORE,
-        semanticWeight: options.semanticWeight ?? DEFAULT_SEMANTIC_WEIGHT,
-    });
-    return options.reranker ? options.reranker.rerank(normalizedQuery, merged) : merged;
-}
-export function searchCommandsLexically(query, commands, haystack = commands.map((command) => commandSearchText(command))) {
-    const uf = new UFuzzy({ intraIns: Infinity });
-    const [idxs, , order] = uf.search(haystack, query, 0, Infinity);
-    if (idxs && idxs.length > 0) {
-        const ranked = order ?? idxs.map((_, i) => i);
-        return ranked.map((oi, rank) => ({ cmd: commands[idxs[oi]], score: rank }));
+    const haystack = commands.map((command) => expandWithSynonyms(commandSearchText(command), synonyms));
+    return searchCommandsLexically(normalizedQuery, commands, haystack, synonyms);
+}
+export function searchCommandsLexically(query, commands, haystack = commands.map((command) => commandSearchText(command)), synonyms = new Map()) {
+    const index = createCommandSearchIndex(haystack);
+    const expandedQuery = expandWithSynonyms(query, synonyms);
+    const idxs = index.search(expandedQuery, { limit: commands.length, suggest: true });
+    if (idxs.length > 0) {
+        return idxs.map((idx, rank) => ({ cmd: commands[Number(idx)], score: rank }));
     }
     // Multi-token fallback: score each command by how many individual query
     // tokens it matches. Handles queries containing unknown alias words (e.g.
     // "atlassian") that don't appear literally in any command field.
-    const tokens = query.trim().split(/\s+/).filter(Boolean);
+    const tokens = expandedQuery.trim().split(/\s+/).filter(Boolean);
     if (tokens.length <= 1)
         return [];
     const hitCount = new Map();
     for (const token of tokens) {
-        const [tIdxs] = uf.search(haystack, token, 0, Infinity);
-        if (tIdxs) {
-            for (const idx of tIdxs)
-                hitCount.set(idx, (hitCount.get(idx) ?? 0) + 1);
+        const tIdxs = index.search(token, { limit: commands.length, suggest: true });
+        for (const idx of tIdxs) {
+            const commandIndex = Number(idx);
+            hitCount.set(commandIndex, (hitCount.get(commandIndex) ?? 0) + 1);
         }
     }
     return [...hitCount.entries()]
         .sort((a, b) => b[1] - a[1] || a[0] - b[0])
         .map(([idx, hits]) => ({ cmd: commands[idx], score: tokens.length - hits }));
 }
+function createCommandSearchIndex(haystack) {
+    const index = new Index({ encoder: 'LatinAdvanced', resolution: 9, tokenize: 'forward' });
+    for (const [idx, text] of haystack.entries()) {
+        index.add(idx, text);
+    }
+    return index;
+}
 function commandSearchText(command) {
     return [command.id, command.summary ?? command.description ?? '', command.pluginName ?? '']
         .filter(Boolean)
@@ -60,47 +48,3 @@ function commandSearchText(command) {
         .replaceAll(/\s+/g, ' ')
         .trim();
 }
-async function searchCommandsSemantically(query, commands, haystack, options) {
-    const embedder = options.embedder ?? (await getDefaultEmbedder());
-    const [queryEmbedding, ...commandEmbeddings] = await embedder.embed([query, ...haystack]);
-    return commandEmbeddings
-        .map((embedding, idx) => ({
-        cmd: commands[idx],
-        score: cosineSimilarity(queryEmbedding, embedding),
-    }))
-        .filter(({ score }) => Number.isFinite(score))
-        .sort((a, b) => b.score - a.score);
-}
-async function getDefaultEmbedder() {
-    defaultEmbedderPromise ??= Promise.resolve(new MiniLMCommandEmbedder());
-    return defaultEmbedderPromise;
-}
-function mergeScores(semantic, lexical, options) {
-    const lexicalById = new Map(lexical.map((entry, idx) => [entry.cmd.id, lexicalScore(idx, lexical.length)]));
-    const lexicalIds = new Set(lexical.map((entry) => entry.cmd.id));
-    return semantic
-        .filter((entry) => entry.score >= options.minSemanticScore || lexicalIds.has(entry.cmd.id))
-        .map((entry) => {
-        const finalScore = entry.score * options.semanticWeight + (lexicalById.get(entry.cmd.id) ?? 0) * options.lexicalWeight;
-        return { cmd: entry.cmd, score: 1 - finalScore };
-    })
-        .sort((a, b) => a.score - b.score);
-}
-function lexicalScore(index, length) {
-    if (length <= 1)
-        return 1;
-    return 1 - index / (length - 1);
-}
-function cosineSimilarity(a, b) {
-    let dot = 0;
-    let aMagnitude = 0;
-    let bMagnitude = 0;
-    for (let i = 0; i < Math.min(a.length, b.length); i++) {
-        dot += a[i] * b[i];
-        aMagnitude += a[i] * a[i];
-        bMagnitude += b[i] * b[i];
-    }
-    if (aMagnitude === 0 || bMagnitude === 0)
-        return 0;
-    return dot / (Math.sqrt(aMagnitude) * Math.sqrt(bMagnitude));
-}

package/dist/synonym-store.d.ts

@@ -0,0 +1,5 @@
+import { type SynonymGroup, type SynonymMap } from './synonyms.js';
+export declare function synonymsPath(configDir: string): string;
+export declare function readSynonymGroups(configDir: string | undefined): SynonymGroup[];
+export declare function writeSynonymGroups(configDir: string, groups: SynonymGroup[]): void;
+export declare function loadStoredSynonymMap(configDir: string | undefined): SynonymMap;

package/dist/synonym-store.js

@@ -0,0 +1,21 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { buildSynonymMap, parseSynonymGroups } from './synonyms.js';
+const SYNONYMS_FILENAME = 'synonyms.json';
+export function synonymsPath(configDir) {
+    return join(configDir, SYNONYMS_FILENAME);
+}
+export function readSynonymGroups(configDir) {
+    if (!configDir)
+        return [];
+    const filePath = synonymsPath(configDir);
+    if (!existsSync(filePath))
+        return [];
+    return parseSynonymGroups(readFileSync(filePath, 'utf8'));
+}
+export function writeSynonymGroups(configDir, groups) {
+    writeFileSync(synonymsPath(configDir), JSON.stringify(groups, null, 2) + '\n', 'utf8');
+}
+export function loadStoredSynonymMap(configDir) {
+    return buildSynonymMap(readSynonymGroups(configDir));
+}

package/dist/synonyms.d.ts

@@ -0,0 +1,28 @@
+export type SynonymGroup = string[];
+export type SynonymMap = Map<string, string[]>;
+/**
+ * Parse and validate a synonyms file.
+ *
+ * File format — a JSON array of synonym groups:
+ *
+ *   [
+ *     ["ticket", "issue", "bug"],
+ *     ["pr", "pull request", "merge request"],
+ *     ["repo", "repository"]
+ *   ]
+ *
+ * Every term in a group is treated as equivalent to every other term. Terms
+ * are matched case-insensitively. Multi-word terms (e.g. "pull request") are
+ * matched as whole phrases.
+ */
+export declare function parseSynonymGroups(raw: string): SynonymGroup[];
+export declare function loadSynonymGroupsFromFile(filePath: string): SynonymGroup[];
+export declare function buildSynonymMap(groups: SynonymGroup[]): SynonymMap;
+/**
+ * Return `text` with synonym expansions appended.
+ *
+ * For every term in `synonyms` that appears in `text`, all sibling terms from
+ * the same group are appended so the search index / query matches any
+ * equivalent spelling.
+ */
+export declare function expandWithSynonyms(text: string, synonyms: SynonymMap): string;

package/dist/synonyms.js

@@ -0,0 +1,65 @@
+import { readFileSync } from 'node:fs';
+/**
+ * Parse and validate a synonyms file.
+ *
+ * File format — a JSON array of synonym groups:
+ *
+ *   [
+ *     ["ticket", "issue", "bug"],
+ *     ["pr", "pull request", "merge request"],
+ *     ["repo", "repository"]
+ *   ]
+ *
+ * Every term in a group is treated as equivalent to every other term. Terms
+ * are matched case-insensitively. Multi-word terms (e.g. "pull request") are
+ * matched as whole phrases.
+ */
+export function parseSynonymGroups(raw) {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed) ||
+        parsed.some((g) => !Array.isArray(g) || g.some((term) => typeof term !== 'string'))) {
+        throw new TypeError('Synonyms file must be a JSON array of string arrays');
+    }
+    return parsed;
+}
+export function loadSynonymGroupsFromFile(filePath) {
+    return parseSynonymGroups(readFileSync(filePath, 'utf8'));
+}
+export function buildSynonymMap(groups) {
+    const map = new Map();
+    for (const group of groups) {
+        const normalized = group.map((t) => t.toLowerCase().trim()).filter(Boolean);
+        for (const term of normalized) {
+            const others = normalized.filter((t) => t !== term);
+            const existing = map.get(term) ?? [];
+            map.set(term, [...new Set([...existing, ...others])]);
+        }
+    }
+    return map;
+}
+/**
+ * Return `text` with synonym expansions appended.
+ *
+ * For every term in `synonyms` that appears in `text`, all sibling terms from
+ * the same group are appended so the search index / query matches any
+ * equivalent spelling.
+ */
+export function expandWithSynonyms(text, synonyms) {
+    if (synonyms.size === 0)
+        return text;
+    const extras = [];
+    for (const [term, syns] of synonyms) {
+        if (containsTerm(text, term)) {
+            extras.push(...syns);
+        }
+    }
+    return extras.length > 0 ? `${text} ${extras.join(' ')}` : text;
+}
+function escapeRegex(s) {
+    // eslint-disable-next-line unicorn/prefer-string-raw
+    return s.replaceAll(/[$()*+.?[\\\]^{|}]/g, '\\$&').replaceAll(/\s+/g, String.raw `\s+`);
+}
+function containsTerm(text, term) {
+    const pattern = new RegExp(`(?<![\\w])${escapeRegex(term)}(?![\\w])`, 'i');
+    return pattern.test(text);
+}

package/oclif.manifest.json

@@ -56,7 +56,76 @@
         "commands",
         "search.js"
       ]
+    },
+    "synonyms:export": {
+      "aliases": [],
+      "args": {
+        "file": {
+          "description": "Output file path (prints to stdout if omitted)",
+          "name": "file",
+          "required": false
+        }
+      },
+      "description": "Export the stored synonyms to a JSON file or stdout",
+      "examples": [
+        "<%= config.bin %> synonyms export",
+        "<%= config.bin %> synonyms export ./my-synonyms.json"
+      ],
+      "flags": {},
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "synonyms:export",
+      "pluginAlias": "@hesed/search",
+      "pluginName": "@hesed/search",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "synonyms",
+        "export.js"
+      ]
+    },
+    "synonyms:import": {
+      "aliases": [],
+      "args": {
+        "file": {
+          "description": "Path to a JSON synonyms file to import",
+          "name": "file",
+          "required": true
+        }
+      },
+      "description": "Import synonyms from a JSON file",
+      "examples": [
+        "<%= config.bin %> synonyms import ./synonyms.json",
+        "<%= config.bin %> synonyms import ./synonyms.json --merge"
+      ],
+      "flags": {
+        "merge": {
+          "description": "Merge with existing synonyms instead of replacing them",
+          "name": "merge",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "synonyms:import",
+      "pluginAlias": "@hesed/search",
+      "pluginName": "@hesed/search",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "synonyms",
+        "import.js"
+      ]
     }
   },
-  "version": "0.2.0"
+  "version": "0.2.2"
 }

package/package.json

@@ -1,16 +1,15 @@
 {
   "name": "@hesed/search",
   "description": "Intelligence search plugin",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "author": "Hesed",
   "bin": {
     "permission": "./bin/run.js"
   },
   "bugs": "https://github.com/hesedcasa/search/issues",
   "dependencies": {
-    "@huggingface/transformers": "^4.2.0",
-    "@leeoniya/ufuzzy": "^1.0.19",
-    "@oclif/core": "^4"
+    "@oclif/core": "^4",
+    "flexsearch": "^0.8.212"
   },
   "devDependencies": {
     "@eslint/compat": "^1",

package/dist/embedders/minilm.d.ts

@@ -1,22 +0,0 @@
-import { type CommandEmbedder } from '../search-logic.js';
-export type ModelLoadProgress = {
-    file?: string;
-    loaded?: number;
-    model?: string;
-    name?: string;
-    progress?: number;
-    status: string;
-    task?: string;
-    total?: number;
-};
-export declare class MiniLMCommandEmbedder implements CommandEmbedder {
-    private readonly options;
-    private extractorPromise;
-    constructor(options?: {
-        onLoadProgress?: (progress: ModelLoadProgress) => void;
-    });
-    embed(texts: string[]): Promise<number[][]>;
-    private getExtractor;
-}
-export declare function isMiniLMModelCached(): boolean;
-export declare function getMiniLMModelCachePath(): string;

package/dist/embedders/minilm.js

@@ -1,49 +0,0 @@
-import { existsSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import path from 'node:path';
-const MINILM_MODEL = 'Xenova/paraphrase-MiniLM-L3-v2';
-const MODEL_CACHE_FILES = ['config.json', 'tokenizer.json', 'tokenizer_config.json', 'onnx/model.onnx'];
-// eslint-disable-next-line no-new-func
-const importTransformers = new Function('specifier', 'return import(specifier)');
-const require = createRequire(import.meta.url);
-export class MiniLMCommandEmbedder {
-    options;
-    extractorPromise;
-    constructor(options = {}) {
-        this.options = options;
-    }
-    async embed(texts) {
-        if (texts.length === 0)
-            return [];
-        const extractor = await this.getExtractor();
-        const output = await extractor(texts, { normalize: true, pooling: 'mean' });
-        return tensorToRows(output.data, output.dims);
-    }
-    async getExtractor() {
-        this.extractorPromise ??= importTransformers('@huggingface/transformers').then(async ({ pipeline }) => {
-            const pipelineOptions = {};
-            // eslint-disable-next-line camelcase
-            pipelineOptions.progress_callback = this.options.onLoadProgress;
-            const extractor = await pipeline('feature-extraction', MINILM_MODEL, pipelineOptions);
-            return extractor;
-        });
-        return this.extractorPromise;
-    }
-}
-export function isMiniLMModelCached() {
-    const cachePath = getMiniLMModelCachePath();
-    return MODEL_CACHE_FILES.every((file) => existsSync(path.join(cachePath, file)));
-}
-export function getMiniLMModelCachePath() {
-    const entrypointPath = require.resolve('@huggingface/transformers');
-    const packagePath = path.dirname(path.dirname(entrypointPath));
-    return path.join(packagePath, '.cache', ...MINILM_MODEL.split('/'));
-}
-function tensorToRows(data, dims) {
-    const rows = dims[0] ?? 0;
-    const columns = dims[1] ?? data.length;
-    return Array.from({ length: rows }, (_, row) => {
-        const rowData = data.slice(row * columns, (row + 1) * columns);
-        return Array.isArray(rowData) ? rowData : [...rowData];
-    });
-}