@cortexkit/opencode-magic-context 0.5.1 → 0.6.0

package/src/shared/normalize-sdk-response.ts

@@ -0,0 +1,40 @@
+export interface NormalizeSDKResponseOptions {
+    preferResponseOnMissingData?: boolean;
+}
+
+// Audit note: `as TData` casts are intentional at this boundary. The OpenCode plugin SDK types
+// external responses as `unknown`. Adding Zod validation here would require schema definitions
+// for every SDK response shape, which changes with each OpenCode release. The fallback parameter
+// provides safe degradation when shapes mismatch.
+export function normalizeSDKResponse<TData>(
+    response: unknown,
+    fallback: TData,
+    options?: NormalizeSDKResponseOptions,
+): TData {
+    if (response === null || response === undefined) {
+        return fallback;
+    }
+
+    if (Array.isArray(response)) {
+        return response as TData;
+    }
+
+    if (typeof response === "object" && "data" in response) {
+        const data = (response as { data?: unknown }).data;
+        if (data !== null && data !== undefined) {
+            return data as TData;
+        }
+
+        if (options?.preferResponseOnMissingData === true) {
+            return response as TData;
+        }
+
+        return fallback;
+    }
+
+    if (options?.preferResponseOnMissingData === true) {
+        return response as TData;
+    }
+
+    return fallback;
+}

package/src/shared/opencode-compaction-detector.test.ts

@@ -0,0 +1,222 @@
+import { afterEach, beforeEach, describe, expect, it, spyOn } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { isOpenCodeAutoCompactionEnabled } from "./opencode-compaction-detector";
+import * as configDir from "./opencode-config-dir";
+
+describe("opencode-compaction-detector", () => {
+    let tmpDir: string;
+
+    beforeEach(() => {
+        tmpDir = join("/tmp", `compaction-detector-test-${Date.now()}`);
+        mkdirSync(join(tmpDir, ".opencode"), { recursive: true });
+        delete process.env.OPENCODE_DISABLE_AUTOCOMPACT;
+        spyOn(configDir, "getOpenCodeConfigPaths").mockReturnValue({
+            configJson: join(tmpDir, "user-config", "opencode.json"),
+            configJsonc: join(tmpDir, "user-config", "opencode.jsonc"),
+        } as ReturnType<typeof configDir.getOpenCodeConfigPaths>);
+    });
+
+    afterEach(() => {
+        rmSync(tmpDir, { recursive: true, force: true });
+        delete process.env.OPENCODE_DISABLE_AUTOCOMPACT;
+    });
+
+    describe("#given no config exists", () => {
+        it("#then returns true (default: compaction enabled)", () => {
+            const emptyDir = join("/tmp", `compaction-empty-${Date.now()}`);
+            mkdirSync(emptyDir, { recursive: true });
+
+            const result = isOpenCodeAutoCompactionEnabled(emptyDir);
+
+            expect(result).toBe(true);
+            rmSync(emptyDir, { recursive: true, force: true });
+        });
+    });
+
+    describe("#given OPENCODE_DISABLE_AUTOCOMPACT env flag is set", () => {
+        it("#then returns false", () => {
+            process.env.OPENCODE_DISABLE_AUTOCOMPACT = "1";
+
+            const result = isOpenCodeAutoCompactionEnabled(tmpDir);
+
+            expect(result).toBe(false);
+        });
+    });
+
+    describe("#given project config has compaction.auto = false", () => {
+        it("#when opencode.json #then returns false", () => {
+            writeFileSync(
+                join(tmpDir, ".opencode", "opencode.json"),
+                JSON.stringify({ compaction: { auto: false } }),
+            );
+
+            const result = isOpenCodeAutoCompactionEnabled(tmpDir);
+
+            expect(result).toBe(false);
+        });
+
+        it("#when opencode.jsonc #then returns false", () => {
+            writeFileSync(
+                join(tmpDir, ".opencode", "opencode.jsonc"),
+                `{
+          // compaction disabled
+          "compaction": { "auto": false }
+        }`,
+            );
+
+            const result = isOpenCodeAutoCompactionEnabled(tmpDir);
+
+            expect(result).toBe(false);
+        });
+    });
+
+    describe("#given project config has compaction.auto = true", () => {
+        it("#then returns true", () => {
+            writeFileSync(
+                join(tmpDir, ".opencode", "opencode.json"),
+                JSON.stringify({ compaction: { auto: true } }),
+            );
+
+            const result = isOpenCodeAutoCompactionEnabled(tmpDir);
+
+            expect(result).toBe(true);
+        });
+    });
+
+    describe("#given project config has compaction.prune = true", () => {
+        it("#then returns true (conflict enabled)", () => {
+            writeFileSync(
+                join(tmpDir, ".opencode", "opencode.json"),
+                JSON.stringify({ compaction: { auto: false, prune: true } }),
+            );
+
+            const result = isOpenCodeAutoCompactionEnabled(tmpDir);
+
+            expect(result).toBe(true);
+        });
+    });
+
+    describe("#given project config has auto/prune both false", () => {
+        it("#then returns false", () => {
+            writeFileSync(
+                join(tmpDir, ".opencode", "opencode.json"),
+                JSON.stringify({ compaction: { auto: false, prune: false } }),
+            );
+
+            const result = isOpenCodeAutoCompactionEnabled(tmpDir);
+
+            expect(result).toBe(false);
+        });
+    });
+
+    describe("#given project config has only compaction.prune = false", () => {
+        it("#then returns false", () => {
+            writeFileSync(
+                join(tmpDir, ".opencode", "opencode.json"),
+                JSON.stringify({ compaction: { prune: false } }),
+            );
+
+            const result = isOpenCodeAutoCompactionEnabled(tmpDir);
+
+            expect(result).toBe(false);
+        });
+    });
+
+    describe("#given jsonc and json both exist", () => {
+        it("#then jsonc takes precedence", () => {
+            writeFileSync(
+                join(tmpDir, ".opencode", "opencode.json"),
+                JSON.stringify({ compaction: { auto: true } }),
+            );
+            writeFileSync(
+                join(tmpDir, ".opencode", "opencode.jsonc"),
+                `{ "compaction": { "auto": false } }`,
+            );
+
+            const result = isOpenCodeAutoCompactionEnabled(tmpDir);
+
+            expect(result).toBe(false);
+        });
+    });
+
+    describe("#given config exists but no compaction field", () => {
+        it("#then returns true (default)", () => {
+            writeFileSync(
+                join(tmpDir, ".opencode", "opencode.json"),
+                JSON.stringify({ model: "claude-opus-4-6" }),
+            );
+
+            const result = isOpenCodeAutoCompactionEnabled(tmpDir);
+
+            expect(result).toBe(true);
+        });
+    });
+
+    describe("#given env flag overrides config", () => {
+        it("#then env flag wins even when config has auto: true", () => {
+            process.env.OPENCODE_DISABLE_AUTOCOMPACT = "true";
+            writeFileSync(
+                join(tmpDir, ".opencode", "opencode.json"),
+                JSON.stringify({ compaction: { auto: true } }),
+            );
+
+            const result = isOpenCodeAutoCompactionEnabled(tmpDir);
+
+            expect(result).toBe(false);
+        });
+    });
+
+    describe("#given root-level project config", () => {
+        it("#when root opencode.json has compaction.auto = false #then returns false", () => {
+            writeFileSync(
+                join(tmpDir, "opencode.json"),
+                JSON.stringify({ compaction: { auto: false } }),
+            );
+
+            const result = isOpenCodeAutoCompactionEnabled(tmpDir);
+
+            expect(result).toBe(false);
+        });
+
+        it("#when root opencode.jsonc has compaction.auto = false #then returns false", () => {
+            writeFileSync(join(tmpDir, "opencode.jsonc"), `{ "compaction": { "auto": false } }`);
+
+            const result = isOpenCodeAutoCompactionEnabled(tmpDir);
+
+            expect(result).toBe(false);
+        });
+    });
+
+    describe("#given .opencode/ overrides root-level config", () => {
+        it("#when root says false but .opencode says true #then .opencode wins", () => {
+            writeFileSync(
+                join(tmpDir, "opencode.json"),
+                JSON.stringify({ compaction: { auto: false } }),
+            );
+            writeFileSync(
+                join(tmpDir, ".opencode", "opencode.json"),
+                JSON.stringify({ compaction: { auto: true } }),
+            );
+
+            const result = isOpenCodeAutoCompactionEnabled(tmpDir);
+
+            expect(result).toBe(true);
+        });
+
+        it("#when root says true but .opencode says false #then .opencode wins", () => {
+            writeFileSync(
+                join(tmpDir, "opencode.json"),
+                JSON.stringify({ compaction: { auto: true } }),
+            );
+            writeFileSync(
+                join(tmpDir, ".opencode", "opencode.json"),
+                JSON.stringify({ compaction: { auto: false } }),
+            );
+
+            const result = isOpenCodeAutoCompactionEnabled(tmpDir);
+
+            expect(result).toBe(false);
+        });
+    });
+});

package/src/shared/opencode-compaction-detector.ts

@@ -0,0 +1,81 @@
+import { join } from "node:path";
+import { readJsoncFile } from "./jsonc-parser";
+import { log } from "./logger";
+import { getOpenCodeConfigPaths } from "./opencode-config-dir";
+
+interface OpenCodeConfig {
+    compaction?: {
+        auto?: boolean;
+        prune?: boolean;
+    };
+}
+
+function hasCompactionConflict(
+    compaction: OpenCodeConfig["compaction"] | undefined,
+): boolean | undefined {
+    if (!compaction) return undefined;
+    const hasExplicitSetting = compaction.auto !== undefined || compaction.prune !== undefined;
+    if (!hasExplicitSetting) return undefined;
+    return compaction.auto === true || compaction.prune === true;
+}
+
+export function isOpenCodeAutoCompactionEnabled(directory: string): boolean {
+    if (process.env.OPENCODE_DISABLE_AUTOCOMPACT) {
+        log(
+            "[compaction-detector] OPENCODE_DISABLE_AUTOCOMPACT env flag set — auto compaction disabled",
+        );
+        return false;
+    }
+
+    const projectCompaction = readProjectCompactionConfig(directory);
+    if (projectCompaction !== undefined) {
+        log("[compaction-detector] project config compaction conflict =", projectCompaction);
+        return projectCompaction;
+    }
+
+    const userCompaction = readUserCompactionConfig(directory);
+    if (userCompaction !== undefined) {
+        log("[compaction-detector] user config compaction conflict =", userCompaction);
+        return userCompaction;
+    }
+
+    log("[compaction-detector] no compaction config found — default is enabled");
+    return true;
+}
+
+function readProjectCompactionConfig(directory: string): boolean | undefined {
+    // .opencode/ dir config has higher precedence than root-level config in OpenCode's loading order.
+    // Check highest precedence first — if .opencode/ sets compaction.auto, that wins.
+    const dotOpenCodeJsonc = join(directory, ".opencode", "opencode.jsonc");
+    const dotOpenCodeJson = join(directory, ".opencode", "opencode.json");
+    const dotOpenCodeConfig =
+        readJsoncFile<OpenCodeConfig>(dotOpenCodeJsonc) ??
+        readJsoncFile<OpenCodeConfig>(dotOpenCodeJson);
+
+    const dotOpenCodeCompactionConflict = hasCompactionConflict(dotOpenCodeConfig?.compaction);
+    if (dotOpenCodeCompactionConflict !== undefined) {
+        return dotOpenCodeCompactionConflict;
+    }
+
+    // Root-level project config (lower precedence than .opencode/)
+    const rootJsonc = join(directory, "opencode.jsonc");
+    const rootJson = join(directory, "opencode.json");
+    const rootConfig =
+        readJsoncFile<OpenCodeConfig>(rootJsonc) ?? readJsoncFile<OpenCodeConfig>(rootJson);
+
+    return hasCompactionConflict(rootConfig?.compaction);
+}
+
+function readUserCompactionConfig(_directory: string): boolean | undefined {
+    try {
+        const paths = getOpenCodeConfigPaths({ binary: "opencode" });
+        const config =
+            readJsoncFile<OpenCodeConfig>(paths.configJsonc) ??
+            readJsoncFile<OpenCodeConfig>(paths.configJson);
+
+        return hasCompactionConflict(config?.compaction);
+    } catch {
+        // Intentional: config read is best-effort; missing/unreadable config is not an error
+        return undefined;
+    }
+}

package/src/shared/opencode-config-dir-types.ts

@@ -0,0 +1,15 @@
+export type OpenCodeBinaryType = "opencode" | "opencode-desktop";
+
+export type OpenCodeConfigDirOptions = {
+    binary: OpenCodeBinaryType;
+    version?: string | null;
+    checkExisting?: boolean;
+};
+
+export type OpenCodeConfigPaths = {
+    configDir: string;
+    configJson: string;
+    configJsonc: string;
+    packageJson: string;
+    omoConfig: string;
+};

package/src/shared/opencode-config-dir.ts

@@ -0,0 +1,38 @@
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+
+import type { OpenCodeConfigDirOptions, OpenCodeConfigPaths } from "./opencode-config-dir-types";
+
+export type {
+    OpenCodeBinaryType,
+    OpenCodeConfigDirOptions,
+    OpenCodeConfigPaths,
+} from "./opencode-config-dir-types";
+
+function getCliConfigDir(): string {
+    const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
+    if (envConfigDir) {
+        return resolve(envConfigDir);
+    }
+
+    if (process.platform === "win32") {
+        return join(homedir(), ".config", "opencode");
+    }
+
+    return join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "opencode");
+}
+
+export function getOpenCodeConfigDir(_options: OpenCodeConfigDirOptions): string {
+    return getCliConfigDir();
+}
+
+export function getOpenCodeConfigPaths(options: OpenCodeConfigDirOptions): OpenCodeConfigPaths {
+    const configDir = getOpenCodeConfigDir(options);
+    return {
+        configDir,
+        configJson: join(configDir, "opencode.json"),
+        configJsonc: join(configDir, "opencode.jsonc"),
+        packageJson: join(configDir, "package.json"),
+        omoConfig: join(configDir, "magic-context.jsonc"),
+    };
+}

package/src/shared/record-type-guard.ts

@@ -0,0 +1,3 @@
+export function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/shared/system-directive.ts

@@ -0,0 +1,9 @@
+const SYSTEM_DIRECTIVE_PREFIX = "[SYSTEM DIRECTIVE: MAGIC-CONTEXT";
+
+export function isSystemDirective(text: string): boolean {
+    return text.trimStart().startsWith(SYSTEM_DIRECTIVE_PREFIX);
+}
+
+export function removeSystemReminders(text: string): string {
+    return text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/gi, "").trim();
+}

package/src/shared/tui-config.ts

@@ -0,0 +1,60 @@
+/**
+ * Auto-configure tui.json with magic-context TUI plugin entry.
+ * Called from the server plugin at startup so the TUI sidebar loads on next restart.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { parse, stringify } from "comment-json";
+import { log } from "./logger";
+import { getOpenCodeConfigPaths } from "./opencode-config-dir";
+
+const PLUGIN_NAME = "@cortexkit/opencode-magic-context";
+const PLUGIN_ENTRY = `${PLUGIN_NAME}@latest`;
+
+function resolveTuiConfigPath(): string {
+    const configDir = getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
+    const jsoncPath = join(configDir, "tui.jsonc");
+    const jsonPath = join(configDir, "tui.json");
+
+    if (existsSync(jsoncPath)) return jsoncPath;
+    if (existsSync(jsonPath)) return jsonPath;
+    return jsonPath; // default: create tui.json
+}
+
+/**
+ * Ensure tui.json has the magic-context TUI plugin entry.
+ * Creates tui.json if it doesn't exist. Silently skips if already present.
+ */
+export function ensureTuiPluginEntry(): boolean {
+    try {
+        const configPath = resolveTuiConfigPath();
+
+        let config: Record<string, unknown> = {};
+        if (existsSync(configPath)) {
+            const raw = readFileSync(configPath, "utf-8");
+            config = (parse(raw) as Record<string, unknown>) ?? {};
+        }
+
+        const plugins = Array.isArray(config.plugin)
+            ? config.plugin.filter((p): p is string => typeof p === "string")
+            : [];
+
+        if (plugins.some((p) => p === PLUGIN_NAME || p.startsWith(`${PLUGIN_NAME}@`))) {
+            return false; // Already present
+        }
+
+        plugins.push(PLUGIN_ENTRY);
+        config.plugin = plugins;
+
+        mkdirSync(dirname(configPath), { recursive: true });
+        writeFileSync(configPath, `${stringify(config, null, 2)}\n`);
+        log(`[magic-context] added TUI plugin entry to ${configPath}`);
+        return true;
+    } catch (error) {
+        log(
+            `[magic-context] failed to update tui.json: ${error instanceof Error ? error.message : String(error)}`,
+        );
+        return false;
+    }
+}

package/src/tui/data/context-db.ts

@@ -70,11 +70,11 @@ function getDb(): Database | null {
         return cachedDb;
     }
     try {
-        // Open without readonly flag — WAL-mode DBs need read-write access to the
-        // -shm file even for read-only queries. We never write from the TUI process.
+        // Open read-write: WAL-mode DBs need write access to the -shm file,
+        // and the TUI writes to plugin_messages for the message bus.
         cachedDb = new Database(targetPath);
         cachedDb.exec("PRAGMA journal_mode = WAL");
-        cachedDb.exec("PRAGMA query_only = ON");
+        cachedDb.exec("PRAGMA busy_timeout = 3000");
         dbPath = targetPath;
         return cachedDb;
     } catch (err) {
@@ -233,7 +233,7 @@ export function loadSidebarSnapshot(sessionId: string, directory: string): Sideb
         try {
             const noteRow = db
                 .query<{ count: number }, [string]>(
-                    `SELECT COUNT(*) as count FROM notes WHERE session_id = ?`,
+                    `SELECT COUNT(*) as count FROM notes WHERE session_id = ? AND type = 'session' AND status = 'active'`,
                 )
                 .get(sessionId);
             sessionNoteCount = noteRow?.count ?? 0;
@@ -247,12 +247,12 @@ export function loadSidebarSnapshot(sessionId: string, directory: string): Sideb
             try {
                 const smartRow = db
                     .query<{ count: number }, [string]>(
-                        `SELECT COUNT(*) as count FROM smart_notes WHERE project_path = ? AND status = 'ready'`,
+                        `SELECT COUNT(*) as count FROM notes WHERE project_path = ? AND type = 'smart' AND status = 'ready'`,
                     )
                     .get(projectIdentity);
                 readySmartNoteCount = smartRow?.count ?? 0;
             } catch {
-                // smart_notes table may not exist
+                // notes table may not exist
             }
         }
 
@@ -582,3 +582,111 @@ function readMagicContextConfig(directory: string): Record<string, unknown> | nu
     }
     return null;
 }
+
+/**
+ * Get compartment count for a session (used by recomp confirmation dialog).
+ */
+export function getCompartmentCount(sessionId: string): number {
+    const db = getDb();
+    if (!db) return 0;
+    try {
+        const row = db
+            .prepare("SELECT COUNT(*) as count FROM compartments WHERE session_id = ?")
+            .get(sessionId) as { count: number } | null;
+        return row?.count ?? 0;
+    } catch {
+        return 0;
+    }
+}
+
+/**
+ * Consume pending server→TUI messages from the plugin_messages table.
+ * Returns consumed messages and marks them as consumed.
+ */
+export interface TuiMessage {
+    id: number;
+    type: string;
+    payload: Record<string, unknown>;
+    sessionId: string | null;
+    createdAt: number;
+}
+
+export function consumeTuiMessages(): TuiMessage[] {
+    const db = getDb();
+    if (!db) return [];
+
+    try {
+        // Check if plugin_messages table exists (migration may not have run yet)
+        const tableCheck = db
+            .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='plugin_messages'")
+            .get();
+        if (!tableCheck) return [];
+
+        const now = Date.now();
+        const rows = db
+            .prepare(
+                "SELECT id, type, payload, session_id, created_at FROM plugin_messages WHERE direction = 'server_to_tui' AND consumed_at IS NULL ORDER BY created_at ASC",
+            )
+            .all() as Array<{
+            id: number;
+            type: string;
+            payload: string;
+            session_id: string | null;
+            created_at: number;
+        }>;
+
+        if (rows.length === 0) return [];
+
+        const ids = rows.map((r) => r.id);
+        db.prepare(
+            `UPDATE plugin_messages SET consumed_at = ? WHERE id IN (${ids.map(() => "?").join(",")})`,
+        ).run(now, ...ids);
+
+        // Cleanup old messages
+        db.prepare("DELETE FROM plugin_messages WHERE created_at < ?").run(now - 5 * 60 * 1000);
+
+        return rows.map((r) => {
+            let payload: Record<string, unknown> = {};
+            try {
+                payload = JSON.parse(r.payload);
+            } catch {
+                // Intentional: malformed payload treated as empty
+            }
+            return {
+                id: r.id,
+                type: r.type,
+                payload,
+                sessionId: r.session_id,
+                createdAt: r.created_at,
+            };
+        });
+    } catch {
+        return [];
+    }
+}
+
+/**
+ * Send a message from TUI to server via plugin_messages.
+ */
+export function sendMessageToServer(
+    type: string,
+    payload: Record<string, unknown>,
+    sessionId?: string,
+): boolean {
+    const db = getDb();
+    if (!db) return false;
+
+    try {
+        const tableCheck = db
+            .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='plugin_messages'")
+            .get();
+        if (!tableCheck) return false;
+
+        db.prepare(
+            "INSERT INTO plugin_messages (direction, type, payload, session_id, created_at) VALUES (?, ?, ?, ?, ?)",
+        ).run("tui_to_server", type, JSON.stringify(payload), sessionId ?? null, Date.now());
+        return true;
+    } catch {
+        return false;
+    }
+}