@cortexkit/opencode-magic-context 0.5.1 → 0.5.2

package/dist/cli/doctor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/cli/doctor.ts"],"names":[],"mappings":"AAWA,wBAAsB,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC,CAwHjD"}
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/cli/doctor.ts"],"names":[],"mappings":"AAYA,wBAAsB,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC,CAwHjD"}

package/dist/cli/setup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../src/cli/setup.ts"],"names":[],"mappings":"AA4JA,wBAAsB,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC,CAyPhD"}
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../src/cli/setup.ts"],"names":[],"mappings":"AA6JA,wBAAsB,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC,CAyPhD"}

package/dist/cli.js

@@ -8368,6 +8368,7 @@ if (!isTestEnv) {
 
 // src/shared/tui-config.ts
 var PLUGIN_NAME = "@cortexkit/opencode-magic-context";
+var PLUGIN_ENTRY = `${PLUGIN_NAME}@latest`;
 function resolveTuiConfigPath() {
   const configDir = getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
   const jsoncPath = join5(configDir, "tui.jsonc");
@@ -8390,7 +8391,7 @@ function ensureTuiPluginEntry() {
     if (plugins.some((p) => p === PLUGIN_NAME || p.startsWith(`${PLUGIN_NAME}@`))) {
       return false;
     }
-    plugins.push(PLUGIN_NAME);
+    plugins.push(PLUGIN_ENTRY);
     config.plugin = plugins;
     mkdirSync2(dirname2(configPath), { recursive: true });
     writeFileSync2(configPath, `${import_comment_json.stringify(config, null, 2)}
@@ -9595,6 +9596,7 @@ async function selectOne(message, options) {
 
 // src/cli/doctor.ts
 var PLUGIN_NAME2 = "@cortexkit/opencode-magic-context";
+var PLUGIN_ENTRY_WITH_VERSION = `${PLUGIN_NAME2}@latest`;
 async function runDoctor() {
   Wt2("Magic Context Doctor");
   let issues = 0;
@@ -9628,7 +9630,7 @@ async function runDoctor() {
       if (hasPlugin) {
         R2.success(`Plugin registered in ${configName}`);
       } else {
-        const updatedPlugins = [...plugins, PLUGIN_NAME2];
+        const updatedPlugins = [...plugins, PLUGIN_ENTRY_WITH_VERSION];
         config.plugin = updatedPlugins;
         writeFileSync3(paths.opencodeConfig, `${import_comment_json2.stringify(config, null, 2)}
 `);
@@ -9691,6 +9693,7 @@ var import_comment_json3 = __toESM(require_src2(), 1);
 import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
 import { dirname as dirname3 } from "node:path";
 var PLUGIN_NAME3 = "@cortexkit/opencode-magic-context";
+var PLUGIN_ENTRY2 = "@cortexkit/opencode-magic-context@latest";
 function ensureDir(dir) {
   if (!existsSync6(dir)) {
     mkdirSync3(dir, { recursive: true });
@@ -9709,7 +9712,7 @@ function addPluginToOpenCodeConfig(configPath, format) {
   ensureDir(dirname3(configPath));
   if (format === "none") {
     const config = {
-      plugin: [PLUGIN_NAME3],
+      plugin: [PLUGIN_ENTRY2],
       compaction: { auto: false, prune: false }
     };
     writeFileSync4(configPath, `${import_comment_json3.stringify(config, null, 2)}
@@ -9724,7 +9727,7 @@ function addPluginToOpenCodeConfig(configPath, format) {
   const plugins = existing.plugin ?? [];
   const hasPlugin = plugins.some((p) => p === PLUGIN_NAME3 || p.startsWith(`${PLUGIN_NAME3}@`));
   if (!hasPlugin) {
-    plugins.push(PLUGIN_NAME3);
+    plugins.push(PLUGIN_ENTRY2);
   }
   existing.plugin = plugins;
   const compaction = existing.compaction ?? {};
@@ -9737,7 +9740,7 @@ function addPluginToOpenCodeConfig(configPath, format) {
 function addPluginToTuiConfig(configPath, format) {
   ensureDir(dirname3(configPath));
   if (format === "none") {
-    writeFileSync4(configPath, `${import_comment_json3.stringify({ plugin: [PLUGIN_NAME3] }, null, 2)}
+    writeFileSync4(configPath, `${import_comment_json3.stringify({ plugin: [PLUGIN_ENTRY2] }, null, 2)}
 `);
     return;
   }
@@ -9749,7 +9752,7 @@ function addPluginToTuiConfig(configPath, format) {
   const plugins = existing.plugin ?? [];
   const hasPlugin = plugins.some((p) => p === PLUGIN_NAME3 || p.startsWith(`${PLUGIN_NAME3}@`));
   if (!hasPlugin) {
-    plugins.push(PLUGIN_NAME3);
+    plugins.push(PLUGIN_ENTRY2);
   }
   existing.plugin = plugins;
   writeFileSync4(configPath, `${import_comment_json3.stringify(existing, null, 2)}

package/dist/index.js

@@ -8502,7 +8502,7 @@ function ensureTuiPluginEntry() {
     if (plugins.some((p) => p === PLUGIN_NAME || p.startsWith(`${PLUGIN_NAME}@`))) {
       return false;
     }
-    plugins.push(PLUGIN_NAME);
+    plugins.push(PLUGIN_ENTRY);
     config2.plugin = plugins;
     mkdirSync3(dirname(configPath), { recursive: true });
     writeFileSync2(configPath, `${import_comment_json.stringify(config2, null, 2)}
@@ -8514,11 +8514,12 @@ function ensureTuiPluginEntry() {
     return false;
   }
 }
-var import_comment_json, PLUGIN_NAME = "@cortexkit/opencode-magic-context";
+var import_comment_json, PLUGIN_NAME = "@cortexkit/opencode-magic-context", PLUGIN_ENTRY;
 var init_tui_config = __esm(() => {
   init_logger();
   init_opencode_config_dir();
   import_comment_json = __toESM(require_src2(), 1);
+  PLUGIN_ENTRY = `${PLUGIN_NAME}@latest`;
 });
 
 // src/agents/dreamer.ts

package/dist/shared/tui-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tui-config.d.ts","sourceRoot":"","sources":["../../src/shared/tui-config.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAoBH;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CA+B9C"}
+{"version":3,"file":"tui-config.d.ts","sourceRoot":"","sources":["../../src/shared/tui-config.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAqBH;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CA+B9C"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/opencode-magic-context",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "type": "module",
   "description": "OpenCode plugin for Magic Context — cross-session memory and context management",
   "main": "dist/index.js",
@@ -28,6 +28,7 @@
   "files": [
     "dist",
     "src/tui",
+    "src/shared",
     "README.md"
   ],
   "scripts": {

package/src/shared/assistant-message-extractor.ts

@@ -0,0 +1,74 @@
+type MessageTime = { created?: number };
+
+type MessageInfo = {
+    role?: string;
+    time?: MessageTime;
+};
+
+type MessagePart = {
+    type?: string;
+    text?: string;
+};
+
+type SessionMessage = {
+    info?: MessageInfo;
+    parts?: unknown;
+};
+
+import { isRecord } from "./record-type-guard";
+
+function asSessionMessage(value: unknown): SessionMessage | null {
+    if (!isRecord(value)) return null;
+    const info = value.info;
+    const parts = value.parts;
+    return {
+        info: isRecord(info)
+            ? {
+                  role: typeof info.role === "string" ? info.role : undefined,
+                  time: isRecord(info.time)
+                      ? {
+                            created:
+                                typeof info.time.created === "number"
+                                    ? info.time.created
+                                    : undefined,
+                        }
+                      : undefined,
+              }
+            : undefined,
+        parts,
+    };
+}
+
+function getCreatedTime(message: SessionMessage): number {
+    return message.info?.time?.created ?? 0;
+}
+
+function getTextParts(message: SessionMessage): MessagePart[] {
+    if (!Array.isArray(message.parts)) return [];
+    return message.parts
+        .filter((part): part is Record<string, unknown> => isRecord(part))
+        .map((part) => ({
+            type: typeof part.type === "string" ? part.type : undefined,
+            text: typeof part.text === "string" ? part.text : undefined,
+        }))
+        .filter((part) => part.type === "text" && Boolean(part.text));
+}
+
+export function extractLatestAssistantText(messages: unknown): string | null {
+    if (!Array.isArray(messages) || messages.length === 0) return null;
+
+    const assistantMessages = messages
+        .map(asSessionMessage)
+        .filter((message): message is SessionMessage => message !== null)
+        .filter((message) => message.info?.role === "assistant")
+        .sort((a, b) => getCreatedTime(b) - getCreatedTime(a));
+
+    const latest = assistantMessages[0];
+    if (!latest) return null;
+
+    return (
+        getTextParts(latest)
+            .map((part) => part.text)
+            .join("\n") || null
+    );
+}

package/src/shared/conflict-detector.ts

@@ -0,0 +1,310 @@
+import { join } from "node:path";
+import { readJsoncFile } from "./jsonc-parser";
+import { getOpenCodeConfigPaths } from "./opencode-config-dir";
+
+interface OpenCodeConfig {
+    compaction?: {
+        auto?: boolean;
+        prune?: boolean;
+    };
+    plugin?: string[];
+}
+
+interface OmoConfig {
+    disabled_hooks?: string[];
+}
+
+export interface ConflictResult {
+    /** Whether any blocking conflict was found */
+    hasConflict: boolean;
+    /** Human-readable reasons for each conflict */
+    reasons: string[];
+    /** Which conflicts were found — used for targeted fixes */
+    conflicts: {
+        compactionAuto: boolean;
+        compactionPrune: boolean;
+        dcpPlugin: boolean;
+        omoPreemptiveCompaction: boolean;
+        omoContextWindowMonitor: boolean;
+        omoAnthropicRecovery: boolean;
+    };
+}
+
+/**
+ * Detect all conflicts that would prevent magic-context from working correctly.
+ * Checks: OpenCode compaction, DCP plugin, OMO conflicting hooks.
+ */
+export function detectConflicts(directory: string): ConflictResult {
+    const conflicts: ConflictResult["conflicts"] = {
+        compactionAuto: false,
+        compactionPrune: false,
+        dcpPlugin: false,
+        omoPreemptiveCompaction: false,
+        omoContextWindowMonitor: false,
+        omoAnthropicRecovery: false,
+    };
+    const reasons: string[] = [];
+
+    // --- Check OpenCode compaction config ---
+    const compactionResult = checkCompaction(directory);
+    if (compactionResult.auto) {
+        conflicts.compactionAuto = true;
+        reasons.push("OpenCode auto-compaction is enabled (compaction.auto=true)");
+    }
+    if (compactionResult.prune) {
+        conflicts.compactionPrune = true;
+        reasons.push("OpenCode prune is enabled (compaction.prune=true)");
+    }
+
+    // --- Check for DCP plugin ---
+    const dcpFound = checkDcpPlugin(directory);
+    if (dcpFound) {
+        conflicts.dcpPlugin = true;
+        reasons.push(
+            "opencode-dcp plugin is installed — it conflicts with Magic Context's context management",
+        );
+    }
+
+    // --- Check OMO conflicting hooks ---
+    const omoResult = checkOmoHooks(directory);
+    if (omoResult.preemptiveCompaction) {
+        conflicts.omoPreemptiveCompaction = true;
+        reasons.push(
+            "oh-my-opencode preemptive-compaction hook is active — it triggers compaction that conflicts with historian",
+        );
+    }
+    if (omoResult.contextWindowMonitor) {
+        conflicts.omoContextWindowMonitor = true;
+        reasons.push(
+            "oh-my-opencode context-window-monitor hook is active — it injects usage warnings that overlap with Magic Context nudges",
+        );
+    }
+    if (omoResult.anthropicRecovery) {
+        conflicts.omoAnthropicRecovery = true;
+        reasons.push(
+            "oh-my-opencode anthropic-context-window-limit-recovery hook is active — it triggers emergency compaction that bypasses historian",
+        );
+    }
+
+    return {
+        hasConflict: reasons.length > 0,
+        reasons,
+        conflicts,
+    };
+}
+
+// --- Compaction detection (extracted from opencode-compaction-detector.ts) ---
+
+function checkCompaction(directory: string): { auto: boolean; prune: boolean } {
+    if (process.env.OPENCODE_DISABLE_AUTOCOMPACT) {
+        return { auto: false, prune: false };
+    }
+
+    // Check project-level config first (higher precedence)
+    const projectResult = readProjectCompaction(directory);
+    if (projectResult.resolved) return projectResult;
+
+    // Fall back to user-level config
+    const userResult = readUserCompaction();
+    if (userResult.resolved) return userResult;
+
+    // Default: OpenCode has compaction enabled by default
+    return { auto: true, prune: false };
+}
+
+function readProjectCompaction(directory: string): {
+    auto: boolean;
+    prune: boolean;
+    resolved: boolean;
+} {
+    // .opencode/ config has higher precedence
+    const dotOcJsonc = join(directory, ".opencode", "opencode.jsonc");
+    const dotOcJson = join(directory, ".opencode", "opencode.json");
+    const dotOcConfig =
+        readJsoncFile<OpenCodeConfig>(dotOcJsonc) ?? readJsoncFile<OpenCodeConfig>(dotOcJson);
+
+    if (dotOcConfig?.compaction) {
+        const c = dotOcConfig.compaction;
+        if (c.auto !== undefined || c.prune !== undefined) {
+            return { auto: c.auto === true, prune: c.prune === true, resolved: true };
+        }
+    }
+
+    // Root-level project config
+    const rootJsonc = join(directory, "opencode.jsonc");
+    const rootJson = join(directory, "opencode.json");
+    const rootConfig =
+        readJsoncFile<OpenCodeConfig>(rootJsonc) ?? readJsoncFile<OpenCodeConfig>(rootJson);
+
+    if (rootConfig?.compaction) {
+        const c = rootConfig.compaction;
+        if (c.auto !== undefined || c.prune !== undefined) {
+            return { auto: c.auto === true, prune: c.prune === true, resolved: true };
+        }
+    }
+
+    return { auto: false, prune: false, resolved: false };
+}
+
+function readUserCompaction(): { auto: boolean; prune: boolean; resolved: boolean } {
+    try {
+        const paths = getOpenCodeConfigPaths({ binary: "opencode" });
+        const config =
+            readJsoncFile<OpenCodeConfig>(paths.configJsonc) ??
+            readJsoncFile<OpenCodeConfig>(paths.configJson);
+
+        if (config?.compaction) {
+            const c = config.compaction;
+            if (c.auto !== undefined || c.prune !== undefined) {
+                return { auto: c.auto === true, prune: c.prune === true, resolved: true };
+            }
+        }
+    } catch {
+        // Intentional: config read is best-effort
+    }
+    return { auto: false, prune: false, resolved: false };
+}
+
+// --- DCP detection ---
+
+function checkDcpPlugin(directory: string): boolean {
+    const plugins = collectPluginEntries(directory);
+    return plugins.some((p) => p.includes("opencode-dcp"));
+}
+
+function collectPluginEntries(directory: string): string[] {
+    const plugins: string[] = [];
+
+    // Project-level configs
+    for (const configPath of [
+        join(directory, ".opencode", "opencode.jsonc"),
+        join(directory, ".opencode", "opencode.json"),
+        join(directory, "opencode.jsonc"),
+        join(directory, "opencode.json"),
+    ]) {
+        const config = readJsoncFile<OpenCodeConfig>(configPath);
+        if (config?.plugin) {
+            plugins.push(...config.plugin);
+        }
+    }
+
+    // User-level config
+    try {
+        const paths = getOpenCodeConfigPaths({ binary: "opencode" });
+        for (const configPath of [paths.configJsonc, paths.configJson]) {
+            const config = readJsoncFile<OpenCodeConfig>(configPath);
+            if (config?.plugin) {
+                plugins.push(...config.plugin);
+            }
+        }
+    } catch {
+        // best-effort
+    }
+
+    return plugins;
+}
+
+// --- OMO hook detection ---
+
+function checkOmoHooks(directory: string): {
+    preemptiveCompaction: boolean;
+    contextWindowMonitor: boolean;
+    anthropicRecovery: boolean;
+} {
+    const result = {
+        preemptiveCompaction: false,
+        contextWindowMonitor: false,
+        anthropicRecovery: false,
+    };
+
+    // First check if OMO is even installed
+    const plugins = collectPluginEntries(directory);
+    const hasOmo = plugins.some(
+        (p) =>
+            p.includes("oh-my-opencode") ||
+            p.includes("oh-my-openagent") ||
+            p.includes("@code-yeongyu/"),
+    );
+    if (!hasOmo) return result;
+
+    // Read OMO config to check disabled_hooks
+    const disabledHooks = readOmoDisabledHooks(directory);
+
+    // Hooks are ACTIVE unless explicitly in disabled_hooks
+    result.preemptiveCompaction = !disabledHooks.has("preemptive-compaction");
+    result.contextWindowMonitor = !disabledHooks.has("context-window-monitor");
+    result.anthropicRecovery = !disabledHooks.has("anthropic-context-window-limit-recovery");
+
+    return result;
+}
+
+function readOmoDisabledHooks(directory: string): Set<string> {
+    const disabled = new Set<string>();
+
+    // Check both old and new OMO config names
+    const configNames = [
+        "oh-my-opencode.jsonc",
+        "oh-my-opencode.json",
+        "oh-my-openagent.jsonc",
+        "oh-my-openagent.json",
+    ];
+
+    try {
+        const paths = getOpenCodeConfigPaths({ binary: "opencode" });
+        for (const name of configNames) {
+            const configPath = join(paths.configDir, name);
+            const config = readJsoncFile<OmoConfig>(configPath);
+            if (config?.disabled_hooks) {
+                for (const hook of config.disabled_hooks) {
+                    disabled.add(hook);
+                }
+            }
+        }
+    } catch {
+        // best-effort
+    }
+
+    // Also check project-level OMO configs
+    for (const name of configNames) {
+        const config = readJsoncFile<OmoConfig>(join(directory, name));
+        if (config?.disabled_hooks) {
+            for (const hook of config.disabled_hooks) {
+                disabled.add(hook);
+            }
+        }
+    }
+
+    return disabled;
+}
+
+/**
+ * Generate a user-facing summary of conflicts for display in dialogs/notifications.
+ */
+export function formatConflictSummary(result: ConflictResult): string {
+    if (!result.hasConflict) return "";
+
+    const lines = [
+        "⚠️ Magic Context is disabled due to conflicting configuration:\n",
+        ...result.reasons.map((r) => `  • ${r}`),
+        "",
+        "Run `bunx @cortexkit/opencode-magic-context doctor` to fix,",
+        "or resolve these conflicts manually in your OpenCode config.",
+    ];
+    return lines.join("\n");
+}
+
+/**
+ * Generate a short conflict summary for ignored message display.
+ */
+export function formatConflictShort(result: ConflictResult): string {
+    if (!result.hasConflict) return "";
+
+    const lines = [
+        "⚠️ Magic Context is disabled due to conflicting configuration:",
+        "",
+        ...result.reasons.map((r) => `• ${r}`),
+        "",
+        "Fix: run `bunx @cortexkit/opencode-magic-context doctor`",
+    ];
+    return lines.join("\n");
+}