engrm 0.2.1 → 0.2.2

package/dist/hooks/session-start.js

@@ -1409,6 +1409,288 @@ function recommendPacks(stacks, installedPacks) {
   return recommendations;
 }
 
+// src/sync/auth.ts
+function getApiKey(config) {
+  const envKey = process.env.ENGRM_TOKEN;
+  if (envKey && envKey.startsWith("cvk_"))
+    return envKey;
+  if (config.candengo_api_key && config.candengo_api_key.length > 0) {
+    return config.candengo_api_key;
+  }
+  return null;
+}
+function getBaseUrl(config) {
+  if (config.candengo_url && config.candengo_url.length > 0) {
+    return config.candengo_url;
+  }
+  return null;
+}
+function buildSourceId(config, localId, type = "obs") {
+  return `${config.user_id}-${config.device_id}-${type}-${localId}`;
+}
+function parseSourceId(sourceId) {
+  const obsIndex = sourceId.lastIndexOf("-obs-");
+  if (obsIndex === -1)
+    return null;
+  const prefix = sourceId.slice(0, obsIndex);
+  const localIdStr = sourceId.slice(obsIndex + 5);
+  const localId = parseInt(localIdStr, 10);
+  if (isNaN(localId))
+    return null;
+  const firstDash = prefix.indexOf("-");
+  if (firstDash === -1)
+    return null;
+  return {
+    userId: prefix.slice(0, firstDash),
+    deviceId: prefix.slice(firstDash + 1),
+    localId
+  };
+}
+
+// src/embeddings/embedder.ts
+var _available = null;
+var _pipeline = null;
+var MODEL_NAME = "Xenova/all-MiniLM-L6-v2";
+async function embedText(text) {
+  const pipe = await getPipeline();
+  if (!pipe)
+    return null;
+  try {
+    const output = await pipe(text, { pooling: "mean", normalize: true });
+    return new Float32Array(output.data);
+  } catch {
+    return null;
+  }
+}
+function composeEmbeddingText(obs) {
+  const parts = [obs.title];
+  if (obs.narrative)
+    parts.push(obs.narrative);
+  if (obs.facts) {
+    try {
+      const facts = JSON.parse(obs.facts);
+      if (Array.isArray(facts) && facts.length > 0) {
+        parts.push(facts.map((f) => `- ${f}`).join(`
+`));
+      }
+    } catch {
+      parts.push(obs.facts);
+    }
+  }
+  if (obs.concepts) {
+    try {
+      const concepts = JSON.parse(obs.concepts);
+      if (Array.isArray(concepts) && concepts.length > 0) {
+        parts.push(concepts.join(", "));
+      }
+    } catch {}
+  }
+  return parts.join(`
+
+`);
+}
+async function getPipeline() {
+  if (_pipeline)
+    return _pipeline;
+  if (_available === false)
+    return null;
+  try {
+    const { pipeline } = await import("@xenova/transformers");
+    _pipeline = await pipeline("feature-extraction", MODEL_NAME);
+    _available = true;
+    return _pipeline;
+  } catch (err) {
+    _available = false;
+    console.error(`[engrm] Local embedding model unavailable: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+}
+
+// src/sync/pull.ts
+var PULL_CURSOR_KEY = "pull_cursor";
+var MAX_PAGES = 20;
+async function pullFromVector(db, client, config, limit = 50) {
+  let cursor = db.getSyncState(PULL_CURSOR_KEY) ?? undefined;
+  let totalReceived = 0;
+  let totalMerged = 0;
+  let totalSkipped = 0;
+  for (let page = 0;page < MAX_PAGES; page++) {
+    const response = await client.pullChanges(cursor, limit);
+    const { merged, skipped } = mergeChanges(db, config, response.changes);
+    totalReceived += response.changes.length;
+    totalMerged += merged;
+    totalSkipped += skipped;
+    if (response.cursor) {
+      db.setSyncState(PULL_CURSOR_KEY, response.cursor);
+      cursor = response.cursor;
+    }
+    if (!response.has_more || response.changes.length === 0)
+      break;
+  }
+  return { received: totalReceived, merged: totalMerged, skipped: totalSkipped };
+}
+function mergeChanges(db, config, changes) {
+  let merged = 0;
+  let skipped = 0;
+  for (const change of changes) {
+    const parsed = parseSourceId(change.source_id);
+    if (parsed && parsed.deviceId === config.device_id) {
+      skipped++;
+      continue;
+    }
+    const existing = db.db.query("SELECT id FROM observations WHERE remote_source_id = ?").get(change.source_id);
+    if (existing) {
+      skipped++;
+      continue;
+    }
+    const projectCanonical = change.metadata?.project_canonical ?? null;
+    if (!projectCanonical) {
+      skipped++;
+      continue;
+    }
+    let project = db.getProjectByCanonicalId(projectCanonical);
+    if (!project) {
+      project = db.upsertProject({
+        canonical_id: projectCanonical,
+        name: change.metadata?.project_name ?? projectCanonical.split("/").pop() ?? "unknown"
+      });
+    }
+    const obs = db.insertObservation({
+      session_id: change.metadata?.session_id ?? null,
+      project_id: project.id,
+      type: change.metadata?.type ?? "discovery",
+      title: change.metadata?.title ?? change.content.split(`
+`)[0] ?? "Untitled",
+      narrative: extractNarrative(change.content),
+      facts: change.metadata?.facts ? JSON.stringify(change.metadata.facts) : null,
+      concepts: change.metadata?.concepts ? JSON.stringify(change.metadata.concepts) : null,
+      quality: change.metadata?.quality ?? 0.5,
+      lifecycle: "active",
+      sensitivity: "shared",
+      user_id: change.metadata?.user_id ?? "unknown",
+      device_id: change.metadata?.device_id ?? "unknown",
+      agent: change.metadata?.agent ?? "unknown"
+    });
+    db.db.query("UPDATE observations SET remote_source_id = ? WHERE id = ?").run(change.source_id, obs.id);
+    if (db.vecAvailable) {
+      embedAndInsert(db, obs).catch(() => {});
+    }
+    merged++;
+  }
+  return { merged, skipped };
+}
+async function embedAndInsert(db, obs) {
+  const text = composeEmbeddingText(obs);
+  const embedding = await embedText(text);
+  if (embedding)
+    db.vecInsert(obs.id, embedding);
+}
+function extractNarrative(content) {
+  const lines = content.split(`
+`);
+  if (lines.length <= 1)
+    return null;
+  const narrative = lines.slice(1).join(`
+`).trim();
+  return narrative.length > 0 ? narrative : null;
+}
+
+// src/sync/client.ts
+class VectorClient {
+  baseUrl;
+  apiKey;
+  siteId;
+  namespace;
+  constructor(config) {
+    const baseUrl = getBaseUrl(config);
+    const apiKey = getApiKey(config);
+    if (!baseUrl || !apiKey) {
+      throw new Error("VectorClient requires candengo_url and candengo_api_key");
+    }
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.apiKey = apiKey;
+    this.siteId = config.site_id;
+    this.namespace = config.namespace;
+  }
+  static isConfigured(config) {
+    return getApiKey(config) !== null && getBaseUrl(config) !== null;
+  }
+  async ingest(doc) {
+    await this.request("POST", "/v1/ingest", doc);
+  }
+  async batchIngest(docs) {
+    if (docs.length === 0)
+      return;
+    await this.request("POST", "/v1/ingest/batch", { documents: docs });
+  }
+  async search(query, metadataFilter, limit = 10) {
+    const body = { query, limit };
+    if (metadataFilter) {
+      body.metadata_filter = metadataFilter;
+    }
+    return this.request("POST", "/v1/search", body);
+  }
+  async deleteBySourceIds(sourceIds) {
+    if (sourceIds.length === 0)
+      return;
+    await this.request("POST", "/v1/documents/delete", {
+      source_ids: sourceIds
+    });
+  }
+  async pullChanges(cursor, limit = 50) {
+    const params = new URLSearchParams;
+    if (cursor)
+      params.set("cursor", cursor);
+    params.set("namespace", this.namespace);
+    params.set("limit", String(limit));
+    return this.request("GET", `/v1/sync/changes?${params.toString()}`);
+  }
+  async sendTelemetry(beacon) {
+    await this.request("POST", "/v1/mem/telemetry", beacon);
+  }
+  async health() {
+    try {
+      await this.request("GET", "/health");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      "Content-Type": "application/json"
+    };
+    const init = { method, headers };
+    if (body && method !== "GET") {
+      init.body = JSON.stringify(body);
+    }
+    const response = await fetch(url, init);
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new VectorApiError(response.status, text, path);
+    }
+    if (response.status === 204 || response.headers.get("content-length") === "0") {
+      return;
+    }
+    return response.json();
+  }
+}
+
+class VectorApiError extends Error {
+  status;
+  body;
+  path;
+  constructor(status, body, path) {
+    super(`Vector API error ${status} on ${path}: ${body}`);
+    this.status = status;
+    this.body = body;
+    this.path = path;
+    this.name = "VectorApiError";
+  }
+}
+
 // hooks/session-start.ts
 async function main() {
   const chunks = [];
@@ -1435,6 +1717,15 @@ async function main() {
     process.exit(0);
   }
   try {
+    if (config.sync.enabled && config.candengo_api_key) {
+      try {
+        const client = new VectorClient(config.candengo_url, config.candengo_api_key, config.site_id, config.namespace);
+        const pullResult = await pullFromVector(db, client, config, 50);
+        if (pullResult.merged > 0) {
+          console.error(`Engrm: synced ${pullResult.merged} observation(s) from server`);
+        }
+      } catch {}
+    }
     const context = buildSessionContext(db, event.cwd, {
       tokenBudget: 800,
       scope: config.search.scope

package/dist/hooks/stop.js

@@ -1074,6 +1074,24 @@ function getBaseUrl(config) {
 function buildSourceId(config, localId, type = "obs") {
   return `${config.user_id}-${config.device_id}-${type}-${localId}`;
 }
+function parseSourceId(sourceId) {
+  const obsIndex = sourceId.lastIndexOf("-obs-");
+  if (obsIndex === -1)
+    return null;
+  const prefix = sourceId.slice(0, obsIndex);
+  const localIdStr = sourceId.slice(obsIndex + 5);
+  const localId = parseInt(localIdStr, 10);
+  if (isNaN(localId))
+    return null;
+  const firstDash = prefix.indexOf("-");
+  if (firstDash === -1)
+    return null;
+  return {
+    userId: prefix.slice(0, firstDash),
+    deviceId: prefix.slice(firstDash + 1),
+    localId
+  };
+}
 
 // src/sync/client.ts
 class VectorClient {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "engrm",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Cross-device, team-shared memory layer for AI coding agents",
   "type": "module",
   "main": "dist/server.js",