@rama_nigg/open-cursor 2.3.20 → 2.4.1

package/dist/cli/opencode-cursor.js

@@ -137,6 +137,173 @@ function formatErrorForUser(error) {
   return output;
 }
 
+// src/utils/logger.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+function getConfiguredLevel() {
+  const env = process.env.CURSOR_ACP_LOG_LEVEL?.toLowerCase();
+  if (env && env in LEVEL_PRIORITY) {
+    return env;
+  }
+  return "info";
+}
+function isSilent() {
+  return process.env.CURSOR_ACP_LOG_SILENT === "1" || process.env.CURSOR_ACP_LOG_SILENT === "true";
+}
+function shouldLog(level) {
+  if (isSilent())
+    return false;
+  const configured = getConfiguredLevel();
+  return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[configured];
+}
+function formatMessage(level, component, message, data) {
+  const timestamp = new Date().toISOString();
+  const prefix = `[cursor-acp:${component}]`;
+  const levelTag = level.toUpperCase().padEnd(5);
+  let formatted = `${prefix} ${levelTag} ${message}`;
+  if (data !== undefined) {
+    if (typeof data === "object") {
+      formatted += ` ${JSON.stringify(data)}`;
+    } else {
+      formatted += ` ${data}`;
+    }
+  }
+  return formatted;
+}
+function isConsoleEnabled() {
+  const consoleEnv = process.env.CURSOR_ACP_LOG_CONSOLE;
+  return consoleEnv === "1" || consoleEnv === "true";
+}
+function ensureLogDir() {
+  if (logDirEnsured)
+    return;
+  try {
+    if (!fs.existsSync(LOG_DIR)) {
+      fs.mkdirSync(LOG_DIR, { recursive: true });
+    }
+    logDirEnsured = true;
+  } catch {
+    logFileError = true;
+  }
+}
+function rotateIfNeeded() {
+  try {
+    const stats = fs.statSync(LOG_FILE);
+    if (stats.size >= MAX_LOG_SIZE) {
+      const backupFile = LOG_FILE + ".1";
+      fs.renameSync(LOG_FILE, backupFile);
+    }
+  } catch {}
+}
+function writeToFile(message) {
+  if (logFileError)
+    return;
+  ensureLogDir();
+  if (logFileError)
+    return;
+  try {
+    rotateIfNeeded();
+    const timestamp = new Date().toISOString();
+    fs.appendFileSync(LOG_FILE, `${timestamp} ${message}
+`);
+  } catch {
+    if (!logFileError) {
+      logFileError = true;
+      console.error(`[cursor-acp] Failed to write logs. Using: ${LOG_FILE}`);
+    }
+  }
+}
+function createLogger(component) {
+  return {
+    debug: (message, data) => {
+      if (!shouldLog("debug"))
+        return;
+      const formatted = formatMessage("debug", component, message, data);
+      writeToFile(formatted);
+      if (isConsoleEnabled())
+        console.error(formatted);
+    },
+    info: (message, data) => {
+      if (!shouldLog("info"))
+        return;
+      const formatted = formatMessage("info", component, message, data);
+      writeToFile(formatted);
+      if (isConsoleEnabled())
+        console.error(formatted);
+    },
+    warn: (message, data) => {
+      if (!shouldLog("warn"))
+        return;
+      const formatted = formatMessage("warn", component, message, data);
+      writeToFile(formatted);
+      if (isConsoleEnabled())
+        console.error(formatted);
+    },
+    error: (message, data) => {
+      if (!shouldLog("error"))
+        return;
+      const formatted = formatMessage("error", component, message, data);
+      writeToFile(formatted);
+      if (isConsoleEnabled())
+        console.error(formatted);
+    }
+  };
+}
+var LOG_DIR, LOG_FILE, MAX_LOG_SIZE, LEVEL_PRIORITY, logDirEnsured = false, logFileError = false;
+var init_logger = __esm(() => {
+  LOG_DIR = path.join(os.homedir(), ".opencode-cursor");
+  LOG_FILE = path.join(LOG_DIR, "plugin.log");
+  MAX_LOG_SIZE = 5 * 1024 * 1024;
+  LEVEL_PRIORITY = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3
+  };
+});
+
+// src/utils/binary.ts
+import { existsSync as fsExistsSync } from "fs";
+import * as pathModule from "path";
+import { homedir as osHomedir } from "os";
+function resolveCursorAgentBinary(deps = {}) {
+  const platform = deps.platform ?? process.platform;
+  const env = deps.env ?? process.env;
+  const checkExists = deps.existsSync ?? fsExistsSync;
+  const home = (deps.homedir ?? osHomedir)();
+  const envOverride = env.CURSOR_AGENT_EXECUTABLE;
+  if (envOverride && envOverride.length > 0) {
+    return envOverride;
+  }
+  if (platform === "win32") {
+    const pathJoin = pathModule.win32.join;
+    const localAppData = env.LOCALAPPDATA ?? pathJoin(home, "AppData", "Local");
+    const knownPath = pathJoin(localAppData, "cursor-agent", "cursor-agent.cmd");
+    if (checkExists(knownPath)) {
+      return knownPath;
+    }
+    log.warn("cursor-agent not found at known Windows path, falling back to PATH", { checkedPath: knownPath });
+    return "cursor-agent.cmd";
+  }
+  const knownPaths = [
+    pathModule.join(home, ".cursor-agent", "cursor-agent"),
+    "/usr/local/bin/cursor-agent"
+  ];
+  for (const p of knownPaths) {
+    if (checkExists(p)) {
+      return p;
+    }
+  }
+  log.warn("cursor-agent not found at known paths, falling back to PATH", { checkedPaths: knownPaths });
+  return "cursor-agent";
+}
+var log;
+var init_binary = __esm(() => {
+  init_logger();
+  log = createLogger("binary");
+});
+
 // src/cli/model-discovery.ts
 import { execFileSync } from "child_process";
 function parseCursorModelsOutput(output) {
@@ -160,9 +327,9 @@ function parseCursorModelsOutput(output) {
   return models;
 }
 function discoverModelsFromCursorAgent() {
-  const raw = execFileSync("cursor-agent", ["models"], {
+  const raw = execFileSync(resolveCursorAgentBinary(), ["models"], {
     encoding: "utf8",
-    killSignal: "SIGTERM",
+    ...process.platform !== "win32" && { killSignal: "SIGTERM" },
     stdio: ["ignore", "pipe", "pipe"],
     timeout: MODEL_DISCOVERY_TIMEOUT_MS
   });
@@ -197,24 +364,453 @@ function fallbackModels() {
   ];
 }
 var MODEL_DISCOVERY_TIMEOUT_MS = 5000;
-var init_model_discovery = () => {};
+var init_model_discovery = __esm(() => {
+  init_binary();
+});
 
 // src/cli/opencode-cursor.ts
 init_model_discovery();
+init_binary();
 import { execFileSync as execFileSync2 } from "child_process";
 import {
   copyFileSync,
-  existsSync,
+  existsSync as existsSync2,
   lstatSync,
-  mkdirSync,
+  mkdirSync as mkdirSync2,
   readFileSync,
   rmSync,
   symlinkSync,
   writeFileSync
 } from "fs";
-import { homedir } from "os";
-import { basename, dirname, join, resolve } from "path";
+import { homedir as homedir2 } from "os";
+import { basename, dirname, join as join3, resolve } from "path";
 import { fileURLToPath } from "url";
+
+// src/models/pricing.ts
+var AUTO_COST = cost(1.25, 6, 0.25, 1.25);
+var COMPOSER_2_COST = cost(0.5, 2.5, 0.2, 0.5);
+var COMPOSER_2_FAST_COST = cost(1.5, 7.5, 0.35, 1.5);
+var COMPOSER_1_5_COST = cost(3.5, 17.5, 0.35, 3.5);
+var CLAUDE_SONNET_COST = cost(3, 15, 0.3, 3.75);
+var CLAUDE_SONNET_LONG_CONTEXT_COST = cost(6, 22.5, 0.6, 7.5);
+var CLAUDE_SONNET_WITH_LONG_CONTEXT_COST = withLongContext(CLAUDE_SONNET_COST, CLAUDE_SONNET_LONG_CONTEXT_COST);
+var CLAUDE_OPUS_COST = cost(5, 25, 0.5, 6.25);
+var CLAUDE_OPUS_FAST_COST = cost(30, 150, 3, 37.5);
+var GEMINI_3_PRO_COST = withLongContext(cost(2, 12, 0.2, 2), cost(4, 18, 0.4, 4));
+var GEMINI_3_FLASH_COST = cost(0.5, 3, 0.05, 0.5);
+var GPT_5_1_COST = cost(1.25, 10, 0.125, 1.25);
+var GPT_5_2_COST = cost(1.75, 14, 0.175, 1.75);
+var GPT_5_3_CODEX_COST = cost(1.75, 14, 0.175, 1.75);
+var GPT_5_4_COST = withLongContext(cost(2.5, 15, 0.25, 2.5), cost(5, 22.5, 0.5, 5));
+var GPT_5_4_FAST_COST = cost(5, 30, 0.5, 5);
+var GPT_5_4_MINI_COST = cost(0.75, 4.5, 0.075, 0.75);
+var GPT_5_4_NANO_COST = cost(0.2, 1.25, 0.02, 0.2);
+var GPT_5_5_COST = withLongContext(cost(5, 30, 0.5, 5), cost(10, 45, 1, 10));
+var GPT_5_MINI_COST = cost(0.25, 2, 0.025, 0.25);
+var GROK_4_20_COST = withLongContext(cost(2, 6, 0.2, 2), cost(4, 12, 0.4, 4));
+var KIMI_K2_5_COST = cost(0.6, 3, 0.1, 0.6);
+function getCursorModelCost(modelId) {
+  if (modelId === "auto")
+    return AUTO_COST;
+  if (modelId === "composer-2-fast")
+    return COMPOSER_2_FAST_COST;
+  if (modelId === "composer-2")
+    return COMPOSER_2_COST;
+  if (modelId === "composer-1.5")
+    return COMPOSER_1_5_COST;
+  if (modelId.startsWith("claude-opus-4-7"))
+    return CLAUDE_OPUS_COST;
+  if (modelId.startsWith("claude-4.6-opus")) {
+    return modelId.endsWith("-fast") ? CLAUDE_OPUS_FAST_COST : CLAUDE_OPUS_COST;
+  }
+  if (modelId.startsWith("claude-4.5-opus"))
+    return CLAUDE_OPUS_COST;
+  if (modelId.startsWith("claude-4.6-sonnet"))
+    return CLAUDE_SONNET_WITH_LONG_CONTEXT_COST;
+  if (modelId.startsWith("claude-4.5-sonnet"))
+    return CLAUDE_SONNET_WITH_LONG_CONTEXT_COST;
+  if (modelId.startsWith("claude-4-sonnet"))
+    return CLAUDE_SONNET_COST;
+  if (modelId === "gemini-3.1-pro")
+    return GEMINI_3_PRO_COST;
+  if (modelId === "gemini-3-flash")
+    return GEMINI_3_FLASH_COST;
+  if (modelId.startsWith("gpt-5.5"))
+    return GPT_5_5_COST;
+  if (modelId.startsWith("gpt-5.4-mini"))
+    return GPT_5_4_MINI_COST;
+  if (modelId.startsWith("gpt-5.4-nano"))
+    return GPT_5_4_NANO_COST;
+  if (modelId.startsWith("gpt-5.4")) {
+    return modelId.endsWith("-fast") ? GPT_5_4_FAST_COST : GPT_5_4_COST;
+  }
+  if (modelId.startsWith("gpt-5.3-codex"))
+    return GPT_5_3_CODEX_COST;
+  if (modelId.startsWith("gpt-5.2-codex"))
+    return GPT_5_2_COST;
+  if (modelId.startsWith("gpt-5.2"))
+    return GPT_5_2_COST;
+  if (modelId.startsWith("gpt-5.1-codex-mini"))
+    return GPT_5_MINI_COST;
+  if (modelId.startsWith("gpt-5.1-codex-max"))
+    return GPT_5_1_COST;
+  if (modelId.startsWith("gpt-5.1"))
+    return GPT_5_1_COST;
+  if (modelId === "gpt-5-mini")
+    return GPT_5_MINI_COST;
+  if (modelId.startsWith("grok-4-20"))
+    return GROK_4_20_COST;
+  if (modelId === "kimi-k2.5")
+    return KIMI_K2_5_COST;
+  return;
+}
+function cost(input, output, cacheRead, cacheWrite) {
+  return {
+    input,
+    output,
+    cache_read: cacheRead,
+    cache_write: cacheWrite
+  };
+}
+function withLongContext(base, longContext) {
+  return {
+    ...base,
+    context_over_200k: longContext
+  };
+}
+
+// src/models/variants.ts
+var DEFAULT_VARIANT_ORDER = [
+  null,
+  "medium",
+  "high",
+  "low",
+  "none",
+  "xhigh",
+  "max"
+];
+var VARIANT_DISPLAY_ORDER = [
+  "none",
+  "low",
+  "low-fast",
+  "fast",
+  "medium",
+  "medium-fast",
+  "medium-thinking",
+  "high",
+  "high-fast",
+  "high-thinking",
+  "high-thinking-fast",
+  "xhigh",
+  "xhigh-fast",
+  "max",
+  "max-thinking",
+  "max-thinking-fast",
+  "thinking",
+  "thinking-low",
+  "thinking-medium",
+  "thinking-high",
+  "thinking-high-fast",
+  "thinking-xhigh",
+  "thinking-max",
+  "extra-high",
+  "spark-preview",
+  "spark-preview-low",
+  "spark-preview-medium",
+  "spark-preview-high",
+  "spark-preview-xhigh"
+];
+function isSafeBaseId(baseId) {
+  const parts = baseId.split("-").filter(Boolean);
+  if (parts.length < 2)
+    return false;
+  if (baseId === "gpt-5")
+    return false;
+  return true;
+}
+function generateBaseCandidates(modelId) {
+  const tokens = modelId.split("-");
+  const candidates = [];
+  for (let i = tokens.length - 1;i >= 1; i--) {
+    const prefix = tokens.slice(0, i).join("-");
+    if (isSafeBaseId(prefix))
+      candidates.push(prefix);
+  }
+  return candidates;
+}
+function computeStats(candidate, modelIds) {
+  const prefix = `${candidate}-`;
+  const firstTokens = new Set;
+  let count = 0;
+  for (const otherId of modelIds) {
+    if (!otherId.startsWith(prefix))
+      continue;
+    count++;
+    const firstToken = otherId.slice(prefix.length).split("-", 1)[0];
+    if (firstToken)
+      firstTokens.add(firstToken);
+  }
+  return { count, diversity: firstTokens.size };
+}
+function chooseBase(modelId, knownModelIds, modelIds) {
+  const candidates = generateBaseCandidates(modelId);
+  if (candidates.length === 0)
+    return null;
+  const stats = new Map;
+  for (const candidate of candidates) {
+    stats.set(candidate, computeStats(candidate, modelIds));
+  }
+  let stepA = null;
+  for (const candidate of candidates) {
+    if (!knownModelIds.has(candidate))
+      continue;
+    const stat = stats.get(candidate);
+    if (!stat || stat.count < 2 || stat.diversity < 2)
+      continue;
+    if (stepA === null || candidate.length < stepA.length)
+      stepA = candidate;
+  }
+  if (stepA !== null)
+    return stepA;
+  let stepB = null;
+  for (const candidate of candidates) {
+    const stat = stats.get(candidate);
+    if (!stat || stat.count < 2)
+      continue;
+    if (stepB === null || stat.diversity > stepB.diversity || stat.diversity === stepB.diversity && candidate.length > stepB.base.length) {
+      stepB = { base: candidate, diversity: stat.diversity };
+    }
+  }
+  if (stepB !== null)
+    return stepB.base;
+  let stepC = null;
+  for (const candidate of candidates) {
+    if (!knownModelIds.has(candidate))
+      continue;
+    if (stepC === null || candidate.length < stepC.length)
+      stepC = candidate;
+  }
+  return stepC;
+}
+function getDefaultMember(members) {
+  for (const variant of DEFAULT_VARIANT_ORDER) {
+    const member = members.find((candidate) => candidate.variant === variant);
+    if (member)
+      return member;
+  }
+  return members[0];
+}
+function formatModelName(modelId) {
+  return modelId.split("-").map((part) => {
+    if (part === "gpt")
+      return "GPT";
+    if (part === "xhigh")
+      return "XHigh";
+    return part.charAt(0).toUpperCase() + part.slice(1);
+  }).join(" ");
+}
+function compareVariants(a, b) {
+  if (a.variant === null)
+    return -1;
+  if (b.variant === null)
+    return 1;
+  const aIndex = VARIANT_DISPLAY_ORDER.indexOf(a.variant);
+  const bIndex = VARIANT_DISPLAY_ORDER.indexOf(b.variant);
+  if (aIndex !== -1 && bIndex !== -1)
+    return aIndex - bIndex;
+  if (aIndex !== -1)
+    return -1;
+  if (bIndex !== -1)
+    return 1;
+  return a.variant.localeCompare(b.variant);
+}
+function createGroup(baseId, members) {
+  const defaultMember = getDefaultMember(members);
+  const variants = {};
+  for (const member of [...members].sort(compareVariants)) {
+    if (member.variant) {
+      variants[member.variant] = member.cursorModelId;
+    }
+  }
+  return {
+    baseId,
+    name: defaultMember.variant === null ? defaultMember.name : formatModelName(baseId),
+    defaultCursorModelId: defaultMember.cursorModelId,
+    variants,
+    members
+  };
+}
+function groupCursorModels(models) {
+  const knownModelIds = new Set(models.map((model) => model.id));
+  const modelIds = models.map((model) => model.id);
+  const preferredBase = new Map;
+  for (const model of models) {
+    const base = chooseBase(model.id, knownModelIds, modelIds);
+    if (base)
+      preferredBase.set(model.id, base);
+  }
+  const baseSet = new Set(preferredBase.values());
+  const groupMembers = new Map;
+  const groupOrder = [];
+  const recordMember = (baseId, member) => {
+    const existing = groupMembers.get(baseId);
+    if (existing) {
+      existing.push(member);
+      return;
+    }
+    groupMembers.set(baseId, [member]);
+    groupOrder.push(baseId);
+  };
+  for (const model of models) {
+    if (baseSet.has(model.id) && knownModelIds.has(model.id)) {
+      recordMember(model.id, {
+        baseId: model.id,
+        variant: null,
+        cursorModelId: model.id,
+        name: model.name
+      });
+      continue;
+    }
+    const base = preferredBase.get(model.id);
+    if (!base)
+      continue;
+    recordMember(base, {
+      baseId: base,
+      variant: model.id.slice(base.length + 1),
+      cursorModelId: model.id,
+      name: model.name
+    });
+  }
+  const groupedIds = new Set;
+  const groups = [];
+  for (const baseId of groupOrder) {
+    const members = groupMembers.get(baseId);
+    if (!members || members.length < 2)
+      continue;
+    groups.push(createGroup(baseId, members));
+    for (const member of members)
+      groupedIds.add(member.cursorModelId);
+  }
+  const direct = [];
+  for (const model of models) {
+    if (groupedIds.has(model.id))
+      continue;
+    direct.push(model);
+  }
+  return { groups, direct };
+}
+function createVariantModelEntries(models) {
+  const { groups, direct } = groupCursorModels(models);
+  const entries = {};
+  const groupedModelIds = new Set;
+  for (const group of groups) {
+    const variants = {};
+    for (const [variant, cursorModel] of Object.entries(group.variants)) {
+      const variantEntry = { cursorModel };
+      const variantCost = getCursorModelCost(cursorModel);
+      if (variantCost)
+        variantEntry.cost = variantCost;
+      variants[variant] = variantEntry;
+    }
+    const groupEntry = {
+      name: group.name,
+      options: {
+        cursorModel: group.defaultCursorModelId
+      },
+      variants
+    };
+    const defaultCost = getCursorModelCost(group.defaultCursorModelId);
+    if (defaultCost)
+      groupEntry.cost = defaultCost;
+    entries[group.baseId] = groupEntry;
+    for (const member of group.members) {
+      groupedModelIds.add(member.cursorModelId);
+    }
+  }
+  for (const model of direct) {
+    const entry = { name: model.name };
+    const directCost = getCursorModelCost(model.id);
+    if (directCost)
+      entry.cost = directCost;
+    entries[model.id] = entry;
+  }
+  return { entries, groupedModelIds };
+}
+function mergeCursorModelEntries(existingModels, discoveredModels, options) {
+  if (!options.variants) {
+    return mergeDirectModelEntries(existingModels, discoveredModels);
+  }
+  const { entries, groupedModelIds } = createVariantModelEntries(discoveredModels);
+  const models = { ...existingModels };
+  let removedCount = 0;
+  if (options.compact) {
+    for (const modelId of groupedModelIds) {
+      if (!Object.prototype.hasOwnProperty.call(models, modelId))
+        continue;
+      if (Object.prototype.hasOwnProperty.call(entries, modelId))
+        continue;
+      delete models[modelId];
+      removedCount++;
+    }
+  }
+  for (const [modelId, entry] of Object.entries(entries)) {
+    models[modelId] = mergeEntryPreservingUserFields(models[modelId], entry);
+  }
+  return {
+    models,
+    syncedCount: Object.keys(entries).length,
+    groupedCount: groupedModelIds.size,
+    removedCount
+  };
+}
+function mergeDirectModelEntries(existingModels, discoveredModels) {
+  const models = { ...existingModels };
+  for (const model of discoveredModels) {
+    const generated = { name: model.name };
+    const directCost = getCursorModelCost(model.id);
+    if (directCost)
+      generated.cost = directCost;
+    models[model.id] = mergeEntryPreservingUserFields(models[model.id], generated);
+  }
+  return {
+    models,
+    syncedCount: discoveredModels.length,
+    groupedCount: 0,
+    removedCount: 0
+  };
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeEntryPreservingUserFields(existing, generated) {
+  if (!isPlainObject(existing))
+    return generated;
+  const merged = { ...existing, ...generated };
+  if (existing.cost !== undefined) {
+    merged.cost = existing.cost;
+  }
+  if (isPlainObject(existing.variants) && isPlainObject(generated.variants)) {
+    const mergedVariants = { ...generated.variants };
+    for (const [variantKey, existingVariant] of Object.entries(existing.variants)) {
+      const generatedVariant = generated.variants[variantKey];
+      if (!isPlainObject(existingVariant))
+        continue;
+      if (!isPlainObject(generatedVariant)) {
+        mergedVariants[variantKey] = existingVariant;
+        continue;
+      }
+      const variantMerged = { ...generatedVariant };
+      if (existingVariant.cost !== undefined) {
+        variantMerged.cost = existingVariant.cost;
+      }
+      mergedVariants[variantKey] = variantMerged;
+    }
+    merged.variants = mergedVariants;
+  }
+  return merged;
+}
+
+// src/cli/opencode-cursor.ts
 var BRANDING_HEADER = `
  ▄▄▄  ▄▄▄▄  ▄▄▄▄▄ ▄▄  ▄▄      ▄▄▄  ▄▄ ▄▄ ▄▄▄▄   ▄▄▄▄   ▄▄▄   ▄▄▄▄
 ██ ██ ██ ██ ██▄▄  ███▄██ ▄▄▄ ██ ▀▀ ██ ██ ██ ██ ██▄▄▄  ██ ██  ██ ██
@@ -237,7 +833,7 @@ function checkBun() {
 }
 function checkCursorAgent() {
   try {
-    const output = execFileSync2("cursor-agent", ["--version"], { encoding: "utf8" }).trim();
+    const output = execFileSync2(resolveCursorAgentBinary(), ["--version"], { encoding: "utf8" }).trim();
     const version = output.split(`
 `)[0] || "installed";
     return { name: "cursor-agent", passed: true, message: version };
@@ -251,7 +847,11 @@ function checkCursorAgent() {
 }
 function checkCursorAgentLogin() {
   try {
-    execFileSync2("cursor-agent", ["models"], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+    execFileSync2(resolveCursorAgentBinary(), ["models"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      timeout: 3000
+    });
     return { name: "cursor-agent login", passed: true, message: "logged in" };
   } catch {
     return {
@@ -284,7 +884,7 @@ function isNpmDirectInstalled(config) {
 }
 function checkPluginFile(pluginPath, config) {
   try {
-    if (!existsSync(pluginPath)) {
+    if (!existsSync2(pluginPath)) {
       if (isNpmDirectInstalled(config)) {
         return {
           name: "Plugin file",
@@ -314,7 +914,7 @@ function checkPluginFile(pluginPath, config) {
 }
 function checkProviderConfig(configPath) {
   try {
-    if (!existsSync(configPath)) {
+    if (!existsSync2(configPath)) {
       return {
         name: "Provider config",
         passed: false,
@@ -342,8 +942,8 @@ function checkProviderConfig(configPath) {
 }
 function checkAiSdk(opencodeDir) {
   try {
-    const sdkPath = join(opencodeDir, "node_modules", "@ai-sdk", "openai-compatible");
-    if (existsSync(sdkPath)) {
+    const sdkPath = join3(opencodeDir, "node_modules", "@ai-sdk", "openai-compatible");
+    if (existsSync2(sdkPath)) {
       return { name: "AI SDK", passed: true, message: "@ai-sdk/openai-compatible installed" };
     }
     return {
@@ -388,6 +988,7 @@ function printHelp() {
 Commands:
   install     Configure OpenCode for Cursor (idempotent, safe to re-run)
   sync-models Refresh model list from cursor-agent
+  models      Explain discovered Cursor model groups and variants
   status      Show current configuration state
   doctor      Diagnose common issues
   uninstall   Remove cursor-acp from OpenCode config
@@ -399,8 +1000,13 @@ Options:
   --base-url <url>      Proxy base URL (default: http://127.0.0.1:32124/v1)
   --copy                Copy plugin instead of symlink
   --skip-models         Skip model sync during install
+  --variants            Generate compact OpenCode model variants from Cursor models
+  --compact             With --variants, remove raw grouped Cursor model entries
+  --dry-run             Preview sync/install config changes without writing files
+  --deep                Run extra doctor checks for models and variant config
+  --explain             Show model grouping explanation (models command)
   --no-backup           Don't create config backup
-  --json                Output in JSON format (status command only)
+  --json                Output in JSON format where supported
 `);
 }
 function parseArgs(argv) {
@@ -413,6 +1019,16 @@ function parseArgs(argv) {
       options.copy = true;
     } else if (arg === "--skip-models") {
       options.skipModels = true;
+    } else if (arg === "--variants") {
+      options.variants = true;
+    } else if (arg === "--compact") {
+      options.compact = true;
+    } else if (arg === "--dry-run") {
+      options.dryRun = true;
+    } else if (arg === "--deep") {
+      options.deep = true;
+    } else if (arg === "--explain") {
+      options.explain = true;
     } else if (arg === "--no-backup") {
       options.noBackup = true;
     } else if (arg === "--config" && rest[i + 1]) {
@@ -436,6 +1052,7 @@ function normalizeCommand(value) {
   switch ((value || "help").toLowerCase()) {
     case "install":
     case "sync-models":
+    case "models":
     case "uninstall":
     case "status":
     case "doctor":
@@ -449,24 +1066,24 @@ function getConfigHome() {
   const xdg = process.env.XDG_CONFIG_HOME;
   if (xdg && xdg.length > 0)
     return xdg;
-  return join(homedir(), ".config");
+  return join3(homedir2(), ".config");
 }
 function resolvePaths(options) {
-  const opencodeDir = join(getConfigHome(), "opencode");
-  const configPath = resolve(options.config || join(opencodeDir, "opencode.json"));
-  const pluginDir = resolve(options.pluginDir || join(opencodeDir, "plugin"));
-  const pluginPath = join(pluginDir, `${PROVIDER_ID}.js`);
+  const opencodeDir = join3(getConfigHome(), "opencode");
+  const configPath = resolve(options.config || join3(opencodeDir, "opencode.json"));
+  const pluginDir = resolve(options.pluginDir || join3(opencodeDir, "plugin"));
+  const pluginPath = join3(pluginDir, `${PROVIDER_ID}.js`);
   return { opencodeDir, configPath, pluginDir, pluginPath };
 }
 function resolvePluginSource() {
   const currentFile = fileURLToPath(import.meta.url);
   const currentDir = dirname(currentFile);
   const candidates = [
-    join(currentDir, "plugin-entry.js"),
-    join(currentDir, "..", "plugin-entry.js")
+    join3(currentDir, "plugin-entry.js"),
+    join3(currentDir, "..", "plugin-entry.js")
   ];
   for (const candidate of candidates) {
-    if (existsSync(candidate)) {
+    if (existsSync2(candidate)) {
       return candidate;
     }
   }
@@ -476,7 +1093,7 @@ function isErrnoException(error) {
   return typeof error === "object" && error !== null && "code" in error;
 }
 function readConfig(configPath) {
-  if (!existsSync(configPath)) {
+  if (!existsSync2(configPath)) {
     return { plugin: [], provider: {} };
   }
   let raw;
@@ -494,12 +1111,14 @@ function readConfig(configPath) {
     throw new Error(`Invalid JSON in config: ${configPath} (${String(error)})`);
   }
 }
-function writeConfig(configPath, config, noBackup) {
-  mkdirSync(dirname(configPath), { recursive: true });
-  if (!noBackup && existsSync(configPath)) {
+function writeConfig(configPath, config, noBackup, silent = false) {
+  mkdirSync2(dirname(configPath), { recursive: true });
+  if (!noBackup && existsSync2(configPath)) {
     const backupPath = `${configPath}.bak.${new Date().toISOString().replace(/[:]/g, "-")}`;
     copyFileSync(configPath, backupPath);
-    console.log(`Backup written: ${backupPath}`);
+    if (!silent) {
+      console.log(`Backup written: ${backupPath}`);
+    }
   }
   writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
 `, "utf8");
@@ -525,7 +1144,7 @@ function ensureProvider(config, baseUrl) {
   };
 }
 function ensurePluginLink(pluginSource, pluginPath, copyMode) {
-  mkdirSync(dirname(pluginPath), { recursive: true });
+  mkdirSync2(dirname(pluginPath), { recursive: true });
   rmSync(pluginPath, { force: true });
   if (copyMode) {
     copyFileSync(pluginSource, pluginPath);
@@ -542,6 +1161,104 @@ function discoverModelsSafe() {
     return fallbackModels();
   }
 }
+function syncModelsIntoProvider(config, options) {
+  if (options.compact && !options.variants) {
+    throw new Error("--compact requires --variants");
+  }
+  const discoveredModels = discoverModelsSafe();
+  const provider = config.provider[PROVIDER_ID];
+  const existingModels = provider.models && typeof provider.models === "object" ? provider.models : {};
+  const beforeModels = snapshotModels(existingModels);
+  const result = mergeCursorModelEntries(existingModels, discoveredModels, {
+    variants: options.variants === true,
+    compact: options.compact === true
+  });
+  provider.models = result.models;
+  return {
+    syncedCount: result.syncedCount,
+    groupedCount: result.groupedCount,
+    removedCount: result.removedCount,
+    summary: summarizeModelSync(beforeModels, result.models)
+  };
+}
+function explainCursorModels(models) {
+  const grouped = groupCursorModels(models);
+  const groupedCount = grouped.groups.reduce((total, group) => total + group.members.length, 0);
+  return {
+    modelCount: models.length,
+    groupedCount,
+    directCount: grouped.direct.length,
+    groups: grouped.groups.map((group) => ({
+      id: group.baseId,
+      name: group.name,
+      defaultCursorModel: group.defaultCursorModelId,
+      memberCount: group.members.length,
+      variants: group.variants
+    })),
+    direct: grouped.direct.map((model) => model.id)
+  };
+}
+function createSyncJsonResult(result, options, configPath) {
+  return {
+    ...result,
+    configPath,
+    dryRun: options.dryRun === true,
+    variants: options.variants === true,
+    compact: options.compact === true
+  };
+}
+function snapshotModels(models) {
+  return JSON.parse(JSON.stringify(models));
+}
+function summarizeModelSync(beforeModels, afterModels) {
+  let added = 0;
+  let updated = 0;
+  let removed = 0;
+  let skipped = 0;
+  for (const [modelId, afterEntry] of Object.entries(afterModels)) {
+    if (!Object.prototype.hasOwnProperty.call(beforeModels, modelId)) {
+      added++;
+      continue;
+    }
+    if (JSON.stringify(beforeModels[modelId]) === JSON.stringify(afterEntry)) {
+      skipped++;
+    } else {
+      updated++;
+    }
+  }
+  for (const modelId of Object.keys(beforeModels)) {
+    if (!Object.prototype.hasOwnProperty.call(afterModels, modelId)) {
+      removed++;
+    }
+  }
+  return {
+    added,
+    updated,
+    removed,
+    priced: countPricedModelEntries(afterModels),
+    skipped
+  };
+}
+function countPricedModelEntries(models) {
+  let priced = 0;
+  for (const entry of Object.values(models)) {
+    if (!isRecord(entry))
+      continue;
+    if (isRecord(entry.cost))
+      priced++;
+    if (!isRecord(entry.variants))
+      continue;
+    for (const variantEntry of Object.values(entry.variants)) {
+      if (isRecord(variantEntry) && isRecord(variantEntry.cost)) {
+        priced++;
+      }
+    }
+  }
+  return priced;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function installAiSdk(opencodeDir) {
   try {
     execFileSync2("bun", ["install", "@ai-sdk/openai-compatible"], {
@@ -558,20 +1275,23 @@ function commandInstall(options) {
   const baseUrl = options.baseUrl || DEFAULT_BASE_URL;
   const copyMode = options.copy === true;
   const pluginSource = resolvePluginSource();
-  mkdirSync(opencodeDir, { recursive: true });
-  ensurePluginLink(pluginSource, pluginPath, copyMode);
+  if (!options.dryRun) {
+    mkdirSync2(opencodeDir, { recursive: true });
+    ensurePluginLink(pluginSource, pluginPath, copyMode);
+  }
   const config = readConfig(configPath);
   ensureProvider(config, baseUrl);
   if (!options.skipModels) {
-    const models = discoverModelsSafe();
-    for (const model of models) {
-      config.provider[PROVIDER_ID].models[model.id] = { name: model.name };
-    }
-    console.log(`Models synced: ${models.length}`);
+    const result = syncModelsIntoProvider(config, options);
+    printSyncResult(result, options);
+  }
+  if (options.dryRun) {
+    console.log("Dry run: no files changed.");
+  } else {
+    writeConfig(configPath, config, options.noBackup === true);
+    installAiSdk(opencodeDir);
   }
-  writeConfig(configPath, config, options.noBackup === true);
-  installAiSdk(opencodeDir);
-  console.log(`Installed ${PROVIDER_ID}`);
+  console.log(`${options.dryRun ? "Would install" : "Installed"} ${PROVIDER_ID}`);
   console.log(`Plugin path: ${pluginPath}${copyMode ? " (copy)" : " (symlink)"}`);
   console.log(`Config path: ${configPath}`);
 }
@@ -579,19 +1299,74 @@ function commandSyncModels(options) {
   const { configPath } = resolvePaths(options);
   const config = readConfig(configPath);
   ensureProvider(config, options.baseUrl || DEFAULT_BASE_URL);
-  const models = discoverModelsSafe();
-  for (const model of models) {
-    config.provider[PROVIDER_ID].models[model.id] = { name: model.name };
+  const result = syncModelsIntoProvider(config, options);
+  if (!options.dryRun) {
+    writeConfig(configPath, config, options.noBackup === true, options.json === true);
+  }
+  if (options.json) {
+    console.log(JSON.stringify(createSyncJsonResult(result, options, configPath), null, 2));
+    return;
+  }
+  printSyncResult(result, options);
+  if (options.dryRun) {
+    console.log("Dry run: no changes written.");
   }
-  writeConfig(configPath, config, options.noBackup === true);
-  console.log(`Models synced: ${models.length}`);
   console.log(`Config path: ${configPath}`);
 }
+function commandModels(options) {
+  const models = discoverModelsSafe();
+  const explanation = explainCursorModels(models);
+  if (options.json) {
+    console.log(JSON.stringify(explanation, null, 2));
+    return;
+  }
+  console.log(`Cursor models discovered: ${explanation.modelCount}`);
+  console.log(`Grouped Cursor models: ${explanation.groupedCount}`);
+  console.log(`Direct models: ${explanation.directCount}`);
+  if (!options.explain) {
+    return;
+  }
+  console.log("");
+  console.log("Model groups:");
+  for (const group of explanation.groups) {
+    console.log(`  ${group.id}`);
+    console.log(`    Default: ${group.defaultCursorModel}`);
+    const variants = Object.entries(group.variants);
+    if (variants.length === 0) {
+      console.log("    Variants: none");
+      continue;
+    }
+    console.log("    Variants:");
+    for (const [variant, cursorModel] of variants) {
+      console.log(`      ${variant}: ${cursorModel}`);
+    }
+  }
+  console.log("");
+  console.log("Direct models:");
+  for (const modelId of explanation.direct) {
+    console.log(`  ${modelId}`);
+  }
+}
+function printSyncResult(result, options) {
+  console.log(`Models synced: ${result.syncedCount}`);
+  if (options.variants) {
+    console.log(`Grouped Cursor models: ${result.groupedCount}`);
+  }
+  if (result.removedCount > 0) {
+    console.log(`Raw grouped models removed: ${result.removedCount}`);
+  }
+  console.log("Sync summary:");
+  console.log(`  Added: ${result.summary.added}`);
+  console.log(`  Updated: ${result.summary.updated}`);
+  console.log(`  Removed: ${result.summary.removed}`);
+  console.log(`  Priced: ${result.summary.priced}`);
+  console.log(`  Skipped: ${result.summary.skipped}`);
+}
 var NPM_PACKAGE = "@rama_nigg/open-cursor";
 function commandUninstall(options) {
   const { configPath, pluginPath } = resolvePaths(options);
   rmSync(pluginPath, { force: true });
-  if (existsSync(configPath)) {
+  if (existsSync2(configPath)) {
     const config = readConfig(configPath);
     if (Array.isArray(config.plugin)) {
       config.plugin = config.plugin.filter((name) => {
@@ -613,7 +1388,7 @@ function commandUninstall(options) {
 function getStatusResult(configPath, pluginPath) {
   let pluginType = "missing";
   let pluginTarget;
-  if (existsSync(pluginPath)) {
+  if (existsSync2(pluginPath)) {
     try {
       const stat = lstatSync(pluginPath);
       pluginType = stat.isSymbolicLink() ? "symlink" : "file";
@@ -636,7 +1411,7 @@ function getStatusResult(configPath, pluginPath) {
   let providerEnabled = false;
   let baseUrl = "http://127.0.0.1:32124/v1";
   let modelCount = 0;
-  if (existsSync(configPath)) {
+  if (existsSync2(configPath)) {
     config = readConfig(configPath);
     const provider = config.provider?.["cursor-acp"];
     providerEnabled = !!provider;
@@ -648,8 +1423,8 @@ function getStatusResult(configPath, pluginPath) {
     config = undefined;
   }
   const opencodeDir = dirname(configPath);
-  const sdkPath = join(opencodeDir, "node_modules", "@ai-sdk", "openai-compatible");
-  const aiSdkInstalled = existsSync(sdkPath);
+  const sdkPath = join3(opencodeDir, "node_modules", "@ai-sdk", "openai-compatible");
+  const aiSdkInstalled = existsSync2(sdkPath);
   let installMethod = "none";
   if (pluginType !== "missing") {
     installMethod = "symlink";
@@ -675,6 +1450,95 @@ function getStatusResult(configPath, pluginPath) {
     }
   };
 }
+function runDeepDoctorChecks(configPath) {
+  const checks = [];
+  let config;
+  try {
+    config = readConfig(configPath);
+  } catch (error) {
+    return [{
+      name: "Deep config read",
+      passed: false,
+      message: error instanceof Error ? error.message : String(error)
+    }];
+  }
+  const provider = config.provider?.[PROVIDER_ID];
+  const models = isRecord(provider?.models) ? provider.models : {};
+  const baseUrl = typeof provider?.options?.baseURL === "string" ? provider.options.baseURL : "";
+  checks.push({
+    name: "Provider base URL",
+    passed: baseUrl.startsWith("http://") || baseUrl.startsWith("https://"),
+    message: baseUrl || "missing - run: open-cursor install"
+  });
+  checks.push({
+    name: "Provider models",
+    passed: Object.keys(models).length > 0,
+    message: `${Object.keys(models).length} configured model(s)`
+  });
+  const variantEntryCount = countVariantModelEntries(models);
+  checks.push({
+    name: "Compact variants",
+    passed: variantEntryCount > 0,
+    warning: variantEntryCount === 0,
+    message: variantEntryCount > 0 ? `${variantEntryCount} model entr${variantEntryCount === 1 ? "y" : "ies"} with variants` : "no compact variants found - run: open-cursor sync-models --variants --compact"
+  });
+  let discoveredModels;
+  try {
+    discoveredModels = discoverModelsFromCursorAgent();
+    checks.push({
+      name: "Cursor model discovery",
+      passed: true,
+      message: `${discoveredModels.length} model(s) from cursor-agent`
+    });
+  } catch (error) {
+    checks.push({
+      name: "Cursor model discovery",
+      passed: false,
+      message: error instanceof Error ? error.message : String(error),
+      warning: true
+    });
+    return checks;
+  }
+  const knownModelIds = new Set(discoveredModels.map((model) => model.id));
+  const unknownTargets = collectConfiguredCursorModels(models).filter((modelId) => !knownModelIds.has(modelId));
+  checks.push({
+    name: "Configured Cursor model targets",
+    passed: unknownTargets.length === 0,
+    warning: unknownTargets.length > 0,
+    message: unknownTargets.length === 0 ? "all configured targets exist in cursor-agent models" : `${unknownTargets.length} target(s) not found: ${unknownTargets.slice(0, 5).join(", ")}`
+  });
+  return checks;
+}
+function countVariantModelEntries(models) {
+  return Object.values(models).filter((entry) => {
+    return isRecord(entry) && isRecord(entry.variants) && Object.keys(entry.variants).length > 0;
+  }).length;
+}
+function collectConfiguredCursorModels(models) {
+  const targets = [];
+  for (const [modelId, entry] of Object.entries(models)) {
+    if (!isRecord(entry)) {
+      targets.push(modelId);
+      continue;
+    }
+    const optionTarget = readCursorModel(entry.options);
+    targets.push(optionTarget || modelId);
+    if (!isRecord(entry.variants))
+      continue;
+    for (const variantEntry of Object.values(entry.variants)) {
+      const variantTarget = readCursorModel(variantEntry);
+      if (variantTarget)
+        targets.push(variantTarget);
+    }
+  }
+  return [...new Set(targets)];
+}
+function readCursorModel(value) {
+  if (!isRecord(value))
+    return;
+  const cursorModel = value.cursorModel;
+  return typeof cursorModel === "string" && cursorModel.trim().length > 0 ? cursorModel.trim() : undefined;
+}
 function commandStatus(options) {
   const { configPath, pluginPath } = resolvePaths(options);
   const result = getStatusResult(configPath, pluginPath);
@@ -706,7 +1570,15 @@ function commandStatus(options) {
 }
 function commandDoctor(options) {
   const { configPath, pluginPath } = resolvePaths(options);
-  const checks = runDoctorChecks(configPath, pluginPath);
+  const checks = [
+    ...runDoctorChecks(configPath, pluginPath),
+    ...options.deep ? runDeepDoctorChecks(configPath) : []
+  ];
+  if (options.json) {
+    const failed2 = checks.filter((c) => !c.passed && !c.warning);
+    console.log(JSON.stringify({ deep: options.deep === true, checks, failed: failed2.length }, null, 2));
+    return;
+  }
   console.log("");
   for (const check of checks) {
     const symbol = check.passed ? "✓" : check.warning ? "⚠" : "✗";
@@ -740,6 +1612,9 @@ function main() {
       case "sync-models":
         commandSyncModels(parsed.options);
         return;
+      case "models":
+        commandModels(parsed.options);
+        return;
       case "uninstall":
         commandUninstall(parsed.options);
         return;
@@ -759,11 +1634,16 @@ function main() {
     process.exit(1);
   }
 }
-main();
+if (fileURLToPath(import.meta.url) === resolve(process.argv[1] || "")) {
+  main();
+}
 export {
+  summarizeModelSync,
   runDoctorChecks,
+  runDeepDoctorChecks,
   getStatusResult,
   getBrandingHeader,
+  explainCursorModels,
   checkCursorAgentLogin,
   checkCursorAgent,
   checkBun