@askexenow/exe-os 0.9.294 → 0.9.296

package/dist/chunk-C2SBESBO.js

@@ -0,0 +1,210 @@
+import {
+  redactSecrets
+} from "./chunk-Y25OJWOQ.js";
+
+// src/lib/memory-write-governor.ts
+import { createHash } from "crypto";
+var HIGH_VALUE_SUPERSESSION_TYPES = /* @__PURE__ */ new Set([
+  "decision",
+  "adr",
+  "behavior",
+  "procedure"
+]);
+var NOISE_DROP_PATTERNS = [
+  /^\s*\[📋\s+\d+\s+reviews?\s+pending\b/im,
+  /^\s*<system-reminder>[\s\S]*?<\/system-reminder>\s*$/im,
+  /^\s*The UserPromptSubmit hook checks the DB for new tasks/im,
+  /^\s*Intercom is a speedup, not delivery/im,
+  /^\s*Context bar reads as USAGE not remaining/im,
+  // Intercom noise — these repeat on every prompt and cause 18K+ duplicates
+  /^\/exe-intercom\b/i,
+  /^You have pending notifications\.\s*Run list_tasks/i,
+  /^You have open tasks\.\s*Run list_tasks/i,
+  /^You have a new P\d+ task/i,
+  /^You have more open tasks to dispatch/i,
+  /^No new tasks\.\s*(Standing by|Idle|Dashboard)/i
+];
+var SKIP_EMBED_PATTERNS = [
+  /tmux capture-pane\b/i,
+  /docker ps\b/i,
+  /docker images\b/i,
+  /git status\b/i,
+  /grep .*node_modules/i,
+  /npm (install|ci)\b[\s\S]*(added \d+ packages|audited \d+ packages)/i
+];
+function normalizeMemoryText(text) {
+  return text.replace(/\r\n/g, "\n").replace(/[ \t]+$/gm, "").replace(/\n{4,}/g, "\n\n\n").trim();
+}
+function classifyMemoryType(input) {
+  if (input.memory_type && input.memory_type.trim()) return input.memory_type.trim();
+  const tool = input.tool_name.toLowerCase();
+  const text = input.raw_text.toLowerCase();
+  if (tool.includes("store_decision") || tool.includes("decision")) return "decision";
+  if (tool.includes("commit") || text.includes("adr-") || text.includes("architectural decision")) return "adr";
+  if (tool.includes("store_behavior") || tool.includes("behavior")) return "behavior";
+  if (tool.includes("global_procedure") || text.includes("organization-wide procedures")) return "procedure";
+  if (tool.includes("checkpoint") || text.startsWith("context checkpoint")) return "checkpoint";
+  if (tool.includes("sessionsummary") || tool.includes("session-summary")) return "summary";
+  if (tool.includes("sessionend") || text.startsWith("session ended")) return "summary";
+  if (tool.includes("send_whatsapp") || tool.includes("conversation")) return "conversation";
+  if (tool === "store_memory" || tool === "manual") return "observation";
+  if (tool === "userprompt" || tool === "slashcommand") return "conversation";
+  return "raw";
+}
+function shouldDropMemory(text) {
+  const normalized = normalizeMemoryText(text);
+  if (normalized.length < 10) return { drop: true, reason: "too_short" };
+  if (NOISE_DROP_PATTERNS.some((pattern) => pattern.test(normalized))) {
+    return { drop: true, reason: "known_boilerplate_noise" };
+  }
+  return { drop: false };
+}
+function shouldSkipEmbedding(input) {
+  const type = classifyMemoryType(input);
+  if (HIGH_VALUE_SUPERSESSION_TYPES.has(type)) return false;
+  if (type === "raw" && input.raw_text.length > 2e4) return true;
+  if (SKIP_EMBED_PATTERNS.some((pattern) => pattern.test(input.raw_text))) return true;
+  return false;
+}
+function hashMemoryContent(text) {
+  return createHash("sha256").update(normalizeMemoryText(text)).digest("hex");
+}
+function scopedDedupArgs(input) {
+  return [input.contentHash, input.agentId, input.projectName, input.memoryType];
+}
+function governMemoryRecord(record) {
+  const redacted = redactSecrets(record.raw_text);
+  const normalized = normalizeMemoryText(redacted.text);
+  const memoryType = classifyMemoryType({
+    raw_text: normalized,
+    agent_id: record.agent_id,
+    project_name: record.project_name,
+    tool_name: record.tool_name,
+    memory_type: record.memory_type
+  });
+  const drop = shouldDropMemory(normalized);
+  const skipEmbedding = shouldSkipEmbedding({
+    raw_text: normalized,
+    agent_id: record.agent_id,
+    project_name: record.project_name,
+    tool_name: record.tool_name,
+    memory_type: memoryType
+  });
+  const trajectoryValue = record.trajectory;
+  const redactedTrajectory = typeof trajectoryValue === "string" ? redactSecrets(trajectoryValue).text : record.trajectory;
+  return {
+    record: {
+      ...record,
+      raw_text: normalized,
+      memory_type: memoryType,
+      vector: skipEmbedding ? null : record.vector,
+      keywords: record.keywords ? redactSecrets(record.keywords).text : record.keywords,
+      trajectory: redactedTrajectory
+    },
+    contentHash: hashMemoryContent(normalized),
+    shouldDrop: drop.drop,
+    dropReason: drop.reason,
+    skipEmbedding,
+    hygiene: {
+      dedup: true,
+      supersession: HIGH_VALUE_SUPERSESSION_TYPES.has(memoryType)
+    }
+  };
+}
+async function findScopedDuplicate(input) {
+  const { getClient } = await import("./lib/database.js");
+  const client = getClient();
+  const args = scopedDedupArgs(input);
+  let sql = `SELECT id FROM memories
+             WHERE content_hash = ?
+               AND agent_id = ?
+               AND project_name = ?
+               AND COALESCE(memory_type, 'raw') = ?
+               AND COALESCE(status, 'active') != 'deleted'`;
+  if (input.excludeId) {
+    sql += " AND id != ?";
+    args.push(input.excludeId);
+  }
+  sql += " ORDER BY timestamp DESC LIMIT 1";
+  const result = await client.execute({ sql, args });
+  return result.rows[0]?.id ? String(result.rows[0].id) : null;
+}
+async function runPostWriteMemoryHygiene(memoryId) {
+  try {
+    const { getClient } = await import("./lib/database.js");
+    const client = getClient();
+    const current = await client.execute({
+      sql: `SELECT id, agent_id, project_name, memory_type, content_hash, supersedes_id,
+                   importance, timestamp
+            FROM memories
+            WHERE id = ?
+            LIMIT 1`,
+      args: [memoryId]
+    });
+    const row = current.rows[0];
+    if (!row) return;
+    const memoryType = String(row.memory_type ?? "raw");
+    const contentHash = row.content_hash ? String(row.content_hash) : null;
+    const agentId = String(row.agent_id);
+    const projectName = String(row.project_name);
+    if (contentHash) {
+      await client.execute({
+        sql: `UPDATE memories
+              SET status = 'deleted',
+                  outcome = COALESCE(outcome, 'superseded')
+              WHERE id != ?
+                AND content_hash = ?
+                AND agent_id = ?
+                AND project_name = ?
+                AND COALESCE(memory_type, 'raw') = ?
+                AND COALESCE(status, 'active') = 'active'`,
+        args: [memoryId, contentHash, agentId, projectName, memoryType]
+      });
+    }
+    const supersedesId = row.supersedes_id ? String(row.supersedes_id) : null;
+    if (supersedesId && HIGH_VALUE_SUPERSESSION_TYPES.has(memoryType)) {
+      const old = await client.execute({
+        sql: `SELECT importance FROM memories WHERE id = ? LIMIT 1`,
+        args: [supersedesId]
+      });
+      const oldImportance = Number(old.rows[0]?.importance ?? 0);
+      const newImportance = Number(row.importance ?? 0);
+      await client.batch([
+        {
+          sql: `UPDATE memories
+                SET status = 'archived',
+                    outcome = COALESCE(outcome, 'superseded')
+                WHERE id = ?`,
+          args: [supersedesId]
+        },
+        {
+          sql: `UPDATE memories
+                SET importance = MAX(COALESCE(importance, 5), ?),
+                    parent_memory_id = COALESCE(parent_memory_id, ?)
+                WHERE id = ?`,
+          args: [Math.max(oldImportance, newImportance), supersedesId, memoryId]
+        }
+      ], "write");
+    }
+  } catch (err) {
+    process.stderr.write(
+      `[memory-governor] post-write hygiene failed for ${memoryId}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+}
+function schedulePostWriteMemoryHygiene(memoryIds) {
+  if (process.env.EXE_SKIP_MEMORY_HYGIENE === "1") return;
+  if (memoryIds.length === 0) return;
+  const run = () => {
+    void Promise.all(memoryIds.map((id) => runPostWriteMemoryHygiene(id)));
+  };
+  if (typeof setImmediate === "function") setImmediate(run);
+  else setTimeout(run, 0);
+}
+
+export {
+  governMemoryRecord,
+  findScopedDuplicate,
+  schedulePostWriteMemoryHygiene
+};

package/dist/chunk-CLSXZUZW.js

@@ -0,0 +1,51 @@
+// src/lib/embeddings-config.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import os from "os";
+import path from "path";
+var EXE_AI_DIR = path.join(os.homedir(), ".exe-os");
+var EMBEDDINGS_SENTINEL_PATH = path.join(EXE_AI_DIR, "embeddings-enabled");
+function parseEmbeddingsEnv(raw) {
+  if (raw === void 0) return null;
+  const v = raw.trim().toLowerCase();
+  if (v === "") return null;
+  if (v === "1" || v === "true") return true;
+  if (v === "0" || v === "false") return false;
+  return null;
+}
+function readSentinel(sentinelPath = EMBEDDINGS_SENTINEL_PATH) {
+  try {
+    if (!existsSync(sentinelPath)) return null;
+    const raw = readFileSync(sentinelPath, "utf8").trim().toLowerCase();
+    if (raw === "0" || raw === "false") return false;
+    return raw === "" || raw === "1" || raw === "true";
+  } catch {
+    return null;
+  }
+}
+function deriveFromLegacyConfig(config) {
+  if (!config) return false;
+  return config.searchMode === "hybrid" || config.hookSearchMode === "hybrid";
+}
+function resolveEmbeddingsEnabled(env, config, sentinelPath = EMBEDDINGS_SENTINEL_PATH) {
+  const envDecision = parseEmbeddingsEnv(env);
+  if (envDecision !== null) return envDecision;
+  const sentinel = readSentinel(sentinelPath);
+  if (sentinel !== null) return sentinel;
+  if (config !== void 0 && config !== null) return deriveFromLegacyConfig(config);
+  return false;
+}
+function setEmbeddingsEnabled(enabled, config, sentinelPath = EMBEDDINGS_SENTINEL_PATH) {
+  try {
+    mkdirSync(path.dirname(sentinelPath), { recursive: true });
+    writeFileSync(sentinelPath, enabled ? "1\n" : "0\n", "utf8");
+  } catch {
+  }
+  config.searchMode = enabled ? "hybrid" : "fts";
+  config.hookSearchMode = enabled ? "hybrid" : "fts";
+  return config;
+}
+
+export {
+  resolveEmbeddingsEnabled,
+  setEmbeddingsEnabled
+};