@intella/sdk 0.0.1 → 0.0.3

package/src/filesystem-manager.ts

@@ -1,213 +0,0 @@
-import type {
-  FilesystemProviderType,
-  FilesystemConfig,
-  IFilesystemProvider,
-  FileStats,
-  DirectoryEntry,
-  ToolCallMetadata,
-} from './types.js';
-import { AgentFSProvider } from './filesystem/agentfs-provider.js';
-import { MemoryFilesystemProvider } from './filesystem/memory-provider.js';
-
-/**
- * Filesystem Manager
- * Manages filesystem provider instances and configurations
- */
-export class FilesystemManager {
-  private providers: Map<FilesystemProviderType, IFilesystemProvider> = new Map();
-  private defaultProviderType: FilesystemProviderType | null = null;
-  private currentProvider: IFilesystemProvider | null = null;
-
-  constructor() {
-    // Initialize default providers
-    this.registerProvider('agentfs', new AgentFSProvider());
-    this.registerProvider('memory', new MemoryFilesystemProvider());
-  }
-
-  /**
-   * Register or update a filesystem provider instance
-   */
-  registerProvider(type: FilesystemProviderType, provider: IFilesystemProvider): void {
-    if (provider.type !== type) {
-      throw new Error(`Provider type mismatch: expected ${type}, got ${provider.type}`);
-    }
-    this.providers.set(type, provider);
-  }
-
-  /**
-   * Get a filesystem provider instance
-   */
-  getProvider(type?: FilesystemProviderType): IFilesystemProvider {
-    if (type) {
-      const provider = this.providers.get(type);
-      if (!provider) {
-        throw new Error(`Filesystem provider ${type} is not registered`);
-      }
-      return provider;
-    }
-
-    // Return current provider if set, otherwise default
-    if (this.currentProvider) {
-      return this.currentProvider;
-    }
-
-    if (this.defaultProviderType) {
-      const provider = this.providers.get(this.defaultProviderType);
-      if (provider) {
-        return provider;
-      }
-    }
-
-    throw new Error('No filesystem provider is initialized. Call initializeFilesystem() first.');
-  }
-
-  /**
-   * Initialize a filesystem provider
-   */
-  async initializeFilesystem(
-    type: FilesystemProviderType,
-    config?: FilesystemConfig
-  ): Promise<IFilesystemProvider> {
-    const provider = this.getProvider(type);
-    await provider.initialize(config);
-    this.currentProvider = provider;
-    if (!this.defaultProviderType) {
-      this.defaultProviderType = type;
-    }
-    return provider;
-  }
-
-  /**
-   * Check if filesystem is initialized
-   */
-  isInitialized(): boolean {
-    if (this.currentProvider) {
-      return this.currentProvider.isInitialized();
-    }
-    return false;
-  }
-
-  /**
-   * Close the current filesystem provider
-   */
-  async closeFilesystem(): Promise<void> {
-    if (this.currentProvider) {
-      await this.currentProvider.close();
-      this.currentProvider = null;
-    }
-  }
-
-  /**
-   * List all available filesystem providers
-   */
-  listProviders(): FilesystemProviderType[] {
-    return Array.from(this.providers.keys());
-  }
-
-  /**
-   * Check if a provider is registered
-   */
-  hasProvider(type: FilesystemProviderType): boolean {
-    return this.providers.has(type);
-  }
-
-  /**
-   * Set the default provider type
-   */
-  setDefaultProvider(type: FilesystemProviderType): void {
-    if (!this.providers.has(type)) {
-      throw new Error(`Filesystem provider ${type} is not registered`);
-    }
-    this.defaultProviderType = type;
-  }
-
-  /**
-   * Get the default provider type
-   */
-  getDefaultProviderType(): FilesystemProviderType | null {
-    return this.defaultProviderType;
-  }
-
-  /**
-   * Get current provider type
-   */
-  getCurrentProviderType(): FilesystemProviderType | null {
-    return this.currentProvider?.type || null;
-  }
-
-  // Convenience methods that delegate to current provider
-  async readFile(path: string): Promise<Buffer | string> {
-    return this.getProvider().readFile(path);
-  }
-
-  async writeFile(path: string, data: Buffer | string): Promise<void> {
-    return this.getProvider().writeFile(path, data);
-  }
-
-  async appendFile(path: string, data: Buffer | string): Promise<void> {
-    return this.getProvider().appendFile(path, data);
-  }
-
-  async exists(path: string): Promise<boolean> {
-    return this.getProvider().exists(path);
-  }
-
-  async stat(path: string): Promise<FileStats> {
-    return this.getProvider().stat(path);
-  }
-
-  async readdir(path: string): Promise<DirectoryEntry[]> {
-    return this.getProvider().readdir(path);
-  }
-
-  async mkdir(path: string, recursive?: boolean): Promise<void> {
-    return this.getProvider().mkdir(path, recursive);
-  }
-
-  async unlink(path: string, recursive?: boolean): Promise<void> {
-    return this.getProvider().unlink(path, recursive);
-  }
-
-  async copy(src: string, dest: string): Promise<void> {
-    return this.getProvider().copy(src, dest);
-  }
-
-  async move(src: string, dest: string): Promise<void> {
-    return this.getProvider().move(src, dest);
-  }
-
-  async get(key: string): Promise<unknown> {
-    return this.getProvider().get(key);
-  }
-
-  async set(key: string, value: unknown): Promise<void> {
-    return this.getProvider().set(key, value);
-  }
-
-  async delete(key: string): Promise<void> {
-    return this.getProvider().delete(key);
-  }
-
-  async listKeys(prefix?: string): Promise<string[]> {
-    return this.getProvider().listKeys(prefix);
-  }
-
-  async hasKey(key: string): Promise<boolean> {
-    return this.getProvider().hasKey(key);
-  }
-
-  async recordToolCall(metadata: ToolCallMetadata): Promise<void> {
-    return this.getProvider().recordToolCall(metadata);
-  }
-
-  async getToolCallHistory(filter?: {
-    tool?: string;
-    status?: ToolCallMetadata['status'];
-    since?: number;
-    until?: number;
-    limit?: number;
-  }): Promise<ToolCallMetadata[]> {
-    return this.getProvider().getToolCallHistory(filter);
-  }
-}
-

package/src/orchestrator.ts

@@ -1,177 +0,0 @@
-import type {
-  TaskRequest,
-  OrchestrationRequest,
-  OrchestrationResponse,
-} from './types.js';
-import { AgentManager } from './agent-manager.js';
-
-/**
- * Orchestrator
- * Coordinates multiple agents for task execution
- */
-export class Orchestrator {
-  private agentManager: AgentManager;
-
-  constructor(agentManager: AgentManager) {
-    this.agentManager = agentManager;
-  }
-
-  /**
-   * Execute orchestration with multiple agents
-   */
-  async orchestrate(request: OrchestrationRequest): Promise<OrchestrationResponse> {
-    switch (request.strategy) {
-      case 'sequential':
-        return this.sequentialOrchestration(request);
-      case 'parallel':
-        return this.parallelOrchestration(request);
-      case 'conditional':
-        return this.conditionalOrchestration(request);
-      default:
-        throw new Error(`Unknown orchestration strategy: ${request.strategy}`);
-    }
-  }
-
-  /**
-   * Sequential orchestration: agents work in sequence, passing results
-   */
-  private async sequentialOrchestration(
-    request: OrchestrationRequest
-  ): Promise<OrchestrationResponse> {
-    const { task, agents, options } = request;
-    const agentResponses: OrchestrationResponse['agentResponses'] = [];
-    let currentTask: TaskRequest = { ...task };
-    let accumulatedResult = '';
-
-    for (const agentType of agents) {
-      const agent = this.agentManager.getAgent(agentType);
-      
-      // If passing results, include previous results in the prompt
-      if (options?.passResults && accumulatedResult) {
-        currentTask = {
-          ...currentTask,
-          prompt: `${currentTask.prompt}\n\nPrevious results:\n${accumulatedResult}`,
-        };
-      }
-
-      const response = await agent.execute(currentTask);
-      agentResponses.push({
-        agentType,
-        response: response.text,
-        metadata: response.metadata,
-      });
-
-      accumulatedResult = response.text;
-      
-      // Update task for next iteration if passing results
-      if (options?.passResults) {
-        currentTask = {
-          ...task,
-          prompt: response.text,
-        };
-      }
-    }
-
-    return {
-      result: accumulatedResult,
-      agentResponses,
-      strategy: 'sequential',
-    };
-  }
-
-  /**
-   * Parallel orchestration: agents work simultaneously, results combined
-   */
-  private async parallelOrchestration(
-    request: OrchestrationRequest
-  ): Promise<OrchestrationResponse> {
-    const { task, agents, options } = request;
-
-    // Execute all agents in parallel
-    const responses = await Promise.all(
-      agents.map(async (agentType) => {
-        const agent = this.agentManager.getAgent(agentType);
-        const response = await agent.execute(task);
-        return {
-          agentType,
-          response: response.text,
-          metadata: response.metadata,
-        };
-      })
-    );
-
-    // Combine results based on strategy
-    const combineStrategy = options?.combineStrategy || 'merge';
-    let result: string;
-
-    switch (combineStrategy) {
-      case 'merge':
-        result = responses.map((r) => r.response).join('\n\n---\n\n');
-        break;
-      case 'first':
-        result = responses[0]?.response || '';
-        break;
-      case 'best':
-        // For now, just use the first response
-        // This could be enhanced with ranking/scoring logic
-        result = responses[0]?.response || '';
-        break;
-      default:
-        result = responses.map((r) => r.response).join('\n\n---\n\n');
-    }
-
-    return {
-      result,
-      agentResponses: responses,
-      strategy: 'parallel',
-    };
-  }
-
-  /**
-   * Conditional orchestration: route to agents based on task characteristics
-   */
-  private async conditionalOrchestration(
-    request: OrchestrationRequest
-  ): Promise<OrchestrationResponse> {
-    const { task, agents, options } = request;
-
-    // Use custom router if provided, otherwise use first agent
-    const router = options?.router || (() => agents[0]);
-    const selectedAgentType = router(task);
-
-    if (!agents.includes(selectedAgentType)) {
-      throw new Error(
-        `Router selected agent ${selectedAgentType} which is not in the agents list`
-      );
-    }
-
-    const agent = this.agentManager.getAgent(selectedAgentType);
-    const response = await agent.execute(task);
-
-    return {
-      result: response.text,
-      agentResponses: [
-        {
-          agentType: selectedAgentType,
-          response: response.text,
-          metadata: response.metadata,
-        },
-      ],
-      strategy: 'conditional',
-    };
-  }
-
-  /**
-   * Register a custom orchestration strategy
-   * This allows extending the orchestrator with custom strategies
-   */
-  async addCustomStrategy(
-    name: string,
-    strategy: (request: OrchestrationRequest) => Promise<OrchestrationResponse>
-  ): Promise<void> {
-    // Store custom strategies (implementation can be extended)
-    // For now, this is a placeholder for future extensibility
-    (this as any)[`${name}Orchestration`] = strategy;
-  }
-}
-

package/src/sandbox/base-provider.ts

@@ -1,184 +0,0 @@
-import type {
-  SandboxProviderType,
-  SandboxConfig,
-  CommandResult,
-  CodeExecutionResult,
-  ISandboxProvider,
-  SandboxInfo,
-} from '../types.js';
-
-/**
- * Base sandbox provider
- * Abstract implementation that provides common functionality
- */
-export abstract class BaseSandboxProvider implements ISandboxProvider {
-  protected initialized = false;
-  protected config: SandboxConfig = {};
-  protected sandboxId: string | null = null;
-  protected client: any | null = null;
-  public readonly type: SandboxProviderType;
-
-  constructor(type: SandboxProviderType, config?: SandboxConfig) {
-    this.type = type;
-    if (config) {
-      this.config = { ...this.config, ...config };
-      if(this.getClient) {
-        this.client = this.getClient();
-      }
-    }
-  }
-
-  abstract getClient(): any;
-
-  /**
-   * Initialize/create a sandbox
-   * If fromSandboxId is provided in config, will call fromSandbox instead
-   */
-  async initialize(config?: SandboxConfig): Promise<void> {
-    if (config) {
-      this.config = { ...this.config, ...config };
-    }
-
-    // If fromSandboxId is provided, use fromSandbox instead of creating new
-    if (this.config.fromSandboxId) {
-      return this.fromSandbox(this.config.fromSandboxId, config);
-    }
-
-    // Otherwise, call the provider-specific initialization
-    return this.initializeSandbox(config);
-  }
-
-  /**
-   * Provider-specific initialization (creates new sandbox)
-   */
-  protected abstract initializeSandbox(config?: SandboxConfig): Promise<void>;
-
-  /**
-   * Connect to an existing sandbox by ID
-   */
-  abstract fromSandbox(sandboxId: string, config?: SandboxConfig): Promise<any>;
-
-  /**
-   * Check if sandbox is initialized
-   */
-  isInitialized(): boolean {
-    return this.initialized;
-  }
-
-  /**
-   * Close/cleanup the sandbox
-   */
-  abstract close(): Promise<void>;
-
-  /**
-   * Get sandbox ID
-   */
-  getSandboxId(): string | null {
-    return this.sandboxId;
-  }
-
-  /**
-   * Execute a command in the sandbox
-   */
-  abstract executeCommand(
-    command: string,
-    options?: {
-      cwd?: string;
-      env?: Record<string, string>;
-      timeout?: number;
-    }
-  ): Promise<CommandResult>;
-
-  /**
-   * Run code (e.g., Python, JavaScript) in the sandbox
-   */
-  abstract runCode(
-    code: string,
-    options?: {
-      language?: string;
-      env?: Record<string, string>;
-      timeout?: number;
-      onStdout?: (data: string) => void;
-      onStderr?: (data: string) => void;
-    }
-  ): Promise<CodeExecutionResult>;
-
-  /**
-   * Upload a file to the sandbox
-   */
-  abstract uploadFile(localPath: string, remotePath: string): Promise<void>;
-
-  /**
-   * Download a file from the sandbox
-   */
-  abstract downloadFile(remotePath: string, localPath: string): Promise<void>;
-
-  /**
-   * Read a file from the sandbox
-   */
-  abstract readFile(path: string): Promise<string>;
-
-  /**
-   * Write a file to the sandbox
-   */
-  abstract writeFile(path: string, content: string): Promise<void>;
-
-  /**
-   * List files in a directory
-   */
-  abstract listFiles(path: string): Promise<string[]>;
-
-  /**
-   * Check if a file exists
-   */
-  abstract fileExists(path: string): Promise<boolean>;
-
-  /**
-   * Delete a file
-   */
-  abstract deleteFile(path: string): Promise<void>;
-
-  /**
-   * Get sandbox status
-   */
-  abstract getStatus(): Promise<{
-    isRunning: boolean;
-    createdAt?: number;
-    [key: string]: unknown;
-  }>;
-
-  /**
-   * Get detailed sandbox information
-   */
-  abstract getInfo(sandboxId?: string): Promise<SandboxInfo>;
-
-  /**
-   * Ensure sandbox is initialized before operation
-   */
-  protected ensureInitialized(): void {
-    if (!this.initialized) {
-      throw new Error(
-        `Sandbox provider ${this.type} is not initialized. Call initialize() first.`
-      );
-    }
-  }
-
-  /**
-   * Normalize path (remove leading/trailing slashes, handle ..)
-   */
-  protected normalizePath(path: string): string {
-    return path
-      .split('/')
-      .filter((segment) => segment !== '' && segment !== '.')
-      .reduce((acc, segment) => {
-        if (segment === '..') {
-          acc.pop();
-        } else {
-          acc.push(segment);
-        }
-        return acc;
-      }, [] as string[])
-      .join('/');
-  }
-}
-