ahok-skill 1.3.1

package/dist/temporal_graph/query.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.get_related_facts = exports.search_facts = exports.get_facts_by_subject = exports.find_conflicting_facts = exports.query_facts_in_range = exports.get_current_fact = exports.query_facts_at_time = void 0;
+const db_1 = require("../core/db");
+const query_facts_at_time = async (subject, predicate, object, at = new Date(), min_confidence = 0.1) => {
+    const timestamp = at.getTime();
+    const conditions = [];
+    const params = [];
+    // Build WHERE clause
+    conditions.push('(valid_from <= ? AND (valid_to IS NULL OR valid_to >= ?))');
+    params.push(timestamp, timestamp);
+    if (subject) {
+        conditions.push('subject = ?');
+        params.push(subject);
+    }
+    if (predicate) {
+        conditions.push('predicate = ?');
+        params.push(predicate);
+    }
+    if (object) {
+        conditions.push('object = ?');
+        params.push(object);
+    }
+    if (min_confidence > 0) {
+        conditions.push('confidence >= ?');
+        params.push(min_confidence);
+    }
+    const sql = `
+        SELECT id, subject, predicate, object, valid_from, valid_to, confidence, last_updated, metadata
+        FROM temporal_facts
+        WHERE ${conditions.join(' AND ')}
+        ORDER BY confidence DESC, valid_from DESC
+    `;
+    const rows = await (0, db_1.all_async)(sql, params);
+    return rows.map(row => ({
+        id: row.id,
+        subject: row.subject,
+        predicate: row.predicate,
+        object: row.object,
+        valid_from: new Date(row.valid_from),
+        valid_to: row.valid_to ? new Date(row.valid_to) : null,
+        confidence: row.confidence,
+        last_updated: new Date(row.last_updated),
+        metadata: row.metadata ? JSON.parse(row.metadata) : undefined
+    }));
+};
+exports.query_facts_at_time = query_facts_at_time;
+const get_current_fact = async (subject, predicate) => {
+    const now = Date.now();
+    const row = await (0, db_1.get_async)(`
+        SELECT id, subject, predicate, object, valid_from, valid_to, confidence, last_updated, metadata
+        FROM temporal_facts
+        WHERE subject = ? AND predicate = ? AND valid_to IS NULL
+        ORDER BY valid_from DESC
+        LIMIT 1
+    `, [subject, predicate]);
+    if (!row)
+        return null;
+    return {
+        id: row.id,
+        subject: row.subject,
+        predicate: row.predicate,
+        object: row.object,
+        valid_from: new Date(row.valid_from),
+        valid_to: row.valid_to ? new Date(row.valid_to) : null,
+        confidence: row.confidence,
+        last_updated: new Date(row.last_updated),
+        metadata: row.metadata ? JSON.parse(row.metadata) : undefined
+    };
+};
+exports.get_current_fact = get_current_fact;
+const query_facts_in_range = async (subject, predicate, from, to, min_confidence = 0.1) => {
+    const conditions = [];
+    const params = [];
+    if (from && to) {
+        const from_ts = from.getTime();
+        const to_ts = to.getTime();
+        conditions.push('((valid_from <= ? AND (valid_to IS NULL OR valid_to >= ?)) OR (valid_from >= ? AND valid_from <= ?))');
+        params.push(to_ts, from_ts, from_ts, to_ts);
+    }
+    else if (from) {
+        conditions.push('valid_from >= ?');
+        params.push(from.getTime());
+    }
+    else if (to) {
+        conditions.push('valid_from <= ?');
+        params.push(to.getTime());
+    }
+    if (subject) {
+        conditions.push('subject = ?');
+        params.push(subject);
+    }
+    if (predicate) {
+        conditions.push('predicate = ?');
+        params.push(predicate);
+    }
+    if (min_confidence > 0) {
+        conditions.push('confidence >= ?');
+        params.push(min_confidence);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+    const sql = `
+        SELECT id, subject, predicate, object, valid_from, valid_to, confidence, last_updated, metadata
+        FROM temporal_facts
+        ${where}
+        ORDER BY valid_from DESC
+    `;
+    const rows = await (0, db_1.all_async)(sql, params);
+    return rows.map(row => ({
+        id: row.id,
+        subject: row.subject,
+        predicate: row.predicate,
+        object: row.object,
+        valid_from: new Date(row.valid_from),
+        valid_to: row.valid_to ? new Date(row.valid_to) : null,
+        confidence: row.confidence,
+        last_updated: new Date(row.last_updated),
+        metadata: row.metadata ? JSON.parse(row.metadata) : undefined
+    }));
+};
+exports.query_facts_in_range = query_facts_in_range;
+const find_conflicting_facts = async (subject, predicate, at) => {
+    const timestamp = at ? at.getTime() : Date.now();
+    const rows = await (0, db_1.all_async)(`
+        SELECT id, subject, predicate, object, valid_from, valid_to, confidence, last_updated, metadata
+        FROM temporal_facts
+        WHERE subject = ? AND predicate = ?
+        AND (valid_from <= ? AND (valid_to IS NULL OR valid_to >= ?))
+        ORDER BY confidence DESC
+    `, [subject, predicate, timestamp, timestamp]);
+    return rows.map(row => ({
+        id: row.id,
+        subject: row.subject,
+        predicate: row.predicate,
+        object: row.object,
+        valid_from: new Date(row.valid_from),
+        valid_to: row.valid_to ? new Date(row.valid_to) : null,
+        confidence: row.confidence,
+        last_updated: new Date(row.last_updated),
+        metadata: row.metadata ? JSON.parse(row.metadata) : undefined
+    }));
+};
+exports.find_conflicting_facts = find_conflicting_facts;
+const get_facts_by_subject = async (subject, at, include_historical = false) => {
+    let sql;
+    let params;
+    if (include_historical) {
+        sql = `
+            SELECT id, subject, predicate, object, valid_from, valid_to, confidence, last_updated, metadata
+            FROM temporal_facts
+            WHERE subject = ?
+            ORDER BY predicate ASC, valid_from DESC
+        `;
+        params = [subject];
+    }
+    else {
+        const timestamp = at ? at.getTime() : Date.now();
+        sql = `
+            SELECT id, subject, predicate, object, valid_from, valid_to, confidence, last_updated, metadata
+            FROM temporal_facts
+            WHERE subject = ?
+            AND (valid_from <= ? AND (valid_to IS NULL OR valid_to >= ?))
+            ORDER BY predicate ASC, confidence DESC
+        `;
+        params = [subject, timestamp, timestamp];
+    }
+    const rows = await (0, db_1.all_async)(sql, params);
+    return rows.map(row => ({
+        id: row.id,
+        subject: row.subject,
+        predicate: row.predicate,
+        object: row.object,
+        valid_from: new Date(row.valid_from),
+        valid_to: row.valid_to ? new Date(row.valid_to) : null,
+        confidence: row.confidence,
+        last_updated: new Date(row.last_updated),
+        metadata: row.metadata ? JSON.parse(row.metadata) : undefined
+    }));
+};
+exports.get_facts_by_subject = get_facts_by_subject;
+const search_facts = async (pattern, field = 'subject', at) => {
+    const timestamp = at ? at.getTime() : Date.now();
+    const search_pattern = `%${pattern}%`;
+    const sql = `
+        SELECT id, subject, predicate, object, valid_from, valid_to, confidence, last_updated, metadata
+        FROM temporal_facts
+        WHERE ${field} LIKE ?
+        AND (valid_from <= ? AND (valid_to IS NULL OR valid_to >= ?))
+        ORDER BY confidence DESC, valid_from DESC
+        LIMIT 100
+    `;
+    const rows = await (0, db_1.all_async)(sql, [search_pattern, timestamp, timestamp]);
+    return rows.map(row => ({
+        id: row.id,
+        subject: row.subject,
+        predicate: row.predicate,
+        object: row.object,
+        valid_from: new Date(row.valid_from),
+        valid_to: row.valid_to ? new Date(row.valid_to) : null,
+        confidence: row.confidence,
+        last_updated: new Date(row.last_updated),
+        metadata: row.metadata ? JSON.parse(row.metadata) : undefined
+    }));
+};
+exports.search_facts = search_facts;
+const get_related_facts = async (fact_id, relation_type, at) => {
+    const timestamp = at ? at.getTime() : Date.now();
+    const conditions = ['(e.valid_from <= ? AND (e.valid_to IS NULL OR e.valid_to >= ?))'];
+    const params = [timestamp, timestamp];
+    if (relation_type) {
+        conditions.push('e.relation_type = ?');
+        params.push(relation_type);
+    }
+    const sql = `
+        SELECT f.*, e.relation_type, e.weight
+        FROM temporal_edges e
+        JOIN temporal_facts f ON e.target_id = f.id
+        WHERE e.source_id = ?
+        AND ${conditions.join(' AND ')}
+        AND (f.valid_from <= ? AND (f.valid_to IS NULL OR f.valid_to >= ?))
+        ORDER BY e.weight DESC, f.confidence DESC
+    `;
+    const rows = await (0, db_1.all_async)(sql, [fact_id, ...params, timestamp, timestamp]);
+    return rows.map(row => ({
+        fact: {
+            id: row.id,
+            subject: row.subject,
+            predicate: row.predicate,
+            object: row.object,
+            valid_from: new Date(row.valid_from),
+            valid_to: row.valid_to ? new Date(row.valid_to) : null,
+            confidence: row.confidence,
+            last_updated: new Date(row.last_updated),
+            metadata: row.metadata ? JSON.parse(row.metadata) : undefined
+        },
+        relation: row.relation_type,
+        weight: row.weight
+    }));
+};
+exports.get_related_facts = get_related_facts;

package/dist/temporal_graph/store.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.get_total_facts_count = exports.get_active_facts_count = exports.apply_confidence_decay = exports.batch_insert_facts = exports.invalidate_edge = exports.insert_edge = exports.delete_fact = exports.invalidate_fact = exports.update_fact = exports.insert_fact = void 0;
+const db_1 = require("../core/db");
+const crypto_1 = require("crypto");
+const insert_fact = async (subject, predicate, object, valid_from = new Date(), confidence = 1.0, metadata) => {
+    const id = (0, crypto_1.randomUUID)();
+    const now = Date.now();
+    const valid_from_ts = valid_from.getTime();
+    const existing = await (0, db_1.all_async)(`
+        SELECT id, valid_from FROM temporal_facts 
+        WHERE subject = ? AND predicate = ? AND valid_to IS NULL
+        ORDER BY valid_from DESC
+    `, [subject, predicate]);
+    for (const old of existing) {
+        if (old.valid_from < valid_from_ts) {
+            await (0, db_1.run_async)(`UPDATE temporal_facts SET valid_to = ? WHERE id = ?`, [valid_from_ts - 1, old.id]);
+            console.error(`[TEMPORAL] Closed fact ${old.id} at ${new Date(valid_from_ts - 1).toISOString()}`); // Use stderr for MCP compatibility
+        }
+    }
+    await (0, db_1.run_async)(`
+        INSERT INTO temporal_facts (id, subject, predicate, object, valid_from, valid_to, confidence, last_updated, metadata)
+        VALUES (?, ?, ?, ?, ?, NULL, ?, ?, ?)
+    `, [id, subject, predicate, object, valid_from_ts, confidence, now, metadata ? JSON.stringify(metadata) : null]);
+    console.error(`[TEMPORAL] Inserted fact: ${subject} ${predicate} ${object} (from ${valid_from.toISOString()}, confidence=${confidence})`); // Use stderr for MCP compatibility
+    return id;
+};
+exports.insert_fact = insert_fact;
+const update_fact = async (id, confidence, metadata) => {
+    const updates = [];
+    const params = [];
+    if (confidence !== undefined) {
+        updates.push('confidence = ?');
+        params.push(confidence);
+    }
+    if (metadata !== undefined) {
+        updates.push('metadata = ?');
+        params.push(JSON.stringify(metadata));
+    }
+    updates.push('last_updated = ?');
+    params.push(Date.now());
+    params.push(id);
+    if (updates.length > 0) {
+        await (0, db_1.run_async)(`UPDATE temporal_facts SET ${updates.join(', ')} WHERE id = ?`, params);
+        console.error(`[TEMPORAL] Updated fact ${id}`); // Use stderr for MCP compatibility
+    }
+};
+exports.update_fact = update_fact;
+const invalidate_fact = async (id, valid_to = new Date()) => {
+    await (0, db_1.run_async)(`UPDATE temporal_facts SET valid_to = ?, last_updated = ? WHERE id = ?`, [valid_to.getTime(), Date.now(), id]);
+    console.error(`[TEMPORAL] Invalidated fact ${id} at ${valid_to.toISOString()}`); // Use stderr for MCP compatibility
+};
+exports.invalidate_fact = invalidate_fact;
+const delete_fact = async (id) => {
+    await (0, db_1.run_async)(`DELETE FROM temporal_facts WHERE id = ?`, [id]);
+    console.error(`[TEMPORAL] Deleted fact ${id}`); // Use stderr for MCP compatibility
+};
+exports.delete_fact = delete_fact;
+const insert_edge = async (source_id, target_id, relation_type, valid_from = new Date(), weight = 1.0, metadata) => {
+    const id = (0, crypto_1.randomUUID)();
+    const valid_from_ts = valid_from.getTime();
+    await (0, db_1.run_async)(`
+        INSERT INTO temporal_edges (id, source_id, target_id, relation_type, valid_from, valid_to, weight, metadata)
+        VALUES (?, ?, ?, ?, ?, NULL, ?, ?)
+    `, [id, source_id, target_id, relation_type, valid_from_ts, weight, metadata ? JSON.stringify(metadata) : null]);
+    console.log(`[TEMPORAL] Created edge: ${source_id} --[${relation_type}]--> ${target_id}`);
+    return id;
+};
+exports.insert_edge = insert_edge;
+const invalidate_edge = async (id, valid_to = new Date()) => {
+    await (0, db_1.run_async)(`UPDATE temporal_edges SET valid_to = ? WHERE id = ?`, [valid_to.getTime(), id]);
+    console.log(`[TEMPORAL] Invalidated edge ${id}`);
+};
+exports.invalidate_edge = invalidate_edge;
+const batch_insert_facts = async (facts) => {
+    const ids = [];
+    await (0, db_1.run_async)('BEGIN TRANSACTION');
+    try {
+        for (const fact of facts) {
+            const id = await (0, exports.insert_fact)(fact.subject, fact.predicate, fact.object, fact.valid_from, fact.confidence, fact.metadata);
+            ids.push(id);
+        }
+        await (0, db_1.run_async)('COMMIT');
+        console.log(`[TEMPORAL] Batch inserted ${ids.length} facts`);
+    }
+    catch (error) {
+        await (0, db_1.run_async)('ROLLBACK');
+        throw error;
+    }
+    return ids;
+};
+exports.batch_insert_facts = batch_insert_facts;
+const apply_confidence_decay = async (decay_rate = 0.01) => {
+    const now = Date.now();
+    const one_day = 86400000;
+    await (0, db_1.run_async)(`
+        UPDATE temporal_facts 
+        SET confidence = MAX(0.1, confidence * (1 - ? * ((? - valid_from) / ?)))
+        WHERE valid_to IS NULL AND confidence > 0.1
+    `, [decay_rate, now, one_day]);
+    const result = await (0, db_1.get_async)(`SELECT changes() as changes`);
+    const changes = result?.changes || 0;
+    console.log(`[TEMPORAL] Applied confidence decay to ${changes} facts`);
+    return changes;
+};
+exports.apply_confidence_decay = apply_confidence_decay;
+const get_active_facts_count = async () => {
+    const result = await (0, db_1.get_async)(`SELECT COUNT(*) as count FROM temporal_facts WHERE valid_to IS NULL`);
+    return result?.count || 0;
+};
+exports.get_active_facts_count = get_active_facts_count;
+const get_total_facts_count = async () => {
+    const result = await (0, db_1.get_async)(`SELECT COUNT(*) as count FROM temporal_facts`);
+    return result?.count || 0;
+};
+exports.get_total_facts_count = get_total_facts_count;

package/dist/temporal_graph/timeline.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.get_volatile_facts = exports.get_change_frequency = exports.compare_time_points = exports.get_changes_in_window = exports.get_predicate_timeline = exports.get_subject_timeline = void 0;
+const db_1 = require("../core/db");
+const get_subject_timeline = async (subject, predicate) => {
+    const conditions = ['subject = ?'];
+    const params = [subject];
+    if (predicate) {
+        conditions.push('predicate = ?');
+        params.push(predicate);
+    }
+    const sql = `
+        SELECT subject, predicate, object, confidence, valid_from, valid_to
+        FROM temporal_facts
+        WHERE ${conditions.join(' AND ')}
+        ORDER BY valid_from ASC
+    `;
+    const rows = await (0, db_1.all_async)(sql, params);
+    const timeline = [];
+    for (const row of rows) {
+        // Creation event
+        timeline.push({
+            timestamp: new Date(row.valid_from),
+            subject: row.subject,
+            predicate: row.predicate,
+            object: row.object,
+            confidence: row.confidence,
+            change_type: 'created'
+        });
+        // Invalidation event (if applicable)
+        if (row.valid_to) {
+            timeline.push({
+                timestamp: new Date(row.valid_to),
+                subject: row.subject,
+                predicate: row.predicate,
+                object: row.object,
+                confidence: row.confidence,
+                change_type: 'invalidated'
+            });
+        }
+    }
+    return timeline.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+};
+exports.get_subject_timeline = get_subject_timeline;
+const get_predicate_timeline = async (predicate, from, to) => {
+    const conditions = ['predicate = ?'];
+    const params = [predicate];
+    if (from) {
+        conditions.push('valid_from >= ?');
+        params.push(from.getTime());
+    }
+    if (to) {
+        conditions.push('valid_from <= ?');
+        params.push(to.getTime());
+    }
+    const sql = `
+        SELECT subject, predicate, object, confidence, valid_from, valid_to
+        FROM temporal_facts
+        WHERE ${conditions.join(' AND ')}
+        ORDER BY valid_from ASC
+    `;
+    const rows = await (0, db_1.all_async)(sql, params);
+    const timeline = [];
+    for (const row of rows) {
+        timeline.push({
+            timestamp: new Date(row.valid_from),
+            subject: row.subject,
+            predicate: row.predicate,
+            object: row.object,
+            confidence: row.confidence,
+            change_type: 'created'
+        });
+        if (row.valid_to) {
+            timeline.push({
+                timestamp: new Date(row.valid_to),
+                subject: row.subject,
+                predicate: row.predicate,
+                object: row.object,
+                confidence: row.confidence,
+                change_type: 'invalidated'
+            });
+        }
+    }
+    return timeline.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+};
+exports.get_predicate_timeline = get_predicate_timeline;
+const get_changes_in_window = async (from, to, subject) => {
+    const from_ts = from.getTime();
+    const to_ts = to.getTime();
+    const conditions = [];
+    const params = [];
+    if (subject) {
+        conditions.push('subject = ?');
+        params.push(subject);
+    }
+    const where = conditions.length > 0 ? `AND ${conditions.join(' AND ')}` : '';
+    const sql = `
+        SELECT subject, predicate, object, confidence, valid_from, valid_to
+        FROM temporal_facts
+        WHERE ((valid_from >= ? AND valid_from <= ?) OR (valid_to >= ? AND valid_to <= ?))
+        ${where}
+        ORDER BY valid_from ASC
+    `;
+    const rows = await (0, db_1.all_async)(sql, [from_ts, to_ts, from_ts, to_ts, ...params]);
+    const timeline = [];
+    for (const row of rows) {
+        if (row.valid_from >= from_ts && row.valid_from <= to_ts) {
+            timeline.push({
+                timestamp: new Date(row.valid_from),
+                subject: row.subject,
+                predicate: row.predicate,
+                object: row.object,
+                confidence: row.confidence,
+                change_type: 'created'
+            });
+        }
+        if (row.valid_to && row.valid_to >= from_ts && row.valid_to <= to_ts) {
+            timeline.push({
+                timestamp: new Date(row.valid_to),
+                subject: row.subject,
+                predicate: row.predicate,
+                object: row.object,
+                confidence: row.confidence,
+                change_type: 'invalidated'
+            });
+        }
+    }
+    return timeline.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+};
+exports.get_changes_in_window = get_changes_in_window;
+const compare_time_points = async (subject, time1, time2) => {
+    const t1_ts = time1.getTime();
+    const t2_ts = time2.getTime();
+    // Get all facts for subject at both times
+    const facts_t1 = await (0, db_1.all_async)(`
+        SELECT id, subject, predicate, object, valid_from, valid_to, confidence, last_updated, metadata
+        FROM temporal_facts
+        WHERE subject = ?
+        AND valid_from <= ? AND (valid_to IS NULL OR valid_to >= ?)
+    `, [subject, t1_ts, t1_ts]);
+    const facts_t2 = await (0, db_1.all_async)(`
+        SELECT id, subject, predicate, object, valid_from, valid_to, confidence, last_updated, metadata
+        FROM temporal_facts
+        WHERE subject = ?
+        AND valid_from <= ? AND (valid_to IS NULL OR valid_to >= ?)
+    `, [subject, t2_ts, t2_ts]);
+    const map_t1 = new Map();
+    const map_t2 = new Map();
+    for (const f of facts_t1) {
+        map_t1.set(f.predicate, f);
+    }
+    for (const f of facts_t2) {
+        map_t2.set(f.predicate, f);
+    }
+    const added = [];
+    const removed = [];
+    const changed = [];
+    const unchanged = [];
+    // Find added and changed
+    for (const [pred, fact2] of map_t2) {
+        const fact1 = map_t1.get(pred);
+        if (!fact1) {
+            added.push(row_to_fact(fact2));
+        }
+        else if (fact1.object !== fact2.object || fact1.id !== fact2.id) {
+            changed.push({
+                before: row_to_fact(fact1),
+                after: row_to_fact(fact2)
+            });
+        }
+        else {
+            unchanged.push(row_to_fact(fact2));
+        }
+    }
+    // Find removed
+    for (const [pred, fact1] of map_t1) {
+        if (!map_t2.has(pred)) {
+            removed.push(row_to_fact(fact1));
+        }
+    }
+    return { added, removed, changed, unchanged };
+};
+exports.compare_time_points = compare_time_points;
+const get_change_frequency = async (subject, predicate, window_days = 30) => {
+    const now = Date.now();
+    const window_start = now - (window_days * 86400000);
+    const rows = await (0, db_1.all_async)(`
+        SELECT valid_from, valid_to
+        FROM temporal_facts
+        WHERE subject = ? AND predicate = ?
+        AND valid_from >= ?
+        ORDER BY valid_from ASC
+    `, [subject, predicate, window_start]);
+    const total_changes = rows.length;
+    let total_duration = 0;
+    let valid_durations = 0;
+    for (const row of rows) {
+        if (row.valid_to) {
+            total_duration += row.valid_to - row.valid_from;
+            valid_durations++;
+        }
+    }
+    const avg_duration_ms = valid_durations > 0 ? total_duration / valid_durations : 0;
+    const change_rate_per_day = total_changes / window_days;
+    return {
+        predicate,
+        total_changes,
+        avg_duration_ms,
+        change_rate_per_day
+    };
+};
+exports.get_change_frequency = get_change_frequency;
+const get_volatile_facts = async (subject, limit = 10) => {
+    const where = subject ? 'WHERE subject = ?' : '';
+    const params = subject ? [subject] : [];
+    const sql = `
+        SELECT subject, predicate, COUNT(*) as change_count, AVG(confidence) as avg_confidence
+        FROM temporal_facts
+        ${where}
+        GROUP BY subject, predicate
+        HAVING change_count > 1
+        ORDER BY change_count DESC, avg_confidence ASC
+        LIMIT ?
+    `;
+    return await (0, db_1.all_async)(sql, [...params, limit]);
+};
+exports.get_volatile_facts = get_volatile_facts;
+// Helper function
+function row_to_fact(row) {
+    return {
+        id: row.id,
+        subject: row.subject,
+        predicate: row.predicate,
+        object: row.object,
+        valid_from: new Date(row.valid_from),
+        valid_to: row.valid_to ? new Date(row.valid_to) : null,
+        confidence: row.confidence,
+        last_updated: new Date(row.last_updated),
+        metadata: row.metadata ? JSON.parse(row.metadata) : undefined
+    };
+}

package/dist/temporal_graph/types.js

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

package/dist/utils/chunking.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.join_chunks = exports.agg_vec = exports.chunk_text = void 0;
+const cpt = 4;
+const est = (t) => Math.ceil(t.length / cpt);
+const chunk_text = (txt, tgt = 768, ovr = 0.1) => {
+    const tot = est(txt);
+    if (tot <= tgt)
+        return [{ text: txt, start: 0, end: txt.length, tokens: tot }];
+    const tch = tgt * cpt, och = Math.floor(tch * ovr);
+    const paras = txt.split(/\n\n+/);
+    const chks = [];
+    let cur = "", cs = 0;
+    for (const p of paras) {
+        const sents = p.split(/(?<=[.!?])\s+/);
+        for (const s of sents) {
+            const pot = cur + (cur ? " " : "") + s;
+            if (pot.length > tch && cur.length > 0) {
+                chks.push({
+                    text: cur,
+                    start: cs,
+                    end: cs + cur.length,
+                    tokens: est(cur),
+                });
+                const ovt = cur.slice(-och);
+                cur = ovt + " " + s;
+                cs = cs + cur.length - ovt.length - 1;
+            }
+            else
+                cur = pot;
+        }
+    }
+    if (cur.length > 0)
+        chks.push({
+            text: cur,
+            start: cs,
+            end: cs + cur.length,
+            tokens: est(cur),
+        });
+    return chks;
+};
+exports.chunk_text = chunk_text;
+const agg_vec = (vecs) => {
+    const n = vecs.length;
+    if (!n)
+        throw new Error("no vecs");
+    if (n === 1)
+        return vecs[0].slice();
+    const d = vecs[0].length, r = new Array(d).fill(0);
+    for (const v of vecs)
+        for (let i = 0; i < d; i++)
+            r[i] += v[i];
+    const rc = 1 / n;
+    for (let i = 0; i < d; i++)
+        r[i] *= rc;
+    return r;
+};
+exports.agg_vec = agg_vec;
+const join_chunks = (cks) => cks.length ? cks.map((c) => c.text).join(" ") : "";
+exports.join_chunks = join_chunks;

package/dist/utils/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buf_to_vec = exports.vec_to_buf = exports.p = exports.j = exports.cos_sim = exports.rid = exports.now = void 0;
+const now = () => Date.now();
+exports.now = now;
+const rid = () => crypto.randomUUID();
+exports.rid = rid;
+const cos_sim = (a, b) => {
+    let dot = 0, na = 0, nb = 0;
+    for (let i = 0; i < a.length; i++) {
+        const x = a[i], y = b[i];
+        dot += x * y;
+        na += x * x;
+        nb += y * y;
+    }
+    const d = Math.sqrt(na) * Math.sqrt(nb);
+    return d ? dot / d : 0;
+};
+exports.cos_sim = cos_sim;
+exports.j = JSON.stringify;
+const p = (x) => JSON.parse(x);
+exports.p = p;
+const vec_to_buf = (v) => {
+    const f32 = new Float32Array(v);
+    return Buffer.from(f32.buffer);
+};
+exports.vec_to_buf = vec_to_buf;
+const buf_to_vec = (buf) => {
+    return new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4);
+};
+exports.buf_to_vec = buf_to_vec;