@intella/sdk 0.0.1

package/src/filesystem-manager.ts

@@ -0,0 +1,213 @@
+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/index.ts

@@ -0,0 +1,66 @@
+// Main SDK exports
+export { IntellaSDK } from './sdk.js';
+
+// Type exports
+export type {
+  AgentType,
+  AgentConfig,
+  TaskRequest,
+  TaskResponse,
+  StreamChunk,
+  OrchestrationStrategy,
+  OrchestrationRequest,
+  OrchestrationResponse,
+  IAgent,
+  FilesystemProviderType,
+  FilesystemConfig,
+  FileStats,
+  DirectoryEntry,
+  ToolCallMetadata,
+  IFilesystemProvider,
+  SandboxProviderType,
+  SandboxConfig,
+  SandboxExecutionResult,
+  SandboxInfo,
+  CommandResult,
+  ISandboxProvider,
+  TextPart,
+  FilePart,
+  MessageContent,
+} from './types.js';
+
+// Agent exports
+export { BaseAgent } from './agents/base-agent.js';
+export { IntellaLiteAgent } from './agents/intella-lite-agent.js';
+export { ClaudeAgent } from './agents/claude-agent.js';
+export { CodexAgent } from './agents/codex-agent.js';
+export { OpenCodeAgent } from './agents/opencode-agent.js';
+
+// Manager and orchestrator exports
+export { AgentManager } from './agent-manager.js';
+export { Orchestrator } from './orchestrator.js';
+export { FilesystemManager } from './filesystem-manager.js';
+export { SandboxManager } from './sandbox-manager.js';
+
+// Filesystem provider exports
+export {
+  BaseFilesystemProvider,
+  AgentFSProvider,
+  MemoryFilesystemProvider,
+} from './filesystem/index.js';
+
+// Sandbox provider exports
+export { BaseSandboxProvider } from './sandbox/base-provider.js';
+export { E2BSandboxProvider } from './sandbox/e2b-provider.js';
+export { DaytonaSandboxProvider } from './sandbox/daytona-provider.js';
+export { ModalSandboxProvider } from './sandbox/modal-provider.js';
+
+// Utility exports
+export {
+  extractCodeBlocks,
+  extractCodeBlock,
+  extractCode,
+  type CodeBlock,
+  type ExtractCodeBlocksOptions,
+} from './utils/code-extractor.js';
+

package/src/orchestrator.ts

@@ -0,0 +1,177 @@
+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

@@ -0,0 +1,184 @@
+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('/');
+  }
+}
+