computesdk 1.0.2 → 1.1.1

package/README.md

@@ -1,135 +1,246 @@
-# ComputeSDK
+<div align="center">
+  <img src="https://www.computesdk.com/_astro/hv_main_logo_light.CpYMD9-V.svg" alt="ComputeSDK" width="300" />
+</div>
 
-A unified abstraction layer for executing code in secure, isolated sandboxed environments across multiple cloud providers.
+<div align="center">
+  <strong>A free and open-source toolkit for running other people's code in your applications.</strong>
+</div>
 
-Similar to how Vercel's AI SDK abstracts different LLM providers, ComputeSDK abstracts different compute sandbox providers into a single, consistent TypeScript interface.
+<div align="center">
 
-## Features
+[![npm version](https://badge.fury.io/js/computesdk.svg)](https://badge.fury.io/js/computesdk)
+[![TypeScript](https://img.shields.io/badge/TypeScript-100%25-blue.svg)](https://www.typescriptlang.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Documentation](https://img.shields.io/badge/docs-computesdk.com-blue)](https://computesdk.com)
+
+</div>
 
-- **Unified API** - Single interface for multiple sandbox providers
-- **Auto-detection** - Automatically detects and uses available providers
-- **Provider-agnostic** - Switch between providers without code changes
-- **Type-safe** - Full TypeScript support with comprehensive type definitions
-- **Extensible** - Easy to add new providers
-- **Production-ready** - Built for real-world applications
+---
 
-## Supported Providers
+## What is ComputeSDK?
 
-- **E2B** - Python-focused code execution with templates
-- **Vercel** - Node.js and Python execution on Vercel infrastructure
-- **Cloudflare** - Edge computing with Cloudflare Workers and Durable Objects
-- **Fly.io** - Fast boot containers (community contribution target)
+ComputeSDK is a free and open-source toolkit for running other people's code in your applications. Think of it as the "AI SDK for compute" - providing a consistent TypeScript interface whether you're using E2B, Vercel, or Daytona.
 
-## Installation
+**Why ComputeSDK?**
+- 🔄 **Provider-agnostic** - Switch between E2B, Vercel, Daytona and more (coming soon) without code changes
+- 🛡️ **Security-first** - Isolated sandboxes protect your infrastructure
+- ⚡ **Developer experience** - Simple, TypeScript-native API
+- 🌍 **Production-ready** - Used by teams building the next generation of developer tools
+
+**Perfect for building:**
+- **Code execution platforms** - Run user-submitted code safely
+- **Educational tools** - Interactive coding environments  
+- **Data analysis applications** - Process code with full filesystem access
+- **AI-powered development tools** - Let AI agents write and execute code
+- **Testing & CI/CD systems** - Isolated test environments
+
+## Features
+
+- 🚀 **Multi-provider support** - E2B, Vercel, Daytona
+- 📁 **Filesystem operations** - Read, write, create directories across providers
+- 🖥️ **Terminal support** - Interactive PTY terminals (E2B)
+- ⚡ **Command execution** - Run shell commands directly
+- 🛡️ **Type-safe** - Full TypeScript support with comprehensive error handling
+- 📦 **Modular** - Install only the providers you need
+- 🔧 **Extensible** - Easy to add custom providers
+- 🌐 **Web Framework Integration** - Built-in request handlers for Next.js, Nuxt, SvelteKit, etc.
+- 🎨 **Frontend Integration** - Client-side hooks and utilities via @computesdk/ui
+
+## Get Started in 30 Seconds
 
 ```bash
+# Install the core SDK
 npm install computesdk
+
+# Add your preferred provider
+npm install @computesdk/e2b        # For data science and Python
+npm install @computesdk/vercel     # For web-scale Node.js/Python  
+npm install @computesdk/daytona    # For development workspaces
+
+# Frontend integration (optional)
+npm install @computesdk/ui         # React hooks and utilities
 ```
 
-### Install Provider Packages
+Set your environment variables and you're ready to go:
 
 ```bash
-# Install the providers you need
-npm install @computesdk/e2b        # E2B provider
-npm install @computesdk/vercel     # Vercel provider
-npm install @computesdk/cloudflare # Cloudflare provider
+export E2B_API_KEY=your_api_key
+# or VERCEL_TOKEN=your_token
+# or DAYTONA_API_KEY=your_key
 ```
 
 ## Quick Start
 
-### Auto-detection (Recommended)
-
 ```typescript
-import { ComputeSDK } from 'computesdk';
+import { compute } from 'computesdk';
+import { e2b } from '@computesdk/e2b';
 
-// Automatically detects and uses available providers
-const sdk = new ComputeSDK();
-const sandbox = await sdk.createSandbox();
+// Set default provider
+compute.setConfig({ 
+  provider: e2b({ apiKey: process.env.E2B_API_KEY }) 
+});
 
-const result = await sandbox.execute('print("Hello from ComputeSDK!")');
-console.log(result.stdout); // "Hello from ComputeSDK!"
+// Create a sandbox
+const sandbox = await compute.sandbox.create({});
 
-await sandbox.kill();
+// Execute code
+const result = await sandbox.runCode('print("Hello World!")');
+console.log(result.stdout); // "Hello World!"
+
+// Clean up
+await compute.sandbox.destroy(sandbox.sandboxId);
 ```
 
-### Provider-specific Usage
+## Provider Setup
+
+### E2B - Full Development Environment
+
+E2B provides full filesystem and terminal support:
+
+```bash
+export E2B_API_KEY=e2b_your_api_key_here
+```
 
 ```typescript
-import { executeSandbox } from 'computesdk';
+import { compute } from 'computesdk';
 import { e2b } from '@computesdk/e2b';
 
-// Execute with specific provider
-const result = await executeSandbox({
-  sandbox: e2b(),
-  code: 'print("Hello from E2B!")',
-  runtime: 'python'
+compute.setConfig({ 
+  provider: e2b({ apiKey: process.env.E2B_API_KEY }) 
 });
 
-console.log(result.stdout);
+const sandbox = await compute.sandbox.create({});
+
+// Execute Python with data science libraries
+const result = await sandbox.runCode(`
+import pandas as pd
+import numpy as np
+
+data = {'A': [1, 2, 3], 'B': [4, 5, 6]}
+df = pd.DataFrame(data)
+print(df)
+print(f"Sum: {df.sum().sum()}")
+`);
+
+// Interactive terminal support
+const terminal = await sandbox.terminal.create({
+  command: 'bash',
+  cols: 80,
+  rows: 24
+});
 ```
 
-### Multiple Providers
+### Vercel - Scalable Serverless Execution
+
+Vercel provides reliable execution with filesystem support:
+
+```bash
+# Method 1: OIDC Token (Recommended)
+vercel env pull  # Downloads VERCEL_OIDC_TOKEN
+
+# Method 2: Traditional
+export VERCEL_TOKEN=your_vercel_token_here
+export VERCEL_TEAM_ID=your_team_id_here
+export VERCEL_PROJECT_ID=your_project_id_here
+```
 
 ```typescript
-import { executeSandbox } from 'computesdk';
-import { e2b } from '@computesdk/e2b';
+import { compute } from 'computesdk';
 import { vercel } from '@computesdk/vercel';
-import { cloudflare } from '@computesdk/cloudflare';
-
-// Try different providers for different use cases
-const providers = [
-  { name: 'E2B', provider: e2b() },
-  { name: 'Vercel', provider: vercel() },
-  { name: 'Cloudflare', provider: cloudflare({ env }) }
-];
-
-for (const { name, provider } of providers) {
-  try {
-    const result = await executeSandbox({
-      sandbox: provider,
-      code: 'print("Hello from ' + name + '!")'
-    });
-    console.log(`${name}:`, result.stdout);
-  } catch (error) {
-    console.error(`${name} failed:`, error.message);
-  }
-}
+
+compute.setConfig({ 
+  provider: vercel({ runtime: 'node' }) 
+});
+
+const sandbox = await compute.sandbox.create({});
+
+// Execute Node.js or Python
+const result = await sandbox.runCode(`
+console.log('Node.js version:', process.version);
+console.log('Hello from Vercel!');
+`);
+
+// Up to 45 minutes execution time
+// Global infrastructure deployment
 ```
 
-## API Reference
+### Daytona - Development Workspaces
 
-### `ComputeSDK`
+Daytona provides development workspace environments:
 
-Main SDK class for auto-detection and management.
+```bash
+export DAYTONA_API_KEY=your_daytona_api_key_here
+```
 
 ```typescript
-const sdk = new ComputeSDK(options?: ComputeSDKOptions);
-```
+import { compute } from 'computesdk';
+import { daytona } from '@computesdk/daytona';
 
-#### Methods
+compute.setConfig({ 
+  provider: daytona({ apiKey: process.env.DAYTONA_API_KEY }) 
+});
 
-- `createSandbox(config?: SandboxConfig)` - Creates a sandbox using auto-detection
-- `getAvailableProviders()` - Returns list of available providers
-- `registerProvider(name: string, provider: ComputeSpecification)` - Registers a custom provider
+const sandbox = await compute.sandbox.create({});
 
-### `executeSandbox(config: ExecutionConfig)`
+// Execute in development workspace
+const result = await sandbox.runCode(`
+print('Hello from Daytona!')
+import sys
+print(f'Python version: {sys.version}')
+`);
+```
 
-Utility function for one-off code execution.
+## Core API
+
+### Configuration
 
 ```typescript
-interface ExecutionConfig {
-  sandbox: ComputeSpecification;
-  code: string;
-  runtime?: 'python' | 'node';
-  timeout?: number;
-}
+import { compute } from 'computesdk';
+
+// Set default provider
+compute.setConfig({ provider: myProvider });
+
+// Get current config
+const config = compute.getConfig();
+
+// Clear config
+compute.clearConfig();
 ```
 
-### `ExecutionResult`
+### Sandbox Management
+
+```typescript
+// Create sandbox with explicit provider
+const sandbox = await compute.sandbox.create({
+  provider: e2b({ apiKey: 'your-key' }),
+  options: { runtime: 'python', timeout: 300000 }
+});
+
+// Create sandbox with default provider
+const sandbox = await compute.sandbox.create({
+  options: { runtime: 'python' }
+});
+
+// Get existing sandbox
+const sandbox = await compute.sandbox.getById('sandbox-id');
 
-Result object returned by all execution methods.
+// List all sandboxes
+const sandboxes = await compute.sandbox.list();
+
+// Destroy sandbox
+await compute.sandbox.destroy('sandbox-id');
+```
+
+### Code Execution
 
 ```typescript
+// Run code
+const result = await sandbox.runCode('print("Hello")', 'python');
+
+// Run shell command
+const result = await sandbox.runCommand('ls', ['-la']);
+
+// Result structure
 interface ExecutionResult {
   stdout: string;
   stderr: string;
@@ -140,219 +251,383 @@ interface ExecutionResult {
 }
 ```
 
-### `SandboxInfo`
-
-Information about a sandbox instance.
+### Filesystem Operations
 
 ```typescript
-interface SandboxInfo {
-  id: string;
-  provider: string;
-  runtime: string;
-  status: 'running' | 'stopped';
-  createdAt: Date;
-  timeout: number;
-  metadata?: Record<string, any>;
-}
+// Write file
+await sandbox.filesystem.writeFile('/tmp/hello.py', 'print("Hello")');
+
+// Read file
+const content = await sandbox.filesystem.readFile('/tmp/hello.py');
+
+// Create directory
+await sandbox.filesystem.mkdir('/tmp/mydir');
+
+// List directory
+const files = await sandbox.filesystem.readdir('/tmp');
+
+// Check if exists
+const exists = await sandbox.filesystem.exists('/tmp/hello.py');
+
+// Remove file/directory
+await sandbox.filesystem.remove('/tmp/hello.py');
 ```
 
-## Configuration
+### Terminal Operations
+
+```typescript
+// Create terminal (E2B only)
+const terminal = await sandbox.terminal.create({
+  command: 'bash',
+  cols: 80,
+  rows: 24
+});
 
-### Environment Variables
+// Write to terminal
+await terminal.write('ls -la\n');
 
-Each provider requires specific environment variables:
+// Resize terminal
+await terminal.resize(120, 30);
 
-```bash
-# E2B
-E2B_API_KEY=your_e2b_api_key
+// Kill terminal
+await terminal.kill();
 
-# Vercel
-VERCEL_TOKEN=your_vercel_token
-VERCEL_TEAM_ID=your_team_id
-VERCEL_PROJECT_ID=your_project_id
+// List terminals
+const terminals = await sandbox.terminal.list();
 
-# Cloudflare (Workers environment only)
-# Requires Durable Object bindings in wrangler.toml
+// Get terminal by ID
+const terminal = await sandbox.terminal.getById('terminal-id');
 ```
 
-### Provider Configuration
+## Web Framework Integration
+
+ComputeSDK provides built-in request handlers for web frameworks:
 
 ```typescript
-import { ComputeSDK } from 'computesdk';
+import { handleComputeRequest } from 'computesdk';
 import { e2b } from '@computesdk/e2b';
-import { vercel } from '@computesdk/vercel';
 
-const sdk = new ComputeSDK({
-  preferredProviders: ['e2b', 'vercel'], // Order of preference
-  timeout: 300000, // Global timeout (5 minutes)
-  retryAttempts: 3 // Retry failed executions
-});
+// Next.js API route
+export async function POST(request: Request) {
+  return handleComputeRequest({
+    request,
+    provider: e2b({ apiKey: process.env.E2B_API_KEY })
+  });
+}
 
-// Or configure providers individually
-const customSandbox = e2b({
-  timeout: 600000, // 10 minutes
-  template: 'python-data-science'
+// Client usage
+const response = await fetch('/api/compute', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({
+    action: 'compute.sandbox.runCode',
+    code: 'print("Hello from web!")',
+    runtime: 'python'
+  })
 });
+
+const result = await response.json();
+console.log(result.result.stdout);
+```
+
+### Supported Actions
+
+- `compute.sandbox.create` - Create new sandbox
+- `compute.sandbox.destroy` - Destroy sandbox
+- `compute.sandbox.getInfo` - Get sandbox information
+- `compute.sandbox.list` - List all sandboxes
+- `compute.sandbox.runCode` - Execute code
+- `compute.sandbox.runCommand` - Run shell command
+- `compute.sandbox.filesystem.readFile` - Read file
+- `compute.sandbox.filesystem.writeFile` - Write file
+- `compute.sandbox.filesystem.mkdir` - Create directory
+- `compute.sandbox.filesystem.readdir` - List directory
+- `compute.sandbox.filesystem.exists` - Check if path exists
+- `compute.sandbox.filesystem.remove` - Remove file/directory
+- `compute.sandbox.terminal.create` - Create terminal
+- `compute.sandbox.terminal.list` - List terminals
+- `compute.sandbox.terminal.getById` - Get terminal by ID
+- `compute.sandbox.terminal.destroy` - Destroy terminal
+- `compute.sandbox.terminal.write` - Write to terminal
+- `compute.sandbox.terminal.resize` - Resize terminal
+- `compute.sandbox.terminal.kill` - Kill terminal
+
+## Frontend Integration
+
+Use `@computesdk/ui` for React hooks and utilities:
+
+```typescript
+import { useCompute } from '@computesdk/ui';
+
+function CodeExecutor() {
+  const compute = useCompute({
+    apiEndpoint: '/api/compute',
+    defaultRuntime: 'python'
+  });
+  
+  const executeCode = async () => {
+    const sandbox = await compute.sandbox.create();
+    const result = await sandbox.runCode('print("Hello World!")');
+    console.log(result.result?.stdout);
+    await sandbox.destroy();
+  };
+  
+  return (
+    <button onClick={executeCode}>
+      Execute Code
+    </button>
+  );
+}
+```
+
+## Error Handling
+
+```typescript
+try {
+  const sandbox = await compute.sandbox.create({});
+  const result = await sandbox.runCode('invalid code');
+} catch (error) {
+  console.error('Execution failed:', error.message);
+}
 ```
 
 ## Examples
 
-### Data Processing
+### Data Science with E2B
 
 ```typescript
-import { executeSandbox } from 'computesdk';
+import { compute } from 'computesdk';
 import { e2b } from '@computesdk/e2b';
 
-const result = await executeSandbox({
-  sandbox: e2b(),
-  code: `
+compute.setConfig({ provider: e2b({ apiKey: process.env.E2B_API_KEY }) });
+
+const sandbox = await compute.sandbox.create({});
+
+// Create project structure
+await sandbox.filesystem.mkdir('/analysis');
+await sandbox.filesystem.mkdir('/analysis/data');
+await sandbox.filesystem.mkdir('/analysis/output');
+
+// Write input data
+const csvData = `name,age,city
+Alice,25,New York
+Bob,30,San Francisco
+Charlie,35,Chicago`;
+
+await sandbox.filesystem.writeFile('/analysis/data/people.csv', csvData);
+
+// Process data with Python
+const result = await sandbox.runCode(`
 import pandas as pd
-import numpy as np
+import matplotlib.pyplot as plt
+
+# Read data
+df = pd.read_csv('/analysis/data/people.csv')
+print("Data loaded:")
+print(df)
+
+# Calculate statistics
+avg_age = df['age'].mean()
+print(f"\\nAverage age: {avg_age}")
+
+# Create visualization
+plt.figure(figsize=(8, 6))
+plt.bar(df['name'], df['age'])
+plt.title('Age by Person')
+plt.xlabel('Name')
+plt.ylabel('Age')
+plt.savefig('/analysis/output/age_chart.png')
+print("\\nChart saved to /analysis/output/age_chart.png")
+
+# Save results
+results = {
+    'total_people': len(df),
+    'average_age': avg_age,
+    'cities': df['city'].unique().tolist()
+}
 
-# Create sample data
-data = pd.DataFrame({
-    'sales': [100, 150, 200, 120, 180],
-    'profit': [20, 30, 45, 25, 40]
-})
-
-# Calculate metrics
-total_sales = data['sales'].sum()
-avg_profit = data['profit'].mean()
-profit_margin = (data['profit'].sum() / total_sales) * 100
-
-print(f"Total Sales: ${total_sales}")
-print(f"Average Profit: ${avg_profit:.2f}")
-print(f"Profit Margin: {profit_margin:.1f}%")
-  `
-});
+import json
+with open('/analysis/output/results.json', 'w') as f:
+    json.dump(results, f, indent=2)
+
+print("Results saved!")
+`);
 
 console.log(result.stdout);
+
+// Read the results
+const results = await sandbox.filesystem.readFile('/analysis/output/results.json');
+console.log('Analysis results:', JSON.parse(results));
+
+await compute.sandbox.destroy(sandbox.sandboxId);
 ```
 
-### Web API Simulation
+### Cross-Provider Data Processing
 
 ```typescript
-import { executeSandbox } from 'computesdk';
+import { compute } from 'computesdk';
 import { vercel } from '@computesdk/vercel';
+import { daytona } from '@computesdk/daytona';
+
+async function processData(provider: any) {
+  compute.setConfig({ provider });
+  
+  const sandbox = await compute.sandbox.create({});
+  
+  // Create workspace
+  await sandbox.filesystem.mkdir('/workspace');
+  
+  // Write input data
+  await sandbox.filesystem.writeFile('/workspace/input.json', 
+    JSON.stringify({ numbers: [1, 2, 3, 4, 5] })
+  );
+  
+  // Process with code execution
+  const result = await sandbox.runCode(`
+import json
 
-const result = await executeSandbox({
-  sandbox: vercel({ runtime: 'node' }),
-  code: `
-const express = require('express');
-const app = express();
+# Read input
+with open('/workspace/input.json', 'r') as f:
+    data = json.load(f)
 
-// Simulate API routes
-const routes = {
-  '/api/users': { users: ['Alice', 'Bob', 'Charlie'] },
-  '/api/stats': { active: 150, total: 1000 }
-};
+# Process
+numbers = data['numbers']
+result = {
+    'sum': sum(numbers),
+    'average': sum(numbers) / len(numbers),
+    'count': len(numbers)
+}
 
-// Process request
-const path = '/api/users';
-const response = routes[path] || { error: 'Not found' };
+# Write output
+with open('/workspace/output.json', 'w') as f:
+    json.dump(result, f, indent=2)
+
+print("Processing complete!")
+  `);
+  
+  // Read results
+  const output = await sandbox.filesystem.readFile('/workspace/output.json');
+  await compute.sandbox.destroy(sandbox.sandboxId);
+  
+  return JSON.parse(output);
+}
 
-console.log('API Response:', JSON.stringify(response, null, 2));
-  `
-});
+// Use with different providers
+const vercelResult = await processData(vercel({ runtime: 'python' }));
+console.log('Vercel result:', vercelResult);
 
-console.log(result.stdout);
+const daytonaResult = await processData(daytona({ runtime: 'python' }));
+console.log('Daytona result:', daytonaResult);
 ```
 
-### Edge Computing
+## Provider Packages
 
-```typescript
-import { executeSandbox } from 'computesdk';
-import { cloudflare } from '@computesdk/cloudflare';
-
-// Within a Cloudflare Worker
-export default {
-  async fetch(request: Request, env: Env): Promise<Response> {
-    const result = await executeSandbox({
-      sandbox: cloudflare({ env }),
-      code: `
-import json
-from datetime import datetime
+ComputeSDK uses separate provider packages:
 
-# Process request data
-data = {
-    "timestamp": datetime.now().isoformat(),
-    "region": "auto",
-    "processed": True
-}
+```bash
+npm install @computesdk/e2b        # E2B provider
+npm install @computesdk/vercel     # Vercel provider  
+npm install @computesdk/daytona    # Daytona provider
+```
+
+Each provider implements the same interface but may support different capabilities (filesystem, terminal, etc.).
 
-print(json.dumps(data))
-      `
-    });
+## Custom Providers
 
-    return new Response(result.stdout, {
-      headers: { 'Content-Type': 'application/json' }
-    });
+Create custom providers using the factory:
+
+```typescript
+import { createProvider } from 'computesdk';
+
+const myProvider = createProvider({
+  name: 'my-provider',
+  methods: {
+    sandbox: {
+      create: async (config, options) => {
+        // Implementation
+      },
+      getById: async (config, id) => {
+        // Implementation  
+      },
+      list: async (config) => {
+        // Implementation
+      },
+      destroy: async (config, id) => {
+        // Implementation
+      }
+    }
   }
-};
+});
 ```
 
-## Error Handling
+## TypeScript Support
 
-ComputeSDK provides comprehensive error handling:
+ComputeSDK is fully typed with comprehensive TypeScript definitions:
 
 ```typescript
-import { 
-  ExecutionError, 
-  TimeoutError, 
-  AuthenticationError,
-  QuotaExceededError 
+import type { 
+  Sandbox, 
+  Provider, 
+  ExecutionResult,
+  ComputeConfig,
+  Runtime 
 } from 'computesdk';
-
-try {
-  const result = await executeSandbox({
-    sandbox: e2b(),
-    code: 'print("Hello World")'
-  });
-} catch (error) {
-  if (error instanceof TimeoutError) {
-    console.error('Execution timed out');
-  } else if (error instanceof AuthenticationError) {
-    console.error('Check your API credentials');
-  } else if (error instanceof QuotaExceededError) {
-    console.error('API quota exceeded');
-  } else if (error instanceof ExecutionError) {
-    console.error('Code execution failed:', error.stderr);
-  } else {
-    console.error('Unknown error:', error.message);
-  }
-}
 ```
 
 ## Provider Comparison
 
-| Provider | Runtimes | Max Timeout | Use Cases |
-|----------|----------|-------------|-----------|
-| E2B | Python | 5 minutes | Data science, AI/ML |
-| Vercel | Node.js, Python | 45 minutes | Web apps, APIs |
-| Cloudflare | Python, Node.js | 30 seconds | Edge computing, real-time |
-| Fly.io | Custom | Variable | Custom containers |
+| Provider | Code Execution | Filesystem | Terminal | Use Cases |
+|----------|----------------|------------|----------|-----------|
+| **E2B** | Python, Node.js | ✅ Full | ✅ PTY | Data science, AI/ML, interactive development |
+| **Vercel** | Node.js, Python | ✅ Full | ❌ | Web apps, APIs, serverless functions |
+| **Daytona** | Python, Node.js | ✅ Full | ❌ | Development workspaces, custom environments |
 
-## Contributing
+### Key Differences
 
-We welcome contributions! Please see our [Contributing Guide](https://github.com/computesdk/computesdk/blob/main/CONTRIBUTING.md) for details.
+- **E2B**: Full development environment with data science libraries and interactive terminals
+- **Vercel**: Ephemeral sandboxes optimized for serverless execution (up to 45 minutes)
+- **Daytona**: Development workspaces with persistent environments
 
-### Adding New Providers
+## Examples
 
-1. Implement the `ComputeSpecification` interface
-2. Add comprehensive tests
-3. Include documentation and examples
-4. Submit a pull request
+Check out the [examples directory](./examples) for complete implementations with different web frameworks:
 
-## License
+- [Next.js](./examples/nextjs)
+- [Nuxt](./examples/nuxt) 
+- [SvelteKit](./examples/sveltekit)
+- [Remix](./examples/remix)
+- [Astro](./examples/astro)
 
-MIT - see [LICENSE](https://github.com/computesdk/computesdk/blob/main/LICENSE) for details.
+## Resources
 
-## Support
+- 📖 **[Full Documentation](https://computesdk.com)** - Complete guides and API reference
+- 🚀 **[Getting Started](https://computesdk.com/getting-started)** - Quick setup guide
+- 💡 **[Examples](./examples)** - Real-world usage examples
+- 🎯 **[Providers](https://computesdk.com/providers)** - Provider-specific guides
+
+## Contributing
+
+ComputeSDK is open source and welcomes contributions! Whether you're fixing bugs, adding features, or improving documentation, we'd love your help.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## Community & Support
+
+- 💬 **[GitHub Discussions](https://github.com/computesdk/computesdk/discussions)** - Ask questions and share ideas
+- 🐛 **[GitHub Issues](https://github.com/computesdk/computesdk/issues)** - Report bugs and request features
+- 📧 **[Contact Us](https://computesdk.com/contact)** - Get in touch with the team
+
+## License
 
-- [GitHub Issues](https://github.com/computesdk/computesdk/issues)
-- [Documentation](https://github.com/computesdk/computesdk)
-- [Examples](https://github.com/computesdk/computesdk/tree/main/examples)
+MIT License - see the [LICENSE](LICENSE) file for details.
 
 ---
 
-Made with ❤️ by the ComputeSDK team
+<div align="center">
+  <strong>Built with ❤️ by the ComputeSDK team</strong><br>
+  <a href="https://computesdk.com">computesdk.com</a>
+</div>