engrm 0.3.2 → 0.4.0

package/dist/hooks/session-start.js

@@ -5,9 +5,9 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/config.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir, hostname } from "node:os";
+import { homedir, hostname, networkInterfaces } from "node:os";
 import { join } from "node:path";
-import { randomBytes } from "node:crypto";
+import { createHash } from "node:crypto";
 var CONFIG_DIR = join(homedir(), ".engrm");
 var SETTINGS_PATH = join(CONFIG_DIR, "settings.json");
 var DB_PATH = join(CONFIG_DIR, "engrm.db");
@@ -16,7 +16,22 @@ function getDbPath() {
 }
 function generateDeviceId() {
   const host = hostname().toLowerCase().replace(/[^a-z0-9-]/g, "");
-  const suffix = randomBytes(4).toString("hex");
+  let mac = "";
+  const ifaces = networkInterfaces();
+  for (const entries of Object.values(ifaces)) {
+    if (!entries)
+      continue;
+    for (const entry of entries) {
+      if (!entry.internal && entry.mac && entry.mac !== "00:00:00:00:00:00") {
+        mac = entry.mac;
+        break;
+      }
+    }
+    if (mac)
+      break;
+  }
+  const material = `${host}:${mac || "no-mac"}`;
+  const suffix = createHash("sha256").update(material).digest("hex").slice(0, 8);
   return `${host}-${suffix}`;
 }
 function createDefaultConfig() {
@@ -58,7 +73,10 @@ function createDefaultConfig() {
     observer: {
       enabled: true,
       mode: "per_event",
-      model: "haiku"
+      model: "sonnet"
+    },
+    transcript_analysis: {
+      enabled: false
     }
   };
 }
@@ -117,6 +135,9 @@ function loadConfig() {
       enabled: asBool(config["observer"]?.["enabled"], defaults.observer.enabled),
       mode: asObserverMode(config["observer"]?.["mode"], defaults.observer.mode),
       model: asString(config["observer"]?.["model"], defaults.observer.model)
+    },
+    transcript_analysis: {
+      enabled: asBool(config["transcript_analysis"]?.["enabled"], defaults.transcript_analysis.enabled)
     }
   };
 }
@@ -515,6 +536,56 @@ function runMigrations(db) {
     }
   }
 }
+function ensureObservationTypes(db) {
+  try {
+    db.exec("INSERT INTO observations (session_id, project_id, type, title, user_id, device_id, agent, created_at, created_at_epoch) " + "VALUES ('_typecheck', 1, 'message', '_test', '_test', '_test', '_test', '2000-01-01', 0)");
+    db.exec("DELETE FROM observations WHERE session_id = '_typecheck'");
+  } catch {
+    db.exec("BEGIN TRANSACTION");
+    try {
+      db.exec(`
+        CREATE TABLE observations_repair (
+          id INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT,
+          project_id INTEGER NOT NULL REFERENCES projects(id),
+          type TEXT NOT NULL CHECK (type IN (
+            'bugfix','discovery','decision','pattern','change','feature',
+            'refactor','digest','standard','message')),
+          title TEXT NOT NULL, narrative TEXT, facts TEXT, concepts TEXT,
+          files_read TEXT, files_modified TEXT,
+          quality REAL DEFAULT 0.5 CHECK (quality BETWEEN 0.0 AND 1.0),
+          lifecycle TEXT DEFAULT 'active' CHECK (lifecycle IN ('active','aging','archived','purged','pinned')),
+          sensitivity TEXT DEFAULT 'shared' CHECK (sensitivity IN ('shared','personal','secret')),
+          user_id TEXT NOT NULL, device_id TEXT NOT NULL, agent TEXT DEFAULT 'claude-code',
+          created_at TEXT NOT NULL, created_at_epoch INTEGER NOT NULL,
+          archived_at_epoch INTEGER,
+          compacted_into INTEGER REFERENCES observations(id) ON DELETE SET NULL,
+          superseded_by INTEGER REFERENCES observations(id) ON DELETE SET NULL,
+          remote_source_id TEXT
+        );
+        INSERT INTO observations_repair SELECT * FROM observations;
+        DROP TABLE observations;
+        ALTER TABLE observations_repair RENAME TO observations;
+        CREATE INDEX IF NOT EXISTS idx_observations_project ON observations(project_id);
+        CREATE INDEX IF NOT EXISTS idx_observations_type ON observations(type);
+        CREATE INDEX IF NOT EXISTS idx_observations_created ON observations(created_at_epoch);
+        CREATE INDEX IF NOT EXISTS idx_observations_session ON observations(session_id);
+        CREATE INDEX IF NOT EXISTS idx_observations_lifecycle ON observations(lifecycle);
+        CREATE INDEX IF NOT EXISTS idx_observations_quality ON observations(quality);
+        CREATE INDEX IF NOT EXISTS idx_observations_user ON observations(user_id);
+        CREATE INDEX IF NOT EXISTS idx_observations_superseded ON observations(superseded_by);
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_observations_remote_source ON observations(remote_source_id) WHERE remote_source_id IS NOT NULL;
+        DROP TABLE IF EXISTS observations_fts;
+        CREATE VIRTUAL TABLE observations_fts USING fts5(
+          title, narrative, facts, concepts, content=observations, content_rowid=id
+        );
+        INSERT INTO observations_fts(observations_fts) VALUES('rebuild');
+      `);
+      db.exec("COMMIT");
+    } catch (err) {
+      db.exec("ROLLBACK");
+    }
+  }
+}
 var LATEST_SCHEMA_VERSION = MIGRATIONS.filter((m) => !m.condition).reduce((max, m) => Math.max(max, m.version), 0);
 
 // src/storage/sqlite.ts
@@ -581,6 +652,7 @@ class MemDatabase {
     this.db.exec("PRAGMA foreign_keys = ON");
     this.vecAvailable = this.loadVecExtension();
     runMigrations(this.db);
+    ensureObservationTypes(this.db);
   }
   loadVecExtension() {
     try {
@@ -1058,7 +1130,7 @@ function estimateTokens(text) {
 }
 function buildSessionContext(db, cwd, options = {}) {
   const opts = typeof options === "number" ? { maxCount: options } : options;
-  const tokenBudget = opts.tokenBudget ?? 800;
+  const tokenBudget = opts.tokenBudget ?? 3000;
   const maxCount = opts.maxCount;
   const detected = detectProject(cwd);
   const project = db.getProjectByCanonicalId(detected.canonical_id);
@@ -1080,6 +1152,12 @@ function buildSessionContext(db, cwd, options = {}) {
        AND superseded_by IS NULL
        ORDER BY quality DESC, created_at_epoch DESC
        LIMIT ?`).all(project.id, MAX_PINNED);
+  const MAX_RECENT = 5;
+  const recent = db.db.query(`SELECT * FROM observations
+       WHERE project_id = ? AND lifecycle IN ('active', 'aging')
+       AND superseded_by IS NULL
+       ORDER BY created_at_epoch DESC
+       LIMIT ?`).all(project.id, MAX_RECENT);
   const candidateLimit = maxCount ?? 50;
   const candidates = db.db.query(`SELECT * FROM observations
        WHERE project_id = ? AND lifecycle IN ('active', 'aging')
@@ -1107,6 +1185,12 @@ function buildSessionContext(db, cwd, options = {}) {
     });
   }
   const seenIds = new Set(pinned.map((o) => o.id));
+  const dedupedRecent = recent.filter((o) => {
+    if (seenIds.has(o.id))
+      return false;
+    seenIds.add(o.id);
+    return true;
+  });
   const deduped = candidates.filter((o) => !seenIds.has(o.id));
   for (const obs of crossProjectCandidates) {
     if (!seenIds.has(obs.id)) {
@@ -1123,8 +1207,8 @@ function buildSessionContext(db, cwd, options = {}) {
     return scoreB - scoreA;
   });
   if (maxCount !== undefined) {
-    const remaining = Math.max(0, maxCount - pinned.length);
-    const all = [...pinned, ...sorted.slice(0, remaining)];
+    const remaining = Math.max(0, maxCount - pinned.length - dedupedRecent.length);
+    const all = [...pinned, ...dedupedRecent, ...sorted.slice(0, remaining)];
     return {
       project_name: project.name,
       canonical_id: project.canonical_id,
@@ -1140,6 +1224,11 @@ function buildSessionContext(db, cwd, options = {}) {
     remainingBudget -= cost;
     selected.push(obs);
   }
+  for (const obs of dedupedRecent) {
+    const cost = estimateObservationTokens(obs, selected.length);
+    remainingBudget -= cost;
+    selected.push(obs);
+  }
   for (const obs of sorted) {
     const cost = estimateObservationTokens(obs, selected.length);
     if (remainingBudget - cost < 0 && selected.length > 0)
@@ -1147,7 +1236,7 @@ function buildSessionContext(db, cwd, options = {}) {
     remainingBudget -= cost;
     selected.push(obs);
   }
-  const summaries = db.getRecentSummaries(project.id, 2);
+  const summaries = db.getRecentSummaries(project.id, 5);
   let securityFindings = [];
   try {
     const weekAgo = Math.floor(Date.now() / 1000) - 7 * 86400;
@@ -1167,7 +1256,7 @@ function buildSessionContext(db, cwd, options = {}) {
   };
 }
 function estimateObservationTokens(obs, index) {
-  const DETAILED_THRESHOLD = 3;
+  const DETAILED_THRESHOLD = 5;
   const titleCost = estimateTokens(`- **[${obs.type}]** ${obs.title} (2026-01-01, q=0.5)`);
   if (index >= DETAILED_THRESHOLD) {
     return titleCost;
@@ -1179,7 +1268,7 @@ function formatContextForInjection(context) {
   if (context.observations.length === 0) {
     return `Project: ${context.project_name} (no prior observations)`;
   }
-  const DETAILED_COUNT = 3;
+  const DETAILED_COUNT = 5;
   const lines = [
     `## Project Memory: ${context.project_name}`,
     `${context.session_count} relevant observation(s) from prior sessions:`,
@@ -1466,6 +1555,202 @@ function recommendPacks(stacks, installedPacks) {
   return recommendations;
 }
 
+// src/config.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir2, hostname as hostname2, networkInterfaces as networkInterfaces2 } from "node:os";
+import { join as join5 } from "node:path";
+import { createHash as createHash2 } from "node:crypto";
+var CONFIG_DIR2 = join5(homedir2(), ".engrm");
+var SETTINGS_PATH2 = join5(CONFIG_DIR2, "settings.json");
+var DB_PATH2 = join5(CONFIG_DIR2, "engrm.db");
+function getDbPath2() {
+  return DB_PATH2;
+}
+function generateDeviceId2() {
+  const host = hostname2().toLowerCase().replace(/[^a-z0-9-]/g, "");
+  let mac = "";
+  const ifaces = networkInterfaces2();
+  for (const entries of Object.values(ifaces)) {
+    if (!entries)
+      continue;
+    for (const entry of entries) {
+      if (!entry.internal && entry.mac && entry.mac !== "00:00:00:00:00:00") {
+        mac = entry.mac;
+        break;
+      }
+    }
+    if (mac)
+      break;
+  }
+  const material = `${host}:${mac || "no-mac"}`;
+  const suffix = createHash2("sha256").update(material).digest("hex").slice(0, 8);
+  return `${host}-${suffix}`;
+}
+function createDefaultConfig2() {
+  return {
+    candengo_url: "",
+    candengo_api_key: "",
+    site_id: "",
+    namespace: "",
+    user_id: "",
+    user_email: "",
+    device_id: generateDeviceId2(),
+    teams: [],
+    sync: {
+      enabled: true,
+      interval_seconds: 30,
+      batch_size: 50
+    },
+    search: {
+      default_limit: 10,
+      local_boost: 1.2,
+      scope: "all"
+    },
+    scrubbing: {
+      enabled: true,
+      custom_patterns: [],
+      default_sensitivity: "shared"
+    },
+    sentinel: {
+      enabled: false,
+      mode: "advisory",
+      provider: "openai",
+      model: "gpt-4o-mini",
+      api_key: "",
+      base_url: "",
+      skip_patterns: [],
+      daily_limit: 100,
+      tier: "free"
+    },
+    observer: {
+      enabled: true,
+      mode: "per_event",
+      model: "sonnet"
+    },
+    transcript_analysis: {
+      enabled: false
+    }
+  };
+}
+function loadConfig2() {
+  if (!existsSync5(SETTINGS_PATH2)) {
+    throw new Error(`Config not found at ${SETTINGS_PATH2}. Run 'engrm init --manual' to configure.`);
+  }
+  const raw = readFileSync4(SETTINGS_PATH2, "utf-8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`Invalid JSON in ${SETTINGS_PATH2}`);
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new Error(`Config at ${SETTINGS_PATH2} is not a JSON object`);
+  }
+  const config = parsed;
+  const defaults = createDefaultConfig2();
+  return {
+    candengo_url: asString2(config["candengo_url"], defaults.candengo_url),
+    candengo_api_key: asString2(config["candengo_api_key"], defaults.candengo_api_key),
+    site_id: asString2(config["site_id"], defaults.site_id),
+    namespace: asString2(config["namespace"], defaults.namespace),
+    user_id: asString2(config["user_id"], defaults.user_id),
+    user_email: asString2(config["user_email"], defaults.user_email),
+    device_id: asString2(config["device_id"], defaults.device_id),
+    teams: asTeams2(config["teams"], defaults.teams),
+    sync: {
+      enabled: asBool2(config["sync"]?.["enabled"], defaults.sync.enabled),
+      interval_seconds: asNumber2(config["sync"]?.["interval_seconds"], defaults.sync.interval_seconds),
+      batch_size: asNumber2(config["sync"]?.["batch_size"], defaults.sync.batch_size)
+    },
+    search: {
+      default_limit: asNumber2(config["search"]?.["default_limit"], defaults.search.default_limit),
+      local_boost: asNumber2(config["search"]?.["local_boost"], defaults.search.local_boost),
+      scope: asScope2(config["search"]?.["scope"], defaults.search.scope)
+    },
+    scrubbing: {
+      enabled: asBool2(config["scrubbing"]?.["enabled"], defaults.scrubbing.enabled),
+      custom_patterns: asStringArray2(config["scrubbing"]?.["custom_patterns"], defaults.scrubbing.custom_patterns),
+      default_sensitivity: asSensitivity2(config["scrubbing"]?.["default_sensitivity"], defaults.scrubbing.default_sensitivity)
+    },
+    sentinel: {
+      enabled: asBool2(config["sentinel"]?.["enabled"], defaults.sentinel.enabled),
+      mode: asSentinelMode2(config["sentinel"]?.["mode"], defaults.sentinel.mode),
+      provider: asLlmProvider2(config["sentinel"]?.["provider"], defaults.sentinel.provider),
+      model: asString2(config["sentinel"]?.["model"], defaults.sentinel.model),
+      api_key: asString2(config["sentinel"]?.["api_key"], defaults.sentinel.api_key),
+      base_url: asString2(config["sentinel"]?.["base_url"], defaults.sentinel.base_url),
+      skip_patterns: asStringArray2(config["sentinel"]?.["skip_patterns"], defaults.sentinel.skip_patterns),
+      daily_limit: asNumber2(config["sentinel"]?.["daily_limit"], defaults.sentinel.daily_limit),
+      tier: asTier2(config["sentinel"]?.["tier"], defaults.sentinel.tier)
+    },
+    observer: {
+      enabled: asBool2(config["observer"]?.["enabled"], defaults.observer.enabled),
+      mode: asObserverMode2(config["observer"]?.["mode"], defaults.observer.mode),
+      model: asString2(config["observer"]?.["model"], defaults.observer.model)
+    },
+    transcript_analysis: {
+      enabled: asBool2(config["transcript_analysis"]?.["enabled"], defaults.transcript_analysis.enabled)
+    }
+  };
+}
+function saveConfig(config) {
+  if (!existsSync5(CONFIG_DIR2)) {
+    mkdirSync2(CONFIG_DIR2, { recursive: true });
+  }
+  writeFileSync2(SETTINGS_PATH2, JSON.stringify(config, null, 2) + `
+`, "utf-8");
+}
+function configExists2() {
+  return existsSync5(SETTINGS_PATH2);
+}
+function asString2(value, fallback) {
+  return typeof value === "string" ? value : fallback;
+}
+function asNumber2(value, fallback) {
+  return typeof value === "number" && !Number.isNaN(value) ? value : fallback;
+}
+function asBool2(value, fallback) {
+  return typeof value === "boolean" ? value : fallback;
+}
+function asStringArray2(value, fallback) {
+  return Array.isArray(value) && value.every((v) => typeof v === "string") ? value : fallback;
+}
+function asScope2(value, fallback) {
+  if (value === "personal" || value === "team" || value === "all")
+    return value;
+  return fallback;
+}
+function asSensitivity2(value, fallback) {
+  if (value === "shared" || value === "personal" || value === "secret")
+    return value;
+  return fallback;
+}
+function asSentinelMode2(value, fallback) {
+  if (value === "advisory" || value === "blocking")
+    return value;
+  return fallback;
+}
+function asLlmProvider2(value, fallback) {
+  if (value === "openai" || value === "anthropic" || value === "ollama" || value === "custom")
+    return value;
+  return fallback;
+}
+function asTier2(value, fallback) {
+  if (value === "free" || value === "vibe" || value === "solo" || value === "pro" || value === "team" || value === "enterprise")
+    return value;
+  return fallback;
+}
+function asObserverMode2(value, fallback) {
+  if (value === "per_event" || value === "per_session")
+    return value;
+  return fallback;
+}
+function asTeams2(value, fallback) {
+  if (!Array.isArray(value))
+    return fallback;
+  return value.filter((t) => typeof t === "object" && t !== null && typeof t.id === "string" && typeof t.name === "string" && typeof t.namespace === "string");
+}
+
 // src/sync/auth.ts
 function getApiKey(config) {
   const envKey = process.env.ENGRM_TOKEN;
@@ -1651,6 +1936,44 @@ function extractNarrative(content) {
 `).trim();
   return narrative.length > 0 ? narrative : null;
 }
+async function pullSettings(client, config) {
+  try {
+    const settings = await client.fetchSettings();
+    if (!settings)
+      return false;
+    let changed = false;
+    if (settings.transcript_analysis !== undefined) {
+      const ta = settings.transcript_analysis;
+      if (typeof ta === "object" && ta !== null) {
+        const taObj = ta;
+        if (taObj.enabled !== undefined && taObj.enabled !== config.transcript_analysis.enabled) {
+          config.transcript_analysis.enabled = !!taObj.enabled;
+          changed = true;
+        }
+      }
+    }
+    if (settings.observer !== undefined) {
+      const obs = settings.observer;
+      if (typeof obs === "object" && obs !== null) {
+        const obsObj = obs;
+        if (obsObj.enabled !== undefined && obsObj.enabled !== config.observer.enabled) {
+          config.observer.enabled = !!obsObj.enabled;
+          changed = true;
+        }
+        if (obsObj.model !== undefined && typeof obsObj.model === "string" && obsObj.model !== config.observer.model) {
+          config.observer.model = obsObj.model;
+          changed = true;
+        }
+      }
+    }
+    if (changed) {
+      saveConfig(config);
+    }
+    return changed;
+  } catch {
+    return false;
+  }
+}
 
 // src/sync/client.ts
 class VectorClient {
@@ -1705,6 +2028,13 @@ class VectorClient {
   async sendTelemetry(beacon) {
     await this.request("POST", "/v1/mem/telemetry", beacon);
   }
+  async fetchSettings() {
+    try {
+      return await this.request("GET", "/v1/mem/user-settings");
+    } catch {
+      return null;
+    }
+  }
   async health() {
     try {
       await this.request("GET", "/health");
@@ -1776,11 +2106,12 @@ async function main() {
   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 client = new VectorClient(config);
         const pullResult = await pullFromVector(db, client, config, 50);
         if (pullResult.merged > 0) {
           console.error(`Engrm: synced ${pullResult.merged} observation(s) from server`);
         }
+        await pullSettings(client, config);
       } catch {}
     }
     const context = buildSessionContext(db, event.cwd, {