infinicode 1.0.0

package/README.md

@@ -0,0 +1,130 @@
+# ⚡ Infinicode
+
+**AI coding agent powered by your local Ollama.** Fork of OpenCode optimized for self-hosted LLMs.
+
+```bash
+npm install -g infinicode
+
+# Connect to your Ollama master
+infinicode connect 192.168.1.100
+
+# Start coding
+infinicode
+```
+
+## Why Infinicode?
+
+- **100% Local** — All inference on YOUR hardware
+- **Zero Cloud** — No API keys, no subscriptions, no data leaving your network
+- **One Command Setup** — `infinicode connect <ip>` and you're done
+- **Multi-Node** — Run on any machine, point to one Ollama master
+
+## Quick Start
+
+### 1. Install
+
+```bash
+npm install -g infinicode
+# or
+pnpm add -g infinicode
+```
+
+### 2. Setup Ollama Master
+
+On your GPU machine:
+
+```bash
+# Allow network connections
+OLLAMA_HOST=0.0.0.0:11434 ollama serve
+
+# Pull a coding model
+ollama pull qwen2.5-coder:14b
+```
+
+### 3. Connect & Code
+
+```bash
+# From any machine on your network
+infinicode connect 192.168.1.100   # Your Ollama IP
+infinicode                          # Start coding!
+```
+
+## Commands
+
+| Command | Alias | Description |
+|---------|-------|-------------|
+| `infinicode connect <ip>` | `ic c` | Quick connect to Ollama master |
+| `infinicode setup` | `ic s` | Interactive setup wizard |
+| `infinicode run` | `ic` | Start the coding agent (default) |
+| `infinicode models` | `ic m` | List available models |
+| `infinicode status` | | Show config & connection status |
+| `infinicode config --list` | | View all configuration |
+| `infinicode config --reset` | | Reset to defaults |
+
+## Configuration
+
+Config is stored automatically. Override with:
+
+```bash
+# Set default model
+infinicode config --set defaultModel=codestral:22b
+
+# Set master URL
+infinicode config --set masterUrl=http://192.168.1.100:11434
+
+# View all
+infinicode config --list
+```
+
+## Recommended Models
+
+For coding tasks on Ollama:
+
+| Model | Size | Best For |
+|-------|------|----------|
+| `qwen2.5-coder:14b` | 9GB | Great balance |
+| `qwen2.5-coder:32b` | 20GB | Best quality |
+| `deepseek-coder-v2:16b` | 10GB | Strong reasoning |
+| `codestral:22b` | 13GB | Fast completion |
+
+## Architecture
+
+```
+┌─────────────────┐
+│   Laptop        │
+│  (infinicode)   │──┐
+└─────────────────┘  │
+                     │    ┌─────────────────┐
+┌─────────────────┐  │    │   GPU Server    │
+│   Desktop       │──┼───▶│    (Ollama)     │
+│  (infinicode)   │  │    │                 │
+└─────────────────┘  │    │ qwen2.5-coder   │
+                     │    │ codestral       │
+┌─────────────────┐  │    └─────────────────┘
+│   Server        │──┘
+│  (infinicode)   │
+└─────────────────┘
+```
+
+## Security
+
+Exposing Ollama to your network means anyone on that network can use it.
+
+**Secure options:**
+1. **VPN/Tailscale** — Only accessible on private network
+2. **SSH Tunnel** — `ssh -L 11434:localhost:11434 gpu-server`
+3. **Firewall** — Allow only specific IPs
+
+## Requirements
+
+- Node.js 20+
+- OpenCode installed (`npm install -g opencode`)
+- Ollama running somewhere on your network
+
+## License
+
+MIT — Based on [OpenCode](https://github.com/sst/opencode)
+
+---
+
+⚡ Built for sovereign computing. Your code, your models, your hardware.

package/bin/infinicode.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import('../dist/cli.js');

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import Conf from 'conf';
+import { setupMaster } from './commands/setup.js';
+import { runAgent } from './commands/run.js';
+import { showStatus } from './commands/status.js';
+import { listModels } from './commands/models.js';
+const VERSION = '1.0.0';
+const config = new Conf({
+    projectName: 'infinicode',
+    defaults: {
+        masterUrl: 'http://localhost:11434',
+        defaultModel: 'qwen2.5-coder:14b',
+        theme: 'infini'
+    }
+});
+const program = new Command();
+console.log(chalk.cyan(`
+  ⚡ ${chalk.bold('INFINICODE')} v${VERSION}
+  ${chalk.dim('AI Coding Agent • Powered by Ollama')}
+`));
+program
+    .name('infinicode')
+    .description('AI coding agent powered by your local Ollama')
+    .version(VERSION);
+// Quick connect command
+program
+    .command('connect <master-ip>')
+    .alias('c')
+    .description('Quick connect to Ollama master (e.g., infinicode connect 192.168.1.100)')
+    .option('-p, --port <port>', 'Ollama port', '11434')
+    .option('-m, --model <model>', 'Default model', 'qwen2.5-coder:14b')
+    .action(async (masterIp, options) => {
+    await setupMaster(masterIp, options.port, options.model, config);
+});
+// Setup wizard
+program
+    .command('setup')
+    .alias('s')
+    .description('Interactive setup wizard')
+    .action(async () => {
+    const inquirer = (await import('inquirer')).default;
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'masterIp',
+            message: 'Ollama master IP:',
+            default: 'localhost'
+        },
+        {
+            type: 'input',
+            name: 'port',
+            message: 'Ollama port:',
+            default: '11434'
+        },
+        {
+            type: 'input',
+            name: 'model',
+            message: 'Default model:',
+            default: 'qwen2.5-coder:14b'
+        }
+    ]);
+    await setupMaster(answers.masterIp, answers.port, answers.model, config);
+});
+// Run the agent (main command)
+program
+    .command('run', { isDefault: true })
+    .alias('r')
+    .description('Start the coding agent')
+    .option('-m, --model <model>', 'Model to use')
+    .option('--no-tui', 'Disable TUI, use simple mode')
+    .action(async (options) => {
+    const masterUrl = config.get('masterUrl');
+    const model = options.model || config.get('defaultModel');
+    if (!masterUrl || masterUrl === 'http://localhost:11434') {
+        console.log(chalk.yellow('\n⚠️  No master configured. Using localhost.'));
+        console.log(chalk.dim('  Run: infinicode connect <master-ip>\n'));
+    }
+    await runAgent(masterUrl, model, options.tui !== false, config);
+});
+// Status command
+program
+    .command('status')
+    .description('Show current configuration and connection status')
+    .action(async () => {
+    await showStatus(config);
+});
+// Models command
+program
+    .command('models')
+    .alias('m')
+    .description('List available models on master')
+    .action(async () => {
+    await listModels(config);
+});
+// Config commands
+program
+    .command('config')
+    .description('View or modify configuration')
+    .option('--get <key>', 'Get a config value')
+    .option('--set <key=value>', 'Set a config value')
+    .option('--list', 'List all config')
+    .option('--reset', 'Reset to defaults')
+    .action((options) => {
+    if (options.reset) {
+        config.clear();
+        console.log(chalk.green('✓ Config reset to defaults'));
+        return;
+    }
+    if (options.list) {
+        console.log(chalk.bold('\nConfiguration:'));
+        console.log(chalk.dim('─'.repeat(40)));
+        for (const [key, value] of Object.entries(config.store)) {
+            console.log(`  ${chalk.cyan(key)}: ${value}`);
+        }
+        console.log();
+        return;
+    }
+    if (options.get) {
+        console.log(config.get(options.get));
+        return;
+    }
+    if (options.set) {
+        const [key, value] = options.set.split('=');
+        config.set(key, value);
+        console.log(chalk.green(`✓ Set ${key} = ${value}`));
+        return;
+    }
+    // Default: show config
+    console.log(chalk.bold('\nConfiguration:'));
+    console.log(chalk.dim('─'.repeat(40)));
+    for (const [key, value] of Object.entries(config.store)) {
+        console.log(`  ${chalk.cyan(key)}: ${value}`);
+    }
+    console.log();
+});
+// Passthrough to opencode
+program
+    .command('opencode [args...]')
+    .description('Run opencode directly with Ollama config injected')
+    .allowUnknownOption()
+    .action(async (args) => {
+    const { execa } = await import('execa');
+    const masterUrl = config.get('masterUrl');
+    process.env.LOCAL_ENDPOINT = `${masterUrl}/v1`;
+    process.env.OPENCODE_CONFIG_CONTENT = JSON.stringify({
+        providers: {
+            anthropic: { disabled: true },
+            openai: { disabled: true },
+            gemini: { disabled: true },
+            local: { apiKey: 'not-needed' }
+        }
+    });
+    try {
+        await execa('opencode', args, {
+            stdio: 'inherit',
+            env: process.env
+        });
+    }
+    catch (e) {
+        if (e.exitCode)
+            process.exit(e.exitCode);
+    }
+});
+program.parse();

package/dist/commands/models.d.ts

@@ -0,0 +1,2 @@
+import type Conf from 'conf';
+export declare function listModels(config: Conf<any>): Promise<void>;

package/dist/commands/models.js

@@ -0,0 +1,76 @@
+import chalk from 'chalk';
+import ora from 'ora';
+function formatSize(bytes) {
+    const gb = bytes / (1024 ** 3);
+    if (gb >= 1)
+        return `${gb.toFixed(1)} GB`;
+    const mb = bytes / (1024 ** 2);
+    return `${mb.toFixed(0)} MB`;
+}
+export async function listModels(config) {
+    const masterUrl = config.get('masterUrl');
+    const defaultModel = config.get('defaultModel');
+    console.log(chalk.bold('\n⚡ Available Models'));
+    console.log(chalk.dim(`  Master: ${masterUrl}`));
+    console.log(chalk.dim('─'.repeat(50)));
+    const spinner = ora('Fetching models...').start();
+    try {
+        const response = await fetch(`${masterUrl}/api/tags`, {
+            signal: AbortSignal.timeout(10000)
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        const data = await response.json();
+        spinner.stop();
+        const models = data.models || [];
+        if (models.length === 0) {
+            console.log(chalk.yellow('\n  No models installed.'));
+            console.log(chalk.dim('\n  Recommended models for coding:'));
+            console.log(chalk.cyan('    ollama pull qwen2.5-coder:14b'));
+            console.log(chalk.cyan('    ollama pull deepseek-coder-v2:16b'));
+            console.log(chalk.cyan('    ollama pull codestral:22b'));
+            console.log();
+            return;
+        }
+        // Categorize models
+        const codingModels = [];
+        const otherModels = [];
+        for (const m of models) {
+            const name = m.name.toLowerCase();
+            if (name.includes('code') || name.includes('coder') || name.includes('stral')) {
+                codingModels.push(m);
+            }
+            else {
+                otherModels.push(m);
+            }
+        }
+        // Display coding models first
+        if (codingModels.length > 0) {
+            console.log(chalk.bold('\n  💻 Coding Models:'));
+            for (const m of codingModels) {
+                const isDefault = m.name === defaultModel || m.name.startsWith(defaultModel.split(':')[0]);
+                const marker = isDefault ? chalk.green('★') : ' ';
+                const size = formatSize(m.size);
+                console.log(`  ${marker} ${chalk.cyan(m.name.padEnd(30))} ${chalk.dim(size)}`);
+            }
+        }
+        if (otherModels.length > 0) {
+            console.log(chalk.bold('\n  🤖 Other Models:'));
+            for (const m of otherModels) {
+                const isDefault = m.name === defaultModel;
+                const marker = isDefault ? chalk.green('★') : ' ';
+                const size = formatSize(m.size);
+                console.log(`  ${marker} ${chalk.cyan(m.name.padEnd(30))} ${chalk.dim(size)}`);
+            }
+        }
+        console.log(chalk.dim(`\n  Total: ${models.length} models`));
+        console.log(chalk.dim(`  ★ = current default\n`));
+    }
+    catch (error) {
+        spinner.fail('Failed to fetch models');
+        console.log(chalk.red(`\n  ✗ Could not reach ${masterUrl}`));
+        console.log(chalk.dim('  Is Ollama running?\n'));
+        process.exit(1);
+    }
+}

package/dist/commands/run.d.ts

@@ -0,0 +1,2 @@
+import type Conf from 'conf';
+export declare function runAgent(masterUrl: string, model: string, useTui: boolean, config: Conf<any>): Promise<void>;

package/dist/commands/run.js

@@ -0,0 +1,84 @@
+import chalk from 'chalk';
+import ora from 'ora';
+export async function runAgent(masterUrl, model, useTui, config) {
+    // Check connection first
+    const spinner = ora('Connecting to Ollama...').start();
+    try {
+        const response = await fetch(`${masterUrl}/api/tags`, {
+            signal: AbortSignal.timeout(5000)
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        const data = await response.json();
+        const models = data.models || [];
+        const hasModel = models.some(m => m.name === model || m.name.startsWith(model.split(':')[0]));
+        if (!hasModel) {
+            spinner.warn(`Model '${model}' not found`);
+            if (models.length > 0) {
+                console.log(chalk.dim(`\nAvailable: ${models.slice(0, 5).map(m => m.name).join(', ')}`));
+            }
+            console.log(chalk.yellow(`\nPull the model first:`));
+            console.log(chalk.cyan(`  ollama pull ${model}\n`));
+            process.exit(1);
+        }
+        spinner.succeed('Ollama connected');
+    }
+    catch (error) {
+        spinner.fail('Connection failed');
+        console.log(chalk.red(`\n✗ Could not connect to ${masterUrl}`));
+        console.log(chalk.dim('\nRun: infinicode connect <master-ip>\n'));
+        process.exit(1);
+    }
+    // Set environment for opencode
+    process.env.LOCAL_ENDPOINT = `${masterUrl}/v1`;
+    process.env.OPENCODE_CONFIG_CONTENT = JSON.stringify({
+        providers: {
+            anthropic: { disabled: true },
+            openai: { disabled: true },
+            gemini: { disabled: true },
+            groq: { disabled: true },
+            openrouter: { disabled: true },
+            xai: { disabled: true },
+            azure: { disabled: true },
+            bedrock: { disabled: true },
+            vertexai: { disabled: true },
+            copilot: { disabled: true },
+            local: { apiKey: 'not-needed' }
+        },
+        agents: {
+            coder: { model: `local.${model}` }
+        },
+        tui: {
+            theme: config.get('theme') || 'infini'
+        }
+    });
+    console.log(chalk.dim(`\nStarting with ${chalk.cyan(model)}...`));
+    console.log(chalk.dim('─'.repeat(40)));
+    // Try to run opencode
+    const { execa } = await import('execa');
+    try {
+        // Check if opencode is installed
+        await execa('which', ['opencode']).catch(() => execa('where', ['opencode']));
+        // Run opencode
+        await execa('opencode', [], {
+            stdio: 'inherit',
+            env: process.env
+        });
+    }
+    catch (e) {
+        if (e.code === 'ENOENT' || e.exitCode === 1) {
+            console.log(chalk.yellow('\n⚠️  OpenCode not found.'));
+            console.log(chalk.dim('\nInstall it with:'));
+            console.log(chalk.cyan('  npm install -g opencode'));
+            console.log(chalk.dim('\nOr use infinicode with the Go binary:'));
+            console.log(chalk.cyan('  cd /path/to/opencode-infini && go build -o infini && ./infini'));
+            console.log();
+            process.exit(1);
+        }
+        if (e.exitCode) {
+            process.exit(e.exitCode);
+        }
+        throw e;
+    }
+}

package/dist/commands/setup.d.ts

@@ -0,0 +1,2 @@
+import type Conf from 'conf';
+export declare function setupMaster(masterIp: string, port: string, model: string, config: Conf<any>): Promise<void>;

package/dist/commands/setup.js

@@ -0,0 +1,60 @@
+import chalk from 'chalk';
+import ora from 'ora';
+export async function setupMaster(masterIp, port, model, config) {
+    const masterUrl = `http://${masterIp}:${port}`;
+    console.log(chalk.bold('\n⚡ Infinicode Setup'));
+    console.log(chalk.dim('─'.repeat(40)));
+    console.log(`  Master: ${chalk.cyan(masterUrl)}`);
+    console.log(`  Model:  ${chalk.cyan(model)}`);
+    console.log();
+    const spinner = ora('Testing connection...').start();
+    try {
+        const response = await fetch(`${masterUrl}/api/tags`, {
+            signal: AbortSignal.timeout(10000)
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        const data = await response.json();
+        spinner.succeed('Connected to Ollama');
+        // Save config
+        config.set('masterUrl', masterUrl);
+        config.set('defaultModel', model);
+        // Show available models
+        console.log(chalk.bold('\nAvailable models:'));
+        const models = data.models || [];
+        if (models.length === 0) {
+            console.log(chalk.yellow('  No models found. Pull one with:'));
+            console.log(chalk.dim(`  ollama pull ${model}`));
+        }
+        else {
+            for (const m of models.slice(0, 10)) {
+                const isDefault = m.name === model || m.name.startsWith(model.split(':')[0]);
+                console.log(`  ${isDefault ? chalk.green('●') : chalk.dim('○')} ${m.name}`);
+            }
+            if (models.length > 10) {
+                console.log(chalk.dim(`  ... and ${models.length - 10} more`));
+            }
+        }
+        // Check if default model exists
+        const hasModel = models.some(m => m.name === model || m.name.startsWith(model.split(':')[0]));
+        if (!hasModel && models.length > 0) {
+            console.log(chalk.yellow(`\n⚠️  Model '${model}' not found.`));
+            console.log(chalk.dim(`  Available: ${models.slice(0, 3).map(m => m.name).join(', ')}`));
+            console.log(chalk.dim(`  Pull it: ollama pull ${model}`));
+        }
+        console.log(chalk.green('\n✓ Configuration saved!'));
+        console.log(chalk.dim('\nRun `infinicode` or `ic` to start coding.\n'));
+    }
+    catch (error) {
+        spinner.fail('Connection failed');
+        console.log(chalk.red(`\n✗ Could not connect to ${masterUrl}`));
+        console.log(chalk.dim('\nMake sure Ollama is running with network access:'));
+        console.log(chalk.cyan('  OLLAMA_HOST=0.0.0.0:11434 ollama serve'));
+        console.log(chalk.dim('\nOr via systemd:'));
+        console.log(chalk.cyan('  sudo systemctl edit ollama'));
+        console.log(chalk.dim('  Add: Environment="OLLAMA_HOST=0.0.0.0:11434"'));
+        console.log(chalk.cyan('  sudo systemctl restart ollama\n'));
+        process.exit(1);
+    }
+}

package/dist/commands/status.d.ts

@@ -0,0 +1,2 @@
+import type Conf from 'conf';
+export declare function showStatus(config: Conf<any>): Promise<void>;

package/dist/commands/status.js

@@ -0,0 +1,40 @@
+import chalk from 'chalk';
+import ora from 'ora';
+export async function showStatus(config) {
+    const masterUrl = config.get('masterUrl');
+    const defaultModel = config.get('defaultModel');
+    console.log(chalk.bold('\n⚡ Infinicode Status'));
+    console.log(chalk.dim('─'.repeat(40)));
+    console.log(`  Master URL:    ${chalk.cyan(masterUrl)}`);
+    console.log(`  Default Model: ${chalk.cyan(defaultModel)}`);
+    const spinner = ora('Checking connection...').start();
+    try {
+        const response = await fetch(`${masterUrl}/api/tags`, {
+            signal: AbortSignal.timeout(5000)
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        const data = await response.json();
+        spinner.succeed('Ollama connected');
+        const models = data.models || [];
+        console.log(`  Models:        ${chalk.green(models.length)} available`);
+        // Check if default model is available
+        const hasDefault = models.some(m => m.name === defaultModel || m.name.startsWith(defaultModel.split(':')[0]));
+        if (hasDefault) {
+            console.log(`  Status:        ${chalk.green('● Ready')}`);
+        }
+        else {
+            console.log(`  Status:        ${chalk.yellow('● Missing model')}`);
+            console.log(chalk.yellow(`\n  ⚠️  Default model '${defaultModel}' not found.`));
+            console.log(chalk.dim(`  Pull it: ollama pull ${defaultModel}`));
+        }
+    }
+    catch (error) {
+        spinner.fail('Connection failed');
+        console.log(`  Status:        ${chalk.red('● Offline')}`);
+        console.log(chalk.red(`\n  ✗ Could not reach ${masterUrl}`));
+        console.log(chalk.dim('  Is Ollama running with OLLAMA_HOST=0.0.0.0?'));
+    }
+    console.log();
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "infinicode",
+  "version": "1.0.0",
+  "description": "AI coding agent powered by your local Ollama. Fork of OpenCode optimized for self-hosted LLMs.",
+  "type": "module",
+  "main": "./dist/cli.js",
+  "bin": {
+    "infinicode": "./bin/infinicode.js",
+    "ic": "./bin/infinicode.js"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "ai",
+    "coding",
+    "agent",
+    "ollama",
+    "llm",
+    "cli",
+    "opencode",
+    "local",
+    "self-hosted"
+  ],
+  "author": "Ra Kai'Un",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chosen-to-build/infinicode"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "conf": "^12.0.0",
+    "execa": "^9.3.0",
+    "inquirer": "^9.2.23",
+    "node-fetch": "^3.3.2",
+    "ora": "^8.0.1"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^20.14.0",
+    "typescript": "^5.4.5"
+  }
+}