@cortexkit/opencode-magic-context 0.5.0 → 0.5.2

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;
+    }
+}