@cortexkit/opencode-magic-context 0.5.1 → 0.5.2

package/src/shared/conflict-fixer.ts

@@ -0,0 +1,216 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+import type { ConflictResult } from "./conflict-detector";
+import { readJsoncFile } from "./jsonc-parser";
+import { getOpenCodeConfigPaths } from "./opencode-config-dir";
+
+type JsonObject = Record<string, unknown>;
+
+const CONFLICTING_OMO_HOOKS = [
+    "context-window-monitor",
+    "preemptive-compaction",
+    "anthropic-context-window-limit-recovery",
+] as const;
+
+const OMO_CONFIG_NAMES = [
+    "oh-my-openagent.jsonc",
+    "oh-my-openagent.json",
+    "oh-my-opencode.jsonc",
+    "oh-my-opencode.json",
+] as const;
+
+function ensureParentDir(filePath: string): void {
+    mkdirSync(dirname(filePath), { recursive: true });
+}
+
+function isRecord(value: unknown): value is JsonObject {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function asStringArray(value: unknown): string[] {
+    return Array.isArray(value)
+        ? value.filter((item): item is string => typeof item === "string")
+        : [];
+}
+
+function readConfig(filePath: string): JsonObject | null {
+    if (!existsSync(filePath)) {
+        return {};
+    }
+
+    return readJsoncFile<JsonObject>(filePath);
+}
+
+// Intentional: conflict-fixer uses JSON.stringify (not comment-json) because this module
+// is imported by the TUI process which loads raw source and cannot resolve npm dependencies.
+// Comment preservation for config writes is handled by the CLI paths (doctor.ts, setup.ts).
+function writeConfig(filePath: string, config: JsonObject): void {
+    ensureParentDir(filePath);
+    writeFileSync(filePath, `${JSON.stringify(config, null, 2)}\n`);
+}
+
+function resolveUserOpenCodeConfigPath(): string {
+    const paths = getOpenCodeConfigPaths({ binary: "opencode" });
+    if (existsSync(paths.configJsonc)) return paths.configJsonc;
+    return paths.configJson;
+}
+
+function collectOpenCodeConfigPaths(directory: string): string[] {
+    const paths = new Set<string>();
+    const userConfig = resolveUserOpenCodeConfigPath();
+
+    paths.add(userConfig);
+
+    for (const filePath of [
+        join(directory, ".opencode", "opencode.jsonc"),
+        join(directory, ".opencode", "opencode.json"),
+        join(directory, "opencode.jsonc"),
+        join(directory, "opencode.json"),
+    ]) {
+        if (existsSync(filePath)) {
+            paths.add(filePath);
+        }
+    }
+
+    return [...paths];
+}
+
+function collectOmoConfigPaths(directory: string): string[] {
+    const paths = new Set<string>();
+    const configDir = getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
+
+    for (const fileName of OMO_CONFIG_NAMES) {
+        const userPath = join(configDir, fileName);
+        const projectPath = join(directory, fileName);
+
+        if (existsSync(userPath)) {
+            paths.add(userPath);
+        }
+
+        if (existsSync(projectPath)) {
+            paths.add(projectPath);
+        }
+    }
+
+    if (paths.size === 0) {
+        paths.add(join(configDir, "oh-my-openagent.json"));
+    }
+
+    return [...paths];
+}
+
+export function fixConflicts(directory: string, conflicts: ConflictResult["conflicts"]): string[] {
+    const actions: string[] = [];
+    let updatedCompaction = false;
+    let removedDcpPlugin = false;
+    let disabledOmoHooks = false;
+
+    if (conflicts.compactionAuto || conflicts.compactionPrune || conflicts.dcpPlugin) {
+        for (const configPath of collectOpenCodeConfigPaths(directory)) {
+            const config = readConfig(configPath);
+            if (!config) {
+                continue;
+            }
+
+            let changed = false;
+
+            if (conflicts.compactionAuto || conflicts.compactionPrune) {
+                const compaction = isRecord(config.compaction) ? { ...config.compaction } : {};
+
+                if (compaction.auto !== false) {
+                    compaction.auto = false;
+                    changed = true;
+                    updatedCompaction = true;
+                }
+
+                if (compaction.prune !== false) {
+                    compaction.prune = false;
+                    changed = true;
+                    updatedCompaction = true;
+                }
+
+                config.compaction = compaction;
+            }
+
+            if (conflicts.dcpPlugin) {
+                const plugins = asStringArray(config.plugin);
+                const filteredPlugins = plugins.filter(
+                    (plugin) => !plugin.includes("opencode-dcp"),
+                );
+
+                if (filteredPlugins.length !== plugins.length) {
+                    config.plugin = filteredPlugins;
+                    changed = true;
+                    removedDcpPlugin = true;
+                }
+            }
+
+            if (changed) {
+                writeConfig(configPath, config);
+            }
+        }
+    }
+
+    if (
+        conflicts.omoContextWindowMonitor ||
+        conflicts.omoPreemptiveCompaction ||
+        conflicts.omoAnthropicRecovery
+    ) {
+        const hooksToDisable = new Set<string>();
+        if (conflicts.omoContextWindowMonitor) {
+            hooksToDisable.add("context-window-monitor");
+        }
+        if (conflicts.omoPreemptiveCompaction) {
+            hooksToDisable.add("preemptive-compaction");
+        }
+        if (conflicts.omoAnthropicRecovery) {
+            hooksToDisable.add("anthropic-context-window-limit-recovery");
+        }
+
+        for (const configPath of collectOmoConfigPaths(directory)) {
+            const config = readConfig(configPath);
+            if (!config) {
+                continue;
+            }
+
+            const disabledHooks = new Set(asStringArray(config.disabled_hooks));
+            let changed = false;
+
+            for (const hook of hooksToDisable) {
+                if (!disabledHooks.has(hook)) {
+                    disabledHooks.add(hook);
+                    changed = true;
+                    disabledOmoHooks = true;
+                }
+            }
+
+            if (changed) {
+                config.disabled_hooks = [
+                    ...CONFLICTING_OMO_HOOKS.filter((hook) => disabledHooks.has(hook)),
+                    ...[...disabledHooks].filter(
+                        (hook) =>
+                            !CONFLICTING_OMO_HOOKS.includes(
+                                hook as (typeof CONFLICTING_OMO_HOOKS)[number],
+                            ),
+                    ),
+                ];
+                writeConfig(configPath, config);
+            }
+        }
+    }
+
+    if (updatedCompaction) {
+        actions.push("Disabled auto-compaction");
+    }
+
+    if (removedDcpPlugin) {
+        actions.push("Removed opencode-dcp plugin");
+    }
+
+    if (disabledOmoHooks) {
+        actions.push("Disabled conflicting oh-my-opencode hooks");
+    }
+
+    return actions;
+}

package/src/shared/data-path.ts

@@ -0,0 +1,10 @@
+import * as os from "node:os";
+import * as path from "node:path";
+
+export function getDataDir(): string {
+    return process.env.XDG_DATA_HOME ?? path.join(os.homedir(), ".local", "share");
+}
+
+export function getOpenCodeStorageDir(): string {
+    return path.join(getDataDir(), "opencode", "storage");
+}

package/src/shared/error-message.ts

@@ -0,0 +1,3 @@
+export function getErrorMessage(error: unknown): string {
+    return error instanceof Error ? error.message : String(error);
+}

package/src/shared/format-bytes.ts

@@ -0,0 +1,5 @@
+export function formatBytes(bytes: number): string {
+    if (bytes < 1024) return `${bytes}B`;
+    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}

package/src/shared/index.ts

@@ -0,0 +1,4 @@
+export * from "./logger";
+export * from "./model-requirements";
+export * from "./model-suggestion-retry";
+export * from "./normalize-sdk-response";

package/src/shared/internal-initiator-marker.ts

@@ -0,0 +1 @@
+export const OMO_INTERNAL_INITIATOR_MARKER = "<!-- OMO_INTERNAL_INITIATOR -->";

package/src/shared/jsonc-parser.ts

@@ -0,0 +1,138 @@
+import { existsSync, readFileSync } from "node:fs";
+
+function stripJsonComments(content: string): string {
+    let result = "";
+    let inString = false;
+    let escaped = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+
+    for (let index = 0; index < content.length; index += 1) {
+        const char = content[index];
+        const next = content[index + 1];
+
+        if (inLineComment) {
+            if (char === "\n") {
+                inLineComment = false;
+                result += char;
+            }
+            continue;
+        }
+
+        if (inBlockComment) {
+            if (char === "*" && next === "/") {
+                inBlockComment = false;
+                index += 1;
+            }
+            continue;
+        }
+
+        if (inString) {
+            result += char;
+            if (escaped) {
+                escaped = false;
+            } else if (char === "\\") {
+                escaped = true;
+            } else if (char === '"') {
+                inString = false;
+            }
+            continue;
+        }
+
+        if (char === '"') {
+            inString = true;
+            result += char;
+            continue;
+        }
+
+        if (char === "/" && next === "/") {
+            inLineComment = true;
+            index += 1;
+            continue;
+        }
+
+        if (char === "/" && next === "*") {
+            inBlockComment = true;
+            index += 1;
+            continue;
+        }
+
+        result += char;
+    }
+
+    return result;
+}
+
+function stripTrailingCommas(content: string): string {
+    let result = "";
+    let inString = false;
+    let escaped = false;
+
+    for (let index = 0; index < content.length; index += 1) {
+        const char = content[index];
+
+        if (inString) {
+            result += char;
+            if (escaped) {
+                escaped = false;
+            } else if (char === "\\") {
+                escaped = true;
+            } else if (char === '"') {
+                inString = false;
+            }
+            continue;
+        }
+
+        if (char === '"') {
+            inString = true;
+            result += char;
+            continue;
+        }
+
+        if (char === ",") {
+            let lookahead = index + 1;
+            while (lookahead < content.length && /\s/.test(content[lookahead] ?? "")) {
+                lookahead += 1;
+            }
+            const next = content[lookahead];
+            if (next === "}" || next === "]") {
+                continue;
+            }
+        }
+
+        result += char;
+    }
+
+    return result;
+}
+
+export function parseJsonc<T = unknown>(content: string): T {
+    const normalized = stripTrailingCommas(stripJsonComments(content));
+    return JSON.parse(normalized) as T;
+}
+
+export function readJsoncFile<T = unknown>(filePath: string): T | null {
+    try {
+        return parseJsonc<T>(readFileSync(filePath, "utf-8"));
+    } catch (_error) {
+        return null;
+    }
+}
+
+export function detectConfigFile(basePath: string): {
+    format: "json" | "jsonc" | "none";
+    path: string;
+} {
+    const jsoncPath = `${basePath}.jsonc`;
+    const jsonPath = `${basePath}.json`;
+
+    if (existsSync(jsoncPath)) {
+        return { format: "jsonc", path: jsoncPath };
+    }
+
+    if (existsSync(jsonPath)) {
+        return { format: "json", path: jsonPath };
+    }
+
+    return { format: "none", path: jsoncPath };
+}

package/src/shared/logger.ts

@@ -0,0 +1,63 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+const logFile = path.join(os.tmpdir(), "magic-context.log");
+const isTestEnv = process.env.NODE_ENV === "test";
+
+let buffer: string[] = [];
+let flushTimer: ReturnType<typeof setTimeout> | null = null;
+const FLUSH_INTERVAL_MS = 500;
+const BUFFER_SIZE_LIMIT = 50;
+
+function flush(): void {
+    if (flushTimer) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+    }
+    if (buffer.length === 0) return;
+    const data = buffer.join("");
+    buffer = [];
+    try {
+        fs.appendFileSync(logFile, data);
+    } catch {
+        // Intentional: logging must never throw
+    }
+}
+
+function scheduleFlush(): void {
+    if (flushTimer) return;
+    flushTimer = setTimeout(() => {
+        flushTimer = null;
+        flush();
+    }, FLUSH_INTERVAL_MS);
+}
+
+export function log(message: string, data?: unknown): void {
+    if (isTestEnv) return;
+    try {
+        const timestamp = new Date().toISOString();
+        const serialized = data === undefined ? "" : ` ${JSON.stringify(data)}`;
+        buffer.push(`[${timestamp}] ${message}${serialized}\n`);
+        if (buffer.length >= BUFFER_SIZE_LIMIT) {
+            flush();
+        } else {
+            scheduleFlush();
+        }
+    } catch {
+        // Intentional: logging must never throw
+    }
+}
+
+export function sessionLog(sessionId: string, message: string, data?: unknown): void {
+    log(`[magic-context][${sessionId}] ${message}`, data);
+}
+
+export function getLogFilePath(): string {
+    return logFile;
+}
+
+// Flush remaining buffer on process exit
+if (!isTestEnv) {
+    process.on("exit", flush);
+}

package/src/shared/model-requirements.ts

@@ -0,0 +1,84 @@
+import { DREAMER_AGENT } from "../agents/dreamer";
+import { HISTORIAN_AGENT } from "../agents/historian";
+import { SIDEKICK_AGENT } from "../agents/sidekick";
+
+/**
+ * Provider-agnostic fallback chain entry.
+ * Each entry specifies a model and the providers to try in priority order.
+ * Follows oh-my-opencode's FallbackEntry pattern — `opencode` acts as a
+ * catch-all proxy provider and is listed last in most entries.
+ */
+export type FallbackEntry = {
+    providers: string[];
+    model: string;
+    variant?: string;
+};
+
+export type AgentModelRequirement = {
+    fallbackChain: FallbackEntry[];
+};
+
+// Historian: quality matters, single long prompt.
+// Copilot first (request-based pricing, ideal for single-prompt background work).
+const HISTORIAN_FALLBACK_CHAIN: FallbackEntry[] = [
+    { providers: ["github-copilot", "anthropic", "opencode"], model: "claude-sonnet-4-6" },
+    { providers: ["opencode-go"], model: "minimax-m2.7" },
+    {
+        providers: ["zai-coding-plan", "bailian-coding-plan", "opencode-go", "opencode"],
+        model: "glm-5",
+    },
+    { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.4" },
+    { providers: ["google", "github-copilot", "opencode"], model: "gemini-3.1-pro" },
+];
+
+// Dreamer: runs overnight during idle time, can be slow.
+// Copilot first (request-based pricing). Local models also work well here.
+const DREAMER_FALLBACK_CHAIN: FallbackEntry[] = [
+    { providers: ["github-copilot", "anthropic", "opencode"], model: "claude-sonnet-4-6" },
+    { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-flash" },
+    {
+        providers: ["zai-coding-plan", "bailian-coding-plan", "opencode-go", "opencode"],
+        model: "glm-5",
+    },
+    { providers: ["opencode-go"], model: "minimax-m2.7" },
+    { providers: ["github-copilot", "openai", "opencode"], model: "gpt-5.4-mini" },
+];
+
+// Sidekick: speed is critical — fast inference providers first.
+// No Copilot preference (low token count, request-based pricing doesn't help).
+const SIDEKICK_FALLBACK_CHAIN: FallbackEntry[] = [
+    { providers: ["cerebras"], model: "qwen-3-235b-a22b-instruct-2507" },
+    { providers: ["google", "github-copilot", "opencode"], model: "gemini-3-flash" },
+    { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.4-mini" },
+    { providers: ["opencode"], model: "gpt-5-nano" },
+];
+
+export const AGENT_MODEL_REQUIREMENTS: Record<string, AgentModelRequirement> = {
+    [HISTORIAN_AGENT]: { fallbackChain: HISTORIAN_FALLBACK_CHAIN },
+    [DREAMER_AGENT]: { fallbackChain: DREAMER_FALLBACK_CHAIN },
+    [SIDEKICK_AGENT]: { fallbackChain: SIDEKICK_FALLBACK_CHAIN },
+};
+
+/**
+ * Expand a provider-agnostic fallback chain into a flat `provider/model` list
+ * that OpenCode's agent config accepts as `fallback_models`.
+ */
+export function expandFallbackChain(chain: FallbackEntry[]): string[] {
+    const models: string[] = [];
+    for (const entry of chain) {
+        for (const provider of entry.providers) {
+            models.push(`${provider}/${entry.model}`);
+        }
+    }
+    return models;
+}
+
+/**
+ * Get the expanded fallback_models list for an agent.
+ * Returns undefined if no requirement is defined.
+ */
+export function getAgentFallbackModels(agent: string): string[] | undefined {
+    const requirement = AGENT_MODEL_REQUIREMENTS[agent];
+    if (!requirement) return undefined;
+    return expandFallbackChain(requirement.fallbackChain);
+}

package/src/shared/model-suggestion-retry.ts

@@ -0,0 +1,160 @@
+import type { createOpencodeClient } from "@opencode-ai/sdk";
+
+import { log } from "./logger";
+
+type Client = ReturnType<typeof createOpencodeClient>;
+
+type PromptBody = {
+    model?: { providerID: string; modelID: string };
+    [key: string]: unknown;
+};
+
+type PromptArgs = {
+    path: { id: string };
+    body: PromptBody;
+    signal?: AbortSignal;
+    [key: string]: unknown;
+};
+
+export interface PromptRetryOptions {
+    timeoutMs?: number;
+    /** External abort signal — cancels the in-flight LLM prompt immediately when aborted */
+    signal?: AbortSignal;
+}
+
+export interface ModelSuggestionInfo {
+    providerID: string;
+    modelID: string;
+    suggestion: string;
+}
+
+function extractMessage(error: unknown): string {
+    if (typeof error === "string") return error;
+    if (error instanceof Error) return error.message;
+    if (typeof error === "object" && error !== null) {
+        const obj = error as Record<string, unknown>;
+        if (typeof obj.message === "string") return obj.message;
+    }
+
+    try {
+        return JSON.stringify(error);
+    } catch (_error) {
+        return String(error);
+    }
+}
+
+export function parseModelSuggestion(error: unknown): ModelSuggestionInfo | null {
+    if (!error) return null;
+
+    if (typeof error === "object" && error !== null) {
+        const errObj = error as Record<string, unknown>;
+
+        if (
+            errObj.name === "ProviderModelNotFoundError" &&
+            typeof errObj.data === "object" &&
+            errObj.data !== null
+        ) {
+            const data = errObj.data as Record<string, unknown>;
+            const suggestions = data.suggestions;
+            if (Array.isArray(suggestions) && typeof suggestions[0] === "string") {
+                return {
+                    providerID: String(data.providerID ?? ""),
+                    modelID: String(data.modelID ?? ""),
+                    suggestion: suggestions[0],
+                };
+            }
+        }
+
+        for (const key of ["data", "error", "cause"] as const) {
+            const nested = errObj[key];
+            if (nested && typeof nested === "object") {
+                const result = parseModelSuggestion(nested);
+                if (result) return result;
+            }
+        }
+    }
+
+    const message = extractMessage(error);
+    const modelMatch = message.match(/model not found:\s*([^/\s]+)\s*\/\s*([^.,\s]+)/i);
+    const suggestionMatch = message.match(/did you mean:\s*([^,?]+)/i);
+
+    if (!modelMatch || !suggestionMatch) {
+        return null;
+    }
+
+    return {
+        providerID: modelMatch[1].trim(),
+        modelID: modelMatch[2].trim(),
+        suggestion: suggestionMatch[1].trim(),
+    };
+}
+
+async function promptWithTimeout(
+    client: Client,
+    args: PromptArgs,
+    timeoutMs: number,
+    signal?: AbortSignal,
+): Promise<void> {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+
+    // Link external signal to internal controller so external abort cancels the fetch
+    const onExternalAbort = () => controller.abort();
+    signal?.addEventListener("abort", onExternalAbort);
+
+    try {
+        await client.session.prompt({
+            ...args,
+            signal: controller.signal,
+        } as Parameters<typeof client.session.prompt>[0]);
+    } catch (error) {
+        if (signal?.aborted) {
+            throw new Error("prompt aborted by external signal");
+        }
+        if (controller.signal.aborted) {
+            throw new Error(`prompt timed out after ${timeoutMs}ms`);
+        }
+        throw error;
+    } finally {
+        clearTimeout(timeout);
+        signal?.removeEventListener("abort", onExternalAbort);
+    }
+}
+
+export async function promptSyncWithModelSuggestionRetry(
+    client: Client,
+    args: PromptArgs,
+    options: PromptRetryOptions = {},
+): Promise<void> {
+    const timeoutMs = options.timeoutMs ?? 300_000;
+
+    try {
+        await promptWithTimeout(client, args, timeoutMs, options.signal);
+    } catch (error) {
+        const suggestion = parseModelSuggestion(error);
+        if (!suggestion || !args.body.model) {
+            throw error;
+        }
+
+        log("[model-suggestion-retry] Model not found, retrying with suggestion", {
+            original: `${suggestion.providerID}/${suggestion.modelID}`,
+            suggested: suggestion.suggestion,
+        });
+
+        await promptWithTimeout(
+            client,
+            {
+                ...args,
+                body: {
+                    ...args.body,
+                    model: {
+                        providerID: suggestion.providerID,
+                        modelID: suggestion.suggestion,
+                    },
+                },
+            },
+            timeoutMs,
+            options.signal,
+        );
+    }
+}