@toothfairyai/tfcode 1.0.0-beta.1

package/README.md

@@ -0,0 +1,127 @@
+# tfcode
+
+**ToothFairyAI's official AI coding agent** - A terminal-based coding assistant with seamless integration to your ToothFairyAI workspace.
+
+## Features
+
+- 🤖 **AI-Powered Coding** - Intelligent code generation, refactoring, and debugging
+- 🔌 **Tool Integration** - Sync and use tools from your ToothFairyAI workspace
+- 💻 **Terminal-Based** - Fast, lightweight, runs in your terminal
+- 🔐 **Secure** - Credentials stay in ToothFairyAI, route via TF Proxy
+
+## Requirements
+
+- **Python 3.10+** - Required for ToothFairyAI integration
+- **Node.js 18+** - Required to run tfcode
+
+## Installation
+
+```bash
+npm install -g tfcode
+```
+
+The installer will:
+- Check Python is installed
+- Install the ToothFairyAI Python SDK automatically
+
+## Quick Start
+
+```bash
+# 1. Set your ToothFairyAI credentials
+export TF_WORKSPACE_ID="your-workspace-id"
+export TF_API_KEY="your-api-key"
+export TF_REGION="au"
+
+# 2. Validate your credentials
+tfcode validate
+
+# 3. Sync tools from your workspace
+tfcode sync
+
+# 4. Start coding!
+tfcode
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `tfcode` | Start the AI coding assistant |
+| `tfcode quickstart` | Show quick start guide |
+| `tfcode validate` | Test your credentials |
+| `tfcode sync` | Sync tools from workspace |
+| `tfcode tools list` | List synced tools |
+| `tfcode tools list --type mcp` | List MCP servers |
+| `tfcode tools credentials <name> --set` | Set API key for a tool |
+
+## Regions
+
+| Region | URL | Use Case |
+|--------|-----|----------|
+| `dev` | api.toothfairylab.link | Development/Testing |
+| `au` | api.toothfairyai.com | Australia (Default) |
+| `eu` | api.eu.toothfairyai.com | Europe |
+| `us` | api.us.toothfairyai.com | United States |
+
+## Configuration
+
+Credentials can be set via environment variables:
+
+```bash
+export TF_WORKSPACE_ID="your-workspace-id"
+export TF_API_KEY="your-api-key"
+export TF_REGION="au"
+```
+
+Or in `~/.tfcode/tfcode.json`:
+
+```json
+{
+  "toothfairy": {
+    "workspace_id": "your-workspace-id",
+    "api_key": "your-api-key",
+    "region": "au"
+  }
+}
+```
+
+## Getting Your Credentials
+
+1. Log in to [ToothFairyAI](https://app.toothfairyai.com)
+2. Go to **Settings** → **API Keys**
+3. Copy your **Workspace ID** and **API Key**
+
+## Troubleshooting
+
+### "Python 3.10+ is required but not found"
+
+Install Python:
+- **macOS**: `brew install python@3.12`
+- **Windows**: Download from https://python.org/downloads
+- **Linux**: `sudo apt install python3.12`
+
+### "Failed to validate: Invalid API key"
+
+- Check your API key is correct
+- Generate a new key in ToothFairyAI Settings → API Keys
+
+### "Failed to validate: Connection test failed"
+
+Try a different region:
+```bash
+export TF_REGION="eu"  # or us, au
+```
+
+## Documentation
+
+- **Full Guide**: https://toothfairyai.com/developers/tfcode
+- **API Docs**: https://apidocs.toothfairyai.com
+- **Issues**: https://github.com/ToothFairyAI/tfcode/issues
+
+## Credits
+
+tfcode is based on [opencode](https://github.com/anomalyco/opencode) by [anomalyco](https://github.com/anomalyco).
+
+## License
+
+MIT

package/bin/tfcode

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+
+const { spawn } = require("child_process")
+const path = require("path")
+
+const scriptDir = __dirname
+const srcPath = path.join(scriptDir, "..", "src", "index.ts")
+
+const child = spawn("npx", ["tsx", srcPath, ...process.argv.slice(2)], {
+  stdio: "inherit",
+  shell: process.platform === "win32",
+  cwd: scriptDir
+})
+
+child.on("exit", (code) => {
+  process.exit(code || 0)
+})

package/bin/tfcode.js

@@ -0,0 +1,333 @@
+#!/usr/bin/env node
+
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { spawn } from 'child_process';
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const TFCODE_DIR = join(homedir(), '.tfcode');
+const TOOLS_FILE = join(TFCODE_DIR, 'tools.json');
+const CREDENTIALS_FILE = join(TFCODE_DIR, 'credentials.json');
+
+const COLORS = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  cyan: '\x1b[36m',
+  dim: '\x1b[90m',
+  yellow: '\x1b[33m'
+};
+
+function log(msg) {
+  console.log(msg);
+}
+
+function success(msg) {
+  console.log(`${COLORS.green}✓${COLORS.reset} ${msg}`);
+}
+
+function error(msg) {
+  console.error(`${COLORS.red}✗${COLORS.reset} ${msg}`);
+}
+
+function info(msg) {
+  console.log(`${COLORS.cyan}ℹ${COLORS.reset} ${msg}`);
+}
+
+function runPythonSync(method) {
+  const pythonCode = `
+import json
+import sys
+import os
+
+try:
+    from tf_sync.config import load_config, validate_credentials, Region
+    from tf_sync.tools import sync_tools
+    from tf_sync.config import get_region_urls
+    
+    method = "${method}"
+    
+    if method == "validate":
+        config = load_config()
+        result = validate_credentials(config)
+        urls = get_region_urls(config.region)
+        print(json.dumps({
+            "success": result.success,
+            "workspace_id": result.workspace_id,
+            "workspace_name": result.workspace_name,
+            "error": result.error,
+            "base_url": urls["base_url"]
+        }))
+    
+    elif method == "sync":
+        config = load_config()
+        result = sync_tools(config)
+        
+        tools_data = []
+        for tool in result.tools:
+            tools_data.append({
+                "id": tool.id,
+                "name": tool.name,
+                "description": tool.description,
+                "tool_type": tool.tool_type.value,
+                "request_type": tool.request_type.value if tool.request_type else None,
+                "url": tool.url,
+                "auth_via": tool.auth_via
+            })
+        
+        print(json.dumps({
+            "success": result.success,
+            "tools": tools_data,
+            "by_type": result.by_type,
+            "error": result.error
+        }))
+
+except Exception as e:
+    print(json.dumps({"success": False, "error": str(e)}))
+sys.exit(0)
+`;
+
+  return new Promise((resolve, reject) => {
+    const pythonPath = process.env.TFCODE_PYTHON_PATH || 'python3';
+    const proc = spawn(pythonPath, ['-c', pythonCode], {
+      env: {
+        ...process.env,
+        PYTHONPATH: process.env.TFCODE_PYTHONPATH || ''
+      }
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    proc.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    proc.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    proc.on('close', (code) => {
+      if (code !== 0 && !stdout) {
+        reject(new Error(`Python sync failed: ${stderr}`));
+        return;
+      }
+
+      try {
+        const result = JSON.parse(stdout.trim());
+        resolve(result);
+      } catch (e) {
+        reject(new Error(`Failed to parse Python output: ${stdout}\nstderr: ${stderr}`));
+      }
+    });
+
+    proc.on('error', (err) => {
+      reject(err);
+    });
+  });
+}
+
+function ensureConfigDir() {
+  if (!existsSync(TFCODE_DIR)) {
+    mkdirSync(TFCODE_DIR, { recursive: true });
+  }
+}
+
+function loadCachedTools() {
+  if (!existsSync(TOOLS_FILE)) {
+    return null;
+  }
+  try {
+    return JSON.parse(readFileSync(TOOLS_FILE, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+function saveToolsCache(tools) {
+  ensureConfigDir();
+  writeFileSync(TOOLS_FILE, JSON.stringify(tools, null, 2));
+}
+
+const cli = yargs(hideBin(process.argv))
+  .scriptName('tfcode')
+  .wrap(100)
+  .help()
+  .alias('help', 'h')
+  .command({
+    command: 'quickstart',
+    describe: 'show quick start guide',
+    handler: () => {
+      log('');
+      log(`${COLORS.bold}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${COLORS.reset}`);
+      log(`${COLORS.bold}  tfcode - Quick Start Guide${COLORS.reset}`);
+      log(`${COLORS.bold}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${COLORS.reset}`);
+      log('');
+      log('Welcome to tfcode! Follow these steps to get started:');
+      log('');
+      log(`${COLORS.cyan}STEP 1: Set Your Credentials${COLORS.reset}`);
+      log(`${COLORS.dim}  export TF_WORKSPACE_ID="your-workspace-id"${COLORS.reset}`);
+      log(`${COLORS.dim}  export TF_API_KEY="your-api-key"${COLORS.reset}`);
+      log(`${COLORS.dim}  export TF_REGION="au"${COLORS.reset}`);
+      log(`${COLORS.dim}  Regions: dev, au, eu, us${COLORS.reset}`);
+      log('');
+      log(`${COLORS.cyan}STEP 2: Validate Connection${COLORS.reset}`);
+      log(`${COLORS.dim}  tfcode validate${COLORS.reset}`);
+      log('');
+      log(`${COLORS.cyan}STEP 3: Sync Your Tools${COLORS.reset}`);
+      log(`${COLORS.dim}  tfcode sync${COLORS.reset}`);
+      log('');
+      log(`${COLORS.cyan}STEP 4: Start Coding!${COLORS.reset}`);
+      log(`${COLORS.dim}  tfcode${COLORS.reset}`);
+      log('');
+      log(`${COLORS.bold}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${COLORS.reset}`);
+      log('');
+      log('  Useful Commands:');
+      log('');
+      log('  tfcode validate          Test your credentials');
+      log('  tfcode sync              Sync tools from workspace');
+      log('  tfcode tools list        Show all your tools');
+      log('');
+      log(`${COLORS.bold}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${COLORS.reset}`);
+      log('');
+      log('  Need help? https://toothfairyai.com/developers/tfcode');
+      log('');
+    }
+  })
+  .command({
+    command: 'validate',
+    describe: 'validate ToothFairyAI credentials',
+    handler: async () => {
+      info('Validating ToothFairyAI credentials...');
+      log('');
+
+      try {
+        const result = await runPythonSync('validate');
+
+        if (result.success) {
+          success('Credentials valid');
+          if (result.base_url) {
+            log(`${COLORS.dim}  API URL: ${result.base_url}${COLORS.reset}`);
+          }
+          if (result.workspace_id) {
+            log(`${COLORS.dim}  Workspace ID: ${result.workspace_id}${COLORS.reset}`);
+          }
+        } else {
+          error(`Validation failed: ${result.error || 'Unknown error'}`);
+          log('');
+          log(`${COLORS.dim}Check your credentials:${COLORS.reset}`);
+          log(`${COLORS.dim}  TF_WORKSPACE_ID: ${process.env.TF_WORKSPACE_ID || 'not set'}${COLORS.reset}`);
+          log(`${COLORS.dim}  TF_API_KEY: ${process.env.TF_API_KEY ? '***' + process.env.TF_API_KEY.slice(-4) : 'not set'}${COLORS.reset}`);
+          log(`${COLORS.dim}  TF_REGION: ${process.env.TF_REGION || 'au (default)'}${COLORS.reset}`);
+          process.exit(1);
+        }
+      } catch (e) {
+        error(`Failed to validate: ${e.message}`);
+        log('');
+        log(`${COLORS.dim}Make sure Python 3.10+ and the ToothFairyAI SDK are installed:${COLORS.reset}`);
+        log(`${COLORS.dim}  pip install toothfairyai pydantic httpx rich${COLORS.reset}`);
+        process.exit(1);
+      }
+    }
+  })
+  .command({
+    command: 'sync',
+    describe: 'sync tools from ToothFairyAI workspace',
+    handler: async () => {
+      info('Syncing tools from ToothFairyAI workspace...');
+      log('');
+
+      try {
+        const result = await runPythonSync('sync');
+
+        if (result.success) {
+          saveToolsCache(result);
+          success(`Synced ${result.tools.length} tools`);
+          log('');
+
+          if (result.by_type && Object.keys(result.by_type).length > 0) {
+            log('By type:');
+            for (const [type, count] of Object.entries(result.by_type)) {
+              log(`  ${type}: ${count}`);
+            }
+            log('');
+          }
+        } else {
+          error(`Sync failed: ${result.error || 'Unknown error'}`);
+          process.exit(1);
+        }
+      } catch (e) {
+        error(`Failed to sync: ${e.message}`);
+        process.exit(1);
+      }
+    }
+  })
+  .command({
+    command: 'tools',
+    describe: 'manage tools',
+    builder: (yargs) => {
+      return yargs
+        .command({
+          command: 'list',
+          describe: 'list synced tools',
+          builder: (yargs) => {
+            return yargs.option('type', {
+              type: 'string',
+              describe: 'filter by type (api_function)'
+            });
+          },
+          handler: (args) => {
+            const cached = loadCachedTools();
+
+            if (!cached || !cached.success) {
+              error('No tools synced. Run \'tfcode sync\' first.');
+              process.exit(1);
+              return;
+            }
+
+            let tools = cached.tools;
+
+            if (args.type) {
+              tools = tools.filter(t => t.tool_type === args.type);
+            }
+
+            if (tools.length === 0) {
+              log('No tools found.');
+              return;
+            }
+
+            log('');
+            log(`${tools.length} tool(s):`);
+            log('');
+
+            for (const tool of tools) {
+              log(`  ${COLORS.cyan}${tool.name}${COLORS.reset}`);
+              log(`    Type: ${tool.tool_type}`);
+              if (tool.description) {
+                log(`    ${COLORS.dim}${tool.description.slice(0, 60)}${tool.description.length > 60 ? '...' : ''}${COLORS.reset}`);
+              }
+              log(`    Auth: ${tool.auth_via}`);
+              log('');
+            }
+          }
+        })
+        .demandCommand();
+    },
+    handler: () => {}
+  })
+  .demandCommand()
+  .strict()
+  .fail((msg, err) => {
+    if (msg) {
+      error(msg);
+    }
+    if (err) {
+      error(err.message);
+    }
+    process.exit(1);
+  });
+
+cli.parse();

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@toothfairyai/tfcode",
+  "version": "1.0.0-beta.1",
+  "description": "ToothFairyAI's official AI coding agent",
+  "keywords": ["toothfairyai", "ai", "coding", "cli"],
+  "author": "ToothFairyAI",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "tfcode": "./bin/tfcode.js"
+  },
+  "files": [
+    "bin/",
+    "scripts/"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/postinstall.cjs"
+  },
+  "dependencies": {
+    "yargs": "^17.7.2"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "homepage": "https://toothfairyai.com/developers/tfcode",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ToothFairyAI/tfcode.git"
+  }
+}

package/scripts/postinstall.cjs

@@ -0,0 +1,171 @@
+#!/usr/bin/env node
+
+const { spawn, execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+const CYAN = '\x1b[36m';
+const DIM = '\x1b[90m';
+
+function log(msg) {
+  console.log(msg);
+}
+
+function logSuccess(msg) {
+  console.log(`${GREEN}✓${RESET} ${msg}`);
+}
+
+function logError(msg) {
+  console.error(`${RED}✗${RESET} ${msg}`);
+}
+
+function logInfo(msg) {
+  console.log(`${CYAN}ℹ${RESET} ${msg}`);
+}
+
+function logWarning(msg) {
+  console.log(`${YELLOW}!${RESET} ${msg}`);
+}
+
+function checkPython() {
+  const commands = ['python3', 'python'];
+  
+  for (const cmd of commands) {
+    try {
+      const result = execSync(`${cmd} --version`, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+      const match = result.match(/Python (\d+)\.(\d+)/);
+      if (match) {
+        const major = parseInt(match[1]);
+        const minor = parseInt(match[2]);
+        if (major >= 3 && minor >= 10) {
+          return { cmd, version: result.trim() };
+        }
+      }
+    } catch {}
+  }
+  
+  return null;
+}
+
+function installPythonDeps(pythonCmd) {
+  return new Promise((resolve, reject) => {
+    const packages = ['toothfairyai', 'pydantic', 'httpx', 'rich'];
+    
+    log(`${DIM}Installing Python packages: ${packages.join(', ')}...${RESET}`);
+    
+    // Try with --user first, then --break-system-packages if needed
+    const args = ['-m', 'pip', 'install', '--user', ...packages];
+    
+    const proc = spawn(pythonCmd, args, {
+      stdio: 'inherit',
+      shell: process.platform === 'win32'
+    });
+    
+    proc.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        // Try with --break-system-packages flag
+        log(`${DIM}Retrying with --break-system-packages...${RESET}`);
+        const retryArgs = ['-m', 'pip', 'install', '--user', '--break-system-packages', ...packages];
+        const retry = spawn(pythonCmd, retryArgs, {
+          stdio: 'inherit',
+          shell: process.platform === 'win32'
+        });
+        
+        retry.on('close', (retryCode) => {
+          if (retryCode === 0) {
+            resolve();
+          } else {
+            reject(new Error(`pip install exited with code ${retryCode}`));
+          }
+        });
+        
+        retry.on('error', (err) => {
+          reject(err);
+        });
+      }
+    });
+    
+    proc.on('error', (err) => {
+      reject(err);
+    });
+  });
+}
+
+async function main() {
+  log('');
+  log(`${BOLD}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}`);
+  log(`${BOLD}  tfcode - ToothFairyAI's official coding agent${RESET}`);
+  log(`${BOLD}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}`);
+  log('');
+  
+  // Check for Python
+  logInfo('Checking Python installation...');
+  const python = checkPython();
+  
+  if (!python) {
+    log('');
+    logError('Python 3.10+ is required but not found.');
+    log('');
+    log(`${BOLD}Please install Python 3.10 or later:${RESET}`);
+    log('');
+    log(`  ${CYAN}macOS:${RESET}   brew install python@3.12`);
+    log(`  ${CYAN}Ubuntu:${RESET}   sudo apt-get install python3.12`);
+    log(`  ${CYAN}Windows:${RESET}   Download from https://python.org/downloads`);
+    log('');
+    log(`${DIM}After installing Python, run: npm rebuild tfcode${RESET}`);
+    log('');
+    process.exit(1);
+  }
+  
+  logSuccess(`Found ${python.version} (${python.cmd})`);
+  log('');
+  
+  // Install Python dependencies
+  logInfo('Installing ToothFairyAI Python SDK...');
+  try {
+    await installPythonDeps(python.cmd);
+    logSuccess('Python dependencies installed');
+  } catch (err) {
+    logWarning(`Failed to install Python dependencies: ${err.message}`);
+    log('');
+    log(`${DIM}You can install them manually with:${RESET}`);
+    log(`  ${CYAN}${python.cmd} -m pip install toothfairyai pydantic httpx rich${RESET}`);
+    log('');
+    // Don't exit - user might install manually later
+  }
+  
+  log('');
+  log(`${BOLD}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}`);
+  log(`${GREEN}✓ tfcode installed successfully!${RESET}`);
+  log(`${BOLD}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${RESET}`);
+  log('');
+  log(`${BOLD}Quick Start:${RESET}`);
+  log('');
+  log(`  ${CYAN}1.${RESET} Set your ToothFairyAI credentials:`);
+  log(`     ${DIM}export TF_WORKSPACE_ID="your-workspace-id"${RESET}`);
+  log(`     ${DIM}export TF_API_KEY="your-api-key"${RESET}`);
+  log('');
+  log(`  ${CYAN}2.${RESET} Validate your credentials:`);
+  log(`     ${DIM}tfcode validate${RESET}`);
+  log('');
+  log(`  ${CYAN}3.${RESET} Sync tools from your workspace:`);
+  log(`     ${DIM}tfcode sync${RESET}`);
+  log('');
+  log(`  ${CYAN}4.${RESET} Start coding:`);
+  log(`     ${DIM}tfcode${RESET}`);
+  log('');
+  log(`${DIM}Documentation: https://toothfairyai.com/developers/tfcode${RESET}`);
+  log('');
+}
+
+main().catch((err) => {
+  logError(`Installation failed: ${err.message}`);
+  process.exit(1);
+});

package/scripts/quickstart.cjs

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+
+console.log(`
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  tfcode - Quick Start Guide
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Welcome to tfcode! Follow these steps to get started:
+
+┌─────────────────────────────────────────────────────────────┐
+│ STEP 1: Set Your Credentials                                │
+├─────────────────────────────────────────────────────────────┤
+│                                                             │
+│   export TF_WORKSPACE_ID="your-workspace-id"               │
+│   export TF_API_KEY="your-api-key"                         │
+│   export TF_REGION="au"                                    │
+│                                                             │
+│   Regions: au (Australia), eu (Europe), us (United States) │
+│                                                             │
+└─────────────────────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────────┐
+│ STEP 2: Validate Connection                                 │
+├─────────────────────────────────────────────────────────────┤
+│                                                             │
+│   tfcode validate                                          │
+│                                                             │
+│   This checks your credentials are correct.                │
+│                                                             │
+└─────────────────────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────────┐
+│ STEP 3: Sync Your Tools                                     │
+├─────────────────────────────────────────────────────────────┤
+│                                                             │
+│   tfcode sync                                              │
+│                                                             │
+│   This downloads your tools from ToothFairyAI.             │
+│                                                             │
+└─────────────────────────────────────────────────────────────┘
+
+┌─────────────────────────────────────────────────────────────┐
+│ STEP 4: Start Coding!                                       │
+├─────────────────────────────────────────────────────────────┤
+│                                                             │
+│   tfcode                                                   │
+│                                                             │
+│   Start the AI coding assistant.                           │
+│                                                             │
+└─────────────────────────────────────────────────────────────┘
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  Useful Commands:
+  
+  tfcode validate          Test your credentials
+  tfcode sync              Sync tools from workspace
+  tfcode tools list        Show all your tools
+  tfcode                   Start coding assistant
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  Need help? https://toothfairyai.com/developers/tfcode
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`);