@cortexkit/opencode-magic-context 0.12.0 → 0.13.0

package/dist/cli.js

@@ -7851,16 +7851,183 @@ var require_src3 = __commonJS((exports, module) => {
 // src/cli/doctor.ts
 var import_comment_json3 = __toESM(require_src2(), 1);
 import { execSync as execSync2, spawnSync } from "node:child_process";
-import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync5, rmSync, statSync as statSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync7, readdirSync as readdirSync2, readFileSync as readFileSync6, rmSync, statSync as statSync2, writeFileSync as writeFileSync4 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import { homedir as homedir5, platform, tmpdir as tmpdir3 } from "node:os";
+import { homedir as homedir6, platform, tmpdir as tmpdir3 } from "node:os";
 import { join as join9 } from "node:path";
 
+// src/config/variable.ts
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, resolve } from "node:path";
+var ENV_PATTERN = /\{env:([^}]+)\}/g;
+var FILE_PATTERN = /\{file:([^}]+)\}/g;
+function substituteConfigVariables(input) {
+  const warnings = [];
+  let text = input.text;
+  text = text.replace(ENV_PATTERN, (_, rawName) => {
+    const varName = rawName.trim();
+    const value = varName ? process.env[varName] : undefined;
+    if (value === undefined || value === "") {
+      warnings.push(`Environment variable ${varName} is not set (referenced via {env:${varName}}); using empty string`);
+      return "";
+    }
+    return value;
+  });
+  const fileMatches = Array.from(text.matchAll(FILE_PATTERN));
+  if (fileMatches.length === 0) {
+    return { text, warnings };
+  }
+  const configDir = input.configPath ? dirname(input.configPath) : process.cwd();
+  let output = "";
+  let cursor = 0;
+  for (const match of fileMatches) {
+    const token = match[0];
+    const rawPath = match[1] ?? "";
+    const index = match.index ?? 0;
+    output += text.slice(cursor, index);
+    cursor = index + token.length;
+    const lineStart = text.lastIndexOf(`
+`, index - 1) + 1;
+    const prefix = text.slice(lineStart, index).trimStart();
+    if (prefix.startsWith("//")) {
+      output += token;
+      continue;
+    }
+    let filePath = rawPath.trim();
+    if (filePath.startsWith("~/")) {
+      filePath = resolve(homedir(), filePath.slice(2));
+    } else if (!isAbsolute(filePath)) {
+      filePath = resolve(configDir, filePath);
+    }
+    if (!existsSync(filePath)) {
+      warnings.push(`File not found for ${token} (resolved to ${filePath}); using empty string`);
+      continue;
+    }
+    let contents;
+    try {
+      contents = readFileSync(filePath, "utf-8").trim();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      warnings.push(`Failed to read file for ${token} (${filePath}): ${message}; using empty string`);
+      continue;
+    }
+    output += JSON.stringify(contents).slice(1, -1);
+  }
+  output += text.slice(cursor);
+  return { text: output, warnings };
+}
+
+// src/features/magic-context/memory/embedding-probe.ts
+var DEFAULT_TIMEOUT_MS = 1e4;
+var MAX_PREVIEW_CHARS = 240;
+async function probeEmbeddingEndpoint(options) {
+  const endpoint = options.endpoint.trim().replace(/\/+$/, "");
+  if (!endpoint) {
+    return { kind: "invalid_scheme", endpoint: options.endpoint };
+  }
+  if (!endpoint.startsWith("https://") && !endpoint.startsWith("http://")) {
+    return { kind: "invalid_scheme", endpoint: options.endpoint };
+  }
+  const fetchImpl = options.fetch ?? fetch;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const url = `${endpoint}/embeddings`;
+  const apiKey = options.apiKey?.trim();
+  const headers = { "content-type": "application/json" };
+  if (apiKey) {
+    headers.authorization = `Bearer ${apiKey}`;
+  }
+  const body = JSON.stringify({ model: options.model, input: "magic-context probe" });
+  let response;
+  try {
+    response = await fetchImpl(url, {
+      method: "POST",
+      headers,
+      body,
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch (error) {
+    if (error instanceof Error && error.name === "TimeoutError") {
+      return { kind: "timeout", timeoutMs };
+    }
+    if (error instanceof Error && error.name === "AbortError") {
+      return { kind: "timeout", timeoutMs };
+    }
+    return {
+      kind: "network_error",
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+  const status = response.status;
+  if (response.ok) {
+    let parsed = null;
+    try {
+      parsed = await response.json();
+    } catch {
+      return { kind: "endpoint_unsupported", status, preview: "" };
+    }
+    const dimensions = extractDimensions(parsed);
+    if (dimensions === null) {
+      return {
+        kind: "endpoint_unsupported",
+        status,
+        preview: await readPreview(parsed)
+      };
+    }
+    return { kind: "ok", status, dimensions };
+  }
+  const preview = await previewErrorBody(response);
+  if (status === 401 || status === 403) {
+    return { kind: "auth_failed", status, preview };
+  }
+  if (status === 404 || status === 405) {
+    return { kind: "endpoint_unsupported", status, preview };
+  }
+  return { kind: "http_error", status, preview };
+}
+function extractDimensions(body) {
+  if (!body || typeof body !== "object")
+    return null;
+  const data = body.data;
+  if (!Array.isArray(data) || data.length === 0)
+    return null;
+  const first = data[0];
+  if (!first || typeof first !== "object")
+    return null;
+  const embedding = first.embedding;
+  if (!Array.isArray(embedding) || embedding.length === 0)
+    return null;
+  const sample = embedding[0];
+  if (typeof sample !== "number" || !Number.isFinite(sample))
+    return null;
+  return embedding.length;
+}
+async function previewErrorBody(response) {
+  try {
+    const text = await response.text();
+    return truncate(text);
+  } catch {
+    return "";
+  }
+}
+async function readPreview(parsed) {
+  try {
+    return truncate(JSON.stringify(parsed));
+  } catch {
+    return "";
+  }
+}
+function truncate(text) {
+  if (text.length <= MAX_PREVIEW_CHARS)
+    return text;
+  return `${text.slice(0, MAX_PREVIEW_CHARS)}…`;
+}
+
 // src/shared/conflict-detector.ts
 import { join as join2 } from "node:path";
 
 // src/shared/jsonc-parser.ts
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
 function stripJsonComments(content) {
   let result = "";
   let inString = false;
@@ -7957,24 +8124,24 @@ function parseJsonc(content) {
 }
 function readJsoncFile(filePath) {
   try {
-    return parseJsonc(readFileSync(filePath, "utf-8"));
+    return parseJsonc(readFileSync2(filePath, "utf-8"));
   } catch (_error) {
     return null;
   }
 }
 
 // src/shared/opencode-config-dir.ts
-import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { join, resolve as resolve2 } from "node:path";
 function getCliConfigDir() {
   const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
   if (envConfigDir) {
-    return resolve(envConfigDir);
+    return resolve2(envConfigDir);
   }
   if (process.platform === "win32") {
-    return join(homedir(), ".config", "opencode");
+    return join(homedir2(), ".config", "opencode");
   }
-  return join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "opencode");
+  return join(process.env.XDG_CONFIG_HOME || join(homedir2(), ".config"), "opencode");
 }
 function getOpenCodeConfigDir(_options) {
   return getCliConfigDir();
@@ -8156,8 +8323,8 @@ function readOmoDisabledHooks(directory) {
 }
 
 // src/shared/conflict-fixer.ts
-import { existsSync as existsSync2, mkdirSync, writeFileSync } from "node:fs";
-import { dirname, join as join3 } from "node:path";
+import { existsSync as existsSync3, mkdirSync, writeFileSync } from "node:fs";
+import { dirname as dirname2, join as join3 } from "node:path";
 var CONFLICTING_OMO_HOOKS = [
   "context-window-monitor",
   "preemptive-compaction",
@@ -8170,7 +8337,7 @@ var OMO_CONFIG_NAMES = [
   "oh-my-opencode.json"
 ];
 function ensureParentDir(filePath) {
-  mkdirSync(dirname(filePath), { recursive: true });
+  mkdirSync(dirname2(filePath), { recursive: true });
 }
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -8179,7 +8346,7 @@ function asStringArray(value) {
   return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 }
 function readConfig(filePath) {
-  if (!existsSync2(filePath)) {
+  if (!existsSync3(filePath)) {
     return {};
   }
   return readJsoncFile(filePath);
@@ -8191,7 +8358,7 @@ function writeConfig(filePath, config) {
 }
 function resolveUserOpenCodeConfigPath() {
   const paths = getOpenCodeConfigPaths({ binary: "opencode" });
-  if (existsSync2(paths.configJsonc))
+  if (existsSync3(paths.configJsonc))
     return paths.configJsonc;
   return paths.configJson;
 }
@@ -8205,7 +8372,7 @@ function collectOpenCodeConfigPaths(directory) {
     join3(directory, "opencode.jsonc"),
     join3(directory, "opencode.json")
   ]) {
-    if (existsSync2(filePath)) {
+    if (existsSync3(filePath)) {
       paths.add(filePath);
     }
   }
@@ -8217,10 +8384,10 @@ function collectOmoConfigPaths(directory) {
   for (const fileName of OMO_CONFIG_NAMES) {
     const userPath = join3(configDir, fileName);
     const projectPath = join3(directory, fileName);
-    if (existsSync2(userPath)) {
+    if (existsSync3(userPath)) {
       paths.add(userPath);
     }
-    if (existsSync2(projectPath)) {
+    if (existsSync3(projectPath)) {
       paths.add(projectPath);
     }
   }
@@ -8317,8 +8484,8 @@ function fixConflicts(directory, conflicts) {
 
 // src/shared/tui-config.ts
 var import_comment_json = __toESM(require_src2(), 1);
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname2, join as join5 } from "node:path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname3, join as join5 } from "node:path";
 
 // src/shared/logger.ts
 import * as fs from "node:fs";
@@ -8378,9 +8545,9 @@ function resolveTuiConfigPath() {
   const configDir = getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
   const jsoncPath = join5(configDir, "tui.jsonc");
   const jsonPath = join5(configDir, "tui.json");
-  if (existsSync3(jsoncPath))
+  if (existsSync4(jsoncPath))
     return jsoncPath;
-  if (existsSync3(jsonPath))
+  if (existsSync4(jsonPath))
     return jsonPath;
   return jsonPath;
 }
@@ -8388,8 +8555,8 @@ function ensureTuiPluginEntry() {
   try {
     const configPath = resolveTuiConfigPath();
     let config = {};
-    if (existsSync3(configPath)) {
-      const raw = readFileSync2(configPath, "utf-8");
+    if (existsSync4(configPath)) {
+      const raw = readFileSync3(configPath, "utf-8");
       config = import_comment_json.parse(raw) ?? {};
     }
     const plugins = Array.isArray(config.plugin) ? config.plugin.filter((p) => typeof p === "string") : [];
@@ -8408,7 +8575,7 @@ function ensureTuiPluginEntry() {
       plugins.push(PLUGIN_ENTRY);
     }
     config.plugin = plugins;
-    mkdirSync2(dirname2(configPath), { recursive: true });
+    mkdirSync2(dirname3(configPath), { recursive: true });
     writeFileSync2(configPath, `${import_comment_json.stringify(config, null, 2)}
 `);
     log(`[magic-context] updated TUI plugin entry in ${configPath}`);
@@ -8420,17 +8587,17 @@ function ensureTuiPluginEntry() {
 }
 
 // src/cli/config-paths.ts
-import { existsSync as existsSync4 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
+import { existsSync as existsSync5 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
 import { join as join6 } from "node:path";
 function getConfigDir() {
   const envDir = process.env.OPENCODE_CONFIG_DIR?.trim();
   if (envDir)
     return envDir;
   if (process.platform === "win32") {
-    return join6(homedir2(), ".config", "opencode");
+    return join6(homedir3(), ".config", "opencode");
   }
-  const xdgConfig = process.env.XDG_CONFIG_HOME || join6(homedir2(), ".config");
+  const xdgConfig = process.env.XDG_CONFIG_HOME || join6(homedir3(), ".config");
   return join6(xdgConfig, "opencode");
 }
 function findOmoConfig(configDir) {
@@ -8441,7 +8608,7 @@ function findOmoConfig(configDir) {
     join6(configDir, "oh-my-opencode.json")
   ];
   for (const loc of locations) {
-    if (existsSync4(loc))
+    if (existsSync5(loc))
       return loc;
   }
   return null;
@@ -8454,10 +8621,10 @@ function detectConfigPaths() {
   let tuiConfigFormat;
   const jsoncPath = join6(configDir, "opencode.jsonc");
   const jsonPath = join6(configDir, "opencode.json");
-  if (existsSync4(jsoncPath)) {
+  if (existsSync5(jsoncPath)) {
     opencodeConfig = jsoncPath;
     opencodeConfigFormat = "jsonc";
-  } else if (existsSync4(jsonPath)) {
+  } else if (existsSync5(jsonPath)) {
     opencodeConfig = jsonPath;
     opencodeConfigFormat = "json";
   } else {
@@ -8466,10 +8633,10 @@ function detectConfigPaths() {
   }
   const tuiJsoncPath = join6(configDir, "tui.jsonc");
   const tuiJsonPath = join6(configDir, "tui.json");
-  if (existsSync4(tuiJsoncPath)) {
+  if (existsSync5(tuiJsoncPath)) {
     tuiConfig = tuiJsoncPath;
     tuiConfigFormat = "jsonc";
-  } else if (existsSync4(tuiJsonPath)) {
+  } else if (existsSync5(tuiJsonPath)) {
     tuiConfig = tuiJsonPath;
     tuiConfigFormat = "json";
   } else {
@@ -8489,9 +8656,9 @@ function detectConfigPaths() {
 
 // src/cli/diagnostics.ts
 var import_comment_json2 = __toESM(require_src2(), 1);
-import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync3, statSync } from "node:fs";
+import { existsSync as existsSync6, readdirSync, readFileSync as readFileSync4, statSync } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { homedir as homedir3, tmpdir as tmpdir2, userInfo } from "node:os";
+import { homedir as homedir4, tmpdir as tmpdir2, userInfo } from "node:os";
 import { join as join7 } from "node:path";
 
 // src/cli/opencode-helpers.ts
@@ -8590,18 +8757,18 @@ function getOpenCodeCacheDir() {
   if (xdgCache)
     return join7(xdgCache, "opencode");
   if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA ?? join7(homedir3(), "AppData", "Local");
+    const localAppData = process.env.LOCALAPPDATA ?? join7(homedir4(), "AppData", "Local");
     return join7(localAppData, "opencode");
   }
-  return join7(homedir3(), ".cache", "opencode");
+  return join7(homedir4(), ".cache", "opencode");
 }
 function getPluginCacheInfo() {
   const path2 = join7(getOpenCodeCacheDir(), "packages", PLUGIN_ENTRY_WITH_VERSION);
   let cached;
   try {
     const installedPkgPath = join7(path2, "node_modules", "@cortexkit", "opencode-magic-context", "package.json");
-    if (existsSync5(installedPkgPath)) {
-      const pkg = JSON.parse(readFileSync3(installedPkgPath, "utf-8"));
+    if (existsSync6(installedPkgPath)) {
+      const pkg = JSON.parse(readFileSync4(installedPkgPath, "utf-8"));
       cached = typeof pkg.version === "string" ? pkg.version : undefined;
     }
   } catch {
@@ -8610,12 +8777,12 @@ function getPluginCacheInfo() {
   return { path: path2, cached, latest: getSelfVersion() };
 }
 function getStorageDir() {
-  const dataHome = process.env.XDG_DATA_HOME || join7(homedir3(), ".local", "share");
+  const dataHome = process.env.XDG_DATA_HOME || join7(homedir4(), ".local", "share");
   return join7(dataHome, "opencode", "storage", "plugin", "magic-context");
 }
 function fileSize(path2) {
   try {
-    return existsSync5(path2) ? statSync(path2).size : 0;
+    return existsSync6(path2) ? statSync(path2).size : 0;
   } catch {
     return 0;
   }
@@ -8624,7 +8791,7 @@ function escapeRegex(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function sanitizeString(value) {
-  const home = homedir3();
+  const home = homedir4();
   const username = userInfo().username;
   let sanitized = value;
   if (home) {
@@ -8649,10 +8816,10 @@ function sanitizeValue(value) {
   return value;
 }
 function readConfig2(path2) {
-  if (!existsSync5(path2))
+  if (!existsSync6(path2))
     return { value: null };
   try {
-    const raw = readFileSync3(path2, "utf-8");
+    const raw = readFileSync4(path2, "utf-8");
     const value = import_comment_json2.parse(raw);
     return { value };
   } catch (error) {
@@ -8675,7 +8842,7 @@ function configHasPluginEntry(config) {
 }
 function collectHistorianDumps() {
   const dir = join7(tmpdir2(), "magic-context-historian");
-  if (!existsSync5(dir)) {
+  if (!existsSync6(dir)) {
     return { dir, count: 0, recent: [] };
   }
   try {
@@ -8707,7 +8874,7 @@ async function collectDiagnostics() {
   const storageDirPath = getStorageDir();
   const contextDbPath = join7(storageDirPath, "context.db");
   const logPath = join7(tmpdir2(), "magic-context.log");
-  const logFileSize = existsSync5(logPath) ? statSync(logPath).size : 0;
+  const logFileSize = existsSync6(logPath) ? statSync(logPath).size : 0;
   const conflictResult = detectConflicts(process.cwd());
   return {
     timestamp: new Date().toISOString(),
@@ -8721,14 +8888,14 @@ async function collectDiagnostics() {
     opencodeConfigHasPlugin: configHasPluginEntry(opencodeConfig.value),
     tuiConfigHasPlugin: configHasPluginEntry(tuiConfig.value),
     magicContextConfig: {
-      exists: existsSync5(configPaths.magicContextConfig),
+      exists: existsSync6(configPaths.magicContextConfig),
       ...magicContextConfig.error ? { parseError: magicContextConfig.error } : {},
       flags: sanitizeValue(magicContextConfig.value ?? {}) ?? {}
     },
     pluginCache: getPluginCacheInfo(),
     storageDir: {
       path: storageDirPath,
-      exists: existsSync5(storageDirPath),
+      exists: existsSync6(storageDirPath),
       contextDbSizeBytes: fileSize(contextDbPath)
     },
     conflicts: {
@@ -8737,7 +8904,7 @@ async function collectDiagnostics() {
     },
     logFile: {
       path: logPath,
-      exists: existsSync5(logPath),
+      exists: existsSync6(logPath),
       sizeKb: Math.round(logFileSize / 1024)
     },
     historianDumps: collectHistorianDumps()
@@ -8822,14 +8989,14 @@ function renderDiagnosticsMarkdown(report) {
 }
 
 // src/cli/logs.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
-import { homedir as homedir4, userInfo as userInfo2 } from "node:os";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "node:fs";
+import { homedir as homedir5, userInfo as userInfo2 } from "node:os";
 import { join as join8 } from "node:path";
 function escapeRegex2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function sanitizeLogContent(content) {
-  const home = homedir4();
+  const home = homedir5();
   const username = userInfo2().username;
   let sanitized = content;
   if (home) {
@@ -8857,11 +9024,11 @@ function formatTimestamp(date) {
 }
 async function bundleIssueReport(report, description, _title) {
   const LOG_TAIL_LINES = 200;
-  const logLines = report.logFile.exists ? readFileSync4(report.logFile.path, "utf-8").split(/\r?\n/) : [];
+  const logLines = report.logFile.exists ? readFileSync5(report.logFile.path, "utf-8").split(/\r?\n/) : [];
   const recentLog = sanitizeLogContent(logLines.slice(-LOG_TAIL_LINES).join(`
 `)).trim();
   const configBody = JSON.stringify(report.magicContextConfig.flags, null, 2);
-  const sanitizedConfigPath = report.configPaths.magicContextConfig.replace(homedir4(), "~");
+  const sanitizedConfigPath = report.configPaths.magicContextConfig.replace(homedir5(), "~");
   const bodyMarkdown = [
     "## Description",
     description,
@@ -10011,22 +10178,22 @@ function getOpenCodeCacheDir2() {
     return join9(xdgCache, "opencode");
   const os2 = platform();
   if (os2 === "win32") {
-    const localAppData = process.env.LOCALAPPDATA ?? join9(homedir5(), "AppData", "Local");
+    const localAppData = process.env.LOCALAPPDATA ?? join9(homedir6(), "AppData", "Local");
     return join9(localAppData, "opencode");
   }
-  return join9(homedir5(), ".cache", "opencode");
+  return join9(homedir6(), ".cache", "opencode");
 }
 async function clearPluginCache(force = false) {
   const cacheDir = getOpenCodeCacheDir2();
   const pluginCacheDir = join9(cacheDir, "packages", PLUGIN_ENTRY_WITH_VERSION2);
-  if (!existsSync6(pluginCacheDir)) {
+  if (!existsSync7(pluginCacheDir)) {
     return { action: "not_found", path: pluginCacheDir };
   }
   let cachedVersion;
   try {
     const installedPkgPath = join9(pluginCacheDir, "node_modules", "@cortexkit", "opencode-magic-context", "package.json");
-    if (existsSync6(installedPkgPath)) {
-      const pkg = JSON.parse(readFileSync5(installedPkgPath, "utf-8"));
+    if (existsSync7(installedPkgPath)) {
+      const pkg = JSON.parse(readFileSync6(installedPkgPath, "utf-8"));
       if (typeof pkg?.version === "string") {
         cachedVersion = pkg.version;
       }
@@ -10137,6 +10304,116 @@ async function runIssueFlow() {
     return 1;
   }
 }
+async function checkEmbeddingConfig(magicContextConfigPath) {
+  if (!existsSync7(magicContextConfigPath)) {
+    return { issues: 0 };
+  }
+  let rawText;
+  try {
+    rawText = readFileSync6(magicContextConfigPath, "utf-8");
+  } catch {
+    R2.warn("Could not read magic-context.jsonc for embedding check");
+    return { issues: 1 };
+  }
+  const substituted = substituteConfigVariables({
+    text: rawText,
+    configPath: magicContextConfigPath
+  });
+  let parsedConfig;
+  try {
+    parsedConfig = import_comment_json3.parse(substituted.text);
+  } catch (error) {
+    R2.warn(`Embedding check skipped — could not parse magic-context.jsonc: ${error instanceof Error ? error.message : String(error)}`);
+    return { issues: 1 };
+  }
+  const embedding = parsedConfig?.embedding;
+  const provider = embedding?.provider;
+  if (provider === "off") {
+    R2.info("Embedding provider disabled — semantic memory search is off");
+    return { issues: 0 };
+  }
+  if (provider === undefined || provider === "local") {
+    R2.success("Embedding provider: local (Xenova/all-MiniLM-L6-v2 bundled)");
+    return { issues: 0 };
+  }
+  if (provider !== "openai-compatible") {
+    R2.warn(`Unknown embedding provider: ${String(provider)} (expected local | openai-compatible | off)`);
+    return { issues: 1 };
+  }
+  const endpoint = typeof embedding?.endpoint === "string" ? embedding.endpoint.trim() : "";
+  const model = typeof embedding?.model === "string" ? embedding.model.trim() : "";
+  const apiKey = typeof embedding?.api_key === "string" ? embedding.api_key : undefined;
+  let localIssues = 0;
+  if (!endpoint) {
+    R2.error("Embedding provider is openai-compatible but 'endpoint' is missing");
+    return { issues: 1 };
+  }
+  if (!model) {
+    R2.error("Embedding provider is openai-compatible but 'model' is missing");
+    return { issues: 1 };
+  }
+  if (apiKey && /\{env:[^}]+\}/.test(apiKey)) {
+    R2.warn("api_key still contains {env:...} after substitution — the referenced environment variable is not set in this shell");
+    R2.info(`  Raw value: ${apiKey}`);
+    R2.info("  Export the variable before launching OpenCode (e.g. in ~/.zshrc, ~/.bashrc, or a shell profile)");
+    localIssues++;
+  }
+  if (substituted.warnings.length > 0) {
+    for (const w of substituted.warnings.slice(0, 3)) {
+      R2.info(`  ${w}`);
+    }
+    if (substituted.warnings.length > 3) {
+      R2.info(`  ... and ${substituted.warnings.length - 3} more`);
+    }
+  }
+  const probeSpinner = be();
+  probeSpinner.start(`Testing embedding endpoint ${endpoint} (model: ${model})`);
+  let outcome;
+  try {
+    outcome = await probeEmbeddingEndpoint({
+      endpoint,
+      model,
+      apiKey,
+      timeoutMs: 1e4
+    });
+  } catch (error) {
+    probeSpinner.stop("Embedding probe failed unexpectedly");
+    R2.error(`Probe threw: ${error instanceof Error ? error.message : String(error)}`);
+    return { issues: localIssues + 1 };
+  }
+  probeSpinner.stop("Embedding endpoint probed");
+  switch (outcome.kind) {
+    case "ok":
+      R2.success(`Embedding endpoint OK (${outcome.status}, ${outcome.dimensions ?? "?"}-dim vectors)`);
+      return { issues: localIssues };
+    case "auth_failed":
+      R2.error(`Embedding endpoint rejected credentials (${outcome.status}) — check api_key / env var`);
+      if (outcome.preview)
+        R2.info(`  ${outcome.preview}`);
+      return { issues: localIssues + 1 };
+    case "endpoint_unsupported":
+      R2.error(`Embedding endpoint does not support embeddings (${outcome.status})`);
+      if (outcome.preview)
+        R2.info(`  ${outcome.preview}`);
+      R2.info("  Common causes: endpoint points at a chat-completion route (should be the provider base, e.g. '.../v1'), or the provider doesn't offer an embeddings API");
+      R2.info("  Known non-embedding providers: OpenRouter (chat proxy), Anthropic (no embeddings endpoint). Use OpenAI, Voyage, Together, or a local provider instead.");
+      return { issues: localIssues + 1 };
+    case "http_error":
+      R2.error(`Embedding endpoint returned ${outcome.status}`);
+      if (outcome.preview)
+        R2.info(`  ${outcome.preview}`);
+      return { issues: localIssues + 1 };
+    case "timeout":
+      R2.warn(`Embedding endpoint did not respond within ${outcome.timeoutMs}ms — check endpoint URL and network`);
+      return { issues: localIssues + 1 };
+    case "network_error":
+      R2.error(`Could not reach embedding endpoint: ${outcome.message}`);
+      return { issues: localIssues + 1 };
+    case "invalid_scheme":
+      R2.error(`Embedding endpoint must start with http:// or https://: ${outcome.endpoint}`);
+      return { issues: localIssues + 1 };
+  }
+}
 async function runDoctor(options = {}) {
   if (options.issue) {
     return runIssueFlow();
@@ -10157,15 +10434,15 @@ async function runDoctor(options = {}) {
   } else {
     R2.success(`OpenCode config: ${paths.opencodeConfig}`);
   }
-  if (existsSync6(paths.magicContextConfig)) {
+  if (existsSync7(paths.magicContextConfig)) {
     R2.success(`Magic Context config: ${paths.magicContextConfig}`);
   } else {
     R2.warn(`No magic-context.jsonc found — using defaults`);
     R2.info("  Run 'setup' to create one with model recommendations");
   }
-  if (existsSync6(paths.magicContextConfig)) {
+  if (existsSync7(paths.magicContextConfig)) {
     try {
-      const mcRaw = readFileSync5(paths.magicContextConfig, "utf-8");
+      const mcRaw = readFileSync6(paths.magicContextConfig, "utf-8");
       const mcConfig = import_comment_json3.parse(mcRaw);
       let mcChanged = false;
       const experimental = mcConfig.experimental;
@@ -10194,7 +10471,7 @@ async function runDoctor(options = {}) {
   }
   if (paths.opencodeConfigFormat !== "none") {
     try {
-      const raw = readFileSync5(paths.opencodeConfig, "utf-8");
+      const raw = readFileSync6(paths.opencodeConfig, "utf-8");
       const config = import_comment_json3.parse(raw);
       const plugins = Array.isArray(config?.plugin) ? config.plugin : [];
       const pluginList = plugins.filter((p) => typeof p === "string");
@@ -10250,9 +10527,9 @@ async function runDoctor(options = {}) {
     R2.success("Added TUI sidebar plugin to tui.json");
     R2.warn("Restart OpenCode to see the sidebar");
     fixed++;
-  } else if (existsSync6(paths.tuiConfig)) {
+  } else if (existsSync7(paths.tuiConfig)) {
     try {
-      const tuiRaw = readFileSync5(paths.tuiConfig, "utf-8");
+      const tuiRaw = readFileSync6(paths.tuiConfig, "utf-8");
       const tuiConfig = import_comment_json3.parse(tuiRaw);
       const tuiPlugins = Array.isArray(tuiConfig?.plugin) ? tuiConfig.plugin.filter((p) => typeof p === "string") : [];
       const tuiIdx = tuiPlugins.findIndex((p) => p === PLUGIN_NAME3 || p.startsWith(`${PLUGIN_NAME3}@`));
@@ -10280,9 +10557,9 @@ async function runDoctor(options = {}) {
   } else {
     R2.success("TUI sidebar plugin configured (tui.json created)");
   }
-  if (existsSync6(paths.magicContextConfig)) {
+  if (existsSync7(paths.magicContextConfig)) {
     try {
-      const mcRaw = readFileSync5(paths.magicContextConfig, "utf-8");
+      const mcRaw = readFileSync6(paths.magicContextConfig, "utf-8");
       const mcConfig = import_comment_json3.parse(mcRaw);
       const userMemObj = mcConfig?.experimental?.user_memories;
       const userMemEnabled = userMemObj?.enabled === true;
@@ -10294,6 +10571,8 @@ async function runDoctor(options = {}) {
       }
     } catch {}
   }
+  const embeddingCheck = await checkEmbeddingConfig(paths.magicContextConfig);
+  issues += embeddingCheck.issues;
   const cacheResult = await clearPluginCache(options.force);
   if (cacheResult.action === "cleared") {
     const versionInfo = cacheResult.cached ? ` (cached: ${cacheResult.cached}${cacheResult.latest ? `, latest: ${cacheResult.latest}` : ""})` : "";
@@ -10311,10 +10590,10 @@ async function runDoctor(options = {}) {
   }
   {
     const ageWarnings = [];
-    const npmrcPath = join9(homedir5(), ".npmrc");
-    if (existsSync6(npmrcPath)) {
+    const npmrcPath = join9(homedir6(), ".npmrc");
+    if (existsSync7(npmrcPath)) {
       try {
-        const npmrc = readFileSync5(npmrcPath, "utf-8");
+        const npmrc = readFileSync6(npmrcPath, "utf-8");
         for (const line of npmrc.split(`
 `)) {
           const trimmed = line.trim();
@@ -10327,10 +10606,10 @@ async function runDoctor(options = {}) {
         }
       } catch {}
     }
-    const bunfigPath = join9(homedir5(), ".bunfig.toml");
-    if (existsSync6(bunfigPath)) {
+    const bunfigPath = join9(homedir6(), ".bunfig.toml");
+    if (existsSync7(bunfigPath)) {
       try {
-        const bunfig = readFileSync5(bunfigPath, "utf-8");
+        const bunfig = readFileSync6(bunfigPath, "utf-8");
         for (const line of bunfig.split(`
 `)) {
           const trimmed = line.trim();
@@ -10353,7 +10632,7 @@ async function runDoctor(options = {}) {
     }
   }
   const logPath = join9(tmpdir3(), "magic-context.log");
-  if (existsSync6(logPath)) {
+  if (existsSync7(logPath)) {
     const logStat = statSync2(logPath);
     const sizeKb = (logStat.size / 1024).toFixed(0);
     R2.info(`Log file: ${logPath} (${sizeKb} KB)`);
@@ -10361,7 +10640,7 @@ async function runDoctor(options = {}) {
     R2.info(`Log file: ${logPath} (not yet created)`);
   }
   const historianDumpDir = join9(tmpdir3(), "magic-context-historian");
-  if (existsSync6(historianDumpDir)) {
+  if (existsSync7(historianDumpDir)) {
     try {
       const dumps = readdirSync2(historianDumpDir).filter((f) => f.endsWith(".xml")).map((f) => ({
         name: f,
@@ -10399,17 +10678,17 @@ async function runDoctor(options = {}) {
 
 // src/cli/setup.ts
 var import_comment_json4 = __toESM(require_src2(), 1);
-import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname3 } from "node:path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname4 } from "node:path";
 var PLUGIN_NAME4 = "@cortexkit/opencode-magic-context";
 var PLUGIN_ENTRY2 = "@cortexkit/opencode-magic-context@latest";
 function ensureDir(dir) {
-  if (!existsSync7(dir)) {
+  if (!existsSync8(dir)) {
     mkdirSync3(dir, { recursive: true });
   }
 }
 function readJsonc(path2) {
-  const content = readFileSync6(path2, "utf-8");
+  const content = readFileSync7(path2, "utf-8");
   try {
     return import_comment_json4.parse(content);
   } catch (err) {
@@ -10418,7 +10697,7 @@ function readJsonc(path2) {
   }
 }
 function addPluginToOpenCodeConfig(configPath, format) {
-  ensureDir(dirname3(configPath));
+  ensureDir(dirname4(configPath));
   if (format === "none") {
     const config = {
       plugin: [PLUGIN_ENTRY2],
@@ -10447,7 +10726,7 @@ function addPluginToOpenCodeConfig(configPath, format) {
 `);
 }
 function addPluginToTuiConfig(configPath, format) {
-  ensureDir(dirname3(configPath));
+  ensureDir(dirname4(configPath));
   if (format === "none") {
     writeFileSync5(configPath, `${import_comment_json4.stringify({ plugin: [PLUGIN_ENTRY2] }, null, 2)}
 `);
@@ -10468,7 +10747,7 @@ function addPluginToTuiConfig(configPath, format) {
 `);
 }
 function writeMagicContextConfig(configPath, options) {
-  const config = (existsSync7(configPath) ? readJsonc(configPath) : null) ?? {};
+  const config = (existsSync8(configPath) ? readJsonc(configPath) : null) ?? {};
   if (!config.$schema) {
     config.$schema = "https://raw.githubusercontent.com/cortexkit/opencode-magic-context/master/assets/magic-context.schema.json";
   }
@@ -10534,7 +10813,7 @@ async function runSetup() {
     R2.warn("You can configure models manually in magic-context.jsonc later");
   }
   const paths = detectConfigPaths();
-  const hadExistingSetup = paths.opencodeConfigFormat !== "none" || existsSync7(paths.magicContextConfig) || paths.tuiConfigFormat !== "none";
+  const hadExistingSetup = paths.opencodeConfigFormat !== "none" || existsSync8(paths.magicContextConfig) || paths.tuiConfigFormat !== "none";
   addPluginToOpenCodeConfig(paths.opencodeConfig, paths.opencodeConfigFormat);
   R2.success(`Plugin added to ${paths.opencodeConfig}`);
   R2.info("Disabled built-in compaction (auto=false, prune=false)");