@cortexkit/opencode-magic-context 0.33.1 → 0.34.1

package/dist/{index-y1c9tcm3.js → index-cn960ffd.js}

@@ -1,3 +1,6 @@
+import {
+  isMidTurn
+} from "./index-fcyvznch.js";
 import {
   sessionLog
 } from "./index-k1esqfwk.js";
@@ -82,6 +85,56 @@ function safeString(value) {
 }
 
 // src/hooks/magic-context/send-session-notification.ts
+var MAX_QUEUED_IGNORED_NOTIFICATIONS = 16;
+var queuedIgnoredNotifications = new Map;
+var flushingIgnoredNotifications = new Set;
+var midTurnDetector = (sessionId) => isMidTurn(undefined, sessionId);
+function queueIgnoredNotification(notification) {
+  const queued = queuedIgnoredNotifications.get(notification.sessionId) ?? [];
+  queued.push(notification);
+  if (queued.length > MAX_QUEUED_IGNORED_NOTIFICATIONS) {
+    queued.splice(0, queued.length - MAX_QUEUED_IGNORED_NOTIFICATIONS);
+    sessionLog(notification.sessionId, `ignored notification queue full; dropped oldest entries (kept newest ${MAX_QUEUED_IGNORED_NOTIFICATIONS})`);
+  }
+  queuedIgnoredNotifications.set(notification.sessionId, queued);
+}
+async function trySendTuiToast(sessionId, text, params, forcePersist) {
+  if (forcePersist)
+    return false;
+  const title = extractToastTitle(text);
+  const message = text.length > 200 ? `${text.slice(0, 200)}…` : text;
+  const toastVariant = inferToastVariant(text);
+  const duration = params.toastDurationMs ?? 5000;
+  const { isTuiConnected: checkTui } = await import("./rpc-notifications-4d22ybn5.js");
+  if (!checkTui(sessionId))
+    return false;
+  try {
+    const { pushNotification } = await import("./rpc-notifications-4d22ybn5.js");
+    pushNotification("toast", {
+      title,
+      message,
+      variant: toastVariant,
+      duration
+    }, sessionId);
+    return true;
+  } catch {
+    sessionLog(sessionId, "TUI RPC toast enqueue failed, falling back to ignored message");
+    return false;
+  }
+}
+var __ignoredNotificationTest = {
+  pendingTexts(sessionId) {
+    return (queuedIgnoredNotifications.get(sessionId) ?? []).map((item) => item.text);
+  },
+  reset() {
+    queuedIgnoredNotifications.clear();
+    flushingIgnoredNotifications.clear();
+    midTurnDetector = (sessionId) => isMidTurn(undefined, sessionId);
+  },
+  setMidTurnDetector(detector) {
+    midTurnDetector = detector;
+  }
+};
 function hasNotificationSessionClient(client) {
   if (client === null || typeof client !== "object")
     return false;
@@ -113,31 +166,20 @@ function extractToastTitle(text) {
     return firstLine;
   return "Magic Context";
 }
-async function sendIgnoredMessage(client, sessionId, text, params, forcePersist = false) {
-  const title = extractToastTitle(text);
-  const message = text.length > 200 ? `${text.slice(0, 200)}…` : text;
-  const toastVariant = inferToastVariant(text);
-  const duration = params.toastDurationMs ?? 5000;
-  const { isTuiConnected: checkTui } = await import("./rpc-notifications-4d22ybn5.js");
-  if (!forcePersist && checkTui(sessionId)) {
-    try {
-      const { pushNotification } = await import("./rpc-notifications-4d22ybn5.js");
-      pushNotification("toast", {
-        title,
-        message,
-        variant: toastVariant,
-        duration
-      }, sessionId);
-      return "sent";
-    } catch {
-      sessionLog(sessionId, "TUI RPC toast enqueue failed, falling back to ignored message");
-    }
+async function sendIgnoredMessageNow(client, sessionId, text, params, forcePersist) {
+  if (midTurnDetector(sessionId)) {
+    queueIgnoredNotification({ client, sessionId, text, params, forcePersist });
+    return "queued";
   }
   const { waitForSafeNotificationTarget } = await import("./safe-notification-target-q9jk5n44.js");
   if (await waitForSafeNotificationTarget(client, sessionId) === "skip") {
     sessionLog(sessionId, "notification skipped (session not titled yet)");
     return "skipped";
   }
+  if (midTurnDetector(sessionId)) {
+    queueIgnoredNotification({ client, sessionId, text, params, forcePersist });
+    return "queued";
+  }
   if (!hasNotificationSessionClient(client)) {
     sessionLog(sessionId, "session prompt API unavailable for notification");
     return "failed";
@@ -157,6 +199,10 @@ async function sendIgnoredMessage(client, sessionId, text, params, forcePersist
       }
     } catch {}
   }
+  if (midTurnDetector(sessionId)) {
+    queueIgnoredNotification({ client, sessionId, text, params, forcePersist });
+    return "queued";
+  }
   const input = {
     path: { id: sessionId },
     body: {
@@ -190,6 +236,41 @@ async function sendIgnoredMessage(client, sessionId, text, params, forcePersist
     return "failed";
   }
 }
+async function sendIgnoredMessage(client, sessionId, text, params, forcePersist = false) {
+  if (await trySendTuiToast(sessionId, text, params, forcePersist))
+    return "sent";
+  if (midTurnDetector(sessionId)) {
+    queueIgnoredNotification({ client, sessionId, text, params, forcePersist });
+    return "queued";
+  }
+  return sendIgnoredMessageNow(client, sessionId, text, params, forcePersist);
+}
+async function flushIgnoredMessages(sessionId) {
+  if (flushingIgnoredNotifications.has(sessionId) || midTurnDetector(sessionId))
+    return;
+  const queued = queuedIgnoredNotifications.get(sessionId);
+  if (!queued || queued.length === 0)
+    return;
+  queuedIgnoredNotifications.delete(sessionId);
+  flushingIgnoredNotifications.add(sessionId);
+  try {
+    for (const notification of queued) {
+      const disposition = await sendIgnoredMessage(notification.client, notification.sessionId, notification.text, notification.params, notification.forcePersist);
+      if (disposition === "queued") {
+        for (const remaining of queued.slice(queued.indexOf(notification) + 1)) {
+          queueIgnoredNotification(remaining);
+        }
+        break;
+      }
+    }
+  } finally {
+    flushingIgnoredNotifications.delete(sessionId);
+  }
+}
+function clearIgnoredMessages(sessionId) {
+  queuedIgnoredNotifications.delete(sessionId);
+  flushingIgnoredNotifications.delete(sessionId);
+}
 async function sendUserPrompt(client, sessionId, text) {
   if (!hasNotificationSessionClient(client)) {
     sessionLog(sessionId, "session prompt API unavailable for user prompt");
@@ -216,4 +297,4 @@ async function sendUserPrompt(client, sessionId, text) {
   }
 }
 
-export { getErrorMessage, describeError, sendIgnoredMessage, sendUserPrompt };
+export { getErrorMessage, describeError, MAX_QUEUED_IGNORED_NOTIFICATIONS, __ignoredNotificationTest, sendIgnoredMessage, flushIgnoredMessages, clearIgnoredMessages, sendUserPrompt };

package/dist/{index-xyaekybw.js → index-dtas91s5.js}

@@ -160,7 +160,8 @@ function getOpenCodeConfigPaths(options) {
 }
 
 // src/shared/conflict-detector.ts
-function detectConflicts(directory) {
+function detectConflicts(directory, options) {
+  const compactionEnabled = options?.compactionEnabled ?? true;
   const conflicts = {
     compactionAuto: false,
     compactionPrune: false,
@@ -171,11 +172,11 @@ function detectConflicts(directory) {
   };
   const reasons = [];
   const compactionResult = checkCompaction(directory);
-  if (compactionResult.auto) {
+  if (compactionEnabled && compactionResult.auto) {
     conflicts.compactionAuto = true;
     reasons.push("OpenCode auto-compaction is enabled (compaction.auto=true)");
   }
-  if (compactionResult.prune) {
+  if (compactionEnabled && compactionResult.prune) {
     conflicts.compactionPrune = true;
     reasons.push("OpenCode prune is enabled (compaction.prune=true)");
   }
@@ -200,7 +201,8 @@ function detectConflicts(directory) {
   return {
     hasConflict: reasons.length > 0,
     reasons,
-    conflicts
+    conflicts,
+    nativeCompaction: { auto: compactionResult.auto, prune: compactionResult.prune }
   };
 }
 function checkCompaction(directory) {

package/dist/index-fcyvznch.js

@@ -0,0 +1,279 @@
+import {
+  log
+} from "./index-k1esqfwk.js";
+import {
+  getDataDir
+} from "./index-kvrcg31b.js";
+
+// src/shared/sqlite-helpers.ts
+function closeQuietly(db) {
+  if (!db)
+    return;
+  try {
+    db.close();
+  } catch {}
+}
+
+// src/hooks/magic-context/read-session-db.ts
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+// src/shared/sqlite.ts
+var isBun = typeof process !== "undefined" && typeof process.versions?.bun === "string";
+var bunSpec = "bun:" + "sqlite";
+var nodeSpec = "node:" + "sqlite";
+var sqliteModule = isBun ? await import(bunSpec) : await import(nodeSpec);
+var DatabaseImpl = isBun ? sqliteModule.Database : buildNodeSqliteDatabaseClass(sqliteModule.DatabaseSync);
+function buildNodeSqliteDatabaseClass(DatabaseSync) {
+  const SAVEPOINT = "mc_tx_sp";
+
+  class NodeSqliteDatabase extends DatabaseSync {
+    constructor(filename, options) {
+      const translated = { ...options };
+      if (options && "readonly" in options) {
+        translated.readOnly = options.readonly;
+        delete translated.readonly;
+      }
+      super(typeof filename === "string" ? filename : ":memory:", translated);
+    }
+    prepare(sql) {
+      const stmt = super.prepare(sql);
+      for (const method of ["run", "get", "all"]) {
+        const original = stmt[method].bind(stmt);
+        stmt[method] = (...args) => args.length === 1 && Array.isArray(args[0]) ? original(...args[0]) : original(...args);
+      }
+      return stmt;
+    }
+    transaction(fn) {
+      const self = this;
+      const execute = (mode, receiver, args) => {
+        const nested = self.isTransaction === true;
+        self.exec(nested ? `SAVEPOINT ${SAVEPOINT}` : `BEGIN${mode ? ` ${mode}` : ""}`);
+        try {
+          const result = fn.apply(receiver, args);
+          self.exec(nested ? `RELEASE ${SAVEPOINT}` : "COMMIT");
+          return result;
+        } catch (error) {
+          if (nested) {
+            self.exec(`ROLLBACK TO ${SAVEPOINT}`);
+            self.exec(`RELEASE ${SAVEPOINT}`);
+          } else {
+            self.exec("ROLLBACK");
+          }
+          throw error;
+        }
+      };
+      const wrapped = function(...args) {
+        return execute("", this, args);
+      };
+      wrapped.default = function(...args) {
+        return execute("", this, args);
+      };
+      wrapped.deferred = function(...args) {
+        return execute("DEFERRED", this, args);
+      };
+      wrapped.immediate = function(...args) {
+        return execute("IMMEDIATE", this, args);
+      };
+      wrapped.exclusive = function(...args) {
+        return execute("EXCLUSIVE", this, args);
+      };
+      return wrapped;
+    }
+  }
+  return NodeSqliteDatabase;
+}
+var Database = DatabaseImpl;
+var privilegeDepth = new WeakMap;
+function isInTransaction(db) {
+  const candidate = db;
+  return candidate.inTransaction === true || candidate.isTransaction === true;
+}
+function withPrivilegedWriter(db, operation) {
+  const previousDepth = privilegeDepth.get(db) ?? 0;
+  const nested = isInTransaction(db);
+  const savepoint = "mc_privilege_scope";
+  if (nested) {
+    db.exec(`SAVEPOINT ${savepoint}`);
+  } else {
+    db.exec("BEGIN IMMEDIATE");
+  }
+  privilegeDepth.set(db, previousDepth + 1);
+  try {
+    db.prepare("INSERT INTO context_privilege_state(id, enabled) VALUES (1, 1) ON CONFLICT(id) DO UPDATE SET enabled = 1").run();
+    const result = operation();
+    if (previousDepth === 0) {
+      db.prepare("UPDATE context_privilege_state SET enabled = 0 WHERE id = 1").run();
+    }
+    if (nested) {
+      db.exec(`RELEASE ${savepoint}`);
+    } else {
+      db.exec("COMMIT");
+    }
+    if (previousDepth > 0)
+      privilegeDepth.set(db, previousDepth);
+    else
+      privilegeDepth.delete(db);
+    return result;
+  } catch (error) {
+    try {
+      if (nested) {
+        db.exec(`ROLLBACK TO ${savepoint}`);
+        db.exec(`RELEASE ${savepoint}`);
+      } else {
+        db.exec("ROLLBACK");
+      }
+    } finally {
+      if (previousDepth > 0)
+        privilegeDepth.set(db, previousDepth);
+      else
+        privilegeDepth.delete(db);
+    }
+    throw error;
+  }
+}
+
+// src/hooks/magic-context/read-session-db.ts
+function getOpenCodeDbPath() {
+  return join(getDataDir(), "opencode", "opencode.db");
+}
+function openCodeDbExists() {
+  return existsSync(getOpenCodeDbPath());
+}
+var cachedReadOnlyDb = null;
+function closeCachedReadOnlyDb() {
+  if (!cachedReadOnlyDb) {
+    return;
+  }
+  try {
+    closeQuietly(cachedReadOnlyDb.db);
+  } catch (error) {
+    log("[magic-context] failed to close cached OpenCode read-only DB:", error);
+  } finally {
+    cachedReadOnlyDb = null;
+  }
+}
+function getReadOnlySessionDb() {
+  const dbPath = getOpenCodeDbPath();
+  if (cachedReadOnlyDb?.path === dbPath) {
+    return cachedReadOnlyDb.db;
+  }
+  closeCachedReadOnlyDb();
+  const db = new Database(dbPath, { readonly: true });
+  cachedReadOnlyDb = { path: dbPath, db };
+  return db;
+}
+function withReadOnlySessionDb(fn) {
+  return fn(getReadOnlySessionDb());
+}
+function getRawSessionMessageCountFromDb(db, sessionId) {
+  const row = db.prepare(`SELECT COUNT(*) as count FROM message WHERE session_id = ?
+             AND NOT (COALESCE(json_extract(data, '$.summary'), 0) = 1
+                      AND COALESCE(json_extract(data, '$.finish'), '') = 'stop')`).get(sessionId);
+  return typeof row?.count === "number" ? row.count : 0;
+}
+function isMidTurn(_deps, sessionId) {
+  try {
+    return withReadOnlySessionDb((db) => isMidTurnFromOpenCodeDb(db, sessionId));
+  } catch (error) {
+    log("[magic-context] failed to inspect OpenCode mid-turn state:", error);
+    return false;
+  }
+}
+function isMidTurnFromOpenCodeDb(db, sessionId) {
+  const latestAssistant = db.prepare(`SELECT id,
+                    json_extract(data, '$.finish') as finish,
+                    time_created as timeCreated
+             FROM message
+             WHERE session_id = ?
+               AND json_extract(data, '$.role') = 'assistant'
+             ORDER BY time_created DESC
+             LIMIT 1`).get(sessionId);
+  if (typeof latestAssistant?.id !== "string")
+    return false;
+  if (hasNewerRealUserMessage(db, sessionId, latestAssistant.timeCreated))
+    return false;
+  if (latestAssistant.finish === "tool-calls")
+    return true;
+  const partRows = db.prepare("SELECT data FROM part WHERE session_id = ? AND message_id = ?").all(sessionId, latestAssistant.id);
+  return partRows.some((row) => {
+    if (typeof row.data !== "string" || row.data.length === 0)
+      return false;
+    try {
+      const part = JSON.parse(row.data);
+      return part.type === "tool" && part.providerExecuted !== true;
+    } catch {
+      return false;
+    }
+  });
+}
+function hasNewerRealUserMessage(db, sessionId, latestAssistantTimeCreated) {
+  if (typeof latestAssistantTimeCreated !== "number")
+    return false;
+  const row = db.prepare(`SELECT 1 as one
+             FROM message m
+             WHERE m.session_id = ?
+               AND m.time_created > ?
+               AND json_extract(m.data, '$.role') = 'user'
+               AND NOT (
+                 EXISTS (SELECT 1 FROM part p WHERE p.message_id = m.id)
+                 AND NOT EXISTS (
+                   SELECT 1 FROM part p
+                   WHERE p.message_id = m.id
+                     AND COALESCE(json_extract(p.data, '$.synthetic'), 0) NOT IN (1, 'true')
+                     AND json_extract(p.data, '$.metadata.marker.kind') IS NULL
+                     AND COALESCE(json_extract(p.data, '$.ignored'), 0) NOT IN (1, 'true')
+                 )
+               )
+             LIMIT 1`).get(sessionId, latestAssistantTimeCreated);
+  return row?.one === 1;
+}
+function getMessageTimesFromOpenCodeDb(sessionId, messageIds) {
+  const result = new Map;
+  if (messageIds.length === 0)
+    return result;
+  try {
+    withReadOnlySessionDb((db) => {
+      const placeholders = messageIds.map(() => "?").join(",");
+      const rows = db.prepare(`SELECT id, time_created FROM message WHERE session_id = ? AND id IN (${placeholders})`).all(sessionId, ...messageIds);
+      for (const row of rows) {
+        if (typeof row.id === "string" && typeof row.time_created === "number") {
+          result.set(row.id, row.time_created);
+        }
+      }
+    });
+  } catch (error) {
+    log("[magic-context] failed to resolve message times from OpenCode DB:", error);
+  }
+  return result;
+}
+function findLastAssistantModelFromOpenCodeDb(sessionId) {
+  try {
+    return withReadOnlySessionDb((db) => {
+      const row = db.prepare(`SELECT json_extract(data, '$.providerID') as providerID,
+                            json_extract(data, '$.modelID') as modelID,
+                            json_extract(data, '$.agent') as agent
+                     FROM message
+                     WHERE session_id = ?
+                       AND json_extract(data, '$.role') = 'assistant'
+                       AND json_extract(data, '$.providerID') IS NOT NULL
+                       AND json_extract(data, '$.modelID') IS NOT NULL
+                     ORDER BY time_created DESC
+                     LIMIT 1`).get(sessionId);
+      if (!row || typeof row.providerID !== "string" || typeof row.modelID !== "string") {
+        return null;
+      }
+      const agent = typeof row.agent === "string" && row.agent.length > 0 ? row.agent : undefined;
+      return {
+        providerID: row.providerID,
+        modelID: row.modelID,
+        ...agent ? { agent } : {}
+      };
+    });
+  } catch (error) {
+    log("[magic-context] failed to recover live model from OpenCode DB:", error);
+    return null;
+  }
+}
+
+export { Database, withPrivilegedWriter, closeQuietly, openCodeDbExists, withReadOnlySessionDb, getRawSessionMessageCountFromDb, isMidTurn, getMessageTimesFromOpenCodeDb, findLastAssistantModelFromOpenCodeDb };