ahok-skill 1.3.1

package/dist/server/routes/keys.js

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keys = keys;
+const db_1 = require("../../core/db");
+const crypto_1 = __importDefault(require("crypto"));
+const backend_1 = require("@clerk/backend");
+async function verifyClerkToken(req) {
+    const token = req.headers.authorization?.replace("Bearer ", "");
+    if (!token)
+        return null;
+    try {
+        const session = await (0, backend_1.verifyToken)(token, { secretKey: process.env.CLERK_SECRET_KEY });
+        const user = await db_1.q.get_user_by_clerk_id.get(session.sub);
+        return user;
+    }
+    catch {
+        return null;
+    }
+}
+function keys(app) {
+    app.get("/keys", async (req, res) => {
+        // Try API key auth first, then Clerk JWT
+        let user = req.user;
+        if (!user?.user_id) {
+            user = await verifyClerkToken(req);
+        }
+        if (!user?.user_id)
+            return res.status(401).json({ error: "Unauthorized" });
+        try {
+            const keys = await db_1.q.get_memory_keys_by_user.all(user.user_id);
+            res.json({ keys });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.post("/keys", async (req, res) => {
+        let user = req.user;
+        if (!user?.user_id) {
+            user = await verifyClerkToken(req);
+        }
+        if (!user?.user_id)
+            return res.status(401).json({ error: "Unauthorized" });
+        const { label } = req.body;
+        if (!label)
+            return res.status(400).json({ error: "Label is required" });
+        try {
+            const id = crypto_1.default.randomUUID();
+            const secret_key = `opm_sk_${crypto_1.default.randomBytes(24).toString("hex")}`;
+            await db_1.q.ins_memory_key.run(id, user.user_id, label, secret_key, Date.now());
+            res.json({ id, label, secret_key });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.patch("/keys/:id", async (req, res) => {
+        let user = req.user;
+        if (!user?.user_id) {
+            user = await verifyClerkToken(req);
+        }
+        if (!user?.user_id)
+            return res.status(401).json({ error: "Unauthorized" });
+        const { id } = req.params;
+        const { label } = req.body;
+        // Validate label is non-empty (reject empty or whitespace-only labels)
+        if (!label || typeof label !== 'string' || label.trim().length === 0) {
+            return res.status(400).json({ error: "Label is required" });
+        }
+        try {
+            const updated_at = Date.now();
+            await db_1.q.upd_memory_key_label.run(label, updated_at, id, user.user_id);
+            res.json({ id, label, updated_at });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.delete("/keys/:id", async (req, res) => {
+        let user = req.user;
+        if (!user?.user_id) {
+            user = await verifyClerkToken(req);
+        }
+        if (!user?.user_id)
+            return res.status(401).json({ error: "Unauthorized" });
+        const { id } = req.params;
+        try {
+            await db_1.q.del_memory_key.run(id, user.user_id);
+            res.json({ ok: true });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    // GET /keys/stats - Get workspace statistics with memory counts
+    app.get("/keys/stats", async (req, res) => {
+        let user = req.user;
+        if (!user?.user_id) {
+            user = await verifyClerkToken(req);
+        }
+        if (!user?.user_id)
+            return res.status(401).json({ error: "Unauthorized" });
+        try {
+            // Get all workspaces for the user (already sorted by created_at desc)
+            const workspaces = await db_1.q.get_memory_keys_by_user.all(user.user_id);
+            // Get memory counts grouped by memory_key_id
+            const memoryCounts = await db_1.q.get_memory_counts_by_key.all(user.user_id);
+            // Create a map of memory_key_id -> count for efficient lookup
+            const countMap = new Map();
+            for (const item of memoryCounts) {
+                if (item.memory_key_id) {
+                    countMap.set(item.memory_key_id, item.count);
+                }
+            }
+            // Merge workspaces with memory counts (default to 0 if no memories)
+            const workspacesWithStats = workspaces.map((workspace) => ({
+                id: workspace.id,
+                label: workspace.label,
+                secret_key: workspace.secret_key,
+                created_at: workspace.created_at,
+                memory_count: countMap.get(workspace.id) || 0
+            }));
+            res.json({ workspaces: workspacesWithStats });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+}

package/dist/server/routes/langgraph.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lg = lg;
+const graph_1 = require("../../ai/graph");
+function lg(app) {
+    app.get("/lgm/config", (_req, res) => {
+        res.json((0, graph_1.get_lg_cfg)());
+    });
+    app.post("/lgm/store", async (req, res) => {
+        try {
+            const r = await (0, graph_1.store_node_mem)(req.body);
+            res.json(r);
+        }
+        catch (e) {
+            console.error("[LGM] store error:", e);
+            res.status(400).json({
+                err: "lgm_store_failed",
+                message: e.message,
+            });
+        }
+    });
+    app.post("/lgm/retrieve", async (req, res) => {
+        try {
+            const r = await (0, graph_1.retrieve_node_mems)(req.body);
+            res.json(r);
+        }
+        catch (e) {
+            console.error("[LGM] retrieve error:", e);
+            res.status(400).json({
+                err: "lgm_retrieve_failed",
+                message: e.message,
+            });
+        }
+    });
+    app.post("/lgm/context", async (req, res) => {
+        try {
+            const r = await (0, graph_1.get_graph_ctx)(req.body);
+            res.json(r);
+        }
+        catch (e) {
+            console.error("[LGM] context error:", e);
+            res.status(400).json({
+                err: "lgm_context_failed",
+                message: e.message,
+            });
+        }
+    });
+    app.post("/lgm/reflection", async (req, res) => {
+        try {
+            const r = await (0, graph_1.create_refl)(req.body);
+            res.json(r);
+        }
+        catch (e) {
+            console.error("[LGM] reflection error:", e);
+            res.status(400).json({
+                err: "lgm_reflection_failed",
+                message: e.message,
+            });
+        }
+    });
+}

package/dist/server/routes/memory.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mem = mem;
+const db_1 = require("../../core/db");
+const utils_1 = require("../../utils");
+const hsg_1 = require("../../memory/hsg");
+const ingest_1 = require("../../ops/ingest");
+const user_summary_1 = require("../../memory/user_summary");
+function mem(app) {
+    app.post("/memory/add", async (req, res) => {
+        const b = req.body;
+        if (!b?.content)
+            return res.status(400).json({ err: "content" });
+        try {
+            const m = await (0, hsg_1.add_hsg_memory)(b.content, (0, utils_1.j)(b.tags || []), b.metadata, b.user_id, req.key_id);
+            res.json(m);
+            if (b.user_id) {
+                (0, user_summary_1.update_user_summary)(b.user_id).catch((e) => console.error("[mem] user summary update failed:", e));
+            }
+        }
+        catch (e) {
+            res.status(500).json({ err: e.message });
+        }
+    });
+    app.post("/memory/ingest", async (req, res) => {
+        const b = req.body;
+        if (!b?.content_type || !b?.data)
+            return res.status(400).json({ err: "missing" });
+        try {
+            const r = await (0, ingest_1.ingestDocument)(b.content_type, b.data, b.metadata, b.config, b.user_id);
+            res.json(r);
+        }
+        catch (e) {
+            res.status(500).json({ err: "ingest_fail", msg: e.message });
+        }
+    });
+    app.post("/memory/ingest/url", async (req, res) => {
+        const b = req.body;
+        if (!b?.url)
+            return res.status(400).json({ err: "no_url" });
+        try {
+            const r = await (0, ingest_1.ingestURL)(b.url, b.metadata, b.config, b.user_id);
+            res.json(r);
+        }
+        catch (e) {
+            res.status(500).json({ err: "url_fail", msg: e.message });
+        }
+    });
+    app.post("/memory/query", async (req, res) => {
+        const b = req.body;
+        const k = b.k || 8;
+        try {
+            const f = {
+                sectors: b.filters?.sector ? [b.filters.sector] : undefined,
+                minSalience: b.filters?.min_score,
+                user_id: b.filters?.user_id || b.user_id,
+                startTime: b.filters?.startTime,
+                endTime: b.filters?.endTime,
+            };
+            const m = await (0, hsg_1.hsg_query)(b.query, k, f);
+            res.json({
+                query: b.query,
+                matches: m.map((x) => ({
+                    id: x.id,
+                    content: x.content,
+                    score: x.score,
+                    sectors: x.sectors,
+                    primary_sector: x.primary_sector,
+                    path: x.path,
+                    salience: x.salience,
+                    last_seen_at: x.last_seen_at,
+                })),
+            });
+        }
+        catch (e) {
+            res.json({ query: b.query, matches: [] });
+        }
+    });
+    app.post("/memory/reinforce", async (req, res) => {
+        const b = req.body;
+        if (!b?.id)
+            return res.status(400).json({ err: "id" });
+        try {
+            await (0, hsg_1.reinforce_memory)(b.id, b.boost);
+            res.json({ ok: true });
+        }
+        catch (e) {
+            res.status(404).json({ err: "nf" });
+        }
+    });
+    app.patch("/memory/:id", async (req, res) => {
+        const id = req.params.id;
+        const b = req.body;
+        if (!id)
+            return res.status(400).json({ err: "id" });
+        try {
+            // Check if memory exists and user has permission
+            const m = await db_1.q.get_mem.get(id);
+            if (!m)
+                return res.status(404).json({ err: "nf" });
+            // Check user ownership if user_id is provided
+            if (b.user_id && m.user_id !== b.user_id) {
+                return res.status(403).json({ err: "forbidden" });
+            }
+            const r = await (0, hsg_1.update_memory)(id, b.content, b.tags, b.metadata);
+            res.json(r);
+        }
+        catch (e) {
+            if (e.message.includes("not found")) {
+                res.status(404).json({ err: "nf" });
+            }
+            else {
+                res.status(500).json({ err: "internal" });
+            }
+        }
+    });
+    app.get("/memory/all", async (req, res) => {
+        try {
+            const u = req.query.u ? parseInt(req.query.u) : 0;
+            const l = req.query.l ? parseInt(req.query.l) : 100;
+            const s = req.query.sector;
+            const user_id = req.query.user_id;
+            let r;
+            if (user_id) {
+                // Filter by user_id
+                r = await db_1.q.all_mem_by_user.all(user_id, l, u);
+            }
+            else if (s) {
+                // Filter by sector
+                r = await db_1.q.all_mem_by_sector.all(s, l, u);
+            }
+            else {
+                // No filter
+                r = await db_1.q.all_mem.all(l, u);
+            }
+            if (req.query.key_id) {
+                r = r.filter((x) => x.memory_key_id === req.query.key_id);
+            }
+            const i = r.map((x) => ({
+                id: x.id,
+                content: x.content,
+                tags: (0, utils_1.p)(x.tags),
+                metadata: (0, utils_1.p)(x.meta),
+                created_at: x.created_at,
+                updated_at: x.updated_at,
+                last_seen_at: x.last_seen_at,
+                salience: x.salience,
+                decay_lambda: x.decay_lambda,
+                primary_sector: x.primary_sector,
+                version: x.version,
+                user_id: x.user_id,
+                memory_key_id: x.memory_key_id,
+            }));
+            res.json({ items: i });
+        }
+        catch (e) {
+            res.status(500).json({ err: "internal" });
+        }
+    });
+    app.get("/memory/:id", async (req, res) => {
+        try {
+            const id = req.params.id;
+            const user_id = req.query.user_id;
+            const m = await db_1.q.get_mem.get(id);
+            if (!m)
+                return res.status(404).json({ err: "nf" });
+            // Check user ownership if user_id is provided
+            if (user_id && m.user_id !== user_id) {
+                return res.status(403).json({ err: "forbidden" });
+            }
+            const v = await db_1.vector_store.getVectorsById(id);
+            const sec = v.map((x) => x.sector);
+            res.json({
+                id: m.id,
+                content: m.content,
+                primary_sector: m.primary_sector,
+                sectors: sec,
+                tags: (0, utils_1.p)(m.tags),
+                metadata: (0, utils_1.p)(m.meta),
+                created_at: m.created_at,
+                updated_at: m.updated_at,
+                last_seen_at: m.last_seen_at,
+                salience: m.salience,
+                decay_lambda: m.decay_lambda,
+                version: m.version,
+                user_id: m.user_id,
+            });
+        }
+        catch (e) {
+            res.status(500).json({ err: "internal" });
+        }
+    });
+    app.delete("/memory/:id", async (req, res) => {
+        try {
+            const id = req.params.id;
+            const user_id = req.query.user_id || req.body?.user_id;
+            const m = await db_1.q.get_mem.get(id);
+            if (!m)
+                return res.status(404).json({ err: "nf" });
+            // Check user ownership if user_id is provided
+            if (user_id && m.user_id !== user_id) {
+                return res.status(403).json({ err: "forbidden" });
+            }
+            await db_1.q.del_mem.run(id);
+            await db_1.vector_store.deleteVectors(id);
+            await db_1.q.del_waypoints.run(id, id);
+            res.json({ ok: true });
+        }
+        catch (e) {
+            res.status(500).json({ err: "internal" });
+        }
+    });
+}

package/dist/server/routes/sources.js

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * sources webhook routes - ingest data from external sources via HTTP
+ *
+ * POST /sources/:source/ingest
+ *   body: { creds: {...}, filters: {...}, user_id?: string }
+ *
+ * POST /sources/webhook/:source
+ *   generic webhook endpoint for source-specific payloads
+ */
+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.src = src;
+const sources = __importStar(require("../../sources"));
+function src(app) {
+    // list available sources
+    app.get("/sources", async (req, res) => {
+        res.json({
+            sources: ["github", "notion", "google_drive", "google_sheets", "google_slides", "onedrive", "web_crawler"],
+            usage: {
+                ingest: "POST /sources/:source/ingest { creds: {}, filters: {}, user_id? }",
+                webhook: "POST /sources/webhook/:source (source-specific payload)"
+            }
+        });
+    });
+    // ingest from a source
+    app.post("/sources/:source/ingest", async (req, res) => {
+        const { source } = req.params;
+        const { creds = {}, filters = {}, user_id } = req.body || {};
+        const source_map = {
+            github: sources.github_source,
+            notion: sources.notion_source,
+            google_drive: sources.google_drive_source,
+            google_sheets: sources.google_sheets_source,
+            google_slides: sources.google_slides_source,
+            onedrive: sources.onedrive_source,
+            web_crawler: sources.web_crawler_source,
+        };
+        if (!source_map[source]) {
+            return res.status(400).json({ error: `unknown source: ${source}`, available: Object.keys(source_map) });
+        }
+        try {
+            const src = new source_map[source](user_id);
+            await src.connect(creds);
+            const ids = await src.ingest_all(filters);
+            res.json({ ok: true, ingested: ids.length, memory_ids: ids });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    // webhook endpoint for github events
+    app.post("/sources/webhook/github", async (req, res) => {
+        const event_type = req.headers["x-github-event"];
+        const payload = req.body;
+        if (!payload) {
+            return res.status(400).json({ error: "no payload" });
+        }
+        try {
+            const { ingestDocument } = await Promise.resolve().then(() => __importStar(require("../../ops/ingest")));
+            // handle different github events
+            let content = "";
+            let meta = { source: "github_webhook", event: event_type };
+            if (event_type === "push") {
+                const commits = payload.commits || [];
+                content = commits.map((c) => `${c.message}\n${c.url}`).join("\n\n");
+                meta.repo = payload.repository?.full_name;
+                meta.ref = payload.ref;
+            }
+            else if (event_type === "issues") {
+                content = `[${payload.action}] ${payload.issue?.title}\n${payload.issue?.body || ""}`;
+                meta.repo = payload.repository?.full_name;
+                meta.issue_number = payload.issue?.number;
+            }
+            else if (event_type === "pull_request") {
+                content = `[${payload.action}] PR: ${payload.pull_request?.title}\n${payload.pull_request?.body || ""}`;
+                meta.repo = payload.repository?.full_name;
+                meta.pr_number = payload.pull_request?.number;
+            }
+            else {
+                content = JSON.stringify(payload, null, 2);
+            }
+            if (content) {
+                const result = await ingestDocument("text", content, meta);
+                res.json({ ok: true, memory_id: result.root_memory_id, event: event_type });
+            }
+            else {
+                res.json({ ok: true, skipped: true, reason: "no content" });
+            }
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    // generic webhook for notion
+    app.post("/sources/webhook/notion", async (req, res) => {
+        const payload = req.body;
+        try {
+            const { ingestDocument } = await Promise.resolve().then(() => __importStar(require("../../ops/ingest")));
+            const content = JSON.stringify(payload, null, 2);
+            const result = await ingestDocument("text", content, { source: "notion_webhook" });
+            res.json({ ok: true, memory_id: result.root_memory_id });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+}

package/dist/server/routes/system.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sys = sys;
+const db_1 = require("../../core/db");
+const hsg_1 = require("../../memory/hsg");
+const embed_1 = require("../../memory/embed");
+const cfg_1 = require("../../core/cfg");
+const TIER_BENEFITS = {
+    hybrid: {
+        recall: 98,
+        qps: "700-800",
+        ram: "0.5gb/10k",
+        use: "For high accuracy",
+    },
+    fast: {
+        recall: 70,
+        qps: "700-850",
+        ram: "0.6GB/10k",
+        use: "Local apps, extensions",
+    },
+    smart: {
+        recall: 85,
+        qps: "500-600",
+        ram: "0.9GB/10k",
+        use: "Production servers",
+    },
+    deep: {
+        recall: 94,
+        qps: "350-400",
+        ram: "1.6GB/10k",
+        use: "Cloud, high-accuracy",
+    },
+};
+function sys(app) {
+    app.get("/health", async (incoming_http_request, outgoing_http_response) => {
+        outgoing_http_response.json({
+            ok: true,
+            version: "2.0-hsg-tiered",
+            embedding: (0, embed_1.getEmbeddingInfo)(),
+            tier: cfg_1.tier,
+            dim: cfg_1.env.vec_dim,
+            cache: cfg_1.env.cache_segments,
+            expected: TIER_BENEFITS[cfg_1.tier],
+        });
+    });
+    app.get("/sectors", async (incoming_http_request, outgoing_http_response) => {
+        try {
+            const database_sector_statistics_rows = await (0, db_1.all_async)(`
+                select primary_sector as sector, count(*) as count, avg(salience) as avg_salience 
+                from memories 
+                group by primary_sector
+            `);
+            outgoing_http_response.json({
+                sectors: Object.keys(hsg_1.sector_configs),
+                configs: hsg_1.sector_configs,
+                stats: database_sector_statistics_rows,
+            });
+        }
+        catch (unexpected_error_fetching_sectors) {
+            outgoing_http_response.status(500).json({ err: "internal" });
+        }
+    });
+}