ahok-skill 1.3.1

package/dist/utils/keyword.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extract_keywords = extract_keywords;
+exports.compute_keyword_overlap = compute_keyword_overlap;
+exports.exact_phrase_match = exact_phrase_match;
+exports.compute_bm25_score = compute_bm25_score;
+exports.keyword_filter_memories = keyword_filter_memories;
+const text_1 = require("./text");
+const cfg_1 = require("../core/cfg");
+function extract_keywords(text, min_length = 3) {
+    const tokens = (0, text_1.canonical_tokens_from_text)(text);
+    const keywords = new Set();
+    for (const token of tokens) {
+        if (token.length >= min_length) {
+            keywords.add(token);
+            if (token.length >= 3) {
+                for (let i = 0; i <= token.length - 3; i++) {
+                    keywords.add(token.slice(i, i + 3));
+                }
+            }
+        }
+    }
+    for (let i = 0; i < tokens.length - 1; i++) {
+        const bigram = `${tokens[i]}_${tokens[i + 1]}`;
+        if (bigram.length >= min_length) {
+            keywords.add(bigram);
+        }
+    }
+    for (let i = 0; i < tokens.length - 2; i++) {
+        const trigram = `${tokens[i]}_${tokens[i + 1]}_${tokens[i + 2]}`;
+        keywords.add(trigram);
+    }
+    return keywords;
+}
+function compute_keyword_overlap(query_keywords, content_keywords) {
+    let matches = 0;
+    let total_weight = 0;
+    for (const qk of query_keywords) {
+        if (content_keywords.has(qk)) {
+            const weight = qk.includes("_") ? 2.0 : 1.0;
+            matches += weight;
+        }
+        total_weight += qk.includes("_") ? 2.0 : 1.0;
+    }
+    if (total_weight === 0)
+        return 0;
+    return matches / total_weight;
+}
+function exact_phrase_match(query, content) {
+    const q_norm = query.toLowerCase().trim();
+    const c_norm = content.toLowerCase();
+    return c_norm.includes(q_norm);
+}
+function compute_bm25_score(query_terms, content_terms, corpus_size = 10000, avg_doc_length = 100) {
+    const k1 = 1.5;
+    const b = 0.75;
+    const term_freq = new Map();
+    for (const term of content_terms) {
+        term_freq.set(term, (term_freq.get(term) || 0) + 1);
+    }
+    const doc_length = content_terms.length;
+    let score = 0;
+    for (const q_term of query_terms) {
+        const tf = term_freq.get(q_term) || 0;
+        if (tf === 0)
+            continue;
+        const idf = Math.log((corpus_size + 1) / (tf + 0.5));
+        const numerator = tf * (k1 + 1);
+        const denominator = tf + k1 * (1 - b + b * (doc_length / avg_doc_length));
+        score += idf * (numerator / denominator);
+    }
+    return score;
+}
+async function keyword_filter_memories(query, all_memories, threshold = 0.1) {
+    const query_keywords = extract_keywords(query, cfg_1.env.keyword_min_length);
+    const query_terms = (0, text_1.canonical_tokens_from_text)(query);
+    const scores = new Map();
+    for (const mem of all_memories) {
+        let total_score = 0;
+        if (exact_phrase_match(query, mem.content)) {
+            total_score += 1.0;
+        }
+        const content_keywords = extract_keywords(mem.content, cfg_1.env.keyword_min_length);
+        const keyword_score = compute_keyword_overlap(query_keywords, content_keywords);
+        total_score += keyword_score * 0.8;
+        const content_terms = (0, text_1.canonical_tokens_from_text)(mem.content);
+        const bm25_score = compute_bm25_score(query_terms, content_terms);
+        total_score += Math.min(1.0, bm25_score / 10) * 0.5;
+        if (total_score > threshold) {
+            scores.set(mem.id, total_score);
+        }
+    }
+    return scores;
+}

package/dist/utils/text.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.add_synonym_tokens = exports.canonical_token_set = exports.build_fts_query = exports.build_search_doc = exports.synonyms_for = exports.canonical_tokens_from_text = exports.canonicalize_token = exports.tokenize = void 0;
+const syn_grps = [
+    ["prefer", "like", "love", "enjoy", "favor"],
+    ["theme", "mode", "style", "layout"],
+    ["meeting", "meet", "session", "call", "sync"],
+    ["dark", "night", "black"],
+    ["light", "bright", "day"],
+    ["user", "person", "people", "customer"],
+    ["task", "todo", "job"],
+    ["note", "memo", "reminder"],
+    ["time", "schedule", "when", "date"],
+    ["project", "initiative", "plan"],
+    ["issue", "problem", "bug"],
+    ["document", "doc", "file"],
+    ["question", "query", "ask"],
+];
+const cmap = new Map();
+const slook = new Map();
+for (const grp of syn_grps) {
+    const can = grp[0];
+    const sset = new Set(grp);
+    for (const w of grp) {
+        cmap.set(w, can);
+        slook.set(can, sset);
+    }
+}
+const stem_rules = [
+    [/ies$/, "y"],
+    [/ing$/, ""],
+    [/ers?$/, "er"],
+    [/ed$/, ""],
+    [/s$/, ""],
+];
+const tok_pat = /[a-z0-9]+/gi;
+const tokenize = (text) => {
+    const toks = [];
+    let m;
+    while ((m = tok_pat.exec(text))) {
+        toks.push(m[0].toLowerCase());
+    }
+    return toks;
+};
+exports.tokenize = tokenize;
+const stem = (tok) => {
+    if (tok.length <= 3)
+        return tok;
+    for (const [pat, rep] of stem_rules) {
+        if (pat.test(tok)) {
+            const st = tok.replace(pat, rep);
+            if (st.length >= 3)
+                return st;
+        }
+    }
+    return tok;
+};
+const canonicalize_token = (tok) => {
+    if (!tok)
+        return "";
+    const low = tok.toLowerCase();
+    if (cmap.has(low))
+        return cmap.get(low);
+    const st = stem(low);
+    return cmap.get(st) || st;
+};
+exports.canonicalize_token = canonicalize_token;
+const canonical_tokens_from_text = (text) => {
+    const res = [];
+    for (const tok of (0, exports.tokenize)(text)) {
+        const can = (0, exports.canonicalize_token)(tok);
+        if (can && can.length > 1) {
+            res.push(can);
+        }
+    }
+    return res;
+};
+exports.canonical_tokens_from_text = canonical_tokens_from_text;
+const synonyms_for = (tok) => {
+    const can = (0, exports.canonicalize_token)(tok);
+    return slook.get(can) || new Set([can]);
+};
+exports.synonyms_for = synonyms_for;
+const build_search_doc = (text) => {
+    const can = (0, exports.canonical_tokens_from_text)(text);
+    const exp = new Set();
+    for (const tok of can) {
+        exp.add(tok);
+        const syns = slook.get(tok);
+        if (syns) {
+            syns.forEach((s) => exp.add(s));
+        }
+    }
+    return Array.from(exp).join(" ");
+};
+exports.build_search_doc = build_search_doc;
+const build_fts_query = (text) => {
+    const can = (0, exports.canonical_tokens_from_text)(text);
+    if (!can.length)
+        return "";
+    const uniq = Array.from(new Set(can.filter((t) => t.length > 1)));
+    return uniq.map((t) => `"${t}"`).join(" OR ");
+};
+exports.build_fts_query = build_fts_query;
+const canonical_token_set = (text) => {
+    return new Set((0, exports.canonical_tokens_from_text)(text));
+};
+exports.canonical_token_set = canonical_token_set;
+const add_synonym_tokens = (toks) => {
+    const res = new Set();
+    for (const tok of toks) {
+        res.add(tok);
+        const syns = slook.get(tok);
+        if (syns) {
+            syns.forEach((s) => res.add((0, exports.canonicalize_token)(s)));
+        }
+    }
+    return res;
+};
+exports.add_synonym_tokens = add_synonym_tokens;

package/nodemon.json

@@ -0,0 +1,7 @@
+{
+    "watch": [
+        "src"
+    ],
+    "ext": "ts",
+    "exec": "tsx src/server/index.ts"
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+    "name": "ahok-skill",
+    "version": "1.3.1",
+    "author": "nullure",
+    "bin": {
+        "opm": "./bin/opm.js",
+        "openmemory-js": "./bin/opm.js"
+    },
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "dev": "nodemon src/server/index.ts",
+        "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+        "build": "tsc -p tsconfig.json",
+        "start": "node dist/server/index.js",
+        "migrate": "tsx src/migrate.ts"
+    },
+    "dependencies": {
+        "@aws-sdk/client-bedrock-runtime": "^3.932.0",
+        "@azure/msal-node": "^2.0.0",
+        "@clerk/backend": "^2.29.5",
+        "@modelcontextprotocol/sdk": "^1.22.0",
+        "@notionhq/client": "^2.2.0",
+        "@octokit/rest": "^21.0.0",
+        "cheerio": "^1.0.0",
+        "dotenv": "^16.6.1",
+        "fluent-ffmpeg": "^2.1.3",
+        "googleapis": "^140.0.0",
+        "ioredis": "^5.8.2",
+        "mammoth": "^1.11.0",
+        "openai": "^4.73.0",
+        "pdf-parse": "^2.4.5",
+        "pg": "^8.16.3",
+        "sqlite3": "^5.1.7",
+        "stripe": "^20.2.0",
+        "turndown": "^7.2.2",
+        "ws": "^8.18.3",
+        "zod": "^3.25.76"
+    },
+    "devDependencies": {
+        "@types/cheerio": "^0.22.35",
+        "@types/fluent-ffmpeg": "^2.1.26",
+        "@types/node": "^20.19.25",
+        "@types/pg": "^8.15.6",
+        "nodemon": "^3.1.11",
+        "prettier": "^3.6.2",
+        "tsx": "^4.21.0",
+        "typescript": "^5.9.3"
+    }
+}

package/references/api_reference.md

@@ -0,0 +1,66 @@
+# Ahok Memory Cloud API Reference
+
+## Authentication
+All requests require an API key in the `x-api-key` header.
+Get your key from: https://your-dashboard-url/dashboard
+
+## Endpoints
+
+### POST /memory/add
+Store a new memory.
+
+**Request Body:**
+```json
+{
+  "content": "The information to remember",
+  "user_id": "optional-user-identifier",
+  "tags": ["optional", "tags"],
+  "metadata": {"any": "json object"},
+  "memory_key_id": "optional-workspace-uuid"
+}
+```
+
+**Response:**
+```json
+{
+  "id": "uuid",
+  "primary_sector": "semantic|procedural|episodic",
+  "sectors": ["semantic"],
+  "chunks": 1
+}
+```
+
+### POST /query
+Search memories semantically.
+
+**Request Body:**
+```json
+{
+  "query": "natural language search",
+  "k": 5,
+  "user_id": "optional-filter"
+}
+```
+
+**Response:**
+```json
+{
+  "query": "natural language search",
+  "result": "Formatted memory results as text",
+  "matches": [
+    {"id": "uuid", "content": "...", "score": 0.95}
+  ]
+}
+```
+
+### GET /memory/all
+List all memories with pagination.
+
+**Query Parameters:**
+- `user_id`: Filter by user
+- `l`: Limit (default 50)
+- `u`: Offset (default 0)
+- `key_id`: Filter by workspace
+
+### DELETE /memory/{id}
+Delete a specific memory.

package/references/examples.md

@@ -0,0 +1,45 @@
+# Ahok Memory Cloud Integration Examples
+
+## Python Integration
+```python
+import requests
+
+API_KEY = "your-api-key"
+BASE_URL = "https://zqmt62peqz.us-east-1.awsapprunner.com"
+
+def remember(content, user_id=None):
+    return requests.post(f"{BASE_URL}/memory/add", 
+        headers={"x-api-key": API_KEY},
+        json={"content": content, "user_id": user_id}
+    ).json()
+
+def recall(query, k=5):
+    return requests.post(f"{BASE_URL}/query",
+        headers={"x-api-key": API_KEY},
+        json={"query": query, "k": k}
+    ).json()
+```
+
+## TypeScript Integration
+```typescript
+const API_KEY = "your-api-key";
+const BASE_URL = "https://zqmt62peqz.us-east-1.awsapprunner.com";
+
+async function remember(content: string, userId?: string) {
+  const res = await fetch(`${BASE_URL}/memory/add`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", "x-api-key": API_KEY },
+    body: JSON.stringify({ content, user_id: userId })
+  });
+  return res.json();
+}
+
+async function recall(query: string, k = 5) {
+  const res = await fetch(`${BASE_URL}/query`, {
+    method: "POST", 
+    headers: { "Content-Type": "application/json", "x-api-key": API_KEY },
+    body: JSON.stringify({ query, k })
+  });
+  return res.json();
+}
+```