engrams 0.1.0

package/dist/http.js

@@ -0,0 +1,255 @@
+// src/http.ts
+import { createServer } from "http";
+import { randomBytes } from "crypto";
+import { eq, and, isNull } from "drizzle-orm";
+
+// ../core/dist/schema.js
+import { sqliteTable, text, real, integer } from "drizzle-orm/sqlite-core";
+var memories = sqliteTable("memories", {
+  id: text("id").primaryKey(),
+  content: text("content").notNull(),
+  detail: text("detail"),
+  domain: text("domain").notNull().default("general"),
+  sourceAgentId: text("source_agent_id").notNull(),
+  sourceAgentName: text("source_agent_name").notNull(),
+  crossAgentId: text("cross_agent_id"),
+  crossAgentName: text("cross_agent_name"),
+  sourceType: text("source_type").notNull(),
+  sourceDescription: text("source_description"),
+  confidence: real("confidence").notNull().default(0.7),
+  confirmedCount: integer("confirmed_count").notNull().default(0),
+  correctedCount: integer("corrected_count").notNull().default(0),
+  mistakeCount: integer("mistake_count").notNull().default(0),
+  usedCount: integer("used_count").notNull().default(0),
+  learnedAt: text("learned_at"),
+  confirmedAt: text("confirmed_at"),
+  lastUsedAt: text("last_used_at"),
+  deletedAt: text("deleted_at"),
+  hasPiiFlag: integer("has_pii_flag").notNull().default(0),
+  entityType: text("entity_type"),
+  entityName: text("entity_name"),
+  structuredData: text("structured_data")
+});
+var memoryConnections = sqliteTable("memory_connections", {
+  sourceMemoryId: text("source_memory_id").notNull().references(() => memories.id),
+  targetMemoryId: text("target_memory_id").notNull().references(() => memories.id),
+  relationship: text("relationship").notNull()
+});
+var memoryEvents = sqliteTable("memory_events", {
+  id: text("id").primaryKey(),
+  memoryId: text("memory_id").notNull().references(() => memories.id),
+  eventType: text("event_type").notNull(),
+  agentId: text("agent_id"),
+  agentName: text("agent_name"),
+  oldValue: text("old_value"),
+  newValue: text("new_value"),
+  timestamp: text("timestamp").notNull()
+});
+var agentPermissions = sqliteTable("agent_permissions", {
+  agentId: text("agent_id").notNull(),
+  domain: text("domain").notNull(),
+  canRead: integer("can_read").notNull().default(1),
+  canWrite: integer("can_write").notNull().default(1)
+});
+
+// ../core/dist/confidence.js
+var DECAY_INTERVAL_MS = 30 * 24 * 60 * 60 * 1e3;
+function applyConfirm(_current) {
+  return 0.99;
+}
+function applyCorrect() {
+  return 0.5;
+}
+function applyMistake(current) {
+  return Math.max(current - 0.15, 0.1);
+}
+
+// ../core/dist/db.js
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+
+// ../core/dist/vec.js
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+
+// ../core/dist/embeddings.js
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+
+// src/http.ts
+function generateId() {
+  return randomBytes(16).toString("hex");
+}
+function now() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function json(res, data, status = 200) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+function parseBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => body += chunk);
+    req.on("end", () => {
+      try {
+        resolve(body ? JSON.parse(body) : {});
+      } catch {
+        reject(new Error("Invalid JSON"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function startHttpApi(db, sqlite, port = 3838) {
+  const server = createServer(async (req, res) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(200);
+      res.end();
+      return;
+    }
+    const url = req.url ?? "";
+    try {
+      const confirmMatch = url.match(/^\/api\/memory\/([^/]+)\/confirm$/);
+      if (confirmMatch && req.method === "POST") {
+        const id = confirmMatch[1];
+        const existing = db.select().from(memories).where(and(eq(memories.id, id), isNull(memories.deletedAt))).get();
+        if (!existing) return json(res, { error: "Not found" }, 404);
+        const newConfidence = applyConfirm(existing.confidence);
+        const timestamp = now();
+        db.update(memories).set({
+          confidence: newConfidence,
+          confirmedCount: existing.confirmedCount + 1,
+          confirmedAt: timestamp
+        }).where(eq(memories.id, id)).run();
+        db.insert(memoryEvents).values({
+          id: generateId(),
+          memoryId: id,
+          eventType: "confirmed",
+          agentName: "dashboard",
+          oldValue: JSON.stringify({ confidence: existing.confidence }),
+          newValue: JSON.stringify({ confidence: newConfidence }),
+          timestamp
+        }).run();
+        return json(res, { id, newConfidence });
+      }
+      const correctMatch = url.match(/^\/api\/memory\/([^/]+)\/correct$/);
+      if (correctMatch && req.method === "POST") {
+        const id = correctMatch[1];
+        const body = await parseBody(req);
+        const content = body.content;
+        if (!content) return json(res, { error: "content required" }, 400);
+        const existing = db.select().from(memories).where(and(eq(memories.id, id), isNull(memories.deletedAt))).get();
+        if (!existing) return json(res, { error: "Not found" }, 404);
+        const newConfidence = applyCorrect();
+        const timestamp = now();
+        db.update(memories).set({
+          content,
+          confidence: newConfidence,
+          correctedCount: existing.correctedCount + 1
+        }).where(eq(memories.id, id)).run();
+        db.insert(memoryEvents).values({
+          id: generateId(),
+          memoryId: id,
+          eventType: "corrected",
+          agentName: "dashboard",
+          oldValue: JSON.stringify({ content: existing.content }),
+          newValue: JSON.stringify({ content, confidence: newConfidence }),
+          timestamp
+        }).run();
+        return json(res, { id, newConfidence });
+      }
+      const flagMatch = url.match(/^\/api\/memory\/([^/]+)\/flag$/);
+      if (flagMatch && req.method === "POST") {
+        const id = flagMatch[1];
+        const existing = db.select().from(memories).where(and(eq(memories.id, id), isNull(memories.deletedAt))).get();
+        if (!existing) return json(res, { error: "Not found" }, 404);
+        const newConfidence = applyMistake(existing.confidence);
+        const timestamp = now();
+        db.update(memories).set({
+          confidence: newConfidence,
+          mistakeCount: existing.mistakeCount + 1
+        }).where(eq(memories.id, id)).run();
+        db.insert(memoryEvents).values({
+          id: generateId(),
+          memoryId: id,
+          eventType: "confidence_changed",
+          agentName: "dashboard",
+          oldValue: JSON.stringify({ confidence: existing.confidence }),
+          newValue: JSON.stringify({ confidence: newConfidence, flaggedAsMistake: true }),
+          timestamp
+        }).run();
+        return json(res, { id, newConfidence });
+      }
+      const deleteMatch = url.match(/^\/api\/memory\/([^/]+)\/delete$/);
+      if (deleteMatch && req.method === "POST") {
+        const id = deleteMatch[1];
+        const timestamp = now();
+        db.update(memories).set({ deletedAt: timestamp }).where(eq(memories.id, id)).run();
+        db.insert(memoryEvents).values({
+          id: generateId(),
+          memoryId: id,
+          eventType: "removed",
+          agentName: "dashboard",
+          newValue: JSON.stringify({ reason: "deleted via dashboard" }),
+          timestamp
+        }).run();
+        return json(res, { id, deleted: true });
+      }
+      const updateMatch = url.match(/^\/api\/memory\/([^/]+)\/update$/);
+      if (updateMatch && req.method === "POST") {
+        const id = updateMatch[1];
+        const body = await parseBody(req);
+        const updates = {};
+        if (body.content) updates.content = body.content;
+        if (body.detail) updates.detail = body.detail;
+        if (body.domain) updates.domain = body.domain;
+        if (Object.keys(updates).length === 0)
+          return json(res, { error: "No fields" }, 400);
+        db.update(memories).set(updates).where(eq(memories.id, id)).run();
+        return json(res, { id, updated: true });
+      }
+      if (url === "/api/permissions" && req.method === "POST") {
+        const body = await parseBody(req);
+        const agentId = body.agentId;
+        const domain = body.domain;
+        const canRead = body.canRead !== false ? 1 : 0;
+        const canWrite = body.canWrite !== false ? 1 : 0;
+        const existing = db.select().from(agentPermissions).where(
+          and(
+            eq(agentPermissions.agentId, agentId),
+            eq(agentPermissions.domain, domain)
+          )
+        ).get();
+        if (existing) {
+          db.update(agentPermissions).set({ canRead, canWrite }).where(
+            and(
+              eq(agentPermissions.agentId, agentId),
+              eq(agentPermissions.domain, domain)
+            )
+          ).run();
+        } else {
+          db.insert(agentPermissions).values({ agentId, domain, canRead, canWrite }).run();
+        }
+        return json(res, { agentId, domain, canRead: !!canRead, canWrite: !!canWrite });
+      }
+      if (url === "/api/clear-all" && req.method === "POST") {
+        const timestamp = now();
+        sqlite.prepare(`UPDATE memories SET deleted_at = ? WHERE deleted_at IS NULL`).run(timestamp);
+        return json(res, { cleared: true });
+      }
+      json(res, { error: "Not found" }, 404);
+    } catch (e) {
+      const message = e instanceof Error ? e.message : "Unknown error";
+      json(res, { error: message }, 500);
+    }
+  });
+  server.listen(port, () => {
+  });
+  return server;
+}
+export {
+  startHttpApi
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+declare function startServer(): Promise<void>;
+
+export { startServer };