ahok-skill 1.3.1

package/dist/core/memory.js

@@ -0,0 +1,116 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Memory = void 0;
+const hsg_1 = require("../memory/hsg");
+const db_1 = require("./db");
+class Memory {
+    default_user;
+    constructor(user_id) {
+        this.default_user = user_id || null;
+    }
+    async add(content, opts) {
+        const uid = opts?.user_id || this.default_user;
+        const tags = opts?.tags || [];
+        const meta = { ...opts };
+        delete meta.user_id;
+        delete meta.tags;
+        // Ensure tags is JSON string if needed by add_hsg_memory
+        // hsg.ts signature: add_hsg_memory(content, tags, meta, user_id)
+        // tags is usually stringified JSON or string? 
+        // Checked hsg.ts: interface hsg_mem { tags?: string }
+        // Let's pass JSON string for tags.
+        const tags_str = JSON.stringify(tags);
+        // hsg.ts add_hsg_memory returns { id, ... } or similar?
+        // Let's check hsg.ts exports. It's likely async and returns object.
+        const res = await (0, hsg_1.add_hsg_memory)(content, tags_str, meta, uid ?? undefined);
+        return res;
+    }
+    async get(id) {
+        return await db_1.q.get_mem.get(id);
+    }
+    async search(query, opts) {
+        // hsg_query(qt, k, f)
+        const k = opts?.limit || 10;
+        const uid = opts?.user_id || this.default_user;
+        const f = {};
+        if (uid)
+            f.user_id = uid;
+        if (opts?.sectors)
+            f.sectors = opts.sectors;
+        return await (0, hsg_1.hsg_query)(query, k, f);
+    }
+    async delete_all(user_id) {
+        const uid = user_id || this.default_user;
+        if (uid) {
+            // q.del_mem usually exists or we execute raw SQL
+            // But we can't easily access q here if not exported or if we want to change memory.ts minimal
+            // I'll add a wipe() method that calls q directly if q is imported
+        }
+    }
+    async wipe() {
+        console.log("[Memory] Wiping DB...");
+        // q is imported from db.ts
+        await db_1.q.clear_all.run();
+    }
+    /**
+     * get a pre-configured source connector.
+     *
+     * usage:
+     *   const github = mem.source("github")
+     *   await github.connect({ token: "ghp_..." })
+     *   await github.ingest_all({ repo: "owner/repo" })
+     *
+     * available sources: github, notion, google_drive, google_sheets,
+     *                   google_slides, onedrive, web_crawler
+     */
+    source(name) {
+        // dynamic import to avoid circular deps
+        const sources = {
+            github: () => Promise.resolve().then(() => __importStar(require("../sources/github"))).then(m => new m.github_source(this.default_user ?? undefined)),
+            notion: () => Promise.resolve().then(() => __importStar(require("../sources/notion"))).then(m => new m.notion_source(this.default_user ?? undefined)),
+            google_drive: () => Promise.resolve().then(() => __importStar(require("../sources/google_drive"))).then(m => new m.google_drive_source(this.default_user ?? undefined)),
+            google_sheets: () => Promise.resolve().then(() => __importStar(require("../sources/google_sheets"))).then(m => new m.google_sheets_source(this.default_user ?? undefined)),
+            google_slides: () => Promise.resolve().then(() => __importStar(require("../sources/google_slides"))).then(m => new m.google_slides_source(this.default_user ?? undefined)),
+            onedrive: () => Promise.resolve().then(() => __importStar(require("../sources/onedrive"))).then(m => new m.onedrive_source(this.default_user ?? undefined)),
+            web_crawler: () => Promise.resolve().then(() => __importStar(require("../sources/web_crawler"))).then(m => new m.web_crawler_source(this.default_user ?? undefined)),
+        };
+        if (!(name in sources)) {
+            throw new Error(`unknown source: ${name}. available: ${Object.keys(sources).join(", ")}`);
+        }
+        return sources[name]();
+    }
+}
+exports.Memory = Memory;

package/dist/core/migrate.js

@@ -0,0 +1,227 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run_migrations = run_migrations;
+const cfg_1 = require("./cfg");
+const sqlite3_1 = __importDefault(require("sqlite3"));
+const pg_1 = require("pg");
+const is_pg = cfg_1.env.metadata_backend === "postgres";
+const log = (msg) => console.log(`[MIGRATE] ${msg}`);
+const migrations = [
+    {
+        version: "1.2.0",
+        desc: "Multi-user tenant support",
+        sqlite: [
+            `ALTER TABLE memories ADD COLUMN user_id TEXT`,
+            `CREATE INDEX IF NOT EXISTS idx_memories_user ON memories(user_id)`,
+            `ALTER TABLE vectors ADD COLUMN user_id TEXT`,
+            `CREATE INDEX IF NOT EXISTS idx_vectors_user ON vectors(user_id)`,
+            `CREATE TABLE IF NOT EXISTS waypoints_new (
+        src_id TEXT, dst_id TEXT NOT NULL, user_id TEXT,
+        weight REAL NOT NULL, created_at INTEGER, updated_at INTEGER,
+        PRIMARY KEY(src_id, user_id)
+      )`,
+            `INSERT INTO waypoints_new SELECT src_id, dst_id, NULL, weight, created_at, updated_at FROM waypoints`,
+            `DROP TABLE waypoints`,
+            `ALTER TABLE waypoints_new RENAME TO waypoints`,
+            `CREATE INDEX IF NOT EXISTS idx_waypoints_src ON waypoints(src_id)`,
+            `CREATE INDEX IF NOT EXISTS idx_waypoints_dst ON waypoints(dst_id)`,
+            `CREATE INDEX IF NOT EXISTS idx_waypoints_user ON waypoints(user_id)`,
+            `CREATE TABLE IF NOT EXISTS users (
+        user_id TEXT PRIMARY KEY, summary TEXT,
+        reflection_count INTEGER DEFAULT 0,
+        created_at INTEGER, updated_at INTEGER
+      )`,
+            `CREATE TABLE IF NOT EXISTS stats (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        type TEXT NOT NULL, count INTEGER DEFAULT 1, ts INTEGER NOT NULL
+      )`,
+            `CREATE INDEX IF NOT EXISTS idx_stats_ts ON stats(ts)`,
+            `CREATE INDEX IF NOT EXISTS idx_stats_type ON stats(type)`,
+        ],
+        postgres: [
+            `ALTER TABLE {m} ADD COLUMN IF NOT EXISTS user_id TEXT`,
+            `CREATE INDEX IF NOT EXISTS openmemory_memories_user_idx ON {m}(user_id)`,
+            `ALTER TABLE {v} ADD COLUMN IF NOT EXISTS user_id TEXT`,
+            `CREATE INDEX IF NOT EXISTS openmemory_vectors_user_idx ON {v}(user_id)`,
+            `ALTER TABLE {w} ADD COLUMN IF NOT EXISTS user_id TEXT`,
+            `ALTER TABLE {w} DROP CONSTRAINT IF EXISTS waypoints_pkey`,
+            `ALTER TABLE {w} ADD PRIMARY KEY (src_id, user_id)`,
+            `CREATE INDEX IF NOT EXISTS openmemory_waypoints_user_idx ON {w}(user_id)`,
+            `CREATE TABLE IF NOT EXISTS {u} (
+        user_id TEXT PRIMARY KEY, summary TEXT,
+        reflection_count INTEGER DEFAULT 0,
+        created_at BIGINT, updated_at BIGINT
+      )`,
+        ],
+    },
+];
+async function get_db_version_sqlite(db) {
+    return new Promise((ok, no) => {
+        db.get(`SELECT name FROM sqlite_master WHERE type='table' AND name='schema_version'`, (err, row) => {
+            if (err)
+                return no(err);
+            if (!row)
+                return ok(null);
+            db.get(`SELECT version FROM schema_version ORDER BY applied_at DESC LIMIT 1`, (e, v) => {
+                if (e)
+                    return no(e);
+                ok(v?.version || null);
+            });
+        });
+    });
+}
+async function set_db_version_sqlite(db, version) {
+    return new Promise((ok, no) => {
+        db.run(`CREATE TABLE IF NOT EXISTS schema_version (
+        version TEXT PRIMARY KEY, applied_at INTEGER
+      )`, (err) => {
+            if (err)
+                return no(err);
+            db.run(`INSERT OR REPLACE INTO schema_version VALUES (?, ?)`, [version, Date.now()], (e) => {
+                if (e)
+                    return no(e);
+                ok();
+            });
+        });
+    });
+}
+async function check_column_exists_sqlite(db, table, column) {
+    return new Promise((ok, no) => {
+        db.all(`PRAGMA table_info(${table})`, (err, rows) => {
+            if (err)
+                return no(err);
+            ok(rows.some((r) => r.name === column));
+        });
+    });
+}
+async function run_sqlite_migration(db, m) {
+    log(`Running migration: ${m.version} - ${m.desc}`);
+    const has_user_id = await check_column_exists_sqlite(db, "memories", "user_id");
+    if (has_user_id) {
+        log(`Migration ${m.version} already applied (user_id exists), skipping`);
+        await set_db_version_sqlite(db, m.version);
+        return;
+    }
+    for (const sql of m.sqlite) {
+        await new Promise((ok, no) => {
+            db.run(sql, (err) => {
+                if (err && !err.message.includes("duplicate column")) {
+                    log(`ERROR: ${err.message}`);
+                    return no(err);
+                }
+                ok();
+            });
+        });
+    }
+    await set_db_version_sqlite(db, m.version);
+    log(`Migration ${m.version} completed successfully`);
+}
+async function get_db_version_pg(pool) {
+    try {
+        const sc = process.env.OM_PG_SCHEMA || "public";
+        const check = await pool.query(`SELECT EXISTS (
+        SELECT FROM information_schema.tables 
+        WHERE table_schema = $1 AND table_name = 'schema_version'
+      )`, [sc]);
+        if (!check.rows[0].exists)
+            return null;
+        const ver = await pool.query(`SELECT version FROM "${sc}"."schema_version" ORDER BY applied_at DESC LIMIT 1`);
+        return ver.rows[0]?.version || null;
+    }
+    catch (e) {
+        return null;
+    }
+}
+async function set_db_version_pg(pool, version) {
+    const sc = process.env.OM_PG_SCHEMA || "public";
+    await pool.query(`CREATE TABLE IF NOT EXISTS "${sc}"."schema_version" (
+      version TEXT PRIMARY KEY, applied_at BIGINT
+    )`);
+    await pool.query(`INSERT INTO "${sc}"."schema_version" VALUES ($1, $2) 
+     ON CONFLICT (version) DO UPDATE SET applied_at = EXCLUDED.applied_at`, [version, Date.now()]);
+}
+async function check_column_exists_pg(pool, table, column) {
+    const sc = process.env.OM_PG_SCHEMA || "public";
+    const tbl = table.replace(/"/g, "").split(".").pop() || table;
+    const res = await pool.query(`SELECT EXISTS (
+      SELECT FROM information_schema.columns 
+      WHERE table_schema = $1 AND table_name = $2 AND column_name = $3
+    )`, [sc, tbl, column]);
+    return res.rows[0].exists;
+}
+async function run_pg_migration(pool, m) {
+    log(`Running migration: ${m.version} - ${m.desc}`);
+    const sc = process.env.OM_PG_SCHEMA || "public";
+    const mt = process.env.OM_PG_TABLE || "openmemory_memories";
+    const has_user_id = await check_column_exists_pg(pool, mt, "user_id");
+    if (has_user_id) {
+        log(`Migration ${m.version} already applied (user_id exists), skipping`);
+        await set_db_version_pg(pool, m.version);
+        return;
+    }
+    const replacements = {
+        "{m}": `"${sc}"."${mt}"`,
+        "{v}": `"${sc}"."${process.env.OM_VECTOR_TABLE || "openmemory_vectors"}"`,
+        "{w}": `"${sc}"."openmemory_waypoints"`,
+        "{u}": `"${sc}"."openmemory_users"`,
+    };
+    for (let sql of m.postgres) {
+        for (const [k, v] of Object.entries(replacements)) {
+            sql = sql.replace(new RegExp(k, "g"), v);
+        }
+        try {
+            await pool.query(sql);
+        }
+        catch (e) {
+            if (!e.message.includes("already exists") &&
+                !e.message.includes("duplicate")) {
+                log(`ERROR: ${e.message}`);
+                throw e;
+            }
+        }
+    }
+    await set_db_version_pg(pool, m.version);
+    log(`Migration ${m.version} completed successfully`);
+}
+async function run_migrations() {
+    log("Checking for pending migrations...");
+    if (is_pg) {
+        const ssl = process.env.OM_PG_SSL === "require"
+            ? { rejectUnauthorized: false }
+            : process.env.OM_PG_SSL === "disable"
+                ? false
+                : undefined;
+        const pool = new pg_1.Pool({
+            host: process.env.OM_PG_HOST,
+            port: process.env.OM_PG_PORT ? +process.env.OM_PG_PORT : undefined,
+            database: process.env.OM_PG_DB || "openmemory",
+            user: process.env.OM_PG_USER,
+            password: process.env.OM_PG_PASSWORD,
+            ssl,
+        });
+        const current = await get_db_version_pg(pool);
+        log(`Current database version: ${current || "none"}`);
+        for (const m of migrations) {
+            if (!current || m.version > current) {
+                await run_pg_migration(pool, m);
+            }
+        }
+        await pool.end();
+    }
+    else {
+        const db_path = process.env.OM_DB_PATH || "./data/openmemory.sqlite";
+        const db = new sqlite3_1.default.Database(db_path);
+        const current = await get_db_version_sqlite(db);
+        log(`Current database version: ${current || "none"}`);
+        for (const m of migrations) {
+            if (!current || m.version > current) {
+                await run_sqlite_migration(db, m);
+            }
+        }
+        await new Promise((ok) => db.close(() => ok()));
+    }
+    log("All migrations completed");
+}

package/dist/core/models.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.get_provider_config = exports.get_model = exports.load_models = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+let cfg = null;
+const load_models = () => {
+    if (cfg)
+        return cfg;
+    const p = (0, path_1.join)(__dirname, "../../../models.yml");
+    if (!(0, fs_1.existsSync)(p)) {
+        console.error("[MODELS] models.yml not found, using defaults");
+        return get_defaults();
+    }
+    try {
+        const yml = (0, fs_1.readFileSync)(p, "utf-8");
+        cfg = parse_yaml(yml);
+        console.error(`[MODELS] Loaded models.yml (${Object.keys(cfg).length} sectors)`);
+        return cfg;
+    }
+    catch (e) {
+        console.error("[MODELS] Failed to parse models.yml:", e);
+        return get_defaults();
+    }
+};
+exports.load_models = load_models;
+const parse_yaml = (yml) => {
+    const lines = yml.split("\n");
+    const obj = {};
+    let cur_sec = null;
+    for (const line of lines) {
+        const trim = line.trim();
+        if (!trim || trim.startsWith("#"))
+            continue;
+        const indent = line.search(/\S/);
+        const [key, ...val_parts] = trim.split(":");
+        const val = val_parts.join(":").trim();
+        if (indent === 0 && val) {
+            continue;
+        }
+        else if (indent === 0) {
+            cur_sec = key;
+            obj[cur_sec] = {};
+        }
+        else if (cur_sec && val) {
+            obj[cur_sec][key] = val;
+        }
+    }
+    return obj;
+};
+const get_defaults = () => ({
+    episodic: {
+        ollama: "nomic-embed-text",
+        openai: "text-embedding-3-small",
+        gemini: "models/embedding-001",
+        aws: "amazon.titan-embed-text-v2:0",
+        local: "all-MiniLM-L6-v2",
+    },
+    semantic: {
+        ollama: "nomic-embed-text",
+        openai: "text-embedding-3-small",
+        gemini: "models/embedding-001",
+        aws: "amazon.titan-embed-text-v2:0",
+        local: "all-MiniLM-L6-v2",
+    },
+    procedural: {
+        ollama: "nomic-embed-text",
+        openai: "text-embedding-3-small",
+        gemini: "models/embedding-001",
+        aws: "amazon.titan-embed-text-v2:0",
+        local: "all-MiniLM-L6-v2",
+    },
+    emotional: {
+        ollama: "nomic-embed-text",
+        openai: "text-embedding-3-small",
+        gemini: "models/embedding-001",
+        aws: "amazon.titan-embed-text-v2:0",
+        local: "all-MiniLM-L6-v2",
+    },
+    reflective: {
+        ollama: "nomic-embed-text",
+        openai: "text-embedding-3-large",
+        gemini: "models/embedding-001",
+        aws: "amazon.titan-embed-text-v2:0",
+        local: "all-mpnet-base-v2",
+    },
+});
+const get_model = (sector, provider) => {
+    // Environment variable overrides
+    if (provider === "ollama" && process.env.OM_OLLAMA_MODEL) {
+        return process.env.OM_OLLAMA_MODEL;
+    }
+    if (provider === "openai" && process.env.OM_OPENAI_MODEL) {
+        return process.env.OM_OPENAI_MODEL;
+    }
+    const cfg = (0, exports.load_models)();
+    return (cfg[sector]?.[provider] ||
+        cfg.semantic?.[provider] ||
+        "nomic-embed-text");
+};
+exports.get_model = get_model;
+const get_provider_config = (provider) => {
+    return {};
+};
+exports.get_provider_config = get_provider_config;

package/dist/core/telemetry.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendTelemetry = void 0;
+const node_os_1 = __importDefault(require("node:os"));
+const cfg_1 = require("./cfg");
+const DISABLED = (process.env.OM_TELEMETRY ?? '').toLowerCase() === 'false';
+const gatherVersion = () => {
+    if (process.env.npm_package_version)
+        return process.env.npm_package_version;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const pkg = require('../../package.json');
+        if (pkg?.version)
+            return pkg.version;
+    }
+    catch {
+        // ignore
+    }
+    return 'unknown';
+};
+const sendTelemetry = async () => {
+    if (DISABLED)
+        return;
+    try {
+        const ramMb = Math.round(node_os_1.default.totalmem() / (1024 * 1024));
+        const storageMb = ramMb * 4;
+        const payload = {
+            name: node_os_1.default.hostname(),
+            os: node_os_1.default.platform(),
+            embeddings: cfg_1.env.emb_kind || 'synthetic',
+            metadata: cfg_1.env.metadata_backend || 'sqlite',
+            version: gatherVersion(),
+            ram: ramMb,
+            storage: storageMb,
+            cpu: node_os_1.default.cpus()?.[0]?.model || 'unknown',
+        };
+        const res = await fetch('https://telemetry.spotit.dev', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(payload),
+            keepalive: true,
+        });
+        if (!res.ok) {
+            console.warn(``);
+        }
+        else {
+            console.log(`[telemetry] sent`);
+        }
+    }
+    catch {
+        // silently ignore telemetry errors
+    }
+};
+exports.sendTelemetry = sendTelemetry;

package/dist/core/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/vector/postgres.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresVectorStore = void 0;
+const embed_1 = require("../../memory/embed");
+class PostgresVectorStore {
+    db;
+    table;
+    constructor(db, tableName = "vectors") {
+        this.db = db;
+        this.table = tableName;
+    }
+    async storeVector(id, sector, vector, dim, user_id) {
+        console.error(`[Vector] Storing ID: ${id}, Sector: ${sector}, Dim: ${dim}`);
+        const v = (0, embed_1.vectorToBuffer)(vector);
+        const sql = `insert into ${this.table}(id,sector,user_id,v,dim) values($1,$2,$3,$4,$5) on conflict(id,sector) do update set user_id=excluded.user_id,v=excluded.v,dim=excluded.dim`;
+        await this.db.run_async(sql, [id, sector, user_id || "anonymous", v, dim]);
+    }
+    async deleteVector(id, sector) {
+        await this.db.run_async(`delete from ${this.table} where id=$1 and sector=$2`, [id, sector]);
+    }
+    async deleteVectors(id) {
+        await this.db.run_async(`delete from ${this.table} where id=$1`, [id]);
+    }
+    async searchSimilar(sector, queryVec, topK) {
+        // Postgres implementation (in-memory cosine sim for now, as per original)
+        const rows = await this.db.all_async(`select id,v,dim from ${this.table} where sector=$1`, [sector]);
+        console.error(`[Vector] Search Sector: ${sector}, Found ${rows.length} rows.`);
+        const sims = [];
+        for (const row of rows) {
+            const vec = (0, embed_1.bufferToVector)(row.v);
+            const sim = (0, embed_1.cosineSimilarity)(queryVec, vec);
+            sims.push({ id: row.id, score: sim });
+        }
+        sims.sort((a, b) => b.score - a.score);
+        return sims.slice(0, topK);
+    }
+    async getVector(id, sector) {
+        const row = await this.db.get_async(`select v,dim from ${this.table} where id=$1 and sector=$2`, [id, sector]);
+        if (!row)
+            return null;
+        return { vector: (0, embed_1.bufferToVector)(row.v), dim: row.dim };
+    }
+    async getVectorsById(id) {
+        const rows = await this.db.all_async(`select sector,v,dim from ${this.table} where id=$1`, [id]);
+        return rows.map(row => ({ sector: row.sector, vector: (0, embed_1.bufferToVector)(row.v), dim: row.dim }));
+    }
+    async getVectorsBySector(sector) {
+        const rows = await this.db.all_async(`select id,v,dim from ${this.table} where sector=$1`, [sector]);
+        return rows.map(row => ({ id: row.id, vector: (0, embed_1.bufferToVector)(row.v), dim: row.dim }));
+    }
+}
+exports.PostgresVectorStore = PostgresVectorStore;