ahok-skill 1.3.1

package/tests/test_omnibus.ts

@@ -0,0 +1,166 @@
+
+import { Memory } from "../src/core/memory";
+import { run_async, q } from "../src/core/db";
+
+// Mock time for evolutionary stability
+let mockTime: number | null = null;
+const originalNow = Date.now;
+Date.now = () => (mockTime !== null ? mockTime : originalNow());
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function cleanup(user_id: string) {
+    await run_async(`DELETE FROM memories`);
+    try { await run_async(`DELETE FROM vectors`); } catch { }
+    try { await run_async(`DELETE FROM openmemory_vectors`); } catch { }
+    try { await run_async(`DELETE FROM waypoints`); } catch { }
+    try { await run_async(`DELETE FROM users`); } catch { }
+    if (global.gc) global.gc();
+}
+
+// Force synthetic for reliability
+process.env.OM_EMBEDDINGS = "synthetic";
+
+async function check_vec(id: string) {
+    const row = await q.get_mem.get(id);
+    if (!row) console.error(`[DEBUG] Memory ${id} NOT FOUND in DB`);
+    else console.log(`[DEBUG] Memory ${id} vector length: ${row.mean_vec ? row.mean_vec.length : 'NULL'}`);
+}
+
+async function test_evolutionary_stability() {
+    console.log("\n[Phase 1] Evolutionary Stability (10 Generations)");
+    const mem = new Memory();
+    const uid = "u1";
+    await cleanup(uid);
+
+    // 1. Genesis
+    mockTime = originalNow();
+    const res_pop = await mem.add("I am the Popular Memory", { user_id: uid });
+    const res_unpop = await mem.add("I am the Unpopular Memory", { user_id: uid });
+    const pid = res_pop.id;
+    const uid_mem = res_unpop.id;
+
+    // 2. Evolution Loop
+    for (let gen = 0; gen < 10; gen++) {
+        // Advance 1 day per generation (86400000 ms)
+        mockTime += 86400 * 1000;
+
+        // Reinforce Popular every other generation
+        if (gen % 2 === 0) {
+            await mem.search("Popular", { user_id: uid, limit: 1 });
+        }
+    }
+
+    // 3. Final Judgment
+    mockTime += 86400 * 1000;
+
+    // Check Salience via DB directly to avoid search side-effects
+    const pop_final = await q.get_mem.get(pid);
+    const unpop_final = await q.get_mem.get(uid_mem);
+
+    if (!pop_final || !unpop_final) {
+        throw new Error("Memories lost in time!");
+    }
+
+    const s_pop = pop_final.salience;
+    const s_unpop = unpop_final.salience;
+
+    console.log(` -> Generation 10 Results:`);
+    console.log(`    Popular Salience: ${s_pop.toFixed(4)}`);
+    console.log(`    Unpopular Salience: ${s_unpop.toFixed(4)}`);
+
+    if (s_pop <= s_unpop) {
+        throw new Error(`FAIL: Popular memory (${s_pop}) should > Unpopular (${s_unpop})`);
+    }
+    console.log(" -> PASS: Survival of the fittest confirmed.");
+    mockTime = null; // Reset
+}
+
+async function test_boolean_metadata_logic() {
+    console.log("\n[Phase 2] Boolean Metadata Logic");
+    const mem = new Memory();
+    const uid = "filter_user_js";
+    await cleanup(uid);
+
+    // Wait 500ms for WAL safety buffer from previous test deletions if any
+    await sleep(500);
+
+    // 1. High Priority, Work context
+    await mem.add("Finish Report", { user_id: uid, tags: ["work", "urgent"], priority: 10 });
+    // 2. Low Priority, Work context
+    await mem.add("Clean Desk", { user_id: uid, tags: ["work"], priority: 2 });
+    // 3. High Prioriy, Home context
+    const res3 = await mem.add("Pay Bills", { user_id: uid, tags: ["home", "urgent"], priority: 10 });
+
+    // Ensure persistence
+    await sleep(1000);
+    await check_vec(res3.id);
+
+    console.log(" -> Filtering for 'work' AND 'urgent'...");
+    // Since search doesn't support complex filter syntax yet, we search semantic and verify post-hoc
+    const hits = await mem.search("Report", { user_id: uid, limit: 10 });
+
+    // Check logic
+    const found = hits.some((h: any) => {
+        const tags = typeof h.tags === 'string' ? JSON.parse(h.tags) : h.tags || [];
+        return tags.includes("urgent") && tags.includes("work");
+    });
+
+    if (!found) {
+        // console.error("DEBUG Hits:", JSON.stringify(hits, null, 2));
+        await require('fs/promises').writeFile('hits.json', JSON.stringify(hits, null, 2));
+        throw new Error("FAIL: Did not find item with both tags. Dumped hits to hits.json");
+    }
+    console.log(" -> PASS: Metadata attributes preserved and queryable.");
+}
+
+async function test_content_robustness() {
+    console.log("\n[Phase 3] Content Robustness");
+    const mem = new Memory();
+    const uid = "format_user_js";
+    await cleanup(uid);
+    await sleep(500);
+
+    const payloads = {
+        "HTML": "<div><h1>Title</h1><p>Body</p></div>",
+        "JSON": '{"key": "value", "list": [1, 2, 3]}',
+        "Markdown": "| Col1 | Col2 |\n|---|---|\n| Val1 | Val2 |"
+    };
+
+    for (const [fmt, content] of Object.entries(payloads)) {
+        await mem.add(content, { user_id: uid });
+        await sleep(200);
+
+        const hits = await mem.search(content.substring(0, 10), { user_id: uid, limit: 1 });
+        if (!hits || hits.length === 0) {
+            throw new Error(`FAIL: ${fmt} retrieval returned no results.`);
+        }
+
+        const retrieved = hits[0].content;
+
+        // Check containment
+        if (retrieved.includes("Title") || retrieved.includes("key") || retrieved.includes("Col1")) {
+            console.log(` -> ${fmt}: Verified (Key Match)`);
+        } else {
+            console.error(`original: ${content}`);
+            console.error(`retrieved: ${retrieved}`);
+            throw new Error(`FAIL: ${fmt} retrieval content mismatch.`);
+        }
+    }
+    console.log(" -> PASS: Complex formats handled.");
+}
+
+async function run_all() {
+    try {
+        await test_evolutionary_stability();
+        await test_boolean_metadata_logic();
+        await test_content_robustness();
+        console.log("\n[OMNIBUS] ALL TESTS PASSED");
+        process.exit(0);
+    } catch (e) {
+        console.error("\n[OMNIBUS] TEST FAILED:", e);
+        process.exit(1);
+    }
+}
+
+run_all();

package/tests/test_workspace_management.ts

@@ -0,0 +1,278 @@
+/**
+ * End-to-end test for Memory Workspace Management
+ * Tests: workspace creation, renaming, statistics, bulk operations
+ * 
+ * This test focuses on the database queries for workspace management
+ * without relying on the full memory creation pipeline.
+ */
+
+import { q, run_async } from "../src/core/db";
+import crypto from "crypto";
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+const TEST_USER_ID = `test_workspace_user_${Date.now()}`;
+
+async function cleanup() {
+    console.log("\n[Cleanup] Removing test data...");
+    try {
+        await run_async(`DELETE FROM memories WHERE user_id = '${TEST_USER_ID}'`);
+        await run_async(`DELETE FROM api_keys WHERE user_id = '${TEST_USER_ID}'`);
+    } catch (e) {
+        console.log("  Cleanup warning:", e);
+    }
+}
+
+/**
+ * Test 1: Create multiple workspaces
+ */
+async function test_create_workspaces(): Promise<string[]> {
+    console.log("\n[Test 1] Creating multiple workspaces...");
+    
+    const workspaceIds: string[] = [];
+    const labels = ["Development", "Production", "Testing"];
+    
+    for (const label of labels) {
+        const id = crypto.randomUUID();
+        const secret_key = `opm_sk_${crypto.randomBytes(24).toString("hex")}`;
+        const created_at = Date.now();
+        
+        await q.ins_memory_key.run(id, TEST_USER_ID, label, secret_key, created_at);
+        workspaceIds.push(id);
+        console.log(`  ✓ Created workspace: ${label} (${id})`);
+    }
+    
+    // Verify workspaces were created
+    const workspaces = await q.get_memory_keys_by_user.all(TEST_USER_ID);
+    if (workspaces.length !== 3) {
+        throw new Error(`Expected 3 workspaces, got ${workspaces.length}`);
+    }
+    
+    console.log(`  ✓ Verified ${workspaces.length} workspaces exist`);
+    return workspaceIds;
+}
+
+/**
+ * Test 2: Rename a workspace
+ */
+async function test_rename_workspace(workspaceId: string) {
+    console.log("\n[Test 2] Renaming workspace...");
+    
+    const newLabel = "Development-Renamed";
+    const updated_at = Date.now();
+    
+    await q.upd_memory_key_label.run(newLabel, updated_at, workspaceId, TEST_USER_ID);
+    
+    // Verify rename
+    const workspaces = await q.get_memory_keys_by_user.all(TEST_USER_ID);
+    const renamed = workspaces.find(w => w.id === workspaceId);
+    
+    if (!renamed || renamed.label !== newLabel) {
+        throw new Error(`Rename failed: expected "${newLabel}", got "${renamed?.label}"`);
+    }
+    
+    console.log(`  ✓ Workspace renamed to: ${newLabel}`);
+}
+
+/**
+ * Test 3: Create memories directly in database (bypassing embedding)
+ */
+async function test_create_memories_in_workspaces(workspaceIds: string[]): Promise<string[]> {
+    console.log("\n[Test 3] Creating memories in different workspaces...");
+    
+    const memoryIds: string[] = [];
+    const timestamp = Date.now();
+    
+    // Create 2 memories in workspace 1
+    for (let i = 0; i < 2; i++) {
+        const id = crypto.randomUUID();
+        await run_async(
+            `INSERT INTO memories (id, user_id, content, primary_sector, created_at, memory_key_id) 
+             VALUES ($1, $2, $3, $4, $5, $6)`,
+            [id, TEST_USER_ID, `Memory ${i + 1} in workspace 1 - ${timestamp}`, 'semantic', timestamp, workspaceIds[0]]
+        );
+        memoryIds.push(id);
+        console.log(`  ✓ Created memory in workspace 1: ${id}`);
+    }
+    
+    // Create 3 memories in workspace 2
+    for (let i = 0; i < 3; i++) {
+        const id = crypto.randomUUID();
+        await run_async(
+            `INSERT INTO memories (id, user_id, content, primary_sector, created_at, memory_key_id) 
+             VALUES ($1, $2, $3, $4, $5, $6)`,
+            [id, TEST_USER_ID, `Memory ${i + 1} in workspace 2 - ${timestamp}`, 'semantic', timestamp, workspaceIds[1]]
+        );
+        memoryIds.push(id);
+        console.log(`  ✓ Created memory in workspace 2: ${id}`);
+    }
+    
+    // Create 1 memory in workspace 3
+    const id = crypto.randomUUID();
+    await run_async(
+        `INSERT INTO memories (id, user_id, content, primary_sector, created_at, memory_key_id) 
+         VALUES ($1, $2, $3, $4, $5, $6)`,
+        [id, TEST_USER_ID, `Memory 1 in workspace 3 - ${timestamp}`, 'semantic', timestamp, workspaceIds[2]]
+    );
+    memoryIds.push(id);
+    console.log(`  ✓ Created memory in workspace 3: ${id}`);
+    
+    console.log(`  ✓ Total memories created: ${memoryIds.length}`);
+    return memoryIds;
+}
+
+/**
+ * Test 4: Get workspace statistics (memory counts)
+ */
+async function test_workspace_statistics(workspaceIds: string[]) {
+    console.log("\n[Test 4] Testing workspace statistics...");
+    
+    const counts = await q.get_memory_counts_by_key.all(TEST_USER_ID);
+    console.log("  Memory counts by workspace:", counts);
+    
+    // Create a map for easy lookup
+    const countMap = new Map<string, number>();
+    for (const item of counts) {
+        if (item.memory_key_id) {
+            countMap.set(item.memory_key_id, Number(item.count));
+        }
+    }
+    
+    // Verify counts
+    const ws1Count = countMap.get(workspaceIds[0]) || 0;
+    const ws2Count = countMap.get(workspaceIds[1]) || 0;
+    const ws3Count = countMap.get(workspaceIds[2]) || 0;
+    
+    console.log(`  Workspace 1 count: ${ws1Count} (expected: 2)`);
+    console.log(`  Workspace 2 count: ${ws2Count} (expected: 3)`);
+    console.log(`  Workspace 3 count: ${ws3Count} (expected: 1)`);
+    
+    if (ws1Count !== 2) throw new Error(`Workspace 1: expected 2, got ${ws1Count}`);
+    if (ws2Count !== 3) throw new Error(`Workspace 2: expected 3, got ${ws2Count}`);
+    if (ws3Count !== 1) throw new Error(`Workspace 3: expected 1, got ${ws3Count}`);
+    
+    console.log("  ✓ All workspace statistics are correct");
+}
+
+/**
+ * Test 5: Bulk move memories between workspaces
+ */
+async function test_bulk_move(memoryIds: string[], workspaceIds: string[]) {
+    console.log("\n[Test 5] Testing bulk move...");
+    
+    // Move first 2 memories (from workspace 1) to workspace 3
+    const idsToMove = memoryIds.slice(0, 2);
+    const targetWorkspace = workspaceIds[2];
+    const updated_at = Date.now();
+    
+    console.log(`  Moving ${idsToMove.length} memories to workspace 3...`);
+    await q.bulk_upd_mem_key.run(targetWorkspace, updated_at, idsToMove, TEST_USER_ID);
+    
+    // Verify the move by checking statistics
+    await sleep(200);
+    const counts = await q.get_memory_counts_by_key.all(TEST_USER_ID);
+    
+    const countMap = new Map<string, number>();
+    for (const item of counts) {
+        if (item.memory_key_id) {
+            countMap.set(item.memory_key_id, Number(item.count));
+        }
+    }
+    
+    const ws1Count = countMap.get(workspaceIds[0]) || 0;
+    const ws3Count = countMap.get(workspaceIds[2]) || 0;
+    
+    console.log(`  Workspace 1 count after move: ${ws1Count} (expected: 0)`);
+    console.log(`  Workspace 3 count after move: ${ws3Count} (expected: 3)`);
+    
+    if (ws1Count !== 0) throw new Error(`Workspace 1 after move: expected 0, got ${ws1Count}`);
+    if (ws3Count !== 3) throw new Error(`Workspace 3 after move: expected 3, got ${ws3Count}`);
+    
+    console.log("  ✓ Bulk move successful");
+}
+
+/**
+ * Test 6: Bulk delete memories
+ */
+async function test_bulk_delete(memoryIds: string[]) {
+    console.log("\n[Test 6] Testing bulk delete...");
+    
+    // Delete the last 2 memories
+    const idsToDelete = memoryIds.slice(-2);
+    
+    console.log(`  Deleting ${idsToDelete.length} memories...`);
+    await q.bulk_del_mem.run(idsToDelete, TEST_USER_ID);
+    
+    // Verify deletion
+    await sleep(200);
+    for (const id of idsToDelete) {
+        const mem = await q.get_mem.get(id);
+        if (mem) {
+            throw new Error(`Memory ${id} should have been deleted`);
+        }
+    }
+    
+    console.log("  ✓ Bulk delete successful");
+}
+
+/**
+ * Test 7: Delete a workspace
+ */
+async function test_delete_workspace(workspaceId: string) {
+    console.log("\n[Test 7] Testing workspace deletion...");
+    
+    await q.del_memory_key.run(workspaceId, TEST_USER_ID);
+    
+    // Verify deletion
+    const workspaces = await q.get_memory_keys_by_user.all(TEST_USER_ID);
+    const deleted = workspaces.find(w => w.id === workspaceId);
+    
+    if (deleted) {
+        throw new Error(`Workspace ${workspaceId} should have been deleted`);
+    }
+    
+    console.log("  ✓ Workspace deleted successfully");
+}
+
+async function run_all_tests() {
+    console.log("=".repeat(60));
+    console.log("Memory Workspace Management - End-to-End Tests");
+    console.log("=".repeat(60));
+    
+    try {
+        // Initialize database by making a simple query
+        console.log("\n[Init] Initializing database...");
+        await sleep(1000); // Give time for db to initialize
+        console.log("  ✓ Database initialized");
+        
+        // Cleanup any previous test data
+        await cleanup();
+        
+        // Run tests
+        const workspaceIds = await test_create_workspaces();
+        await test_rename_workspace(workspaceIds[0]);
+        const memoryIds = await test_create_memories_in_workspaces(workspaceIds);
+        await test_workspace_statistics(workspaceIds);
+        await test_bulk_move(memoryIds, workspaceIds);
+        await test_bulk_delete(memoryIds);
+        await test_delete_workspace(workspaceIds[0]);
+        
+        // Final cleanup
+        await cleanup();
+        
+        console.log("\n" + "=".repeat(60));
+        console.log("✅ ALL TESTS PASSED");
+        console.log("=".repeat(60));
+        process.exit(0);
+    } catch (error) {
+        console.error("\n" + "=".repeat(60));
+        console.error("❌ TEST FAILED:", error);
+        console.error("=".repeat(60));
+        
+        // Cleanup on failure
+        await cleanup();
+        process.exit(1);
+    }
+}
+
+run_all_tests();

package/tests/verify.ts

@@ -0,0 +1,104 @@
+
+import { Memory } from "../src/core/memory";
+import { env } from "../src/core/cfg";
+import { q } from "../src/core/db";
+
+async function runTest() {
+    console.log("\\n[TEST] 🧪 Starting JS Deep Sector & Vector Verification...");
+    console.log(`[TEST] Target Vector Dim: ${env.vec_dim}`);
+
+    const uid = "js_sector_tester_v1";
+    // We need to implement delete_all in JS if not present?
+    // JS `Memory` class likely has it? Checked API parity.
+    // If not, we can use `q` directly.
+    try {
+        await q.conn.run("DELETE FROM memories WHERE user_id = ?", [uid]);
+    } catch (e) {
+        console.log("Cleanup warning:", e);
+    }
+
+    const mem = new Memory(uid);
+    console.log(`[TEST] Cleared memory for user: ${uid}`);
+
+    const testCases = [
+        {
+            type: "episodic",
+            text: "Yesterday I went to the park at 4:00 PM and saw a dog.",
+            expected: "episodic"
+        },
+        {
+            type: "emotional",
+            text: "I feel absolutely amazing and excited about this new project! Wow!",
+            expected: "emotional"
+        },
+        {
+            type: "procedural",
+            text: "To install the package, first run npm install, then configure the settings.",
+            expected: "procedural"
+        },
+        {
+            type: "reflective",
+            text: "I realized that the pattern of failure was due to my own lack of patience.",
+            expected: "reflective"
+        },
+        {
+            type: "semantic",
+            text: "Python is a high-level programming language known for its readability.",
+            expected: "semantic"
+        }
+    ];
+
+    console.log("\\n[TEST] Ingesting Samples...");
+    let passed = true;
+
+    for (const c of testCases) {
+        console.log(`  > Ingesting (${c.type}): "${c.text.substring(0, 40)}..."`);
+        const res = await mem.add(c.text);
+        const mid = res.id;
+
+        // Wait for WAL
+        await new Promise(r => setTimeout(r, 500));
+
+        // Get from DB
+        const row = await q.get_mem.get(mid);
+        if (!row) {
+            console.log("    FAIL: Memory not found in DB");
+            passed = false;
+            continue;
+        }
+
+        const actual = row.primary_sector;
+        const status = actual === c.expected ? "PASS" : `FAIL (Got: ${actual})`;
+        console.log(`    - ID: ${mid}`);
+        console.log(`    - Assigned Sector: ${actual.toUpperCase()} ${status}`);
+
+        if (actual !== c.expected) passed = false;
+
+        console.log(`    - Checking Vector Dimensions...`);
+        const vecBuf = row.mean_vec;
+        if (!vecBuf) {
+            console.log("    FAIL: No vector generated!");
+            passed = false;
+        } else {
+            // Buffer in Node/Bun.
+            const vecLen = vecBuf.length; // bytes
+            const dim = vecLen / 4;
+            if (dim === 1536) {
+                console.log(`    PASS: Vector Dim ${dim} (Size: ${vecLen} bytes)`);
+            } else {
+                console.log(`    FAIL: Vector Dim ${dim} (Expected 1536)`);
+                passed = false;
+            }
+        }
+    }
+
+    console.log("\\n[TEST] Summary:");
+    if (passed) {
+        console.log("ALL JS SECTOR & VECTOR TESTS PASSED.");
+    } else {
+        console.log("SOME TESTS FAILED.");
+        process.exit(1);
+    }
+}
+
+runTest().catch(console.error);

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+"compilerOptions": {
+"target": "ES2022",
+"module": "CommonJS",
+"moduleResolution": "node",
+"outDir": "dist",
+"allowJs": true,
+"checkJs": false,
+"esModuleInterop": true,
+"forceConsistentCasingInFileNames": true,
+"strict": true,
+"skipLibCheck": true
+},
+"include": ["src"]
+}