ahok-skill 1.3.1

package/src/server/routes/ide.ts

@@ -0,0 +1,283 @@
+import { q } from "../../core/db";
+import { add_hsg_memory, hsg_query } from "../../memory/hsg";
+import { update_user_summary } from "../../memory/user_summary";
+import { j, p } from "../../utils";
+import * as crypto from "crypto";
+export function ide(app: any) {
+    app.post("/api/ide/events", async (req: any, res: any) => {
+        try {
+            const event_type = req.body.event_type;
+            const file_path = req.body.file_path || "unknown";
+            const content = req.body.content || "";
+            const session_id = req.body.session_id || "default";
+            const metadata = req.body.metadata || {};
+            const user_id = req.body.user_id || "anonymous";
+
+            if (!event_type)
+                return res.status(400).json({ err: "event_type_required" });
+
+            let memory_content = "";
+            if (event_type === "open") {
+                memory_content = `Opened file: ${file_path}`;
+            } else if (event_type === "save") {
+                if (content) {
+                    memory_content = `Saved file: ${file_path}\n\n${content}`;
+                } else {
+                    memory_content = `Saved file: ${file_path}`;
+                }
+            } else if (event_type === "close") {
+                memory_content = `Closed file: ${file_path}`;
+            } else {
+                memory_content = `[${event_type}] ${file_path}\n${content}`.trim();
+            }
+
+            const full_metadata = {
+                ...metadata,
+                ide_event_type: event_type,
+                ide_file_path: file_path,
+                ide_session_id: session_id,
+                ide_timestamp: Date.now(),
+                ide_mode: true,
+            };
+
+            const result = await add_hsg_memory(
+                memory_content,
+                undefined,
+                full_metadata,
+                user_id,
+            );
+
+            // Update user summary asynchronously
+            if (user_id && user_id !== "anonymous") {
+                update_user_summary(user_id).catch(err =>
+                    console.error("[IDE] Failed to update user summary:", err)
+                );
+            }
+
+            res.json({
+                success: true,
+                memory_id: result.id,
+                primary_sector: result.primary_sector,
+                sectors: result.sectors,
+            });
+        } catch (err) {
+            console.error("[IDE] Error storing IDE event:", err);
+            res.status(500).json({ err: "internal" });
+        }
+    });
+
+    app.post("/api/ide/context", async (req: any, res: any) => {
+        try {
+            const query = req.body.query;
+            const k = req.body.k || req.body.limit || 5;
+            const session_id = req.body.session_id;
+            const file_path = req.body.file_path;
+
+            if (!query) return res.status(400).json({ err: "query_required" });
+
+            const results = await hsg_query(query, k);
+
+            let filtered = results;
+
+            if (session_id) {
+                filtered = [];
+                for (const r of results) {
+                    const mem = await q.get_mem.get(r.id);
+                    if (mem) {
+                        const meta = p(mem.meta);
+                        if (meta && meta.ide_session_id === session_id) {
+                            filtered.push(r);
+                        }
+                    }
+                }
+            }
+
+            if (file_path) {
+                filtered = filtered.filter((r: any) =>
+                    r.content.includes(file_path),
+                );
+            }
+
+            const formatted = filtered.map((r: any) => ({
+                memory_id: r.id,
+                content: r.content,
+                primary_sector: r.primary_sector,
+                sectors: r.sectors,
+                score: r.score,
+                salience: r.salience,
+                last_seen_at: r.last_seen_at,
+                path: r.path,
+            }));
+
+            res.json({
+                success: true,
+                memories: formatted,
+                total: formatted.length,
+                query: query,
+            });
+        } catch (err) {
+            console.error("[IDE] Error retrieving IDE context:", err);
+            res.status(500).json({ err: "internal" });
+        }
+    });
+
+    app.post("/api/ide/session/start", async (req: any, res: any) => {
+        try {
+            const user_id = req.body.user_id || "anonymous";
+            const project_name = req.body.project_name || "unknown";
+            const ide_name = req.body.ide_name || "unknown";
+
+            const session_id = `session_${Date.now()}_${crypto.randomBytes(7).toString("hex")}`;
+            const now_ts = Date.now();
+
+            const content = `Session started: ${user_id} in ${project_name} using ${ide_name}`;
+
+            const metadata = {
+                ide_session_id: session_id,
+                ide_user_id: user_id,
+                ide_project_name: project_name,
+                ide_name: ide_name,
+                session_start_time: now_ts,
+                session_type: "ide_session",
+                ide_mode: true,
+            };
+
+            const result = await add_hsg_memory(content, undefined, metadata, user_id);
+
+            if (user_id && user_id !== "anonymous") {
+                update_user_summary(user_id).catch(err =>
+                    console.error("[IDE] Failed to update summary on session start:", err)
+                );
+            }
+
+            res.json({
+                success: true,
+                session_id: session_id,
+                memory_id: result.id,
+                started_at: now_ts,
+                user_id: user_id,
+                project_name: project_name,
+                ide_name: ide_name,
+            });
+        } catch (err) {
+            console.error("[IDE] Error starting IDE session:", err);
+            res.status(500).json({ err: "internal" });
+        }
+    });
+
+    app.post("/api/ide/session/end", async (req: any, res: any) => {
+        try {
+            const session_id = req.body.session_id;
+            const user_id = req.body.user_id || "anonymous";
+
+            if (!session_id)
+                return res.status(400).json({ err: "session_id_required" });
+
+            const now_ts = Date.now();
+
+            const all_memories = await q.all_mem.all(10000, 0);
+            const session_memories = all_memories.filter((m: any) => {
+                try {
+                    const meta = p(m.meta);
+                    return meta && meta.ide_session_id === session_id;
+                } catch {
+                    return false;
+                }
+            });
+
+            const total_events = session_memories.length;
+            const sectors: Record<string, number> = {};
+            const files = new Set<string>();
+
+            for (const m of session_memories) {
+                sectors[m.primary_sector] =
+                    (sectors[m.primary_sector] || 0) + 1;
+                try {
+                    const meta = p(m.meta);
+                    if (
+                        meta &&
+                        meta.ide_file_path &&
+                        meta.ide_file_path !== "unknown"
+                    ) {
+                        files.add(meta.ide_file_path);
+                    }
+                } catch { }
+            }
+
+            const summary = `Session ${session_id} ended. Events: ${total_events}, Files: ${files.size}, Sectors: ${j(sectors)}`;
+
+            const metadata = {
+                ide_session_id: session_id,
+                session_end_time: now_ts,
+                session_type: "ide_session_end",
+                total_events: total_events,
+                sectors_distribution: sectors,
+                files_touched: Array.from(files),
+                ide_mode: true,
+            };
+
+            const result = await add_hsg_memory(summary, undefined, metadata, user_id);
+
+            if (user_id && user_id !== "anonymous") {
+                update_user_summary(user_id).catch(err =>
+                    console.error("[IDE] Failed to update summary on session end:", err)
+                );
+            }
+
+            res.json({
+                success: true,
+                session_id: session_id,
+                ended_at: now_ts,
+                summary_memory_id: result.id,
+                statistics: {
+                    total_events: total_events,
+                    sectors: sectors,
+                    unique_files: files.size,
+                    files: Array.from(files),
+                },
+            });
+        } catch (err) {
+            console.error("[IDE] Error ending IDE session:", err);
+            res.status(500).json({ err: "internal" });
+        }
+    });
+
+    app.get("/api/ide/patterns/:session_id", async (req: any, res: any) => {
+        try {
+            const session_id = req.params.session_id;
+
+            if (!session_id)
+                return res.status(400).json({ err: "session_id_required" });
+
+            const all_memories = await q.all_mem.all(10000, 0);
+
+            const procedural = all_memories.filter((m: any) => {
+                if (m.primary_sector !== "procedural") return false;
+                try {
+                    const meta = p(m.meta);
+                    return meta && meta.ide_session_id === session_id;
+                } catch {
+                    return false;
+                }
+            });
+
+            const patterns = procedural.map((m: any) => ({
+                pattern_id: m.id,
+                description: m.content,
+                salience: m.salience,
+                detected_at: m.created_at,
+                last_reinforced: m.last_seen_at,
+            }));
+
+            res.json({
+                success: true,
+                session_id: session_id,
+                pattern_count: patterns.length,
+                patterns: patterns,
+            });
+        } catch (err) {
+            console.error("[IDE] Error detecting patterns:", err);
+            res.status(500).json({ err: "internal" });
+        }
+    });
+}

package/src/server/routes/index.ts

@@ -0,0 +1,32 @@
+import { sys } from "./system";
+import { mem } from "./memory";
+import { dynroutes } from "./dynamics";
+import { ide } from "./ide";
+import { compression } from "./compression";
+import { lg } from "./langgraph";
+import { usr } from "./users";
+import { temporal } from "./temporal";
+import { dash } from "./dashboard";
+import { vercel } from "./vercel";
+import { src } from "./sources";
+import { auth } from "./auth";
+import { docs_route } from "./docs";
+import { keys } from "./keys";
+
+export function routes(app: any) {
+    sys(app);
+    mem(app);
+    dynroutes(app);
+    ide(app);
+    compression(app);
+    lg(app);
+    usr(app);
+    temporal(app);
+    dash(app);
+    vercel(app);
+    src(app);
+    auth(app);
+    docs_route(app);
+    keys(app);
+}
+

package/src/server/routes/keys.ts

@@ -0,0 +1,131 @@
+import { q } from "../../core/db";
+import crypto from "crypto";
+import { verifyToken } from "@clerk/backend";
+
+async function verifyClerkToken(req: any): Promise<any | null> {
+    const token = req.headers.authorization?.replace("Bearer ", "");
+    if (!token) return null;
+    try {
+        const session = await verifyToken(token, { secretKey: process.env.CLERK_SECRET_KEY });
+        const user = await q.get_user_by_clerk_id.get(session.sub);
+        return user;
+    } catch {
+        return null;
+    }
+}
+
+export function keys(app: any) {
+    app.get("/keys", async (req: any, res: any) => {
+        // 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 q.get_memory_keys_by_user.all(user.user_id);
+            res.json({ keys });
+        } catch (e: any) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+
+    app.post("/keys", async (req: any, res: any) => {
+        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.randomUUID();
+            const secret_key = `opm_sk_${crypto.randomBytes(24).toString("hex")}`;
+            await q.ins_memory_key.run(id, user.user_id, label, secret_key, Date.now());
+            res.json({ id, label, secret_key });
+        } catch (e: any) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+
+    app.patch("/keys/:id", async (req: any, res: any) => {
+        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 q.upd_memory_key_label.run(label, updated_at, id, user.user_id);
+            res.json({ id, label, updated_at });
+        } catch (e: any) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+
+    app.delete("/keys/:id", async (req: any, res: any) => {
+        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 q.del_memory_key.run(id, user.user_id);
+            res.json({ ok: true });
+        } catch (e: any) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+
+    // GET /keys/stats - Get workspace statistics with memory counts
+    app.get("/keys/stats", async (req: any, res: any) => {
+        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 q.get_memory_keys_by_user.all(user.user_id);
+            
+            // Get memory counts grouped by memory_key_id
+            const memoryCounts = await 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<string, number>();
+            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: any) => ({
+                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: any) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+}

package/src/server/routes/langgraph.ts

@@ -0,0 +1,71 @@
+import {
+    store_node_mem,
+    retrieve_node_mems,
+    get_graph_ctx,
+    create_refl,
+    get_lg_cfg,
+} from "../../ai/graph";
+import type {
+    lgm_store_req,
+    lgm_retrieve_req,
+    lgm_context_req,
+    lgm_reflection_req,
+} from "../../core/types";
+
+export function lg(app: any) {
+    app.get("/lgm/config", (_req: any, res: any) => {
+        res.json(get_lg_cfg());
+    });
+
+    app.post("/lgm/store", async (req: any, res: any) => {
+        try {
+            const r = await store_node_mem(req.body as lgm_store_req);
+            res.json(r);
+        } catch (e) {
+            console.error("[LGM] store error:", e);
+            res.status(400).json({
+                err: "lgm_store_failed",
+                message: (e as Error).message,
+            });
+        }
+    });
+
+    app.post("/lgm/retrieve", async (req: any, res: any) => {
+        try {
+            const r = await retrieve_node_mems(req.body as lgm_retrieve_req);
+            res.json(r);
+        } catch (e) {
+            console.error("[LGM] retrieve error:", e);
+            res.status(400).json({
+                err: "lgm_retrieve_failed",
+                message: (e as Error).message,
+            });
+        }
+    });
+
+    app.post("/lgm/context", async (req: any, res: any) => {
+        try {
+            const r = await get_graph_ctx(req.body as lgm_context_req);
+            res.json(r);
+        } catch (e) {
+            console.error("[LGM] context error:", e);
+            res.status(400).json({
+                err: "lgm_context_failed",
+                message: (e as Error).message,
+            });
+        }
+    });
+
+    app.post("/lgm/reflection", async (req: any, res: any) => {
+        try {
+            const r = await create_refl(req.body as lgm_reflection_req);
+            res.json(r);
+        } catch (e) {
+            console.error("[LGM] reflection error:", e);
+            res.status(400).json({
+                err: "lgm_reflection_failed",
+                message: (e as Error).message,
+            });
+        }
+    });
+}