@intella/sdk 0.0.1 → 0.0.2

package/src/sandbox-manager.ts

@@ -1,175 +0,0 @@
-import type { SandboxProviderType, SandboxConfig, ISandboxProvider } from './types.js';
-import { E2BSandboxProvider } from './sandbox/e2b-provider.js';
-import { DaytonaSandboxProvider } from './sandbox/daytona-provider.js';
-import { ModalSandboxProvider } from './sandbox/modal-provider.js';
-
-/**
- * Sandbox Manager
- * Manages sandbox provider instances and configurations
- */
-export class SandboxManager {
-  private sandboxes: Map<SandboxProviderType, ISandboxProvider> = new Map();
-  private defaultProviderType: SandboxProviderType | null = null;
-  private activeSandbox: ISandboxProvider | null = null;
-
-  constructor(config?: {
-    provider?: SandboxProviderType;
-    config?: SandboxConfig;
-  }) {
-    // Initialize providers (but don't create sandboxes yet)
-    if(config?.provider) {
-      this.defaultProviderType = config.provider;
-    }
-    this.registerProvider('e2b', new E2BSandboxProvider(config?.config));
-    this.registerProvider('daytona', new DaytonaSandboxProvider(config?.config));
-    this.registerProvider('modal', new ModalSandboxProvider(config?.config));
-  }
-
-  /**
-   * Register or update a sandbox provider instance
-   */
-  registerProvider(type: SandboxProviderType, provider: ISandboxProvider): void {
-    if (provider.type !== type) {
-      throw new Error(
-        `Sandbox provider type mismatch: expected ${type}, got ${provider.type}`
-      );
-    }
-    this.sandboxes.set(type, provider);
-  }
-
-  /**
-   * Get a sandbox provider instance
-   */
-  getProvider(type?: SandboxProviderType): ISandboxProvider {
-    const providerType = type || this.defaultProviderType;
-    
-    if (!providerType) {
-      throw new Error(
-        'No sandbox provider selected. Call selectProvider() or initializeSandbox() first.'
-      );
-    }
-
-    const provider = this.sandboxes.get(providerType);
-    
-    if (!provider) {
-      throw new Error(`Sandbox provider ${providerType} is not registered`);
-    }
-    
-    return provider;
-  }
-
-  /**
-   * List all available sandbox providers
-   */
-  listProviders(): SandboxProviderType[] {
-    return Array.from(this.sandboxes.keys());
-  }
-
-  /**
-   * Check if a provider is registered
-   */
-  hasProvider(type: SandboxProviderType): boolean {
-    return this.sandboxes.has(type);
-  }
-
-  /**
-   * Initialize/create a sandbox with the specified provider
-   */
-  async initializeSandbox(
-    type: SandboxProviderType,
-    config?: SandboxConfig
-  ): Promise<ISandboxProvider> {
-    const provider = this.getProvider(type);
-    
-    // Close existing active sandbox if different
-    if (this.activeSandbox && this.activeSandbox !== provider) {
-      try {
-        await this.activeSandbox.close();
-      } catch (error) {
-        console.warn('Error closing previous sandbox:', error);
-      }
-    }
-
-    await provider.initialize(config);
-    this.activeSandbox = provider;
-    this.defaultProviderType = type;
-
-    return provider;
-  }
-
-  /**
-   * Get the active sandbox provider
-   */
-  getActiveSandbox(): ISandboxProvider | null {
-    return this.activeSandbox;
-  }
-
-  /**
-   * Set the default provider type (does not initialize)
-   */
-  setDefaultProvider(type: SandboxProviderType): void {
-    if (!this.sandboxes.has(type)) {
-      throw new Error(`Sandbox provider ${type} is not registered`);
-    }
-    this.defaultProviderType = type;
-  }
-
-  /**
-   * Get the default provider type
-   */
-  getDefaultProviderType(): SandboxProviderType | null {
-    return this.defaultProviderType;
-  }
-
-  /**
-   * Close the active sandbox
-   */
-  async closeActiveSandbox(): Promise<void> {
-    if (this.activeSandbox) {
-      try {
-        await this.activeSandbox.close();
-      } catch (error) {
-        console.warn('Error closing active sandbox:', error);
-      }
-      this.activeSandbox = null;
-    }
-  }
-
-  /**
-   * Close all sandboxes
-   */
-  async closeAll(): Promise<void> {
-    const closePromises = Array.from(this.sandboxes.values()).map(
-      async (provider) => {
-        if (provider.isInitialized()) {
-          try {
-            await provider.close();
-          } catch (error) {
-            console.warn(`Error closing sandbox ${provider.type}:`, error);
-          }
-        }
-      }
-    );
-
-    await Promise.all(closePromises);
-    this.activeSandbox = null;
-  }
-
-  /**
-   * Remove a provider (cannot remove if it's the active sandbox)
-   */
-  removeProvider(type: SandboxProviderType): void {
-    const provider = this.sandboxes.get(type);
-    
-    if (provider && provider === this.activeSandbox) {
-      throw new Error('Cannot remove the active sandbox provider. Close it first.');
-    }
-    
-    this.sandboxes.delete(type);
-    
-    if (this.defaultProviderType === type) {
-      this.defaultProviderType = null;
-    }
-  }
-}
-

package/src/sdk.ts

@@ -1,401 +0,0 @@
-import type {
-  AgentType,
-  AgentConfig,
-  TaskRequest,
-  TaskResponse,
-  OrchestrationRequest,
-  OrchestrationResponse,
-  FilesystemProviderType,
-  FilesystemConfig,
-  FileStats,
-  DirectoryEntry,
-  ToolCallMetadata,
-  IFilesystemProvider,
-  SandboxProviderType,
-  SandboxConfig,
-  SandboxExecutionResult,
-  ISandboxProvider,
-} from './types.js';
-import { AgentManager } from './agent-manager.js';
-import { Orchestrator } from './orchestrator.js';
-import { FilesystemManager } from './filesystem-manager.js';
-import { SandboxManager } from './sandbox-manager.js';
-
-/**
- * Intella SDK
- * Main class for orchestrating and managing tasks across multiple AI agents
- */
-export class IntellaSDK {
-  private agentManager: AgentManager;
-  private orchestrator: Orchestrator;
-  private filesystemManager: FilesystemManager;
-  private sandboxManager: SandboxManager;
-
-  constructor(
-    config?: {
-      sandbox?: {
-        provider?: SandboxProviderType;
-        config?: SandboxConfig;
-      }
-  }) {
-    this.agentManager = new AgentManager();
-    this.orchestrator = new Orchestrator(this.agentManager);
-    this.filesystemManager = new FilesystemManager();
-    this.sandboxManager = new SandboxManager(config?.sandbox);
-  }
-
-  /**
-   * Select and configure an agent
-   */
-  selectAgent(agentType: AgentType, config?: AgentConfig): void {
-    this.agentManager.updateConfig(agentType, config || {});
-    this.agentManager.setDefaultAgent(agentType);
-  }
-
-  /**
-   * Configure an agent without selecting it as default
-  */
-  configureAgent(agentType: AgentType, config: AgentConfig): void {
-    this.agentManager.updateConfig(agentType, config);
-  }
-
-  /**
-   * Execute a task with a selected agent (or default)
-   */
-  async executeTask(
-    task: string | TaskRequest,
-    agentType?: AgentType
-  ): Promise<TaskResponse> {
-    const request: TaskRequest =
-      typeof task === 'string' ? { prompt: task } : task;
-    const agent = this.agentManager.getAgent(agentType);
-    return agent.execute(request);
-  }
-
-  /**
-   * Stream a task execution
-   */
-  async *streamTask(
-    task: string | TaskRequest,
-    agentType?: AgentType
-  ): AsyncIterable<{ text: string; agentType: AgentType; isDone: boolean }> {
-    const request: TaskRequest =
-      typeof task === 'string' ? { prompt: task } : task;
-    const agent = this.agentManager.getAgent(agentType);
-    yield* agent.stream(request);
-  }
-
-  /**
-   * Orchestrate a task across multiple agents
-   */
-  async orchestrateTask(
-    task: string | TaskRequest,
-    agents: AgentType[],
-    strategy: OrchestrationRequest['strategy'] = 'sequential',
-    options?: OrchestrationRequest['options']
-  ): Promise<OrchestrationResponse> {
-    const request: TaskRequest =
-      typeof task === 'string' ? { prompt: task } : task;
-
-    return this.orchestrator.orchestrate({
-      task: request,
-      agents,
-      strategy,
-      options,
-    });
-  }
-
-  /**
-   * Get the agent manager (for advanced usage)
-   */
-  getAgentManager(): AgentManager {
-    return this.agentManager;
-  }
-
-  /**
-   * Get the orchestrator (for advanced usage)
-   */
-  getOrchestrator(): Orchestrator {
-    return this.orchestrator;
-  }
-
-  /**
-   * List available agents
-   */
-  listAgents(): AgentType[] {
-    return this.agentManager.listAgents();
-  }
-
-  /**
-   * Get agent configuration
-   */
-  getAgentConfig(agentType: AgentType): AgentConfig {
-    return this.agentManager.getConfig(agentType);
-  }
-
-  /**
-   * Set default agent
-   */
-  setDefaultAgent(agentType: AgentType): void {
-    this.agentManager.setDefaultAgent(agentType);
-  }
-
-  /**
-   * Get default agent type
-   */
-  getDefaultAgentType(): AgentType {
-    return this.agentManager.getDefaultAgentType();
-  }
-
-  // ============================================================================
-  // Sandbox Methods
-  // ============================================================================
-
-  /**
-   * Initialize a sandbox with the specified provider
-   */
-  async initializeSandbox(
-    providerType: SandboxProviderType,
-    config?: SandboxConfig
-  ): Promise<ISandboxProvider> {
-    return this.sandboxManager.initializeSandbox(providerType, config);
-  }
-
-  /**
-   * Execute a command in the active sandbox
-   */
-  async executeInSandbox(
-    command: string,
-    options?: {
-      cwd?: string;
-      env?: Record<string, string>;
-      timeout?: number;
-    }
-  ): Promise<SandboxExecutionResult> {
-    const sandbox = this.sandboxManager.getActiveSandbox();
-    if (!sandbox) {
-      throw new Error(
-        'No active sandbox. Call initializeSandbox() first.'
-      );
-    }
-
-    const result = await sandbox.executeCommand(command, options);
-    return {
-      result,
-      sandboxId: sandbox.getSandboxId() || 'unknown',
-      provider: sandbox.type,
-    };
-  }
-
-  /**
-   * Get the active sandbox provider
-   */
-  getActiveSandbox(): ISandboxProvider | null {
-    return this.sandboxManager.getActiveSandbox();
-  }
-
-  /**
-   * Close the active sandbox
-   */
-  async closeSandbox(): Promise<void> {
-    await this.sandboxManager.closeActiveSandbox();
-  }
-
-  /**
-   * List available sandbox providers
-   */
-  listSandboxProviders(): SandboxProviderType[] {
-    return this.sandboxManager.listProviders();
-  }
-
-  /**
-   * Set default sandbox provider (does not initialize)
-   */
-  setDefaultSandboxProvider(type: SandboxProviderType): void {
-    this.sandboxManager.setDefaultProvider(type);
-  }
-
-  /**
-   * Get default sandbox provider type
-   */
-  getDefaultSandboxProviderType(): SandboxProviderType | null {
-    return this.sandboxManager.getDefaultProviderType();
-  }
-
-  /**
-   * Get the sandbox manager (for advanced usage)
-   */
-  getSandboxManager(): SandboxManager {
-    return this.sandboxManager;
-  }
-
-  /**
-   * Execute a task in a sandbox environment
-   * This combines agent execution with sandbox command execution
-   */
-  async executeTaskInSandbox(
-    task: string | TaskRequest,
-    command: string,
-    agentType?: AgentType,
-    sandboxOptions?: {
-      cwd?: string;
-      env?: Record<string, string>;
-      timeout?: number;
-    }
-  ): Promise<{
-    agentResponse: TaskResponse;
-    sandboxResult: SandboxExecutionResult;
-  }> {
-    // Execute the task with the agent
-    const agentResponse = await this.executeTask(task, agentType);
-
-    // Execute the command in the sandbox
-    const sandboxResult = await this.executeInSandbox(command, sandboxOptions);
-
-    return {
-      agentResponse,
-      sandboxResult,
-    };
-  }
-
-  // ============================================================================
-  // Filesystem Methods
-  // ============================================================================
-
-  /**
-   * Initialize filesystem with a provider
-   */
-  async initializeFilesystem(
-    provider: FilesystemProviderType = 'memory',
-    config?: FilesystemConfig
-  ): Promise<void> {
-    await this.filesystemManager.initializeFilesystem(provider, config);
-  }
-
-  /**
-   * Get filesystem manager (for advanced usage)
-   */
-  getFilesystemManager(): FilesystemManager {
-    return this.filesystemManager;
-  }
-
-  /**
-   * Get current filesystem provider
-   */
-  getFilesystem(): IFilesystemProvider {
-    return this.filesystemManager.getProvider();
-  }
-
-  /**
-   * Check if filesystem is initialized
-   */
-  isFilesystemInitialized(): boolean {
-    return this.filesystemManager.isInitialized();
-  }
-
-  /**
-   * Close filesystem
-   */
-  async closeFilesystem(): Promise<void> {
-    await this.filesystemManager.closeFilesystem();
-  }
-
-  /**
-   * List available filesystem providers
-   */
-  listFilesystemProviders(): FilesystemProviderType[] {
-    return this.filesystemManager.listProviders();
-  }
-
-  /**
-   * Set default filesystem provider
-   */
-  setDefaultFilesystemProvider(provider: FilesystemProviderType): void {
-    this.filesystemManager.setDefaultProvider(provider);
-  }
-
-  /**
-   * Get default filesystem provider type
-   */
-  getDefaultFilesystemProviderType(): FilesystemProviderType | null {
-    return this.filesystemManager.getDefaultProviderType();
-  }
-
-  // Convenience methods for filesystem operations
-  async readFile(path: string): Promise<Buffer | string> {
-    return this.filesystemManager.readFile(path);
-  }
-
-  async writeFile(path: string, data: Buffer | string): Promise<void> {
-    return this.filesystemManager.writeFile(path, data);
-  }
-
-  async appendFile(path: string, data: Buffer | string): Promise<void> {
-    return this.filesystemManager.appendFile(path, data);
-  }
-
-  async fileExists(path: string): Promise<boolean> {
-    return this.filesystemManager.exists(path);
-  }
-
-  async fileStat(path: string): Promise<FileStats> {
-    return this.filesystemManager.stat(path);
-  }
-
-  async readDirectory(path: string): Promise<DirectoryEntry[]> {
-    return this.filesystemManager.readdir(path);
-  }
-
-  async createDirectory(path: string, recursive = false): Promise<void> {
-    return this.filesystemManager.mkdir(path, recursive);
-  }
-
-  async deleteFile(path: string, recursive = false): Promise<void> {
-    return this.filesystemManager.unlink(path, recursive);
-  }
-
-  async copyFile(src: string, dest: string): Promise<void> {
-    return this.filesystemManager.copy(src, dest);
-  }
-
-  async moveFile(src: string, dest: string): Promise<void> {
-    return this.filesystemManager.move(src, dest);
-  }
-
-  // Key-value operations
-  async getValue(key: string): Promise<unknown> {
-    return this.filesystemManager.get(key);
-  }
-
-  async setValue(key: string, value: unknown): Promise<void> {
-    return this.filesystemManager.set(key, value);
-  }
-
-  async deleteValue(key: string): Promise<void> {
-    return this.filesystemManager.delete(key);
-  }
-
-  async listValues(prefix?: string): Promise<string[]> {
-    return this.filesystemManager.listKeys(prefix);
-  }
-
-  async hasValue(key: string): Promise<boolean> {
-    return this.filesystemManager.hasKey(key);
-  }
-
-  // Tool call tracking
-  async recordToolCall(metadata: ToolCallMetadata): Promise<void> {
-    return this.filesystemManager.recordToolCall(metadata);
-  }
-
-  async getToolCallHistory(filter?: {
-    tool?: string;
-    status?: ToolCallMetadata['status'];
-    since?: number;
-    until?: number;
-    limit?: number;
-  }): Promise<ToolCallMetadata[]> {
-    return this.filesystemManager.getToolCallHistory(filter);
-  }
-}
-