agentikit 0.0.12 → 0.0.13

package/README.md

@@ -35,11 +35,24 @@ When you search or open an asset, the working stash takes priority. This
 means you can install a kit and override individual assets by cloning them
 into your working stash.
 
+## Prerequisites
+
+Agent-i-Kit requires [Bun](https://bun.sh) (v1.0+) as its runtime. It uses
+Bun-specific APIs (`bun:sqlite`) that are not available in Node.js.
+
+```sh
+# Install Bun if you don't have it
+curl -fsSL https://bun.sh/install | bash
+```
+
+> **Don't want to install Bun?** Use the [standalone binary](#standalone-binary)
+> instead -- it has no runtime dependencies.
+
 ## Quick Start
 
 ```sh
 # Install
-npm install -g agentikit
+bun install -g agentikit
 
 # Initialize your stash
 akm init
@@ -59,6 +72,9 @@ akm search "lint" --source both
 
 ### Standalone Binary
 
+The standalone binary bundles everything it needs and does **not** require Bun
+or Node.js.
+
 ```sh
 # macOS / Linux
 curl -fsSL https://raw.githubusercontent.com/itlackey/agentikit/main/install.sh | bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentikit",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "type": "module",
   "description": "CLI tool to search, open, and run extension assets from an agentikit stash directory.",
   "keywords": [

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));
-}