@ebowwa/sandbox 0.1.1

package/src/multi/polyglot.ts

@@ -0,0 +1,461 @@
+/**
+ * Polyglot Primitive
+ *
+ * Execute code across multiple languages with shared state.
+ * Enables true multi-language programming with seamless data exchange.
+ */
+
+import type {
+  Language,
+  Cell,
+  ExecutionResult,
+  Permissions,
+  Limits,
+  PolyglotCell,
+  LanguageBridge,
+} from "../core/types.js";
+import { BaseKernel, KernelManager } from "../session/kernel.js";
+import { CellRegistry } from "../core/cell.js";
+import type { ExecutableCell } from "../core/cell.js";
+import { v4 as uuid } from "uuid";
+
+/**
+ * Polyglot session options
+ */
+export interface PolyglotOptions {
+  /** Available languages */
+  languages?: Language[];
+  /** Permissions */
+  permissions?: Permissions;
+  /** Resource limits */
+  limits?: Limits;
+  /** Kernel manager */
+  kernelManager?: KernelManager;
+  /** Kernel factory */
+  kernelFactory?: (language: Language) => Promise<BaseKernel>;
+}
+
+/**
+ * Language variable binding
+ */
+export interface VariableBinding {
+  /** Variable name */
+  name: string;
+  /** Source language */
+  fromLanguage: Language;
+  /** Target language */
+  toLanguage: Language;
+  /** Serialized value */
+  serializedValue: Uint8Array;
+  /** Type information */
+  type?: string;
+}
+
+/**
+ * Polyglot execution context
+ */
+export interface PolyglotContext {
+  /** Current language */
+  language: Language;
+  /** Variables from other languages */
+  bindings: Map<string, VariableBinding>;
+  /** Shared state */
+  sharedState: Map<string, unknown>;
+  /** Kernel for current language */
+  kernel: BaseKernel;
+}
+
+/**
+ * Built-in language bridges
+ */
+const BUILTIN_BRIDGES: Partial<Record<`${Language}:${Language}`, LanguageBridge>> = {
+  // JSON is universal
+  "javascript:python": createJsonBridge("javascript", "python"),
+  "python:javascript": createJsonBridge("python", "javascript"),
+  "javascript:typescript": createJsonBridge("javascript", "typescript"),
+  "typescript:javascript": createJsonBridge("typescript", "javascript"),
+  "python:typescript": createJsonBridge("python", "typescript"),
+  "typescript:python": createJsonBridge("typescript", "python"),
+};
+
+/**
+ * Create JSON-based language bridge
+ */
+function createJsonBridge(from: Language, to: Language): LanguageBridge {
+  return {
+    from,
+    to,
+    serialize(value: unknown): Uint8Array {
+      return new TextEncoder().encode(JSON.stringify(value));
+    },
+    deserialize(bytes: Uint8Array): unknown {
+      return JSON.parse(new TextDecoder().decode(bytes));
+    },
+    canBridge(type: string): boolean {
+      // JSON can bridge most primitive and composite types
+      return ["number", "string", "boolean", "object", "array"].includes(type);
+    },
+  };
+}
+
+/**
+ * Polyglot Session
+ *
+ * Manages multi-language execution with variable sharing.
+ */
+export class PolyglotSession {
+  private kernelManager: KernelManager;
+  private kernelFactory?: (language: Language) => Promise<BaseKernel>;
+  private kernels = new Map<Language, BaseKernel>();
+  private bridges: Map<`${Language}:${Language}`, LanguageBridge>;
+  private sharedState = new Map<string, unknown>();
+  private variableBindings = new Map<string, VariableBinding>();
+  private permissions: Permissions;
+  private limits: Limits;
+
+  constructor(options: PolyglotOptions = {}) {
+    this.kernelManager = options.kernelManager ?? new KernelManager();
+    this.kernelFactory = options.kernelFactory;
+    this.permissions = options.permissions ?? {};
+    this.limits = options.limits ?? {};
+    this.bridges = new Map(Object.entries(BUILTIN_BRIDGES) as Array<[`${Language}:${Language}`, LanguageBridge]>);
+  }
+
+  /**
+   * Execute code in a language
+   */
+  async execute(
+    code: string,
+    language: Language,
+    options?: {
+      imports?: Map<string, string>; // name -> language
+    }
+  ): Promise<ExecutionResult> {
+    const kernel = await this.getKernel(language);
+
+    // Import variables from other languages
+    if (options?.imports) {
+      const importCode = await this.generateImportCode(language, options.imports);
+      code = importCode + "\n" + code;
+    }
+
+    const result = await kernel.execute(code);
+
+    // Capture exports to shared state
+    if (result.success && result.exports) {
+      for (const [name, value] of result.exports) {
+        this.sharedState.set(`${language}:${name}`, value);
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Execute polyglot cell (multiple language variants)
+   */
+  async executePolyglot(
+    cell: PolyglotCell,
+    preferredLanguage?: Language
+  ): Promise<{ language: Language; result: ExecutionResult }> {
+    // Try preferred language first
+    const langOrder = preferredLanguage
+      ? [preferredLanguage, ...cell.variants.keys()].filter(
+          (v, i, a) => a.indexOf(v) === i
+        )
+      : Array.from(cell.variants.keys());
+
+    for (const language of langOrder) {
+      const code = cell.variants.get(language);
+      if (!code) continue;
+
+      try {
+        const kernel = await this.getKernel(language);
+        if (!kernel.isRunning()) {
+          await kernel.start();
+        }
+
+        const result = await kernel.execute(code);
+        return { language, result };
+      } catch (error) {
+        // Try next language
+        continue;
+      }
+    }
+
+    throw new Error("No available language for polyglot cell");
+  }
+
+  /**
+   * Get or create kernel for language
+   */
+  private async getKernel(language: Language): Promise<BaseKernel> {
+    let kernel = this.kernels.get(language);
+
+    if (!kernel) {
+      if (this.kernelFactory) {
+        kernel = await this.kernelFactory(language);
+      } else {
+        throw new Error(`No kernel available for language: ${language}`);
+      }
+
+      this.kernels.set(language, kernel);
+    }
+
+    return kernel;
+  }
+
+  /**
+   * Generate import code for a language
+   */
+  private async generateImportCode(
+    targetLanguage: Language,
+    imports: Map<string, string>
+  ): Promise<string> {
+    const lines: string[] = [];
+
+    for (const [name, sourceLanguage] of imports) {
+      const value = this.sharedState.get(`${sourceLanguage}:${name}`);
+      if (value === undefined) continue;
+
+      const bridge = this.getBridge(sourceLanguage as Language, targetLanguage);
+      if (!bridge) {
+        throw new Error(
+          `No bridge from ${sourceLanguage} to ${targetLanguage}`
+        );
+      }
+
+      const serialized = bridge.serialize(value);
+      const deserialized = bridge.deserialize(serialized);
+
+      // Generate language-specific import
+      const importLine = this.generateVariableAssignment(
+        targetLanguage,
+        name,
+        deserialized
+      );
+      lines.push(importLine);
+    }
+
+    return lines.join("\n");
+  }
+
+  /**
+   * Generate variable assignment in target language
+   */
+  private generateVariableAssignment(
+    language: Language,
+    name: string,
+    value: unknown
+  ): string {
+    const json = JSON.stringify(value);
+
+    switch (language) {
+      case "javascript":
+      case "typescript":
+        return `const ${name} = ${json};`;
+
+      case "python":
+        return `${name} = ${json}`;
+
+      case "assemblyscript":
+        return `const ${name} = ${json};`;
+
+      case "json":
+        return json;
+
+      default:
+        return `// ${name} = ${json}`;
+    }
+  }
+
+  /**
+   * Get bridge between languages
+   */
+  getBridge(from: Language, to: Language): LanguageBridge | undefined {
+    return this.bridges.get(`${from}:${to}`);
+  }
+
+  /**
+   * Register custom bridge
+   */
+  registerBridge(bridge: LanguageBridge): void {
+    this.bridges.set(`${bridge.from}:${bridge.to}`, bridge);
+  }
+
+  /**
+   * Set shared variable
+   */
+  setVariable(language: Language, name: string, value: unknown): void {
+    this.sharedState.set(`${language}:${name}`, value);
+  }
+
+  /**
+   * Get shared variable
+   */
+  getVariable(language: Language, name: string): unknown {
+    return this.sharedState.get(`${language}:${name}`);
+  }
+
+  /**
+   * Transfer variable between languages
+   */
+  async transferVariable(
+    fromLanguage: Language,
+    name: string,
+    toLanguage: Language
+  ): Promise<unknown> {
+    const value = this.sharedState.get(`${fromLanguage}:${name}`);
+    if (value === undefined) {
+      throw new Error(`Variable ${name} not found in ${fromLanguage}`);
+    }
+
+    const bridge = this.getBridge(fromLanguage, toLanguage);
+    if (!bridge) {
+      throw new Error(`No bridge from ${fromLanguage} to ${toLanguage}`);
+    }
+
+    const serialized = bridge.serialize(value);
+    const transferred = bridge.deserialize(serialized);
+
+    // Store in target language
+    this.sharedState.set(`${toLanguage}:${name}`, transferred);
+
+    return transferred;
+  }
+
+  /**
+   * Get all shared variables
+   */
+  getSharedVariables(): Map<string, unknown> {
+    return new Map(this.sharedState);
+  }
+
+  /**
+   * Clear shared state
+   */
+  clearState(): void {
+    this.sharedState.clear();
+    this.variableBindings.clear();
+  }
+
+  /**
+   * Shutdown all kernels
+   */
+  async shutdown(): Promise<void> {
+    for (const kernel of this.kernels.values()) {
+      await kernel.shutdown();
+    }
+    this.kernels.clear();
+  }
+}
+
+/**
+ * Polyglot Notebook
+ *
+ * Notebook with multi-language cells and variable sharing.
+ */
+export class PolyglotNotebook {
+  private cells = new Map<string, PolyglotCell>();
+  private session: PolyglotSession;
+  private executionOrder: string[] = [];
+
+  constructor(options?: PolyglotOptions) {
+    this.session = new PolyglotSession(options);
+  }
+
+  /**
+   * Add polyglot cell
+   */
+  addCell(variants: Map<Language, string>, id?: string): PolyglotCell {
+    const cell: PolyglotCell = {
+      id: id ?? uuid(),
+      variants,
+    };
+
+    this.cells.set(cell.id, cell);
+    this.executionOrder.push(cell.id);
+
+    return cell;
+  }
+
+  /**
+   * Add single-language cell
+   */
+  addSingleCell(language: Language, code: string, id?: string): PolyglotCell {
+    const variants = new Map<Language, string>();
+    variants.set(language, code);
+    return this.addCell(variants, id);
+  }
+
+  /**
+   * Execute all cells
+   */
+  async runAll(): Promise<Array<{ cellId: string; language: Language; result: ExecutionResult }>> {
+    const results: Array<{ cellId: string; language: Language; result: ExecutionResult }> = [];
+
+    for (const cellId of this.executionOrder) {
+      const cell = this.cells.get(cellId);
+      if (!cell) continue;
+
+      const { language, result } = await this.session.executePolyglot(cell);
+      results.push({ cellId, language, result });
+
+      if (!result.success) {
+        break;
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Execute single cell
+   */
+  async runCell(cellId: string, preferredLanguage?: Language): Promise<{
+    language: Language;
+    result: ExecutionResult;
+  }> {
+    const cell = this.cells.get(cellId);
+    if (!cell) {
+      throw new Error(`Cell not found: ${cellId}`);
+    }
+
+    return this.session.executePolyglot(cell, preferredLanguage);
+  }
+
+  /**
+   * Get cell
+   */
+  getCell(id: string): PolyglotCell | undefined {
+    return this.cells.get(id);
+  }
+
+  /**
+   * Get all cells
+   */
+  getCells(): PolyglotCell[] {
+    return this.executionOrder.map(id => this.cells.get(id)!).filter(Boolean);
+  }
+
+  /**
+   * Get session
+   */
+  getSession(): PolyglotSession {
+    return this.session;
+  }
+}
+
+/**
+ * Create polyglot session
+ */
+export function createPolyglotSession(options?: PolyglotOptions): PolyglotSession {
+  return new PolyglotSession(options);
+}
+
+/**
+ * Create polyglot notebook
+ */
+export function createPolyglotNotebook(options?: PolyglotOptions): PolyglotNotebook {
+  return new PolyglotNotebook(options);
+}