@intella/sdk 0.0.1 → 0.0.2

package/src/types.ts

@@ -1,451 +0,0 @@
-import { LanguageModel } from 'ai';
-
-/**
- * Supported agent types
- */
-export type AgentType = 'intella-lite' | 'claude' | 'codex' | 'opencode';
-
-/**
- * Agent configuration interface
- */
-export interface AgentConfig {
-  /** API key for the agent (provider-specific) */
-  apiKey?: string;
-  /** Model identifier to use */
-  model?: string;
-  /** Temperature for generation (0-2) */
-  temperature?: number;
-  /** Maximum tokens to generate */
-  maxTokens?: number;
-  /** Custom headers for the provider */
-  headers?: Record<string, string>;
-  /** Base URL for the provider (if applicable) */
-  baseURL?: string;
-  /** Additional provider-specific options */
-  [key: string]: unknown;
-}
-
-/**
- * Text part for message content
- */
-export interface TextPart {
-  type: 'text';
-  text: string;
-}
-
-/**
- * File part for message content (attachments)
- */
-export interface FilePart {
-  type: 'file';
-  data: string | Uint8Array | ArrayBuffer | Buffer | URL; // base64-encoded string or binary data
-  filename?: string;
-  mediaType: string;
-}
-
-/**
- * Message content can be a string or array of parts (text and/or files)
- */
-export type MessageContent = string | Array<TextPart | FilePart>;
-
-/**
- * Task execution request
- */
-export interface TaskRequest {
-  /** The prompt or task description */
-  prompt: string;
-  /** System prompt (optional) */
-  systemPrompt?: string;
-  /** Additional messages for context */
-  messages?: Array<{
-    role: 'user' | 'assistant' | 'system';
-    content: MessageContent;
-  }>;
-  /** Generation parameters */
-  temperature?: number;
-  maxTokens?: number;
-  /** Additional options */
-  [key: string]: unknown;
-}
-
-/**
- * Task execution response
- */
-export interface TaskResponse {
-  /** Generated text response */
-  text: string;
-  /** Agent type that generated the response */
-  agentType: AgentType;
-  /** Additional metadata */
-  metadata?: {
-    usage?: {
-      promptTokens?: number;
-      completionTokens?: number;
-      totalTokens?: number;
-    };
-    finishReason?: string;
-    [key: string]: unknown;
-  };
-}
-
-/**
- * Streaming response chunk
- */
-export interface StreamChunk {
-  /** Text chunk */
-  text: string;
-  /** Agent type */
-  agentType: AgentType;
-  /** Whether this is the final chunk */
-  isDone: boolean;
-}
-
-/**
- * Orchestration strategy types
- */
-export type OrchestrationStrategy = 'sequential' | 'parallel' | 'conditional';
-
-/**
- * Multi-agent orchestration request
- */
-export interface OrchestrationRequest {
-  /** The task to execute */
-  task: TaskRequest;
-  /** List of agent types to use */
-  agents: AgentType[];
-  /** Orchestration strategy */
-  strategy: OrchestrationStrategy;
-  /** Strategy-specific options */
-  options?: {
-    /** For sequential: whether to pass previous results to next agent */
-    passResults?: boolean;
-    /** For parallel: how to combine results */
-    combineStrategy?: 'merge' | 'first' | 'best';
-    /** For conditional: routing function */
-    router?: (task: TaskRequest) => AgentType;
-  };
-}
-
-/**
- * Multi-agent orchestration response
- */
-export interface OrchestrationResponse {
-  /** Final result */
-  result: string;
-  /** Individual agent responses */
-  agentResponses: Array<{
-    agentType: AgentType;
-    response: string;
-    metadata?: TaskResponse['metadata'];
-  }>;
-  /** Strategy used */
-  strategy: OrchestrationStrategy;
-}
-
-/**
- * Base agent interface
- */
-export interface IAgent {
-  /** Agent type */
-  readonly type: AgentType;
-  /** Execute a task and return the response */
-  execute(request: TaskRequest): Promise<TaskResponse>;
-  /** Stream a task execution */
-  stream(request: TaskRequest): AsyncIterable<StreamChunk>;
-  /** Configure the agent */
-  configure(config: AgentConfig): void;
-  /** Get current configuration */
-  getConfig(): AgentConfig;
-  /** Get the underlying language model */
-  getModel(): LanguageModel | Promise<LanguageModel>;
-}
-
-/**
- * Supported filesystem provider types
- */
-export type FilesystemProviderType = 'agentfs' | 'memory' | 'sandbox';
-
-/**
- * Filesystem provider configuration
- */
-export interface FilesystemConfig {
-  /** Provider-specific configuration */
-  provider?: FilesystemProviderType;
-  /** Agent ID for the filesystem (used by AgentFS) */
-  agentId?: string;
-  /** Database path for AgentFS */
-  dbPath?: string;
-  /** Additional provider-specific options */
-  [key: string]: unknown;
-}
-
-/**
- * File statistics
- */
-export interface FileStats {
-  /** File size in bytes */
-  size: number;
-  /** Whether it's a directory */
-  isDirectory: boolean;
-  /** Whether it's a file */
-  isFile: boolean;
-  /** Creation time (Unix timestamp) */
-  createdAt?: number;
-  /** Modification time (Unix timestamp) */
-  modifiedAt?: number;
-}
-
-/**
- * Directory entry
- */
-export interface DirectoryEntry {
-  /** Entry name */
-  name: string;
-  /** Entry path */
-  path: string;
-  /** Entry statistics */
-  stats: FileStats;
-}
-
-/**
- * Tool call metadata for recording
- */
-export interface ToolCallMetadata {
-  /** Tool name */
-  tool: string;
-  /** Start time (Unix timestamp in seconds) */
-  startedAt: number;
-  /** End time (Unix timestamp in seconds) */
-  endedAt: number;
-  /** Tool input parameters */
-  input?: Record<string, unknown>;
-  /** Tool output/result */
-  output?: unknown;
-  /** Tool status */
-  status?: 'success' | 'error' | 'pending';
-  /** Error message if status is 'error' */
-  error?: string;
-}
-
-/**
- * Filesystem provider interface
- */
-export interface IFilesystemProvider {
-  /** Provider type */
-  readonly type: FilesystemProviderType;
-  /** Initialize the filesystem */
-  initialize(config?: FilesystemConfig): Promise<void>;
-  /** Check if filesystem is initialized */
-  isInitialized(): boolean;
-  /** Close/cleanup the filesystem */
-  close(): Promise<void>;
-
-  // Filesystem operations
-  /** Read file contents */
-  readFile(path: string): Promise<Buffer | string>;
-  /** Write file contents */
-  writeFile(path: string, data: Buffer | string): Promise<void>;
-  /** Append to file */
-  appendFile(path: string, data: Buffer | string): Promise<void>;
-  /** Check if file/directory exists */
-  exists(path: string): Promise<boolean>;
-  /** Get file/directory statistics */
-  stat(path: string): Promise<FileStats>;
-  /** Read directory contents */
-  readdir(path: string): Promise<DirectoryEntry[]>;
-  /** Create directory */
-  mkdir(path: string, recursive?: boolean): Promise<void>;
-  /** Remove file or directory */
-  unlink(path: string, recursive?: boolean): Promise<void>;
-  /** Copy file or directory */
-  copy(src: string, dest: string): Promise<void>;
-  /** Move/rename file or directory */
-  move(src: string, dest: string): Promise<void>;
-
-  // Key-value operations
-  /** Get value by key */
-  get(key: string): Promise<unknown>;
-  /** Set value for key */
-  set(key: string, value: unknown): Promise<void>;
-  /** Delete key */
-  delete(key: string): Promise<void>;
-  /** List all keys (optionally with prefix) */
-  listKeys(prefix?: string): Promise<string[]>;
-  /** Check if key exists */
-  hasKey(key: string): Promise<boolean>;
-
-  // Tool call tracking
-  /** Record a tool call */
-  recordToolCall(metadata: ToolCallMetadata): Promise<void>;
-  /** Get tool call history (optionally filtered) */
-  getToolCallHistory(filter?: {
-    tool?: string;
-    status?: ToolCallMetadata['status'];
-    since?: number;
-    until?: number;
-    limit?: number;
-  }): Promise<ToolCallMetadata[]>;
-}
-
-/**
- * Supported sandbox provider types
- */
-export type SandboxProviderType = 'e2b' | 'daytona' | 'modal';
-
-/**
- * Sandbox provider configuration
- */
-export interface SandboxConfig {
-  fromSandboxId?: string;
-  /** Provider-specific configuration */
-  provider?: SandboxProviderType;
-  /** API key for the sandbox provider */
-  apiKey?: string;
-  /** Sandbox template ID (for E2B) or workspace ID (for Daytona) */
-  templateId?: string;
-  /** Base URL for the provider (if applicable) */
-  baseURL?: string;
-  /** Environment variables to set in the sandbox */
-  env?: Record<string, string>;
-  /** Timeout in milliseconds */
-  timeout?: number;
-  /** Additional provider-specific options */
-  [key: string]: unknown;
-}
-
-/**
- * Command execution result
- */
-export interface CommandResult {
-  /** Exit code */
-  exitCode: number;
-  /** Standard output */
-  stdout: string;
-  /** Standard error */
-  stderr: string;
-  /** Execution time in milliseconds */
-  executionTime?: number;
-}
-
-/**
- * Code execution result (for interpreted code like Python, JavaScript, etc.)
- */
-export interface CodeExecutionResult {
-  /** Text representation of the main result */
-  text?: string;
-  /** All results from the execution (including charts, tables, etc.) */
-  results: Array<{
-    text?: string;
-    html?: string;
-    markdown?: string;
-    [key: string]: unknown;
-  }>;
-  /** Logs printed to stdout during execution */
-  stdout: string[];
-  /** Logs printed to stderr during execution */
-  stderr: string[];
-  /** Error information if execution failed */
-  error?: {
-    name: string;
-    value: string;
-    traceback: string;
-  };
-  /** Execution time in milliseconds */
-  executionTime?: number;
-}
-
-/**
- * Sandbox execution result
- */
-export interface SandboxExecutionResult {
-  /** Command execution result */
-  result: CommandResult;
-  /** Sandbox ID */
-  sandboxId: string;
-  /** Provider type */
-  provider: SandboxProviderType;
-  /** Additional metadata */
-  metadata?: {
-    [key: string]: unknown;
-  };
-}
-
-/**
- * Sandbox information
- */
-export interface SandboxInfo {
-  /** Sandbox ID */
-  sandboxId: string;
-  /** Provider type */
-  provider: SandboxProviderType;
-  /** Whether the sandbox is running */
-  isRunning: boolean;
-  /** Whether the sandbox is initialized */
-  isInitialized: boolean;
-  /** Creation timestamp (Unix timestamp in milliseconds) */
-  createdAt?: Date | string | number;
-  /** Additional provider-specific information */
-  metadata?: {
-    [key: string]: any;
-  };
-
-  /** Sandbox raw info from the provider*/
-  info?: any;
-}
-
-/**
- * Sandbox provider interface
- */
-export interface ISandboxProvider {
-  /** Provider type */
-  readonly type: SandboxProviderType;
-  /** Get the client */
-  getClient(): any;
-  /** Initialize/create a sandbox (or connect to existing if fromSandboxId is provided) */
-  initialize(config?: SandboxConfig): Promise<void>;
-  /** Connect to an existing sandbox by ID */
-  fromSandbox(sandboxId: string, config?: SandboxConfig): Promise<any>;
-  /** Check if sandbox is initialized */
-  isInitialized(): boolean;
-  /** Close/cleanup the sandbox */
-  close(): Promise<void>;
-  /** Get sandbox ID */
-  getSandboxId(): string | null;
-  /** Execute a command in the sandbox */
-  executeCommand(command: string, options?: {
-    cwd?: string;
-    env?: Record<string, string>;
-    timeout?: number;
-  }): Promise<CommandResult>;
-  /** Run code (e.g., Python, JavaScript) in the sandbox */
-  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 */
-  uploadFile(localPath: string, remotePath: string): Promise<void>;
-  /** Download a file from the sandbox */
-  downloadFile(remotePath: string, localPath: string): Promise<void>;
-  /** Read a file from the sandbox */
-  readFile(path: string): Promise<string>;
-  /** Write a file to the sandbox */
-  writeFile(path: string, content: string): Promise<void>;
-  /** List files in a directory */
-  listFiles(path: string): Promise<string[]>;
-  /** Check if a file exists */
-  fileExists(path: string): Promise<boolean>;
-  /** Delete a file */
-  deleteFile(path: string): Promise<void>;
-  /** Get sandbox status */
-  getStatus(): Promise<{
-    isRunning: boolean;
-    createdAt?: number;
-    [key: string]: unknown;
-  }>;
-  /** Get detailed sandbox information */
-  getInfo(sandboxId?: string): Promise<SandboxInfo>;
-}
-

package/src/utils/code-extractor.ts

@@ -1,194 +0,0 @@
-/**
- * Represents a code block extracted from markdown
- */
-export interface CodeBlock {
-  /** The language identifier (e.g., 'typescript', 'bash', 'python') */
-  language: string;
-  /** The code content without the markdown fences */
-  code: string;
-  /** The full match including fences (for reference) */
-  fullMatch?: string;
-}
-
-/**
- * Options for extracting code blocks
- */
-export interface ExtractCodeBlocksOptions {
-  /** If true, only extract code blocks with the specified language(s) */
-  languages?: string[];
-  /** If true, return only the code content without language info */
-  codeOnly?: boolean;
-  /** If true, include the full match in the result */
-  includeFullMatch?: boolean;
-  /** Custom wrapper for code blocks */
-  customWrapper?: {
-    start: string;
-    end: string;
-  };
-}
-
-/**
- * Extracts code blocks from markdown text.
- * Handles multiple code blocks and returns an array of extracted blocks.
- *
- * @param text - The markdown text containing code blocks
- * @param options - Optional configuration for extraction
- * @returns Array of code blocks or code strings (if codeOnly is true)
- *
- * @example
- * ```typescript
- * const markdown = `
- * Here's some code:
- * \`\`\`typescript
- * const x = 1;
- * \`\`\`
- *
- * And a command:
- * \`\`\`bash
- * npm install
- * \`\`\`
- * `;
- *
- * const blocks = extractCodeBlocks(markdown);
- * // Returns:
- * // [
- * //   { language: 'typescript', code: 'const x = 1;' },
- * //   { language: 'bash', code: 'npm install' }
- * // ]
- *
- * const typescriptOnly = extractCodeBlocks(markdown, { languages: ['typescript'] });
- * const codeStrings = extractCodeBlocks(markdown, { codeOnly: true });
- *
- * // Using custom wrapper
- * const customMarkdown = '<code>typescript\nconst x = 1;\n</code>';
- * const customBlocks = extractCodeBlocks(customMarkdown, {
- *   customWrapper: { start: '<code>', end: '</code>' }
- * });
- * ```
- */
-export function extractCodeBlocks(
-  text: string,
-  options: ExtractCodeBlocksOptions = {}
-): CodeBlock[] | string[] {
-  const {
-    languages,
-    codeOnly = false,
-    includeFullMatch = false,
-    customWrapper,
-  } = options;
-
-  // Determine the wrapper strings to use
-  const startWrapper = customWrapper?.start ?? '```';
-  const endWrapper = customWrapper?.end ?? '```';
-
-  // Escape special regex characters in the wrapper strings
-  const escapeRegex = (str: string): string => {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  };
-
-  const escapedStart = escapeRegex(startWrapper);
-  const escapedEnd = escapeRegex(endWrapper);
-
-  // Build regex pattern: startWrapper language?\n?code\nendWrapper
-  // Handles:
-  // - Optional language identifier (with optional whitespace)
-  // - Code blocks with or without newline after language
-  // - Empty code blocks
-  // - Code blocks without language
-  // - Custom wrappers
-  const codeBlockRegex = new RegExp(
-    `${escapedStart}(\\w+)?\\s*\\n?([\\s\\S]*?)${escapedEnd}`,
-    'g'
-  );
-
-  const blocks: CodeBlock[] = [];
-  let match: RegExpExecArray | null;
-
-  // Reset regex lastIndex to ensure we start from the beginning
-  codeBlockRegex.lastIndex = 0;
-
-  while ((match = codeBlockRegex.exec(text)) !== null) {
-    const language = match[1] || '';
-    const code = match[2]?.trim() || '';
-
-    // Filter by language if specified
-    if (languages && languages.length > 0) {
-      const normalizedLanguage = language.toLowerCase();
-      const normalizedLanguages = languages.map((lang) => lang.toLowerCase());
-      if (!normalizedLanguages.includes(normalizedLanguage)) {
-        continue;
-      }
-    }
-
-    const codeBlock: CodeBlock = {
-      language,
-      code,
-    };
-
-    if (includeFullMatch) {
-      codeBlock.fullMatch = match[0];
-    }
-
-    blocks.push(codeBlock);
-  }
-
-  // Return code strings only if requested
-  if (codeOnly) {
-    return blocks.map((block) => block.code);
-  }
-
-  return blocks;
-}
-
-/**
- * Extracts a single code block from markdown text.
- * Returns the first matching code block, or null if none found.
- *
- * @param text - The markdown text containing code blocks
- * @param language - Optional language filter (case-insensitive)
- * @returns The first matching code block, or null
- *
- * @example
- * ```typescript
- * const markdown = '```bash\nnpm install\n```';
- * const block = extractCodeBlock(markdown);
- * // Returns: { language: 'bash', code: 'npm install' }
- *
- * const tsBlock = extractCodeBlock(markdown, 'typescript');
- * // Returns: null (no typescript block found)
- * ```
- */
-export function extractCodeBlock(
-  text: string,
-  language?: string
-): CodeBlock | null {
-  const options: ExtractCodeBlocksOptions = language
-    ? { languages: [language] }
-    : {};
-
-  const blocks = extractCodeBlocks(text, options) as CodeBlock[];
-  return blocks.length > 0 ? blocks[0] : null;
-}
-
-/**
- * Extracts code content from a single code block (without language info).
- * Returns the code string, or null if no code block found.
- *
- * @param text - The markdown text containing code blocks
- * @param language - Optional language filter (case-insensitive)
- * @returns The code content as a string, or null
- *
- * @example
- * ```typescript
- * const markdown = '```bash\nnpm install\n```';
- * const code = extractCode(markdown);
- * // Returns: 'npm install'
- * ```
- */
-export function extractCode(
-  text: string,
-  language?: string
-): string | null {
-  const block = extractCodeBlock(text, language);
-  return block ? block.code : null;
-}

package/tsconfig.json

@@ -1,25 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ESNext",
-    "lib": ["ES2020"],
-    "moduleResolution": "node",
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "resolveJsonModule": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}
-