chutes-plugin 0.1.0

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "chutes-plugin",
+  "version": "0.1.0",
+  "description": "Chutes Models plugin for OpenCode - Access 48+ state-of-the-art AI models through the Chutes API",
+  "author": {
+    "name": "Gianmarco Martinelli",
+    "email": "mark182@gmail.com"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "chutes-plugin": "dist/cli/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zenobi-us/chutes-plugin"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "src/version.ts",
+    "src/cli"
+  ],
+  "dependencies": {
+    "@opencode-ai/plugin": "1.0.85",
+    "cac": "^6.7.14"
+  },
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir dist --target bun && bun build ./src/cli/index.ts --outdir dist/cli --target bun --external cac",
+    "build:plugin": "bun build ./src/index.ts --outdir dist --target bun",
+    "build:cli": "bun build ./src/cli/index.ts --outdir dist/cli --target bun --external cac"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.1",
+    "@types/node": "^20.11.5",
+    "@typescript-eslint/eslint-plugin": "8.47.0",
+    "@typescript-eslint/parser": "8.47.0",
+    "bun-types": "latest",
+    "eslint": "^9.39.1",
+    "eslint-config-prettier": "10.1.8",
+    "eslint-plugin-prettier": "^5.1.3",
+    "prettier": "^3.2.4",
+    "typescript-eslint": "^8.47.0",
+    "vitest": "^3.2.4"
+  }
+}

package/src/cli/doctor.ts

@@ -0,0 +1,119 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+export async function doctor(): Promise<void> {
+  console.log('🐍 chutes-plugin doctor\n');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+
+  let checks = 0;
+  let passed = 0;
+
+  function check(name: string, result: boolean, message: string): void {
+    checks++;
+    if (result) {
+      passed++;
+      console.log(`✅ ${name}`);
+    } else {
+      console.log(`❌ ${name}`);
+      console.log(`   ${message}`);
+    }
+  }
+
+  const projectDir = process.cwd();
+  const homeDir = process.env.HOME || process.env.USERPROFILE;
+
+  console.log('Installation Checks:\n');
+
+  let hasProjectConfig = false;
+  let hasGlobalConfig = false;
+  let installType = 'none';
+
+  const projectConfigPath = path.join(projectDir, 'opencode.json');
+  if (fs.existsSync(projectConfigPath)) {
+    const content = fs.readFileSync(projectConfigPath, 'utf-8');
+    const config = JSON.parse(content);
+    const plugins = (config.plugins as string[]) || [];
+
+    for (const p of plugins) {
+      if (p.includes('chutes-plugin')) {
+        hasProjectConfig = true;
+        installType = 'npm';
+        break;
+      }
+    }
+
+    const opencodeDir = path.join(projectDir, '.opencode', 'plugin', 'chutes-plugin');
+    if (fs.existsSync(opencodeDir)) {
+      hasProjectConfig = true;
+      installType = 'project';
+    }
+  }
+
+  if (!hasProjectConfig && homeDir) {
+    const globalConfigPath = path.join(homeDir, '.config', 'opencode', 'opencode.json');
+    if (fs.existsSync(globalConfigPath)) {
+      const content = fs.readFileSync(globalConfigPath, 'utf-8');
+      const config = JSON.parse(content);
+      const plugins = (config.plugins as string[]) || [];
+
+      for (const p of plugins) {
+        if (p.includes('chutes-plugin')) {
+          hasGlobalConfig = true;
+          installType = 'global';
+          break;
+        }
+      }
+    }
+  }
+
+  check(
+    'Plugin installed',
+    hasProjectConfig || hasGlobalConfig,
+    installType === 'none' ? 'Run: bunx chutes-plugin install' : `Installed as ${installType}`
+  );
+
+  console.log('\nAPI Checks:\n');
+
+  let hasAuth = false;
+  if (homeDir) {
+    const authPath = path.join(homeDir, '.local', 'share', 'opencode', 'auth.json');
+    if (fs.existsSync(authPath)) {
+      const content = fs.readFileSync(authPath, 'utf-8');
+      const auth = JSON.parse(content);
+      hasAuth = !!(auth.chutes || auth.CHUTES_API_TOKEN || auth.chutes_api_token);
+    }
+  }
+
+  check('API token connected', hasAuth, 'Run: opencode, then type: /connect chutes');
+
+  console.log('\nNetwork Checks:\n');
+
+  try {
+    const response = await fetch('https://llm.chutes.ai/v1/models', {
+      method: 'GET',
+      headers: { 'Content-Type': 'application/json' },
+    });
+
+    check('Can reach Chutes API', response.ok, `HTTP ${response.status}: ${response.statusText}`);
+
+    if (response.ok) {
+      const data = (await response.json()) as { data: Array<{ id: string }> };
+      console.log(`   Found ${data.data?.length || 0} models available\n`);
+    }
+  } catch (error) {
+    check(
+      'Can reach Chutes API',
+      false,
+      `Connection failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+  console.log(`Results: ${passed}/${checks} checks passed\n`);
+
+  if (passed === checks) {
+    console.log("🎉 Everything looks good! You're ready to use chutes-plugin.\n");
+  } else {
+    console.log('⚠️  Some checks failed. Please address the issues above.\n');
+  }
+}

package/src/cli/index.ts

@@ -0,0 +1,61 @@
+import cac from 'cac';
+
+const cli = cac('chutes-plugin');
+
+cli.version('0.1.0');
+cli.usage(`
+🐍 chutes-plugin
+
+A plugin for OpenCode that provides access to 48+ state-of-the-art AI models through the Chutes API.
+
+Usage:
+  $ chutes-plugin <command>
+
+Commands:
+  install    Install the plugin (project, global, or npm)
+  status     Check plugin status and configuration
+  list       List available models from the Chutes API
+  refresh    Force refresh the model cache
+  doctor     Verify that everything is configured correctly
+
+Examples:
+  $ chutes-plugin install
+  $ chutes-plugin status
+  $ chutes-plugin list
+  $ chutes-plugin refresh
+  $ chutes-plugin doctor
+`);
+
+cli
+  .command('install', 'Install the plugin to OpenCode')
+  .option('--type <type>', 'Installation type: project, global, or npm')
+  .action(async (options) => {
+    const { install } = await import('./install.js');
+    await install(options);
+  });
+
+cli.command('status', 'Check plugin status and configuration').action(async () => {
+  const { status } = await import('./status.js');
+  await status();
+});
+
+cli.command('list', 'List available models from the Chutes API').action(async () => {
+  const { list } = await import('./list.js');
+  await list();
+});
+
+cli.command('refresh', 'Force refresh the model cache').action(async () => {
+  const { refresh } = await import('./refresh.js');
+  await refresh();
+});
+
+cli.command('doctor', 'Verify that everything is configured correctly').action(async () => {
+  const { doctor } = await import('./doctor.js');
+  await doctor();
+});
+
+cli.parse();
+
+if (process.argv.length === 2) {
+  cli.outputHelp();
+}

package/src/cli/install.ts

@@ -0,0 +1,186 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+interface InstallOptions {
+  type?: string;
+}
+
+export async function install(options: InstallOptions): Promise<void> {
+  console.log('🐍 chutes-plugin installer\n');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+
+  let installType = options.type;
+
+  if (!installType) {
+    console.log('Choose installation type:');
+    console.log('1. Project (install to .opencode/plugin/)');
+    console.log('2. Global (install to ~/.config/opencode/plugin/)');
+    console.log('3. NPM (add to opencode.json for auto-install)\n');
+
+    const readline = await import('node:readline');
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    installType = await new Promise<string>((resolve) => {
+      rl.question('> ', (answer) => {
+        rl.close();
+        resolve(answer.trim());
+      });
+    });
+  }
+
+  switch (installType) {
+    case '1':
+    case 'project':
+      await installProject();
+      break;
+    case '2':
+    case 'global':
+      await installGlobal();
+      break;
+    case '3':
+    case 'npm':
+      await installNpm();
+      break;
+    default:
+      console.log('Invalid installation type. Please choose 1, 2, or 3.');
+      process.exit(1);
+  }
+}
+
+async function installProject(): Promise<void> {
+  const projectDir = process.cwd();
+  const opencodeDir = path.join(projectDir, '.opencode');
+  const pluginDir = path.join(opencodeDir, 'plugin', 'chutes-plugin');
+
+  console.log('Installing to project...\n');
+
+  if (!fs.existsSync(opencodeDir)) {
+    fs.mkdirSync(opencodeDir, { recursive: true });
+  }
+
+  if (!fs.existsSync(path.join(opencodeDir, 'plugin'))) {
+    fs.mkdirSync(path.join(opencodeDir, 'plugin'), { recursive: true });
+  }
+
+  fs.mkdirSync(pluginDir, { recursive: true });
+
+  const distDir = path.join(__dirname, '..', '..', 'dist');
+  if (fs.existsSync(distDir)) {
+    fs.cpSync(distDir, path.join(pluginDir, 'dist'), { recursive: true });
+  }
+
+  const srcCliDir = path.join(__dirname, '..');
+  if (fs.existsSync(srcCliDir)) {
+    fs.cpSync(srcCliDir, path.join(pluginDir, 'src'), { recursive: true });
+  }
+
+  const packageJsonPath = path.join(opencodeDir, 'opencode.json');
+  let config: Record<string, unknown> = {};
+  if (fs.existsSync(packageJsonPath)) {
+    const content = fs.readFileSync(packageJsonPath, 'utf-8');
+    config = JSON.parse(content);
+  }
+
+  config.plugins = config.plugins || [];
+  if (!Array.isArray(config.plugins)) {
+    config.plugins = [];
+  }
+
+  const pluginPath = './.opencode/plugin/chutes-plugin/dist/index.js';
+  if (!config.plugins.includes(pluginPath)) {
+    config.plugins.push(pluginPath);
+  }
+
+  fs.writeFileSync(packageJsonPath, JSON.stringify(config, null, 2));
+
+  console.log('✅ Successfully installed to project!');
+  console.log('\nNext steps:');
+  console.log('1. Start OpenCode: opencode');
+  console.log('2. Connect your Chutes token: /connect chutes');
+  console.log('3. Select a Chutes model from the dropdown\n');
+}
+
+async function installGlobal(): Promise<void> {
+  const homeDir = process.env.HOME || process.env.USERPROFILE;
+  if (!homeDir) {
+    console.log('❌ Error: Could not determine home directory');
+    process.exit(1);
+  }
+
+  const configDir = path.join(homeDir, '.config', 'opencode');
+  const pluginDir = path.join(configDir, 'plugin', 'chutes-plugin');
+
+  console.log('Installing globally...\n');
+
+  fs.mkdirSync(pluginDir, { recursive: true });
+
+  const distDir = path.join(__dirname, '..', '..', 'dist');
+  if (fs.existsSync(distDir)) {
+    fs.cpSync(distDir, path.join(pluginDir, 'dist'), { recursive: true });
+  }
+
+  const srcCliDir = path.join(__dirname, '..');
+  if (fs.existsSync(srcCliDir)) {
+    fs.cpSync(srcCliDir, path.join(pluginDir, 'src'), { recursive: true });
+  }
+
+  const configPath = path.join(configDir, 'opencode.json');
+  let config: Record<string, unknown> = {};
+  if (fs.existsSync(configPath)) {
+    const content = fs.readFileSync(configPath, 'utf-8');
+    config = JSON.parse(content);
+  }
+
+  config.plugins = config.plugins || [];
+  if (!Array.isArray(config.plugins)) {
+    config.plugins = [];
+  }
+
+  const pluginPath = `${configDir}/plugin/chutes-plugin/dist/index.js`;
+  if (!config.plugins.includes(pluginPath)) {
+    config.plugins.push(pluginPath);
+  }
+
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+
+  console.log('✅ Successfully installed globally!');
+  console.log('\nNext steps:');
+  console.log('1. Start OpenCode: opencode');
+  console.log('2. Connect your Chutes token: /connect chutes');
+  console.log('3. Select a Chutes model from the dropdown\n');
+}
+
+async function installNpm(): Promise<void> {
+  const projectDir = process.cwd();
+  const configPath = path.join(projectDir, 'opencode.json');
+
+  console.log('Installing via npm...\n');
+
+  let config: Record<string, unknown> = {};
+  if (fs.existsSync(configPath)) {
+    const content = fs.readFileSync(configPath, 'utf-8');
+    config = JSON.parse(content);
+  }
+
+  config.plugins = config.plugins || [];
+  if (!Array.isArray(config.plugins)) {
+    config.plugins = [];
+  }
+
+  if (!config.plugins.includes('chutes-plugin')) {
+    config.plugins.push('chutes-plugin');
+  }
+
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+
+  console.log('✅ Added "chutes-plugin" to opencode.json!');
+  console.log('\nNext steps:');
+  console.log('1. Start OpenCode: opencode');
+  console.log('2. The plugin will be auto-installed on first run');
+  console.log('3. Connect your Chutes token: /connect chutes');
+  console.log('4. Select a Chutes model from the dropdown\n');
+}

package/src/cli/list.ts

@@ -0,0 +1,50 @@
+export async function list(): Promise<void> {
+  console.log('🐍 chutes-plugin models\n');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+  console.log('Fetching models from Chutes API...\n');
+
+  try {
+    const response = await fetch('https://llm.chutes.ai/v1/models', {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+
+    if (!response.ok) {
+      console.log(`❌ Error fetching models: ${response.status} ${response.statusText}`);
+      process.exit(1);
+    }
+
+    const data = (await response.json()) as {
+      data: Array<{
+        id: string;
+        owned_by: string;
+        pricing: { prompt: number; completion: number };
+      }>;
+    };
+    const models = data.data || [];
+
+    console.log(`Found ${models.length} models:\n`);
+
+    for (const model of models) {
+      console.log(`• ${model.id}`);
+      console.log(`  Owner: ${model.owned_by}`);
+      console.log(
+        `  Pricing: $${model.pricing.prompt.toFixed(2)}/M input, $${model.pricing.completion.toFixed(2)}/M output\n`
+      );
+    }
+
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+    console.log('Tip: To use these models:');
+    console.log('1. Install the plugin: bunx chutes-plugin install');
+    console.log('2. Start OpenCode: opencode');
+    console.log('3. Connect token: /connect chutes');
+    console.log('4. Select a Chutes model from the dropdown\n');
+  } catch (error) {
+    console.log(
+      `❌ Error fetching models: ${error instanceof Error ? error.message : String(error)}`
+    );
+    process.exit(1);
+  }
+}

package/src/cli/refresh.ts

@@ -0,0 +1,31 @@
+export async function refresh(): Promise<void> {
+  console.log('🐍 chutes-plugin refresh\n');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+  console.log('Refreshing model cache...\n');
+
+  try {
+    const response = await fetch('https://llm.chutes.ai/v1/models', {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+
+    if (!response.ok) {
+      console.log(`❌ Error refreshing models: ${response.status} ${response.statusText}`);
+      process.exit(1);
+    }
+
+    const data = (await response.json()) as { data: Array<{ id: string }> };
+    const models = data.data || [];
+
+    console.log(`✅ Successfully refreshed ${models.length} models\n`);
+    console.log('Note: The cache will be automatically refreshed when OpenCode restarts.');
+    console.log('Models are cached in-memory for 1 hour during each OpenCode session.\n');
+  } catch (error) {
+    console.log(
+      `❌ Error refreshing models: ${error instanceof Error ? error.message : String(error)}`
+    );
+    process.exit(1);
+  }
+}

package/src/cli/status.ts

@@ -0,0 +1,80 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+export async function status(): Promise<void> {
+  console.log('🐍 chutes-plugin status\n');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+
+  let hasConfig = false;
+  let pluginPath = '';
+  let installType = '';
+
+  const projectDir = process.cwd();
+  const projectConfigPath = path.join(projectDir, 'opencode.json');
+
+  const homeDir = process.env.HOME || process.env.USERPROFILE;
+  const globalConfigPath = homeDir
+    ? path.join(homeDir, '.config', 'opencode', 'opencode.json')
+    : null;
+
+  if (fs.existsSync(projectConfigPath)) {
+    const content = fs.readFileSync(projectConfigPath, 'utf-8');
+    const config = JSON.parse(content);
+    const plugins = (config.plugins as string[]) || [];
+
+    for (const p of plugins) {
+      if (p.includes('chutes-plugin')) {
+        hasConfig = true;
+        installType = 'npm';
+        pluginPath = p;
+        break;
+      }
+    }
+
+    const opencodeDir = path.join(projectDir, '.opencode', 'plugin', 'chutes-plugin');
+    if (fs.existsSync(opencodeDir)) {
+      hasConfig = true;
+      installType = 'project';
+      pluginPath = opencodeDir;
+    }
+  }
+
+  if (!hasConfig && globalConfigPath && fs.existsSync(globalConfigPath)) {
+    const content = fs.readFileSync(globalConfigPath, 'utf-8');
+    const config = JSON.parse(content);
+    const plugins = (config.plugins as string[]) || [];
+
+    for (const p of plugins) {
+      if (p.includes('chutes-plugin')) {
+        hasConfig = true;
+        installType = 'global';
+        pluginPath = p;
+        break;
+      }
+    }
+  }
+
+  console.log(`Installation: ${hasConfig ? '✅ Configured' : '❌ Not configured'}`);
+  if (hasConfig) {
+    console.log(`Type: ${installType}`);
+    console.log(`Path: ${pluginPath}\n`);
+  }
+
+  const authPath = homeDir ? path.join(homeDir, '.local', 'share', 'opencode', 'auth.json') : null;
+  let hasAuth = false;
+  if (authPath && fs.existsSync(authPath)) {
+    const content = fs.readFileSync(authPath, 'utf-8');
+    const auth = JSON.parse(content);
+    hasAuth = !!(auth.chutes || auth.CHUTES_API_TOKEN || auth.chutes_api_token);
+  }
+
+  console.log(`API Token: ${hasAuth ? '✅ Connected' : '⚠️  Not connected'}`);
+  if (!hasAuth) {
+    console.log('\nTo connect your token:');
+    console.log('1. Run: opencode');
+    console.log('2. Type: /connect chutes');
+    console.log('3. Follow the prompts\n');
+  }
+
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+}