ahok-skill 1.3.1

package/src/server/routes/temporal.ts

@@ -0,0 +1,335 @@
+import { insert_fact, update_fact, invalidate_fact, delete_fact, apply_confidence_decay, get_active_facts_count, get_total_facts_count } from '../../temporal_graph/store'
+import { query_facts_at_time, get_current_fact, query_facts_in_range, search_facts, get_facts_by_subject, get_related_facts } from '../../temporal_graph/query'
+import { get_subject_timeline, get_predicate_timeline, get_changes_in_window, compare_time_points, get_change_frequency, get_volatile_facts } from '../../temporal_graph/timeline'
+
+export const create_temporal_fact = async (req: any, res: any) => {
+    try {
+        const { subject, predicate, object, valid_from, confidence, metadata } = req.body
+
+        if (!subject || !predicate || !object) {
+            return res.status(400).json({ error: 'Missing required fields: subject, predicate, object' })
+        }
+
+        const valid_from_date = valid_from ? new Date(valid_from) : new Date()
+        const conf = confidence !== undefined ? Math.max(0, Math.min(1, confidence)) : 1.0
+
+        const id = await insert_fact(subject, predicate, object, valid_from_date, conf, metadata)
+
+        res.json({
+            id,
+            subject,
+            predicate,
+            object,
+            valid_from: valid_from_date.toISOString(),
+            confidence: conf,
+            message: 'Fact created successfully'
+        })
+    } catch (error) {
+        console.error('[TEMPORAL API] Error creating fact:', error)
+        res.status(500).json({ error: 'Failed to create fact' })
+    }
+}
+
+
+export const get_temporal_fact = async (req: any, res: any) => {
+    try {
+        const { subject, predicate, object, at, min_confidence } = req.query
+
+        if (!subject && !predicate && !object) {
+            return res.status(400).json({ error: 'At least one of subject, predicate, or object is required' })
+        }
+
+        const at_date = at ? new Date(at) : new Date()
+        const min_conf = min_confidence ? parseFloat(min_confidence) : 0.1
+
+        const facts = await query_facts_at_time(subject, predicate, object, at_date, min_conf)
+
+        res.json({
+            facts,
+            query: { subject, predicate, object, at: at_date.toISOString(), min_confidence: min_conf },
+            count: facts.length
+        })
+    } catch (error) {
+        console.error('[TEMPORAL API] Error querying facts:', error)
+        res.status(500).json({ error: 'Failed to query facts' })
+    }
+}
+
+
+export const get_current_temporal_fact = async (req: any, res: any) => {
+    try {
+        const { subject, predicate } = req.query
+
+        if (!subject || !predicate) {
+            return res.status(400).json({ error: 'Both subject and predicate are required' })
+        }
+
+        const fact = await get_current_fact(subject, predicate)
+
+        if (!fact) {
+            return res.status(404).json({ error: 'No current fact found', subject, predicate })
+        }
+
+        res.json({ fact })
+    } catch (error) {
+        console.error('[TEMPORAL API] Error getting current fact:', error)
+        res.status(500).json({ error: 'Failed to get current fact' })
+    }
+}
+
+
+export const get_entity_timeline = async (req: any, res: any) => {
+    try {
+        const { subject, predicate } = req.query
+
+        if (!subject) {
+            return res.status(400).json({ error: 'Subject parameter is required' })
+        }
+
+        const timeline = await get_subject_timeline(subject, predicate)
+
+        res.json({
+            subject,
+            predicate,
+            timeline,
+            count: timeline.length
+        })
+    } catch (error) {
+        console.error('[TEMPORAL API] Error getting timeline:', error)
+        res.status(500).json({ error: 'Failed to get timeline' })
+    }
+}
+
+
+export const get_predicate_history = async (req: any, res: any) => {
+    try {
+        const { predicate, from, to } = req.query
+
+        if (!predicate) {
+            return res.status(400).json({ error: 'Predicate parameter is required' })
+        }
+
+        const from_date = from ? new Date(from) : undefined
+        const to_date = to ? new Date(to) : undefined
+
+        const timeline = await get_predicate_timeline(predicate, from_date, to_date)
+
+        res.json({
+            predicate,
+            from: from_date?.toISOString(),
+            to: to_date?.toISOString(),
+            timeline,
+            count: timeline.length
+        })
+    } catch (error) {
+        console.error('[TEMPORAL API] Error getting predicate timeline:', error)
+        res.status(500).json({ error: 'Failed to get predicate timeline' })
+    }
+}
+
+
+export const update_temporal_fact = async (req: any, res: any) => {
+    try {
+        const { id } = req.params
+        const { confidence, metadata } = req.body
+
+        if (!id) {
+            return res.status(400).json({ error: 'Fact ID is required' })
+        }
+
+        if (confidence === undefined && metadata === undefined) {
+            return res.status(400).json({ error: 'At least one of confidence or metadata must be provided' })
+        }
+
+        const conf = confidence !== undefined ? Math.max(0, Math.min(1, confidence)) : undefined
+
+        await update_fact(id, conf, metadata)
+
+        res.json({ id, confidence: conf, metadata, message: 'Fact updated successfully' })
+    } catch (error) {
+        console.error('[TEMPORAL API] Error updating fact:', error)
+        res.status(500).json({ error: 'Failed to update fact' })
+    }
+}
+
+
+export const invalidate_temporal_fact = async (req: any, res: any) => {
+    try {
+        const { id } = req.params
+        const { valid_to } = req.body
+
+        if (!id) {
+            return res.status(400).json({ error: 'Fact ID is required' })
+        }
+
+        const valid_to_date = valid_to ? new Date(valid_to) : new Date()
+
+        await invalidate_fact(id, valid_to_date)
+
+        res.json({ id, valid_to: valid_to_date.toISOString(), message: 'Fact invalidated successfully' })
+    } catch (error) {
+        console.error('[TEMPORAL API] Error invalidating fact:', error)
+        res.status(500).json({ error: 'Failed to invalidate fact' })
+    }
+}
+
+
+export const get_subject_facts = async (req: any, res: any) => {
+    try {
+        const { subject } = req.params
+        const { at, include_historical } = req.query
+
+        if (!subject) {
+            return res.status(400).json({ error: 'Subject parameter is required' })
+        }
+
+        const at_date = at ? new Date(at) : undefined
+        const include_hist = include_historical === 'true'
+
+        const facts = await get_facts_by_subject(subject, at_date, include_hist)
+
+        res.json({
+            subject,
+            at: at_date?.toISOString(),
+            include_historical: include_hist,
+            facts,
+            count: facts.length
+        })
+    } catch (error) {
+        console.error('[TEMPORAL API] Error getting subject facts:', error)
+        res.status(500).json({ error: 'Failed to get subject facts' })
+    }
+}
+
+
+export const search_temporal_facts = async (req: any, res: any) => {
+    try {
+        const { pattern, field = 'subject', at } = req.query
+
+        if (!pattern) {
+            return res.status(400).json({ error: 'Pattern parameter is required' })
+        }
+
+        if (!['subject', 'predicate', 'object'].includes(field)) {
+            return res.status(400).json({ error: 'Field must be one of: subject, predicate, object' })
+        }
+
+        const at_date = at ? new Date(at) : undefined
+        const facts = await search_facts(pattern, field as any, at_date)
+
+        res.json({
+            pattern,
+            field,
+            at: at_date?.toISOString(),
+            facts,
+            count: facts.length
+        })
+    } catch (error) {
+        console.error('[TEMPORAL API] Error searching facts:', error)
+        res.status(500).json({ error: 'Failed to search facts' })
+    }
+}
+
+
+export const get_temporal_stats = async (req: any, res: any) => {
+    try {
+        const active_facts = await get_active_facts_count()
+        const total_facts = await get_total_facts_count()
+        const historical_facts = total_facts - active_facts
+
+        res.json({
+            active_facts,
+            historical_facts,
+            total_facts,
+            historical_percentage: total_facts > 0 ? ((historical_facts / total_facts) * 100).toFixed(2) + '%' : '0%'
+        })
+    } catch (error) {
+        console.error('[TEMPORAL API] Error getting stats:', error)
+        res.status(500).json({ error: 'Failed to get statistics' })
+    }
+}
+
+
+export const apply_decay = async (req: any, res: any) => {
+    try {
+        const { decay_rate = 0.01 } = req.body
+
+        const updated = await apply_confidence_decay(decay_rate)
+
+        res.json({
+            decay_rate,
+            facts_updated: updated,
+            message: 'Confidence decay applied successfully'
+        })
+    } catch (error) {
+        console.error('[TEMPORAL API] Error applying decay:', error)
+        res.status(500).json({ error: 'Failed to apply confidence decay' })
+    }
+}
+
+
+export const compare_facts = async (req: any, res: any) => {
+    try {
+        const { subject, time1, time2 } = req.query
+
+        if (!subject || !time1 || !time2) {
+            return res.status(400).json({ error: 'subject, time1, and time2 parameters are required' })
+        }
+
+        const t1 = new Date(time1)
+        const t2 = new Date(time2)
+
+        const comparison = await compare_time_points(subject, t1, t2)
+
+        res.json({
+            subject,
+            time1: t1.toISOString(),
+            time2: t2.toISOString(),
+            ...comparison,
+            summary: {
+                added: comparison.added.length,
+                removed: comparison.removed.length,
+                changed: comparison.changed.length,
+                unchanged: comparison.unchanged.length
+            }
+        })
+    } catch (error) {
+        console.error('[TEMPORAL API] Error comparing facts:', error)
+        res.status(500).json({ error: 'Failed to compare facts' })
+    }
+}
+
+
+export const get_most_volatile = async (req: any, res: any) => {
+    try {
+        const { subject, limit = 10 } = req.query
+
+        const volatile = await get_volatile_facts(subject, parseInt(limit))
+
+        res.json({
+            subject,
+            limit: parseInt(limit),
+            volatile_facts: volatile,
+            count: volatile.length
+        })
+    } catch (error) {
+        console.error('[TEMPORAL API] Error getting volatile facts:', error)
+        res.status(500).json({ error: 'Failed to get volatile facts' })
+    }
+}
+
+export function temporal(app: any) {
+    app.post('/api/temporal/fact', create_temporal_fact)
+    app.get('/api/temporal/fact', get_temporal_fact)
+    app.get('/api/temporal/fact/current', get_current_temporal_fact)
+    app.patch('/api/temporal/fact/:id', update_temporal_fact)
+    app.delete('/api/temporal/fact/:id', invalidate_temporal_fact)
+
+    app.get('/api/temporal/timeline', get_entity_timeline)
+    app.get('/api/temporal/subject/:subject', get_subject_facts)
+    app.get('/api/temporal/search', search_temporal_facts)
+    app.get('/api/temporal/compare', compare_facts)
+    app.get('/api/temporal/stats', get_temporal_stats)
+    app.post('/api/temporal/decay', apply_decay)
+    app.get('/api/temporal/volatile', get_most_volatile)
+}

package/src/server/routes/users.ts

@@ -0,0 +1,111 @@
+import { q, vector_store } from "../../core/db";
+import { p } from "../../utils";
+import {
+    update_user_summary,
+    auto_update_user_summaries,
+} from "../../memory/user_summary";
+
+export const usr = (app: any) => {
+    app.get("/users/:user_id/summary", async (req: any, res: any) => {
+        try {
+            const { user_id } = req.params;
+            if (!user_id)
+                return res.status(400).json({ error: "user_id required" });
+
+            const user = await q.get_user.get(user_id);
+            if (!user) return res.status(404).json({ error: "user not found" });
+
+            res.json({
+                user_id: user.user_id,
+                summary: user.summary,
+                reflection_count: user.reflection_count,
+                updated_at: user.updated_at,
+            });
+        } catch (err: any) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+
+    app.post(
+        "/users/:user_id/summary/regenerate",
+        async (req: any, res: any) => {
+            try {
+                const { user_id } = req.params;
+                if (!user_id)
+                    return res.status(400).json({ err: "user_id required" });
+
+                await update_user_summary(user_id);
+                const user = await q.get_user.get(user_id);
+
+                res.json({
+                    ok: true,
+                    user_id,
+                    summary: user?.summary,
+                    reflection_count: user?.reflection_count,
+                });
+            } catch (err: any) {
+                res.status(500).json({ err: err.message });
+            }
+        },
+    );
+
+    app.post("/users/summaries/regenerate-all", async (req: any, res: any) => {
+        try {
+            const result = await auto_update_user_summaries();
+            res.json({ ok: true, updated: result.updated });
+        } catch (err: any) {
+            res.status(500).json({ err: err.message });
+        }
+    });
+
+    app.get("/users/:user_id/memories", async (req: any, res: any) => {
+        try {
+            const { user_id } = req.params;
+            if (!user_id)
+                return res.status(400).json({ err: "user_id required" });
+
+            const l = req.query.l ? parseInt(req.query.l) : 100;
+            const u = req.query.u ? parseInt(req.query.u) : 0;
+
+            const r = await q.all_mem_by_user.all(user_id, l, u);
+            const i = r.map((x: any) => ({
+                id: x.id,
+                content: x.content,
+                tags: p(x.tags),
+                metadata: 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,
+            }));
+            res.json({ user_id, items: i });
+        } catch (err: any) {
+            res.status(500).json({ err: err.message });
+        }
+    });
+
+    app.delete("/users/:user_id/memories", async (req: any, res: any) => {
+        try {
+            const { user_id } = req.params;
+            if (!user_id)
+                return res.status(400).json({ err: "user_id required" });
+
+            const mems = await q.all_mem_by_user.all(user_id, 10000, 0);
+            let deleted = 0;
+
+            for (const m of mems) {
+                await q.del_mem.run(m.id);
+                await vector_store.deleteVectors(m.id);
+                await q.del_waypoints.run(m.id, m.id);
+                deleted++;
+            }
+
+            res.json({ ok: true, deleted });
+        } catch (err: any) {
+            res.status(500).json({ err: err.message });
+        }
+    });
+};

package/src/server/routes/vercel.ts

@@ -0,0 +1,55 @@
+import { hsg_query, add_hsg_memory } from "../../memory/hsg";
+import { j } from "../../utils";
+
+export function vercel(app: any) {
+    // Simple memory query endpoint for Vercel AI SDK adapters
+    app.post("/query", async (req: any, res: any) => {
+        try {
+            const b = req.body || {};
+            const query: string = String(b.query || "").slice(0, 4000);
+            const user_id: string | undefined = b.user_id || req.query.user_id;
+            const k: number = Math.max(1, Math.min(32, Number(b.k) || 8));
+            if (!query) return res.status(400).json({ err: "query" });
+
+            const startTime: number | undefined = b.startTime ? Number(b.startTime) : undefined;
+            const endTime: number | undefined = b.endTime ? Number(b.endTime) : undefined;
+            const matches = await hsg_query(query, k, { user_id, startTime, endTime });
+            const lines = matches.map((m: any) => `- (${(m.score ?? 0).toFixed(2)}) ${m.content}`);
+            const result = lines.join("\n");
+
+            res.json({
+                query,
+                user_id: user_id || null,
+                k,
+                result,
+                matches: matches.map((m: any) => ({
+                    id: m.id,
+                    content: m.content,
+                    score: m.score,
+                    sectors: m.sectors,
+                    primary_sector: m.primary_sector,
+                    last_seen_at: m.last_seen_at,
+                })),
+            });
+        } catch (e: any) {
+            res.status(500).json({ err: "internal", msg: e?.message || String(e) });
+        }
+    });
+
+    // Simple memory store endpoint for chat transcripts or summaries
+    app.post("/memories", async (req: any, res: any) => {
+        try {
+            const b = req.body || {};
+            const content: string = String(b.content || "").trim();
+            const user_id: string | undefined = b.user_id || req.query.user_id;
+            const tags: string[] = Array.isArray(b.tags) ? b.tags : [];
+            const metadata: any = b.metadata || undefined;
+            if (!content) return res.status(400).json({ err: "content" });
+
+            const r = await add_hsg_memory(content, j(tags), metadata, user_id);
+            res.json(r);
+        } catch (e: any) {
+            res.status(500).json({ err: "internal", msg: e?.message || String(e) });
+        }
+    });
+}