agentikit 0.0.12 → 0.0.14

package/dist/src/frontmatter.d.ts

@@ -1,30 +0,0 @@
-/**
- * Shared frontmatter parsing utilities.
- *
- * Provides a single, canonical YAML-subset frontmatter parser used by both
- * the stash open logic and the metadata generator.
- */
-/**
- * Parse YAML-subset frontmatter from a Markdown (or similar) string.
- *
- * Returns the parsed key-value data and the remaining body content.
- */
-export declare function parseFrontmatter(raw: string): {
-    data: Record<string, unknown>;
-    content: string;
-    frontmatter: string | null;
-    bodyStartLine: number;
-};
-export declare function parseFrontmatterBlock(raw: string): {
-    frontmatter: string;
-    content: string;
-    bodyStartLine: number;
-} | null;
-/**
- * Parse a simple YAML scalar value (string, boolean, or number).
- */
-export declare function parseYamlScalar(value: string): unknown;
-/**
- * Coerce an unknown value to a trimmed string, or return undefined if empty/non-string.
- */
-export declare function toStringOrUndefined(value: unknown): string | undefined;

package/dist/src/github.d.ts

@@ -1,4 +0,0 @@
-export declare const GITHUB_API_BASE = "https://api.github.com";
-export declare function githubHeaders(): HeadersInit;
-export declare function asRecord(value: unknown): Record<string, unknown>;
-export declare function asString(value: unknown): string | undefined;

package/dist/src/handlers/agent-handler.d.ts

@@ -1,2 +0,0 @@
-import type { AssetTypeHandler } from "../asset-type-handler";
-export declare const agentHandler: AssetTypeHandler;

package/dist/src/handlers/command-handler.d.ts

@@ -1,2 +0,0 @@
-import type { AssetTypeHandler } from "../asset-type-handler";
-export declare const commandHandler: AssetTypeHandler;

package/dist/src/handlers/index.d.ts

@@ -1,6 +0,0 @@
-export { toolHandler } from "./tool-handler";
-export { skillHandler } from "./skill-handler";
-export { commandHandler } from "./command-handler";
-export { agentHandler } from "./agent-handler";
-export { knowledgeHandler } from "./knowledge-handler";
-export { scriptHandler } from "./script-handler";

package/dist/src/handlers/knowledge-handler.d.ts

@@ -1,2 +0,0 @@
-import type { AssetTypeHandler } from "../asset-type-handler";
-export declare const knowledgeHandler: AssetTypeHandler;

package/dist/src/handlers/markdown-helpers.d.ts

@@ -1,7 +0,0 @@
-/**
- * Shared file-system helpers for markdown-based asset types
- * (command, agent, knowledge).
- */
-export declare function isMarkdownFile(fileName: string): boolean;
-export declare function markdownCanonicalName(typeRoot: string, filePath: string): string | undefined;
-export declare function markdownAssetPath(typeRoot: string, name: string): string;

package/dist/src/handlers/script-handler.d.ts

@@ -1,2 +0,0 @@
-import type { AssetTypeHandler } from "../asset-type-handler";
-export declare const scriptHandler: AssetTypeHandler;

package/dist/src/handlers/skill-handler.d.ts

@@ -1,2 +0,0 @@
-import type { AssetTypeHandler } from "../asset-type-handler";
-export declare const skillHandler: AssetTypeHandler;

package/dist/src/handlers/tool-handler.d.ts

@@ -1,2 +0,0 @@
-import type { AssetTypeHandler } from "../asset-type-handler";
-export declare const toolHandler: AssetTypeHandler;

package/dist/src/indexer.d.ts

@@ -1,22 +0,0 @@
-import { type StashEntry } from "./metadata";
-export interface IndexResponse {
-    stashDir: string;
-    totalEntries: number;
-    generatedMetadata: number;
-    indexPath: string;
-    mode: "full" | "incremental";
-    directoriesScanned: number;
-    directoriesSkipped: number;
-    /** Timing counters in milliseconds */
-    timing?: {
-        totalMs: number;
-        walkMs: number;
-        embedMs: number;
-        ftsMs: number;
-    };
-}
-export declare function agentikitIndex(options?: {
-    stashDir?: string;
-    full?: boolean;
-}): Promise<IndexResponse>;
-export declare function buildSearchText(entry: StashEntry): string;

package/dist/src/init.d.ts

@@ -1,19 +0,0 @@
-/**
- * Agentikit initialization logic.
- *
- * Creates the working stash directory structure, sets the AKM_STASH_DIR
- * environment variable, and ensures ripgrep is available.
- */
-export interface InitResponse {
-    stashDir: string;
-    created: boolean;
-    envSet: boolean;
-    profileUpdated?: string;
-    configPath: string;
-    ripgrep?: {
-        rgPath: string;
-        installed: boolean;
-        version: string;
-    };
-}
-export declare function agentikitInit(): Promise<InitResponse>;

package/dist/src/init.js

@@ -1,99 +0,0 @@
-/**
- * Agentikit initialization logic.
- *
- * Creates the working stash directory structure, sets the AKM_STASH_DIR
- * environment variable, and ensures ripgrep is available.
- */
-import { spawnSync } from "node:child_process";
-import fs from "node:fs";
-import path from "node:path";
-import { IS_WINDOWS, TYPE_DIRS } from "./common";
-import { ensureRg } from "./ripgrep-install";
-import { getConfigPath, saveConfig, DEFAULT_CONFIG } from "./config";
-export async function agentikitInit() {
-    let stashDir;
-    if (IS_WINDOWS) {
-        const userProfile = process.env.USERPROFILE?.trim();
-        if (!userProfile) {
-            throw new Error("Unable to determine Documents folder. Ensure USERPROFILE is set.");
-        }
-        const docs = path.join(userProfile, "Documents");
-        stashDir = path.join(docs, "agentikit");
-    }
-    else {
-        const home = process.env.HOME?.trim();
-        if (!home) {
-            throw new Error("Unable to determine home directory. Set HOME.");
-        }
-        stashDir = path.join(home, "agentikit");
-    }
-    let created = false;
-    if (!fs.existsSync(stashDir)) {
-        fs.mkdirSync(stashDir, { recursive: true });
-        created = true;
-    }
-    for (const sub of Object.values(TYPE_DIRS)) {
-        const subDir = path.join(stashDir, sub);
-        if (!fs.existsSync(subDir)) {
-            fs.mkdirSync(subDir, { recursive: true });
-        }
-    }
-    let envSet = false;
-    let profileUpdated;
-    if (IS_WINDOWS) {
-        const result = spawnSync("setx", ["AKM_STASH_DIR", stashDir], {
-            encoding: "utf8",
-            timeout: 10_000,
-        });
-        envSet = result.status === 0;
-    }
-    else {
-        const shell = process.env.SHELL || "";
-        const homeDir = process.env.HOME; // already validated non-empty above
-        let profile;
-        if (shell.endsWith("/zsh")) {
-            profile = path.join(homeDir, ".zshrc");
-        }
-        else if (shell.endsWith("/bash")) {
-            profile = path.join(homeDir, ".bashrc");
-        }
-        else {
-            profile = path.join(homeDir, ".profile");
-        }
-        const exportLine = `export AKM_STASH_DIR="${stashDir}"`;
-        const existing = fs.existsSync(profile) ? fs.readFileSync(profile, "utf8") : "";
-        if (!existing.includes("AKM_STASH_DIR")) {
-            const updated = existing + `\n# Agentikit working stash directory\n${exportLine}\n`;
-            const tmpPath = profile + `.tmp.${process.pid}`;
-            try {
-                fs.writeFileSync(tmpPath, updated, "utf8");
-                fs.renameSync(tmpPath, profile);
-            }
-            catch (err) {
-                try {
-                    fs.unlinkSync(tmpPath);
-                }
-                catch { /* ignore */ }
-                throw err;
-            }
-            envSet = true;
-            profileUpdated = profile;
-        }
-    }
-    // Create default config.json if it doesn't exist
-    const configPath = getConfigPath();
-    if (!fs.existsSync(configPath)) {
-        saveConfig(DEFAULT_CONFIG);
-    }
-    process.env.AKM_STASH_DIR = stashDir;
-    // Ensure ripgrep is available (install to stash/bin if needed)
-    let ripgrep;
-    try {
-        const rgResult = ensureRg(stashDir);
-        ripgrep = rgResult;
-    }
-    catch {
-        // Non-fatal: ripgrep is optional, search works without it
-    }
-    return { stashDir, created, envSet, profileUpdated, configPath, ripgrep };
-}

package/dist/src/llm.d.ts

@@ -1,15 +0,0 @@
-import type { LlmConnectionConfig } from "./config";
-import type { StashEntry } from "./metadata";
-/**
- * Use an LLM to enhance a stash entry's metadata: improve description,
- * generate intents, and suggest tags.
- */
-export declare function enhanceMetadata(config: LlmConnectionConfig, entry: StashEntry, fileContent?: string): Promise<{
-    description?: string;
-    intents?: string[];
-    tags?: string[];
-}>;
-/**
- * Check if the LLM endpoint is reachable.
- */
-export declare function isLlmAvailable(config: LlmConnectionConfig): Promise<boolean>;

package/dist/src/markdown.d.ts

@@ -1,18 +0,0 @@
-export interface TocHeading {
-    level: number;
-    text: string;
-    line: number;
-}
-export interface KnowledgeToc {
-    headings: TocHeading[];
-    totalLines: number;
-}
-export declare function parseMarkdownToc(content: string): KnowledgeToc;
-export declare function extractSection(content: string, heading: string): {
-    content: string;
-    startLine: number;
-    endLine: number;
-} | null;
-export declare function extractLineRange(content: string, start: number, end: number): string;
-export declare function extractFrontmatterOnly(content: string): string | null;
-export declare function formatToc(toc: KnowledgeToc): string;

package/dist/src/metadata.d.ts

@@ -1,41 +0,0 @@
-import { type AgentikitAssetType } from "./common";
-import { type TocHeading } from "./markdown";
-export interface StashIntent {
-    when?: string;
-    input?: string;
-    output?: string;
-}
-export interface StashEntry {
-    name: string;
-    type: AgentikitAssetType;
-    description?: string;
-    tags?: string[];
-    examples?: string[];
-    intents?: string[];
-    intent?: StashIntent;
-    entry?: string;
-    generated?: boolean;
-    quality?: "generated" | "curated";
-    confidence?: number;
-    source?: "package" | "frontmatter" | "comments" | "filename" | "manual" | "llm";
-    aliases?: string[];
-    toc?: TocHeading[];
-    usage?: string[];
-}
-export interface StashFile {
-    entries: StashEntry[];
-}
-export declare function stashFilePath(dirPath: string): string;
-export declare function loadStashFile(dirPath: string): StashFile | null;
-export declare function writeStashFile(dirPath: string, stash: StashFile): void;
-export declare function validateStashEntry(entry: unknown): StashEntry | null;
-export declare function generateMetadata(dirPath: string, assetType: AgentikitAssetType, files: string[], typeRoot?: string): StashFile;
-export declare function extractDescriptionFromComments(filePath: string): string | null;
-export declare function extractFrontmatterDescription(filePath: string): string | null;
-export declare function extractPackageMetadata(dirPath: string): {
-    name?: string;
-    description?: string;
-    keywords?: string[];
-} | null;
-export declare function fileNameToDescription(fileName: string): string;
-export declare function extractTagsFromPath(filePath: string, rootDir: string): string[];

package/dist/src/origin-resolve.d.ts

@@ -1,19 +0,0 @@
-import type { StashSource } from "./stash-source";
-/**
- * Given an origin string (from an AssetRef) and the full list of stash
- * sources, return the subset of sources to search.
- *
- * Resolution order:
- *   1. undefined   → all sources (working → mounted → installed)
- *   2. "local"     → working stash only
- *   3. exact match → installed source whose registryId matches verbatim
- *   4. parsed match → parse origin as a registry ref, match by parsed ID
- *   5. path match  → mounted source whose path matches
- *   6. empty       → indicates a remote/uninstalled origin (caller decides)
- */
-export declare function resolveSourcesForOrigin(origin: string | undefined, allSources: StashSource[]): StashSource[];
-/**
- * Check whether an origin refers to something that could be fetched remotely
- * (i.e. it looks like a registry ref but isn't installed locally).
- */
-export declare function isRemoteOrigin(origin: string, allSources: StashSource[]): boolean;

package/dist/src/registry-install.d.ts

@@ -1,11 +0,0 @@
-import { type AgentikitConfig } from "./config";
-import type { RegistryInstallResult, RegistryInstalledEntry } from "./registry-types";
-export interface InstallRegistryRefOptions {
-    cacheRootDir?: string;
-    now?: Date;
-}
-export declare function installRegistryRef(ref: string, options?: InstallRegistryRefOptions): Promise<RegistryInstallResult>;
-export declare function upsertInstalledRegistryEntry(entry: RegistryInstalledEntry): AgentikitConfig;
-export declare function removeInstalledRegistryEntry(id: string): AgentikitConfig;
-export declare function getRegistryCacheRootDir(): string;
-export declare function detectStashRoot(extractedDir: string): string;

package/dist/src/registry-resolve.d.ts

@@ -1,3 +0,0 @@
-import type { ParsedRegistryRef, ResolvedRegistryArtifact } from "./registry-types";
-export declare function parseRegistryRef(rawRef: string): ParsedRegistryRef;
-export declare function resolveRegistryArtifact(parsed: ParsedRegistryRef): Promise<ResolvedRegistryArtifact>;

package/dist/src/registry-search.d.ts

@@ -1,27 +0,0 @@
-import type { RegistrySearchResponse } from "./registry-types";
-export interface RegistryIndex {
-    version: number;
-    updatedAt: string;
-    kits: RegistryKitEntry[];
-}
-export interface RegistryKitEntry {
-    id: string;
-    name: string;
-    description?: string;
-    ref: string;
-    source: "npm" | "github" | "git";
-    homepage?: string;
-    tags?: string[];
-    assetTypes?: string[];
-    author?: string;
-    license?: string;
-    latestVersion?: string;
-    /** Whether this entry was manually reviewed and approved */
-    curated?: boolean;
-}
-export interface RegistrySearchOptions {
-    limit?: number;
-    /** Override registry URL(s). Accepts a single URL or an array. */
-    registryUrls?: string | string[];
-}
-export declare function searchRegistry(query: string, options?: RegistrySearchOptions): Promise<RegistrySearchResponse>;

package/dist/src/registry-types.d.ts

@@ -1,62 +0,0 @@
-export type RegistrySource = "npm" | "github" | "git";
-export interface RegistryRefBase {
-    source: RegistrySource;
-    ref: string;
-    id: string;
-}
-export interface ParsedNpmRef extends RegistryRefBase {
-    source: "npm";
-    packageName: string;
-    requestedVersionOrTag?: string;
-}
-export interface ParsedGithubRef extends RegistryRefBase {
-    source: "github";
-    owner: string;
-    repo: string;
-    requestedRef?: string;
-}
-export interface ParsedGitRef extends RegistryRefBase {
-    source: "git";
-    repoRoot: string;
-    sourcePath: string;
-}
-export type ParsedRegistryRef = ParsedNpmRef | ParsedGithubRef | ParsedGitRef;
-export interface ResolvedRegistryArtifact {
-    id: string;
-    source: RegistrySource;
-    ref: string;
-    artifactUrl: string;
-    resolvedVersion?: string;
-    resolvedRevision?: string;
-}
-export interface RegistryInstalledEntry {
-    id: string;
-    source: RegistrySource;
-    ref: string;
-    resolvedVersion?: string;
-    resolvedRevision?: string;
-    artifactUrl: string;
-    stashRoot: string;
-    cacheDir: string;
-    installedAt: string;
-}
-export interface RegistryInstallResult extends RegistryInstalledEntry {
-    extractedDir: string;
-}
-export interface RegistrySearchHit {
-    source: RegistrySource;
-    id: string;
-    title: string;
-    description?: string;
-    ref: string;
-    homepage?: string;
-    score?: number;
-    metadata?: Record<string, string>;
-    /** Whether this entry was manually reviewed and approved */
-    curated?: boolean;
-}
-export interface RegistrySearchResponse {
-    query: string;
-    hits: RegistrySearchHit[];
-    warnings: string[];
-}

package/dist/src/ripgrep-install.d.ts

@@ -1,12 +0,0 @@
-export interface EnsureRgResult {
-    rgPath: string;
-    installed: boolean;
-    version: string;
-}
-/**
- * Ensure ripgrep is available. If not found on PATH or in stash/bin,
- * download and install it to stash/bin.
- *
- * Returns the path to the ripgrep binary and whether it was newly installed.
- */
-export declare function ensureRg(stashDir: string): EnsureRgResult;

package/dist/src/ripgrep-resolve.d.ts

@@ -1,13 +0,0 @@
-export declare const RG_BINARY: string;
-/**
- * Resolve the path to a usable ripgrep binary.
- * Checks in order:
- *   1. stashDir/bin/rg
- *   2. system PATH (rg)
- * Returns null if ripgrep is not available.
- */
-export declare function resolveRg(stashDir?: string): string | null;
-/**
- * Check if ripgrep is available (either in stash/bin or system PATH).
- */
-export declare function isRgAvailable(stashDir?: string): boolean;

package/dist/src/ripgrep.d.ts

@@ -1,3 +0,0 @@
-export { resolveRg, isRgAvailable } from "./ripgrep-resolve";
-export { ensureRg } from "./ripgrep-install";
-export type { EnsureRgResult } from "./ripgrep-install";

package/dist/src/similarity.js

@@ -1,211 +0,0 @@
-export class TfIdfAdapter {
-    documents = [];
-    idf = new Map();
-    entries = [];
-    buildIndex(entries) {
-        this.entries = entries;
-        const docCount = entries.length;
-        if (docCount === 0)
-            return;
-        // Compute term frequencies per document
-        const docFreqs = new Map();
-        this.documents = entries.map((entry) => {
-            const tokens = tokenize(entry.text);
-            const termFreqs = new Map();
-            for (const token of tokens) {
-                termFreqs.set(token, (termFreqs.get(token) || 0) + 1);
-            }
-            // Track document frequency for IDF
-            for (const term of termFreqs.keys()) {
-                docFreqs.set(term, (docFreqs.get(term) || 0) + 1);
-            }
-            return { entry, termFreqs, magnitude: 0 };
-        });
-        // Compute IDF: log(N / df)
-        this.idf = new Map();
-        for (const [term, df] of docFreqs) {
-            this.idf.set(term, Math.log(docCount / df));
-        }
-        // Compute document magnitudes for cosine similarity
-        for (const doc of this.documents) {
-            let sumSq = 0;
-            for (const [term, tf] of doc.termFreqs) {
-                const idf = this.idf.get(term) || 0;
-                const tfidf = tf * idf;
-                sumSq += tfidf * tfidf;
-            }
-            doc.magnitude = Math.sqrt(sumSq);
-        }
-    }
-    search(query, limit, typeFilter) {
-        if (this.documents.length === 0)
-            return [];
-        const queryTokens = tokenize(query.toLowerCase());
-        if (queryTokens.length === 0) {
-            // Empty query: return all, sorted by type
-            return this.documents
-                .filter((d) => !typeFilter || typeFilter === "any" || d.entry.entry.type === typeFilter)
-                .slice(0, limit)
-                .map((d) => ({
-                entry: d.entry.entry,
-                path: d.entry.path,
-                score: 1,
-            }));
-        }
-        // Build query TF-IDF vector
-        const queryTermFreqs = new Map();
-        for (const token of queryTokens) {
-            queryTermFreqs.set(token, (queryTermFreqs.get(token) || 0) + 1);
-        }
-        let queryMagnitude = 0;
-        const queryVector = new Map();
-        for (const [term, tf] of queryTermFreqs) {
-            const idf = this.idf.get(term) || 0;
-            const tfidf = tf * idf;
-            queryVector.set(term, tfidf);
-            queryMagnitude += tfidf * tfidf;
-        }
-        queryMagnitude = Math.sqrt(queryMagnitude);
-        if (queryMagnitude === 0) {
-            // All query terms are unknown — fallback to substring match
-            return this.substringFallback(query, limit, typeFilter);
-        }
-        const results = [];
-        const querySet = new Set(queryTokens);
-        for (const doc of this.documents) {
-            if (typeFilter && typeFilter !== "any" && doc.entry.entry.type !== typeFilter)
-                continue;
-            // Cosine similarity
-            let dotProduct = 0;
-            for (const [term, queryTfidf] of queryVector) {
-                const docTf = doc.termFreqs.get(term) || 0;
-                if (docTf === 0)
-                    continue;
-                const docIdf = this.idf.get(term) || 0;
-                dotProduct += queryTfidf * (docTf * docIdf);
-            }
-            let score = doc.magnitude > 0 && queryMagnitude > 0
-                ? dotProduct / (doc.magnitude * queryMagnitude)
-                : 0;
-            // Boost: tag exact match
-            const tags = doc.entry.entry.tags || [];
-            for (const tag of tags) {
-                if (querySet.has(tag.toLowerCase())) {
-                    score += 0.15;
-                }
-            }
-            // Boost: intent phrase contains query token
-            const intents = doc.entry.entry.intents || [];
-            for (const intent of intents) {
-                const intentLower = intent.toLowerCase();
-                for (const token of queryTokens) {
-                    if (intentLower.includes(token)) {
-                        score += 0.12;
-                        break; // one boost per intent phrase
-                    }
-                }
-            }
-            // Boost: name contains query token
-            const nameLower = doc.entry.entry.name.toLowerCase().replace(/[-_]/g, " ");
-            for (const token of queryTokens) {
-                if (nameLower.includes(token)) {
-                    score += 0.1;
-                    break;
-                }
-            }
-            if (score > 0) {
-                results.push({
-                    entry: doc.entry.entry,
-                    path: doc.entry.path,
-                    score: Math.round(score * 1000) / 1000,
-                });
-            }
-        }
-        results.sort((a, b) => b.score - a.score);
-        return results.slice(0, limit);
-    }
-    serialize() {
-        const idf = {};
-        for (const [term, val] of this.idf) {
-            idf[term] = val;
-        }
-        const docs = this.documents.map((d) => {
-            const termFreqs = {};
-            for (const [term, tf] of d.termFreqs) {
-                termFreqs[term] = tf;
-            }
-            return { id: d.entry.id, termFreqs, magnitude: d.magnitude };
-        });
-        return { idf, docs };
-    }
-    static deserialize(data, entries) {
-        const adapter = new TfIdfAdapter();
-        adapter.entries = entries;
-        adapter.idf = new Map(Object.entries(data.idf));
-        const entryMap = new Map(entries.map((e) => [e.id, e]));
-        adapter.documents = data.docs
-            .map((d) => {
-            const entry = entryMap.get(d.id);
-            if (!entry)
-                return null;
-            return {
-                entry,
-                termFreqs: new Map(Object.entries(d.termFreqs)),
-                magnitude: d.magnitude,
-            };
-        })
-            .filter((d) => d !== null);
-        return adapter;
-    }
-    substringFallback(query, limit, typeFilter) {
-        const q = query.toLowerCase();
-        const tokens = tokenize(q);
-        return this.documents
-            .map((d) => {
-            if (typeFilter && typeFilter !== "any" && d.entry.entry.type !== typeFilter)
-                return null;
-            // Check if any query token matches the document text or name
-            const text = d.entry.text;
-            const name = d.entry.entry.name.toLowerCase();
-            let matchCount = 0;
-            for (const token of tokens) {
-                if (text.includes(token) || name.includes(token))
-                    matchCount++;
-            }
-            // Also check full substring match
-            if (text.includes(q) || name.includes(q))
-                matchCount = Math.max(matchCount, tokens.length);
-            if (matchCount === 0)
-                return null;
-            return {
-                entry: d.entry.entry,
-                path: d.entry.path,
-                score: Math.round((matchCount / Math.max(tokens.length, 1)) * 500) / 1000,
-            };
-        })
-            .filter((d) => d !== null)
-            .sort((a, b) => b.score - a.score)
-            .slice(0, limit);
-    }
-}
-// ── Tokenization ────────────────────────────────────────────────────────────
-const STOP_WORDS = new Set([
-    "a", "an", "the", "is", "are", "was", "were", "be", "been", "being",
-    "have", "has", "had", "do", "does", "did", "will", "would", "could",
-    "should", "may", "might", "shall", "can", "need", "dare", "ought",
-    "to", "of", "in", "for", "on", "with", "at", "by", "from", "as",
-    "into", "through", "during", "before", "after", "above", "below",
-    "and", "but", "or", "nor", "not", "so", "yet", "both", "either",
-    "neither", "each", "every", "all", "any", "few", "more", "most",
-    "other", "some", "such", "no", "only", "own", "same", "than",
-    "too", "very", "just", "because", "if", "when", "where", "how",
-    "what", "which", "who", "whom", "this", "that", "these", "those",
-    "it", "its",
-]);
-function tokenize(text) {
-    return text
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, " ")
-        .split(/\s+/)
-        .filter((t) => t.length > 1 && !STOP_WORDS.has(t));
-}