jbai-cli 1.8.2 → 1.9.2

package/README.md

@@ -2,7 +2,7 @@
 
 **Use AI coding tools with your JetBrains AI subscription** — no separate API keys needed.
 
-One token, all tools: Claude Code, Codex, Aider, Gemini CLI, OpenCode, **Codex Desktop, Cursor**.
+One token, all tools: Claude Code, Codex, Gemini CLI, OpenCode, Goose, Continue, **Codex Desktop, Cursor**.
 
 ## Install
 
@@ -149,17 +149,27 @@ jbai-codex
 jbai-codex exec "explain this codebase"
 ```
 
-### Aider
+### OpenCode
+```bash
+jbai-opencode
+```
+
+### Goose (Block)
 ```bash
-jbai-aider
+# Interactive session
+jbai-goose
 
-# Use Gemini models with Aider
-jbai-aider --model gemini/gemini-2.5-pro
+# One-shot task
+jbai-goose run -t "explain this codebase"
 ```
 
-### OpenCode
+### Continue CLI
 ```bash
-jbai-opencode
+# Interactive TUI
+jbai-continue
+
+# One-shot (print and exit)
+jbai-continue -p "explain this function"
 ```
 
 ### Handoff to Orca Lab (local)
@@ -179,7 +189,7 @@ jbai handoff --task "add new e2e test" \
 ```
 
 ### In-session handoff (interactive tools)
-While running `jbai-codex`, `jbai-claude`, `jbai-gemini`, or `jbai-opencode`:
+While running `jbai-codex`, `jbai-claude`, `jbai-gemini`, `jbai-opencode`, `jbai-goose`, or `jbai-continue`:
 - Press `Ctrl+]` to trigger a handoff to Orca Lab.
 - The last prompt you typed is used as the task.
 
@@ -206,67 +216,78 @@ jbai-claude --super
 # Codex - full auto mode
 jbai-codex --super exec "refactor this code"
 
-# Aider - auto-confirm all changes
-jbai-aider --super
 ```
 
 | Tool | Super Mode Flag |
 |------|-----------------|
 | Claude Code | `--dangerously-skip-permissions` |
 | Codex | `--full-auto` |
-| Aider | `--yes` |
 | Gemini CLI | `--yolo` |
 | OpenCode | N/A (run mode is already non-interactive) |
+| Goose | `GOOSE_MODE=auto` |
+| Continue CLI | `--auto` |
 
 ## Using Different Models
 
 Each tool has a sensible default, but you can specify any available model:
 
 ```bash
-# Claude with Opus
-jbai-claude --model claude-opus-4-1-20250805
+# Claude with Opus 4.6
+jbai-claude --model claude-opus-4-6
 
-# Codex with GPT-5
-jbai-codex --model gpt-5.2-codex
+# Codex with GPT-5.3
+jbai-codex --model gpt-5.3-codex
 
-# Aider with Gemini Pro
-jbai-aider --model gemini/gemini-2.5-pro
+# Goose with GPT-5.2
+jbai-goose run -t "your task" --provider openai --model gpt-5.2-2025-12-11
+
+# Continue with Claude Opus 4.6
+jbai-continue  # select model in TUI
 ```
 
 ### Available Models
 
-**Claude (Anthropic)**
+**Claude (Anthropic)** - Default for Goose, Continue
 | Model | Notes |
 |-------|-------|
-| `claude-sonnet-4-5-20250929` | Default, recommended |
-| `claude-opus-4-1-20250805` | Most capable |
+| `claude-sonnet-4-5-20250929` | Default |
+| `claude-opus-4-6` | Most capable (latest) |
+| `claude-opus-4-5-20251101` | |
+| `claude-opus-4-1-20250805` | |
 | `claude-sonnet-4-20250514` | |
+| `claude-haiku-4-5-20251001` | Fast |
 | `claude-3-7-sonnet-20250219` | |
-| `claude-3-5-haiku-20241022` | Fast |
+| `claude-3-5-haiku-20241022` | Fastest |
 
-**GPT (OpenAI)**
+**GPT (OpenAI Chat)** - Default for OpenCode
 | Model | Notes |
 |-------|-------|
-| `gpt-4o-2024-11-20` | Default |
-| `gpt-5-2025-08-07` | Latest |
+| `gpt-5.2-2025-12-11` | Default, latest |
+| `gpt-5.2` | Alias |
 | `gpt-5.1-2025-11-13` | |
-| `gpt-5.2-2025-12-11` | |
+| `gpt-5-2025-08-07` | |
 | `gpt-5-mini-2025-08-07` | Fast |
+| `gpt-5-nano-2025-08-07` | Fastest |
+| `gpt-4.1-2025-04-14` | |
+| `o4-mini-2025-04-16` | Reasoning |
 | `o3-2025-04-16` | Reasoning |
-| `o3-mini-2025-01-31` | |
 
 **Codex (OpenAI Responses)** - Use with Codex CLI: `jbai-codex --model <model>`
 | Model | Notes |
 |-------|-------|
-| `gpt-5.2-codex` | Default, coding-optimized |
+| `gpt-5.3-codex` | Default, latest |
+| `gpt-5.3-codex-api-preview` | Alias |
+| `gpt-5.2-codex` | Coding-optimized |
+| `gpt-5.2-pro-2025-12-11` | |
 | `gpt-5.1-codex` | |
-| `gpt-5.1-codex-mini` | Faster |
-| `gpt-5.1-codex-max` | |
+| `gpt-5.1-codex-max` | Most capable |
+| `gpt-5.1-codex-mini` | Fast |
+| `gpt-5-codex` | |
 
-**Gemini (Google)** - Use with Aider: `jbai-aider --model gemini/<model>`
+**Gemini (Google)** - Use with Gemini CLI: `jbai-gemini`
 | Model | Notes |
 |-------|-------|
-| `gemini-2.5-flash` | Fast |
+| `gemini-2.5-flash` | Default, fast |
 | `gemini-2.5-pro` | More capable |
 | `gemini-3-pro-preview` | Preview |
 | `gemini-3-flash-preview` | Preview |
@@ -301,8 +322,6 @@ jbai install
 # Install specific tool
 jbai install claude
 jbai install codex
-jbai install aider
-
 # Check what's installed
 jbai doctor
 ```
@@ -313,8 +332,9 @@ jbai doctor
 |------|-----------------|
 | Claude Code | `npm i -g @anthropic-ai/claude-code` |
 | Codex | `npm i -g @openai/codex` |
-| Aider | `pipx install aider-chat` |
-| OpenCode | `go install github.com/opencode-ai/opencode@latest` |
+| OpenCode | `npm i -g opencode-ai` |
+| Goose | `brew install block-goose-cli` |
+| Continue CLI | `npm i -g @continuedev/cli` |
 
 ## Token Management
 

package/bin/jbai-continue.js

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+
+/**
+ * jbai-continue - Continue CLI wrapper for JetBrains AI Platform
+ *
+ * Generates ~/.continue/config.yaml with Grazie models via jbai-proxy,
+ * then launches `cn` (Continue CLI).
+ */
+
+const { runWithHandoff, stripHandoffFlag } = require('../lib/interactive-handoff');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const http = require('http');
+const config = require('../lib/config');
+const { ensureToken } = require('../lib/ensure-token');
+
+const PROXY_PORT = 18080;
+
+function isProxyRunning() {
+  return new Promise((resolve) => {
+    const req = http.get(`http://127.0.0.1:${PROXY_PORT}/health`, { timeout: 1000 }, (res) => {
+      let body = '';
+      res.on('data', chunk => body += chunk);
+      res.on('end', () => {
+        try {
+          const info = JSON.parse(body);
+          resolve(info.status === 'ok');
+        } catch {
+          resolve(false);
+        }
+      });
+    });
+    req.on('error', () => resolve(false));
+    req.on('timeout', () => { req.destroy(); resolve(false); });
+  });
+}
+
+function startProxy() {
+  const { spawn } = require('child_process');
+  const proxyScript = path.join(__dirname, 'jbai-proxy.js');
+  const child = spawn(process.execPath, [proxyScript, '--port', String(PROXY_PORT), '--_daemon'], {
+    detached: true,
+    stdio: 'ignore',
+  });
+  child.unref();
+}
+
+function buildContinueConfig() {
+  const proxyBase = `http://127.0.0.1:${PROXY_PORT}`;
+  const models = [];
+
+  // Add Claude models first (default provider)
+  config.MODELS.claude.available.forEach(model => {
+    const isDefault = model === config.MODELS.claude.default;
+    models.push({
+      name: isDefault ? `${model} (default)` : model,
+      provider: 'anthropic',
+      model,
+      apiBase: `${proxyBase}/anthropic/v1`,
+      apiKey: 'placeholder',
+      roles: ['chat', 'edit'],
+    });
+  });
+
+  // Add OpenAI models via proxy
+  config.MODELS.openai.available.forEach(model => {
+    models.push({
+      name: model,
+      provider: 'openai',
+      model,
+      apiBase: `${proxyBase}/openai/v1`,
+      apiKey: 'placeholder',
+      roles: ['chat', 'edit'],
+    });
+  });
+
+  const defaultModel = `${config.MODELS.claude.default} (default)`;
+
+  return {
+    name: 'JetBrains AI',
+    version: '0.0.1',
+    schema: 'v1',
+    defaultModel,
+    models,
+  };
+}
+
+function toYaml(obj, indent = 0) {
+  const pad = ' '.repeat(indent);
+  let out = '';
+  if (Array.isArray(obj)) {
+    for (const item of obj) {
+      if (typeof item === 'object' && item !== null) {
+        out += `${pad}-\n`;
+        out += toYaml(item, indent + 2);
+      } else {
+        out += `${pad}- ${item}\n`;
+      }
+    }
+  } else if (typeof obj === 'object' && obj !== null) {
+    for (const [key, val] of Object.entries(obj)) {
+      if (Array.isArray(val)) {
+        out += `${pad}${key}:\n`;
+        out += toYaml(val, indent + 2);
+      } else if (typeof val === 'object' && val !== null) {
+        out += `${pad}${key}:\n`;
+        out += toYaml(val, indent + 2);
+      } else {
+        out += `${pad}${key}: ${JSON.stringify(val)}\n`;
+      }
+    }
+  }
+  return out;
+}
+
+(async () => {
+  const token = await ensureToken();
+  const environment = config.getEnvironment();
+  let args = process.argv.slice(2);
+  const handoffConfig = stripHandoffFlag(args);
+  args = handoffConfig.args;
+
+  // Check for super mode (--super, --yolo, -s)
+  const superFlags = ['--super', '--yolo', '-s'];
+  const superMode = args.some(a => superFlags.includes(a));
+  args = args.filter(a => !superFlags.includes(a));
+
+  // Auto-start proxy if not running
+  if (!await isProxyRunning()) {
+    startProxy();
+    await new Promise(r => setTimeout(r, 500));
+  }
+
+  // Write Continue config
+  const configDir = path.join(os.homedir(), '.continue');
+  const configFile = path.join(configDir, 'config.yaml');
+
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+
+  const continueConfig = buildContinueConfig();
+  const yaml = `# Auto-generated by jbai-cli — do not edit manually\n${toYaml(continueConfig)}`;
+  fs.writeFileSync(configFile, yaml);
+
+  let finalArgs = [];
+
+  // Add auto mode (allow all tools) if super
+  if (superMode) {
+    finalArgs.push('--auto');
+    console.log('🚀 Super mode: --auto (all tools allowed) enabled');
+  }
+
+  finalArgs.push(...args);
+
+  const childEnv = {
+    ...process.env,
+    OPENAI_API_KEY: 'placeholder',
+    ANTHROPIC_API_KEY: 'placeholder',
+  };
+
+  const child = runWithHandoff({
+    command: 'cn',
+    args: finalArgs,
+    env: childEnv,
+    toolName: 'jbai-continue',
+    handoffDefaults: {
+      enabled: !handoffConfig.disabled,
+      grazieToken: token,
+      grazieEnvironment: environment === 'production' ? 'PRODUCTION' : 'STAGING',
+      grazieModel: config.MODELS.claude.default,
+      cwd: process.cwd(),
+    },
+  });
+
+  if (child && typeof child.on === 'function') {
+    child.on('error', (err) => {
+      if (err.code === 'ENOENT') {
+        const tool = config.TOOLS.continue;
+        console.error(`❌ ${tool.name} not found.\n`);
+        console.error(`Install with: ${tool.install}`);
+        console.error(`Or run: jbai install continue`);
+      } else {
+        console.error(`Error: ${err.message}`);
+      }
+      process.exit(1);
+    });
+  }
+})();

package/bin/jbai-goose.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+
+/**
+ * jbai-goose - Goose CLI wrapper for JetBrains AI Platform
+ *
+ * Uses jbai-proxy on localhost:18080 to route requests through Grazie.
+ * Goose uses OPENAI_HOST + OPENAI_API_KEY env vars for the OpenAI provider.
+ */
+
+const { runWithHandoff, stripHandoffFlag } = require('../lib/interactive-handoff');
+const path = require('path');
+const http = require('http');
+const config = require('../lib/config');
+const { ensureToken } = require('../lib/ensure-token');
+
+const PROXY_PORT = 18080;
+
+function isProxyRunning() {
+  return new Promise((resolve) => {
+    const req = http.get(`http://127.0.0.1:${PROXY_PORT}/health`, { timeout: 1000 }, (res) => {
+      let body = '';
+      res.on('data', chunk => body += chunk);
+      res.on('end', () => {
+        try {
+          const info = JSON.parse(body);
+          resolve(info.status === 'ok');
+        } catch {
+          resolve(false);
+        }
+      });
+    });
+    req.on('error', () => resolve(false));
+    req.on('timeout', () => { req.destroy(); resolve(false); });
+  });
+}
+
+function startProxy() {
+  const { spawn } = require('child_process');
+  const proxyScript = path.join(__dirname, 'jbai-proxy.js');
+  const child = spawn(process.execPath, [proxyScript, '--port', String(PROXY_PORT), '--_daemon'], {
+    detached: true,
+    stdio: 'ignore',
+  });
+  child.unref();
+}
+
+(async () => {
+  const token = await ensureToken();
+  const environment = config.getEnvironment();
+  let args = process.argv.slice(2);
+  const handoffConfig = stripHandoffFlag(args);
+  args = handoffConfig.args;
+
+  // Check for super mode (--super, --yolo, -s)
+  const superFlags = ['--super', '--yolo', '-s'];
+  const superMode = args.some(a => superFlags.includes(a));
+  args = args.filter(a => !superFlags.includes(a));
+
+  // Auto-start proxy if not running
+  if (!await isProxyRunning()) {
+    startProxy();
+    await new Promise(r => setTimeout(r, 500));
+  }
+
+  // Determine if this is a "run" or "session" command
+  const isRun = args[0] === 'run';
+  const isSession = args[0] === 'session' || args.length === 0;
+
+  // Check if model specified via args or env
+  const hasModel = args.includes('--model');
+  const hasProvider = args.includes('--provider');
+
+  let finalArgs = [...args];
+
+  // Default to session if no subcommand given
+  if (args.length === 0 || (!isRun && !isSession && !['configure', 'info', 'update', 'help'].includes(args[0]))) {
+    if (args.length === 0) {
+      finalArgs = ['session'];
+    }
+  }
+
+  // Determine provider from --model flag or default to anthropic (Claude)
+  const modelIdx = args.indexOf('--model');
+  const requestedModel = modelIdx >= 0 ? args[modelIdx + 1] : null;
+  const isClaudeModel = requestedModel
+    ? requestedModel.startsWith('claude')
+    : true; // default to Claude
+
+  const defaultProvider = isClaudeModel ? 'anthropic' : 'openai';
+  const defaultModel = isClaudeModel ? config.MODELS.claude.default : config.MODELS.openai.default;
+
+  // Inject provider and model if not specified
+  if (!hasProvider && (isSession || isRun || args.length === 0)) {
+    finalArgs.push('--provider', defaultProvider);
+  }
+  if (!hasModel && (isSession || isRun || args.length === 0)) {
+    finalArgs.push('--model', defaultModel);
+  }
+
+  // Add super mode (auto-approve all tool calls)
+  if (superMode) {
+    console.log('🚀 Super mode: auto-approve enabled');
+  }
+
+  const childEnv = {
+    ...process.env,
+    // Configure both providers so --provider/--model can switch freely
+    OPENAI_HOST: `http://127.0.0.1:${PROXY_PORT}/openai`,
+    OPENAI_API_KEY: 'placeholder',
+    ANTHROPIC_HOST: `http://127.0.0.1:${PROXY_PORT}/anthropic`,
+    ANTHROPIC_API_KEY: 'placeholder',
+    GOOSE_PROVIDER: defaultProvider,
+    GOOSE_MODEL: defaultModel,
+    // Auto-approve mode if super
+    ...(superMode ? { GOOSE_MODE: 'auto' } : {}),
+  };
+
+  const child = runWithHandoff({
+    command: 'goose',
+    args: finalArgs,
+    env: childEnv,
+    toolName: 'jbai-goose',
+    handoffDefaults: {
+      enabled: !handoffConfig.disabled,
+      grazieToken: token,
+      grazieEnvironment: environment === 'production' ? 'PRODUCTION' : 'STAGING',
+      grazieModel: config.MODELS.claude.default,
+      cwd: process.cwd(),
+    },
+  });
+
+  if (child && typeof child.on === 'function') {
+    child.on('error', (err) => {
+      if (err.code === 'ENOENT') {
+        const tool = config.TOOLS.goose;
+        console.error(`❌ ${tool.name} not found.\n`);
+        console.error(`Install with: ${tool.install}`);
+        console.error(`Or run: jbai install goose`);
+      } else {
+        console.error(`Error: ${err.message}`);
+      }
+      process.exit(1);
+    });
+  }
+})();

package/bin/jbai-opencode.js

@@ -106,8 +106,20 @@ const { ensureToken } = require('../lib/ensure-token');
   // format (used by jbai-gemini), not OpenAI chat/completions format.
   // Use `jbai gemini` instead for Gemini models.
 
-  // Enable max permissions (yolo mode) by default
-  opencodeConfig.yolo = true;
+  // Enable max permissions for the build agent (allow all tools without asking)
+  if (!opencodeConfig.agent) {
+    opencodeConfig.agent = {};
+  }
+  if (!opencodeConfig.agent.build) {
+    opencodeConfig.agent.build = {};
+  }
+  opencodeConfig.agent.build.permission = 'allow';
+
+  // Only show JetBrains AI providers in the model picker
+  opencodeConfig.enabled_providers = [providerName, anthropicProviderName];
+
+  // Clean up legacy keys that newer OpenCode versions reject
+  delete opencodeConfig.yolo;
 
   // Write config
   fs.writeFileSync(configFile, JSON.stringify(opencodeConfig, null, 2));

package/bin/jbai-proxy.js

@@ -68,6 +68,10 @@ function resolveRoute(method, urlPath) {
 
   // Explicit provider prefix routes
   if (urlPath.startsWith('/openai/')) {
+    // Intercept /openai/v1/models → return synthetic list (Grazie doesn't list codex models)
+    if (urlPath === '/openai/v1/models') {
+      return { target: null, provider: 'models' };
+    }
     const rest = urlPath.slice('/openai'.length); // keeps /v1/...
     return { target: endpoints.openai.replace(/\/v1$/, '') + rest, provider: 'openai' };
   }
@@ -132,7 +136,8 @@ function buildModelsResponse() {
 // Codex CLI model picker response (matches chatgpt.com/backend-api/codex/models format)
 function buildCodexModelsResponse() {
   const descriptions = {
-    'gpt-5.3-codex-api-preview': 'Latest GPT-5.3 Codex model. Designed for long-running, detailed software engineering tasks.',
+    'gpt-5.3-codex': 'Latest GPT-5.3 Codex model. Designed for long-running, detailed software engineering tasks.',
+    'gpt-5.3-codex-api-preview': 'GPT-5.3 Codex (api-preview alias).',
     'gpt-5.2-codex': 'Latest frontier agentic coding model.',
     'gpt-5.2-pro-2025-12-11': 'GPT-5.2 Pro for deep reasoning and complex tasks.',
     'gpt-5.2-2025-12-11': 'Latest frontier model with improvements across knowledge, reasoning and coding.',
@@ -245,7 +250,23 @@ function proxy(req, res) {
   const chunks = [];
   req.on('data', (chunk) => chunks.push(chunk));
   req.on('end', () => {
-    const body = Buffer.concat(chunks);
+    let body = Buffer.concat(chunks);
+
+    // Rewrite model aliases so Grazie accepts the request
+    if (body.length > 0 && (req.headers['content-type'] || '').includes('application/json')) {
+      try {
+        const parsed = JSON.parse(body.toString('utf-8'));
+        if (parsed.model && config.MODEL_ALIASES[parsed.model]) {
+          const original = parsed.model;
+          parsed.model = config.MODEL_ALIASES[parsed.model];
+          body = Buffer.from(JSON.stringify(parsed), 'utf-8');
+          log(`[alias] Rewrote model "${original}" → "${parsed.model}"`);
+        }
+      } catch {
+        // Not valid JSON or parse error — forward as-is
+      }
+    }
+
     const targetUrl = new URL(route.target + (query ? '?' + query : ''));
 
     // Build forwarded headers - pass through everything except host/authorization

package/bin/jbai.js

@@ -30,6 +30,18 @@ const TOOLS = {
     command: 'opencode',
     install: 'npm install -g opencode-ai',
     check: 'opencode --version'
+  },
+  goose: {
+    name: 'Goose',
+    command: 'goose',
+    install: 'brew install block-goose-cli',
+    check: 'goose --version'
+  },
+  continue: {
+    name: 'Continue CLI',
+    command: 'cn',
+    install: 'npm install -g @continuedev/cli',
+    check: 'cn --version'
   }
 };
 
@@ -46,7 +58,7 @@ COMMANDS:
   jbai handoff         Continue task in Orca Lab
   jbai env [staging|production]  Switch environment
   jbai models          List available models
-  jbai install         Install all AI tools (claude, codex, gemini, opencode)
+  jbai install         Install all AI tools (claude, codex, gemini, opencode, goose, continue)
   jbai install claude  Install specific tool
   jbai doctor          Check which tools are installed
   jbai help            Show this help
@@ -300,7 +312,7 @@ function showModels() {
     console.log(`  - ${m}${def}`);
   });
 
-  console.log('\nGPT (OpenAI Chat) - jbai-aider, jbai-opencode:');
+  console.log('\nGPT (OpenAI Chat) - jbai-opencode:');
   config.MODELS.openai.available.forEach((m) => {
     const def = m === config.MODELS.openai.default ? ' (default)' : '';
     console.log(`  - ${m}${def}`);

package/lib/config.js

@@ -48,11 +48,12 @@ const MODELS = {
     ]
   },
   openai: {
-    // Chat/Completions models (used by Aider/OpenCode)
+    // Chat/Completions models (used by OpenCode)
     // Keep in sync with the OpenAI proxy's advertised list.
-    default: 'gpt-4o-2024-11-20',
+    default: 'gpt-5.2-2025-12-11',
     available: [
       // GPT-5.x series (latest) - require date-versioned names
+      // NOTE: gpt-5.3-codex / gpt-5.3-codex-api-preview are Responses-API-only → use via jbai codex
       'gpt-5.2-2025-12-11',
       'gpt-5.2',
       'gpt-5.1-2025-11-13',
@@ -80,9 +81,10 @@ const MODELS = {
   // Codex CLI uses OpenAI models via the "responses" API (wire_api = "responses")
   // Includes chat-capable models PLUS codex-only models (responses API only)
   codex: {
-    default: 'gpt-5.3-codex-api-preview',
+    default: 'gpt-5.3-codex',
     available: [
       // Codex-specific models (responses API only, NOT available via chat/completions)
+      'gpt-5.3-codex',
       'gpt-5.3-codex-api-preview',
       // GPT-5.x chat models (also work via responses API)
       'gpt-5.2-2025-12-11',
@@ -120,6 +122,12 @@ const MODELS = {
   // They are not supported by CLI tools that use OpenAI API format.
 };
 
+// Model aliases: new Codex CLI sends short names that Grazie doesn't recognise yet.
+// Map them to the Grazie-accepted equivalents so the proxy can rewrite on the fly.
+const MODEL_ALIASES = {
+  'gpt-5.3-codex': 'gpt-5.3-codex-api-preview',
+};
+
 // All models for tools that support multiple providers (OpenCode, Codex)
 const ALL_MODELS = {
   openai: MODELS.openai.available,
@@ -295,6 +303,16 @@ const TOOLS = {
     name: 'OpenCode',
     command: 'opencode',
     install: 'npm install -g opencode-ai'
+  },
+  goose: {
+    name: 'Goose',
+    command: 'goose',
+    install: 'brew install block-goose-cli'
+  },
+  continue: {
+    name: 'Continue CLI',
+    command: 'cn',
+    install: 'npm install -g @continuedev/cli'
   }
 };
 
@@ -304,6 +322,7 @@ module.exports = {
   CONFIG_FILE,
   ENDPOINTS,
   MODELS,
+  MODEL_ALIASES,
   ALL_MODELS,
   TOOLS,
   ensureConfigDir,

package/lib/postinstall.js

@@ -41,8 +41,10 @@ Next steps:
 3. Start using AI tools:
    $ jbai-claude     # Claude Code
    $ jbai-codex      # OpenAI Codex
-   $ jbai-aider      # Aider
-   $ jbai-gemini     # Gemini
+   $ jbai-opencode   # OpenCode
+   $ jbai-gemini     # Gemini CLI
+   $ jbai-goose      # Goose (Block)
+   $ jbai-continue   # Continue CLI
 
 Run 'jbai help' for more options.
 `);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jbai-cli",
-  "version": "1.8.2",
-  "description": "CLI wrappers to use AI coding tools (Claude Code, Codex, Gemini CLI, OpenCode) with JetBrains AI Platform",
+  "version": "1.9.2",
+  "description": "CLI wrappers to use AI coding tools (Claude Code, Codex, Gemini CLI, OpenCode, Goose, Continue) with JetBrains AI Platform",
   "keywords": [
     "jetbrains",
     "ai",
@@ -9,6 +9,8 @@
     "codex",
     "gemini",
     "opencode",
+    "goose",
+    "continue",
     "cli",
     "openai",
     "anthropic",
@@ -30,7 +32,9 @@
     "jbai-claude": "bin/jbai-claude.js",
     "jbai-codex": "bin/jbai-codex.js",
     "jbai-gemini": "bin/jbai-gemini.js",
-    "jbai-opencode": "bin/jbai-opencode.js"
+    "jbai-opencode": "bin/jbai-opencode.js",
+    "jbai-goose": "bin/jbai-goose.js",
+    "jbai-continue": "bin/jbai-continue.js"
   },
   "files": [
     "bin/",