@askexenow/exe-os 0.9.227 → 0.9.229

package/dist/bin/age-ontology-load.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+import {
+  pgSslConfig
+} from "../chunk-EQSQ4HBW.js";
+import {
+  politeBatchPause,
+  startManagedJob
+} from "../chunk-X3AVWFWW.js";
+import "../chunk-TNTFEWU5.js";
+import "../chunk-LYH5HE24.js";
+import "../chunk-R5U7XKVJ.js";
+
+// src/bin/age-ontology-load.ts
+import { Client } from "pg";
+function q(value) {
+  return `'${String(value ?? "").replace(/\u0000/g, "").slice(0, 500).replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+function sqlString(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+async function main() {
+  const job = startManagedJob({ type: "age-ontology-load", name: "Apache AGE ontology loader", lowPriority: true });
+  if (!job) {
+    process.stderr.write("[age-ontology-load] Another AGE ontology load is already running.\n");
+    return;
+  }
+  const sourceUrl = process.env.DATABASE_URL || process.env.EXED_DATABASE_URL;
+  const ageUrl = process.env.AGE_DATABASE_URL;
+  if (!sourceUrl) throw new Error("DATABASE_URL or EXED_DATABASE_URL is required for canonical source");
+  if (!ageUrl) throw new Error("AGE_DATABASE_URL is required for Apache AGE target");
+  const graph = process.env.AGE_GRAPH_NAME || "exe_ontology";
+  const limit = Number(process.argv[process.argv.indexOf("--limit") + 1] || "1000");
+  const source = new Client({ connectionString: sourceUrl, ...pgSslConfig() });
+  const age = new Client({ connectionString: ageUrl, ...pgSslConfig() });
+  await source.connect();
+  await age.connect();
+  try {
+    await age.query(`CREATE EXTENSION IF NOT EXISTS age`);
+    await age.query(`LOAD 'age'`);
+    await age.query(`SET search_path = ag_catalog, "$user", public`);
+    if (process.argv.includes("--reset")) {
+      try {
+        await age.query(`SELECT drop_graph(${sqlString(graph)}, true)`);
+      } catch {
+      }
+    }
+    try {
+      await age.query(`SELECT create_graph(${sqlString(graph)})`);
+    } catch {
+    }
+    const entities = await source.query(`SELECT id, name, type FROM memory.entities ORDER BY last_seen DESC NULLS LAST, id LIMIT $1`, [limit]);
+    let nodeCount = 0;
+    for (const entity of entities.rows) {
+      const cypher = `CREATE (:Entity {id: ${q(entity.id)}, name: ${q(entity.name)}, type: ${q(entity.type)}})`;
+      await age.query(`SELECT * FROM cypher(${sqlString(graph)}, $$ ${cypher} $$) AS (v agtype)`);
+      nodeCount++;
+      if (nodeCount % 250 === 0) {
+        job.update({ current: nodeCount, total: limit, label: `Loaded ${nodeCount} AGE nodes` });
+        await politeBatchPause(250);
+      }
+    }
+    const relationships = await source.query(`SELECT source_entity_id, target_entity_id, type, confidence FROM memory.relationships ORDER BY id LIMIT $1`, [limit * 2]);
+    let edgeCount = 0;
+    for (const rel of relationships.rows) {
+      const cypher = `MATCH (a:Entity {id: ${q(rel.source_entity_id)}}), (b:Entity {id: ${q(rel.target_entity_id)}}) CREATE (a)-[:RELATED {type: ${q(rel.type)}}]->(b)`;
+      await age.query(`SELECT * FROM cypher(${sqlString(graph)}, $$ ${cypher} $$) AS (e agtype)`);
+      edgeCount++;
+      if (edgeCount % 500 === 0) {
+        job.update({ current: nodeCount + edgeCount, total: limit * 3, label: `Loaded ${nodeCount} nodes, ${edgeCount} edges` });
+        await politeBatchPause(250);
+      }
+    }
+    process.stderr.write(`[age-ontology-load] Loaded ${nodeCount} nodes and ${edgeCount} edges into ${graph}.
+`);
+    job.complete();
+  } finally {
+    await age.end();
+    await source.end();
+  }
+}
+main().catch((err) => {
+  process.stderr.write(`[age-ontology-load] FATAL: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(1);
+});

package/dist/bin/agentic-ontology-backfill.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+import {
+  insertOntologyForBatch
+} from "../chunk-WWPX2LLP.js";
+import {
+  politeBatchPause,
+  startManagedJob
+} from "../chunk-X3AVWFWW.js";
+import {
+  disposeStore,
+  initStore
+} from "../chunk-HTCBLSIB.js";
+import "../chunk-CHCA3ZM2.js";
+import "../chunk-IW53DAYO.js";
+import "../chunk-F7LU65PQ.js";
+import "../chunk-MP2AFCGL.js";
+import {
+  getClient
+} from "../chunk-UJOSFVWG.js";
+import "../chunk-QHIGMP2M.js";
+import "../chunk-FXU7JOXK.js";
+import "../chunk-7NNXBDOO.js";
+import "../chunk-TNTFEWU5.js";
+import "../chunk-LYH5HE24.js";
+import "../chunk-R5U7XKVJ.js";
+
+// src/bin/agentic-ontology-backfill.ts
+var BATCH_SIZE = 500;
+async function main() {
+  const job = startManagedJob({ type: "agentic-ontology-backfill", name: "Agentic ontology backfill", lowPriority: true });
+  if (!job) {
+    process.stderr.write("[agentic-ontology-backfill] Another ontology backfill is already running.\n");
+    return;
+  }
+  await initStore({ lightweight: true });
+  const client = getClient();
+  let offset = 0;
+  let total = 0;
+  while (true) {
+    const result = await client.execute({
+      sql: `SELECT id, agent_id, agent_role, session_id, timestamp, tool_name, project_name,
+                   has_error, raw_text, version, task_id, intent, outcome, domain, trajectory
+            FROM memories
+            WHERE id NOT IN (SELECT evidence_memory_id FROM agent_events WHERE evidence_memory_id IS NOT NULL)
+            ORDER BY version ASC, timestamp ASC
+            LIMIT ? OFFSET ?`,
+      args: [BATCH_SIZE, offset]
+    });
+    if (result.rows.length === 0) break;
+    const rows = result.rows.map((row) => ({
+      id: String(row.id),
+      agent_id: String(row.agent_id),
+      agent_role: String(row.agent_role),
+      session_id: String(row.session_id),
+      timestamp: String(row.timestamp),
+      tool_name: String(row.tool_name),
+      project_name: String(row.project_name),
+      has_error: Number(row.has_error ?? 0),
+      raw_text: String(row.raw_text),
+      version: Number(row.version ?? 0),
+      task_id: row.task_id == null ? null : String(row.task_id),
+      intent: row.intent == null ? null : String(row.intent),
+      outcome: row.outcome == null ? null : String(row.outcome),
+      domain: row.domain == null ? null : String(row.domain),
+      trajectory: row.trajectory == null ? null : String(row.trajectory)
+    }));
+    const inserted = await insertOntologyForBatch(rows, client);
+    total += inserted;
+    process.stderr.write(`[agentic-ontology-backfill] +${inserted} memories projected (${total} total)
+`);
+    job.update({ current: total, label: `Projected ${total} memories` });
+    await politeBatchPause(250);
+    offset = 0;
+  }
+  process.stderr.write(`[agentic-ontology-backfill] Complete: ${total} memories projected.
+`);
+  job.complete();
+  await disposeStore();
+}
+main().catch((err) => {
+  process.stderr.write(`[agentic-ontology-backfill] FATAL: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(1);
+});

package/dist/bin/agentic-reflection-backfill.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+import {
+  generateReflectionCheckpoints
+} from "../chunk-OE6SYHTC.js";
+import "../chunk-WWPX2LLP.js";
+import {
+  startManagedJob
+} from "../chunk-X3AVWFWW.js";
+import {
+  initStore
+} from "../chunk-HTCBLSIB.js";
+import "../chunk-CHCA3ZM2.js";
+import "../chunk-IW53DAYO.js";
+import "../chunk-F7LU65PQ.js";
+import "../chunk-MP2AFCGL.js";
+import "../chunk-UJOSFVWG.js";
+import "../chunk-QHIGMP2M.js";
+import "../chunk-FXU7JOXK.js";
+import "../chunk-7NNXBDOO.js";
+import "../chunk-TNTFEWU5.js";
+import "../chunk-LYH5HE24.js";
+import "../chunk-R5U7XKVJ.js";
+
+// src/bin/agentic-reflection-backfill.ts
+async function main() {
+  const job = startManagedJob({ type: "agentic-reflection-backfill", name: "Agentic reflection checkpoint backfill", lowPriority: true });
+  if (!job) {
+    process.stderr.write("[agentic-reflection-backfill] Another reflection backfill is already running.\n");
+    return;
+  }
+  const projectName = process.argv.includes("--project") ? process.argv[process.argv.indexOf("--project") + 1] : void 0;
+  const limitArg = process.argv.includes("--limit") ? process.argv[process.argv.indexOf("--limit") + 1] : void 0;
+  await initStore();
+  const inserted = await generateReflectionCheckpoints({ projectName, limit: limitArg ? Number(limitArg) : void 0 });
+  process.stderr.write(`[agentic-reflection-backfill] Inserted/updated ${inserted} reflection checkpoints.
+`);
+  job.update({ current: inserted, label: `Inserted/updated ${inserted} reflection checkpoints` });
+  job.complete();
+  process.exit(0);
+}
+main().catch((err) => {
+  process.stderr.write(`[agentic-reflection-backfill] FATAL: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(1);
+});

package/dist/bin/agentic-semantic-label.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+import {
+  clean,
+  inferSemanticLabel,
+  stableId
+} from "../chunk-WWPX2LLP.js";
+import {
+  politeBatchPause,
+  startManagedJob
+} from "../chunk-X3AVWFWW.js";
+import {
+  initStore
+} from "../chunk-HTCBLSIB.js";
+import "../chunk-CHCA3ZM2.js";
+import "../chunk-IW53DAYO.js";
+import "../chunk-F7LU65PQ.js";
+import "../chunk-MP2AFCGL.js";
+import {
+  getClient
+} from "../chunk-UJOSFVWG.js";
+import "../chunk-QHIGMP2M.js";
+import "../chunk-FXU7JOXK.js";
+import "../chunk-7NNXBDOO.js";
+import "../chunk-TNTFEWU5.js";
+import "../chunk-LYH5HE24.js";
+import "../chunk-R5U7XKVJ.js";
+
+// src/lib/agentic-llm-labeler.ts
+import OpenAI from "openai";
+function jsonFromText(text) {
+  const trimmed = text.trim().replace(/^```json\s*/i, "").replace(/^```\s*/i, "").replace(/```$/i, "").trim();
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+}
+function stringArray(value, max = 6) {
+  if (!Array.isArray(value)) return [];
+  return value.map(String).map((v) => clean(v, 220)).filter(Boolean).slice(0, max);
+}
+function normalizeLlmLabel(raw, fallback) {
+  const impact = ["positive", "negative", "neutral", "mixed"].includes(String(raw.impact)) ? String(raw.impact) : fallback.impact;
+  const confidenceRaw = Number(raw.confidence ?? fallback.confidence);
+  return {
+    labeler: "llm",
+    schemaVersion: 1,
+    eventType: String(raw.eventType ?? fallback.eventType),
+    intention: raw.intention == null ? fallback.intention : clean(String(raw.intention), 260),
+    outcome: raw.outcome == null ? fallback.outcome : clean(String(raw.outcome), 260),
+    impact,
+    confidence: Number.isFinite(confidenceRaw) ? Math.max(0, Math.min(1, confidenceRaw)) : fallback.confidence,
+    goals: stringArray(raw.goals).length ? stringArray(raw.goals) : fallback.goals,
+    milestones: stringArray(raw.milestones).length ? stringArray(raw.milestones) : fallback.milestones,
+    problems: stringArray(raw.problems).length ? stringArray(raw.problems) : fallback.problems,
+    decisions: stringArray(raw.decisions).length ? stringArray(raw.decisions) : fallback.decisions,
+    actors: stringArray(raw.actors).length ? stringArray(raw.actors) : fallback.actors,
+    temporalAnchors: stringArray(raw.temporalAnchors, 10).length ? stringArray(raw.temporalAnchors, 10) : fallback.temporalAnchors,
+    successSignals: stringArray(raw.successSignals).length ? stringArray(raw.successSignals) : fallback.successSignals,
+    failureSignals: stringArray(raw.failureSignals).length ? stringArray(raw.failureSignals) : fallback.failureSignals,
+    nextActions: stringArray(raw.nextActions).length ? stringArray(raw.nextActions) : fallback.nextActions,
+    summary: clean(String(raw.summary ?? fallback.summary), 360)
+  };
+}
+async function labelMemoryWithLlm(row, opts = {}) {
+  const fallback = inferSemanticLabel(row);
+  const apiKey = opts.apiKey ?? process.env.OPENAI_API_KEY ?? process.env.API_ROUTER_KEY;
+  const baseURL = opts.baseUrl ?? process.env.OPENAI_BASE_URL ?? process.env.API_ROUTER_URL;
+  const model = opts.model ?? process.env.EXE_AGENTIC_LABEL_MODEL;
+  if (!apiKey || !model) return fallback;
+  const client = new OpenAI({ apiKey, baseURL: baseURL || void 0 });
+  const prompt = `Label this agent-memory event for agentic memory. Return ONLY valid JSON with keys:
+{
+  "eventType": "tool_action|milestone|problem|error|decision|goal_signal|memory_observation|memory_card",
+  "intention": string|null,
+  "outcome": string|null,
+  "impact": "positive|negative|neutral|mixed",
+  "confidence": number between 0 and 1,
+  "goals": string[],
+  "milestones": string[],
+  "problems": string[],
+  "decisions": string[],
+  "actors": string[],
+  "temporalAnchors": string[],
+  "successSignals": string[],
+  "failureSignals": string[],
+  "nextActions": string[],
+  "summary": string
+}
+Focus on explicit goals, chronology, intended action, actual outcome, and whether the event moved the goal forward.
+
+Metadata: ${JSON.stringify({ agent_id: row.agent_id, role: row.agent_role, project: row.project_name, session: row.session_id, timestamp: row.timestamp, tool: row.tool_name, has_error: row.has_error })}
+Text: ${clean(row.raw_text, 5e3)}`;
+  try {
+    const response = await client.chat.completions.create({
+      model,
+      messages: [
+        { role: "system", content: "You are a precise ontology labeler. Output compact JSON only." },
+        { role: "user", content: prompt }
+      ],
+      max_tokens: opts.maxTokens ?? 900,
+      response_format: { type: "json_object" }
+    });
+    const raw = jsonFromText(response.choices[0]?.message?.content ?? "");
+    return raw ? normalizeLlmLabel(raw, fallback) : fallback;
+  } catch {
+    return fallback;
+  }
+}
+async function resolveClient(client) {
+  if (client) return client;
+  const { getClient: getClient2 } = await import("../lib/database.js");
+  return getClient2();
+}
+async function upsertSemanticLabel(row, label, client) {
+  const db = await resolveClient(client);
+  const eventId = stableId("event", row.id);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await db.execute({
+    sql: `INSERT INTO agent_semantic_labels
+      (id, source_memory_id, event_id, labeler, schema_version, confidence, labels, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET confidence = excluded.confidence, labels = excluded.labels,
+        updated_at = excluded.updated_at`,
+    args: [
+      stableId("semantic", row.id, label.labeler, label.schemaVersion),
+      row.id,
+      eventId,
+      label.labeler,
+      label.schemaVersion,
+      label.confidence,
+      JSON.stringify(label),
+      now,
+      now
+    ]
+  });
+  if (label.labeler === "llm") {
+    await db.execute({
+      sql: `UPDATE agent_events SET intention = COALESCE(?, intention), outcome = COALESCE(?, outcome),
+            impact = COALESCE(?, impact)
+            WHERE id = ?`,
+      args: [label.intention, label.outcome, label.impact, eventId]
+    });
+  }
+}
+
+// src/bin/agentic-semantic-label.ts
+function arg(name) {
+  const i = process.argv.indexOf(name);
+  return i >= 0 ? process.argv[i + 1] : void 0;
+}
+async function main() {
+  const limit = Number(arg("--limit") ?? "100");
+  const project = arg("--project");
+  const llm = process.argv.includes("--llm");
+  const job = startManagedJob({ type: "agentic-semantic-label", name: "Agentic semantic label pass", lowPriority: true });
+  if (!job) {
+    process.stderr.write("[agentic-semantic-label] Another semantic label job is already running.\n");
+    return;
+  }
+  await initStore();
+  const db = getClient();
+  const where = project ? "WHERE project_name = ?" : "";
+  const rows = await db.execute({
+    sql: `SELECT id, agent_id, agent_role, session_id, timestamp, tool_name, project_name, has_error, raw_text,
+                 version, task_id, intent, outcome, domain, trajectory
+          FROM memories ${where}
+          ORDER BY timestamp DESC
+          LIMIT ?`,
+    args: project ? [project, limit] : [limit]
+  });
+  let count = 0;
+  for (const row of rows.rows) {
+    const label = llm ? await labelMemoryWithLlm(row) : inferSemanticLabel(row);
+    await upsertSemanticLabel(row, label, db);
+    count++;
+    if (count % 25 === 0) {
+      process.stderr.write(`[agentic-semantic-label] labeled ${count}
+`);
+      job.update({ current: count, total: limit, label: `Labeled ${count}/${limit}` });
+      await politeBatchPause(250);
+    }
+  }
+  process.stderr.write(`[agentic-semantic-label] Complete: ${count} memories labeled (${llm ? "llm-if-configured" : "deterministic"}).
+`);
+  job.complete();
+  process.exit(0);
+}
+main().catch((err) => {
+  process.stderr.write(`[agentic-semantic-label] FATAL: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(1);
+});