dirac-lang 0.1.23 → 0.1.25

package/src/tags/throw.ts

@@ -1,26 +0,0 @@
-/**
- * <throw> tag - throws an exception
- * Maps to mask_throw_integrate in MASK
- */
-
-import type { DiracSession, DiracElement } from '../types/index.js';
-import { throwException } from '../runtime/session.js';
-
-export async function executeThrow(session: DiracSession, element: DiracElement): Promise<void> {
-  // Get exception name from 'name' attribute (default to "exception")
-  const exceptionName = element.attributes?.name || 'exception';
-  
-  // Process children to build exception content
-  const { integrateChildren } = await import('../runtime/interpreter.js');
-  
-  // Create a wrapper element to capture the processed content
-  const exceptionDom: DiracElement = {
-    tag: 'exception-content',
-    attributes: { name: exceptionName },
-    children: element.children,
-    text: element.text,
-  };
-  
-  // Throw the exception (add to exception stack)
-  throwException(session, exceptionName, exceptionDom);
-}

package/src/tags/try.ts

@@ -1,19 +0,0 @@
-/**
- * <try> tag - establishes exception boundary
- * Maps to mask_try_integrate in MASK
- */
-
-import type { DiracSession, DiracElement } from '../types/index.js';
-import { setExceptionBoundary, unsetExceptionBoundary } from '../runtime/session.js';
-
-export async function executeTry(session: DiracSession, element: DiracElement): Promise<void> {
-  // Set exception boundary (mark the start of try block)
-  setExceptionBoundary(session);
-  
-  // Execute children (the try block content)
-  const { integrateChildren } = await import('../runtime/interpreter.js');
-  await integrateChildren(session, element);
-  
-  // Unset boundary after execution
-  unsetExceptionBoundary(session);
-}

package/src/tags/variable.ts

@@ -1,25 +0,0 @@
-/**
- * <variable> tag - retrieve variable value
- * Outputs the stored variable content (text or tags)
- */
-
-import type { DiracSession, DiracElement } from '../types/index.js';
-import { getVariable, emit } from '../runtime/session.js';
-
-export function executeVariable(session: DiracSession, element: DiracElement): void {
-  const name = element.attributes.name;
-  if (!name) {
-    // Debug: print the full element for diagnosis
-    console.error('[VariableTagError] <variable> tag missing name attribute:', JSON.stringify(element));
-    throw new Error('<variable> requires name attribute');
-  }
-  const value = getVariable(session, name);
-  if (value === undefined) {
-    if (session.debug) {
-      console.error(`[Warning] Variable '${name}' is undefined`);
-    }
-    return;
-  }
-  // Output the variable value
-  emit(session, String(value));
-}

package/src/test-runner.ts

@@ -1,300 +0,0 @@
-/**
- * Simple test runner for Dirac
- * Tests are defined as .di files with expected output in comments
- */
-
-import fs from 'fs';
-import path from 'path';
-import { DiracParser } from './runtime/parser.js';
-import { createSession, getOutput } from './runtime/session.js';
-import { integrate } from './runtime/interpreter.js';
-import yaml from 'js-yaml';
-
-interface TestCase {
-  name: string;
-  file: string;
-  expectedOutput?: string;
-  expectedError?: string;
-  config?: any;
-}
-
-interface TestResult {
-  name: string;
-  passed: boolean;
-  error?: string;
-  actualOutput?: string;
-  expectedOutput?: string;
-}
-
-export class TestRunner {
-  private testDir: string;
-  private config: any;
-
-  constructor(testDir: string = 'tests', configPath?: string) {
-    this.testDir = testDir;
-    
-    // For tests, always use ollama as the default provider (no API keys needed)
-    // Unless a specific test config is provided
-    if (configPath && fs.existsSync(configPath)) {
-      this.config = yaml.load(fs.readFileSync(configPath, 'utf8')) || {};
-    } else {
-      this.config = { llmProvider: 'ollama', llmModel: 'llama2' };
-    }
-  }
-
-  /**
-   * Parse test metadata from comments in .di file
-   * Format:
-   *   <!-- TEST: test_name -->
-   *   <!-- EXPECT: expected output -->
-   *   <!-- EXPECT_ERROR: expected error message -->
-   */
-  private parseTestMetadata(content: string): { name?: string; expected?: string; expectError?: string } {
-    const nameMatch = content.match(/<!--\s*TEST:\s*(.+?)\s*-->/);
-    const expectMatch = content.match(/<!--\s*EXPECT:\s*(.+?)\s*-->/s);
-    const errorMatch = content.match(/<!--\s*EXPECT_ERROR:\s*(.+?)\s*-->/s);
-    
-    return {
-      name: nameMatch?.[1],
-      expected: expectMatch?.[1]?.trim(),
-      expectError: errorMatch?.[1]?.trim(),
-    };
-  }
-
-  /**
-   * Run a single test file
-   */
-  async runTest(filePath: string): Promise<TestResult> {
-    const content = fs.readFileSync(filePath, 'utf-8');
-    const metadata = this.parseTestMetadata(content);
-    const testName = metadata.name || path.basename(filePath);
-
-    // Remove test comments before execution
-    const cleanContent = content
-      .replace(/<!--\s*TEST:.*?-->/gs, '')
-      .replace(/<!--\s*EXPECT:.*?-->/gs, '')
-      .replace(/<!--\s*EXPECT_ERROR:.*?-->/gs, '');
-
-    const result: TestResult = {
-      name: testName,
-      passed: false,
-    };
-
-    try {
-      // Check if there's a stdin input file for this test
-      const stdinFile = filePath.replace('.test.di', '.txt');
-      let stdinData: string | undefined;
-      if (fs.existsSync(stdinFile)) {
-        stdinData = fs.readFileSync(stdinFile, 'utf-8');
-      }
-
-      // If stdin data exists, we need to mock stdin
-      // Since we can't replace process.stdin directly, we'll use a workaround:
-      // temporarily store data in a place the input tag can access it
-      if (stdinData !== undefined) {
-        // Save original methods
-        const originalOn = process.stdin.on.bind(process.stdin);
-        const originalResume = process.stdin.resume.bind(process.stdin);
-        const originalRemoveAllListeners = process.stdin.removeAllListeners.bind(process.stdin);
-        const originalRemoveListener = process.stdin.removeListener.bind(process.stdin);
-        
-        // Mock stdin methods
-        const listeners: { [key: string]: Function[] } = {};
-        
-        (process.stdin as any).on = function(event: string, callback: Function) {
-          if (!listeners[event]) listeners[event] = [];
-          listeners[event].push(callback);
-          return this;
-        };
-        
-        (process.stdin as any).removeAllListeners = function(event?: string) {
-          if (event) {
-            delete listeners[event];
-          } else {
-            Object.keys(listeners).forEach(k => delete listeners[k]);
-          }
-          return this;
-        };
-        
-        (process.stdin as any).removeListener = function(event: string, callback: Function) {
-          if (listeners[event]) {
-            listeners[event] = listeners[event].filter(fn => fn !== callback);
-          }
-          return this;
-        };
-        
-        (process.stdin as any).resume = function() {
-          // Simulate data event
-          setImmediate(() => {
-            if (listeners['data']) {
-              listeners['data'].forEach(fn => fn(Buffer.from(stdinData!, 'utf-8')));
-            }
-            // Simulate end event
-            setImmediate(() => {
-              if (listeners['end']) {
-                listeners['end'].forEach(fn => fn());
-              }
-            });
-          });
-          return this;
-        };
-        
-        try {
-          const parser = new DiracParser();
-          const ast = parser.parse(cleanContent);
-          const session = createSession({ ...this.config, filePath });
-          await integrate(session, ast);
-          const output = getOutput(session);
-          result.actualOutput = output;
-        } finally {
-          // Restore original methods
-          (process.stdin as any).on = originalOn;
-          (process.stdin as any).resume = originalResume;
-          (process.stdin as any).removeAllListeners = originalRemoveAllListeners;
-          (process.stdin as any).removeListener = originalRemoveListener;
-        }
-      } else {
-        // Normal test without stdin
-        const parser = new DiracParser();
-        const ast = parser.parse(cleanContent);
-        const session = createSession({ ...this.config, filePath });
-        await integrate(session, ast);
-        const output = getOutput(session);
-        result.actualOutput = output;
-      }
-
-      if (metadata.expectError) {
-        // Expected an error but got success
-        result.passed = false;
-        result.error = `Expected error but test succeeded. Output: ${result.actualOutput}`;
-      } else if (metadata.expected !== undefined) {
-        // Check if output matches expected
-        // Normalize whitespace for comparison (collapse multiple spaces/newlines)
-        const normalizedActual = result.actualOutput!.replace(/\s+/g, ' ').trim();
-        const normalizedExpected = metadata.expected.replace(/\s+/g, ' ').trim();
-        
-        if (normalizedActual === normalizedExpected) {
-          result.passed = true;
-        } else {
-          result.passed = false;
-          result.error = `Output mismatch`;
-          result.expectedOutput = normalizedExpected;
-          result.actualOutput = normalizedActual;
-        }
-      } else {
-        // No expected output specified, just check it runs without error
-        result.passed = true;
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      
-      if (metadata.expectError) {
-        // Check if error matches expected
-        if (errorMessage.includes(metadata.expectError)) {
-          result.passed = true;
-        } else {
-          result.passed = false;
-          result.error = `Error mismatch. Expected: "${metadata.expectError}", Got: "${errorMessage}"`;
-        }
-      } else {
-        // Unexpected error
-        result.passed = false;
-        result.error = errorMessage;
-      }
-    }
-
-    return result;
-  }
-
-  /**
-   * Run all tests in the test directory
-   */
-  async runAll(pattern: string = '*.test.di'): Promise<TestResult[]> {
-    const testFiles = this.findTestFiles(this.testDir, pattern);
-    const results: TestResult[] = [];
-
-    console.log(`Running ${testFiles.length} tests...\n`);
-
-    for (const file of testFiles) {
-      const result = await this.runTest(file);
-      results.push(result);
-      
-      // Print result immediately
-      if (result.passed) {
-        console.log(`✓ ${result.name}`);
-      } else {
-        console.log(`✗ ${result.name}`);
-        if (result.error) {
-          console.log(`  Error: ${result.error}`);
-        }
-        if (result.expectedOutput !== undefined && result.actualOutput !== undefined) {
-          console.log(`  Expected: ${JSON.stringify(result.expectedOutput)}`);
-          console.log(`  Actual:   ${JSON.stringify(result.actualOutput)}`);
-        }
-      }
-    }
-
-    return results;
-  }
-
-  /**
-   * Find test files matching pattern
-   */
-  private findTestFiles(dir: string, pattern: string): string[] {
-    if (!fs.existsSync(dir)) {
-      return [];
-    }
-
-    const files: string[] = [];
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-      
-      if (entry.isDirectory()) {
-        files.push(...this.findTestFiles(fullPath, pattern));
-      } else if (entry.isFile() && entry.name.endsWith('.test.di')) {
-        files.push(fullPath);
-      }
-    }
-
-    return files;
-  }
-
-  /**
-   * Print summary of test results
-   */
-  printSummary(results: TestResult[]): void {
-    const passed = results.filter(r => r.passed).length;
-    const failed = results.filter(r => !r.passed).length;
-    
-    console.log('\n' + '='.repeat(50));
-    console.log(`Tests: ${passed} passed, ${failed} failed, ${results.length} total`);
-    
-    if (failed > 0) {
-      console.log('\nFailed tests:');
-      results.filter(r => !r.passed).forEach(r => {
-        console.log(`  - ${r.name}`);
-      });
-    }
-    
-    console.log('='.repeat(50));
-  }
-}
-
-// CLI interface
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const testDir = process.argv[2] || 'tests';
-  const runner = new TestRunner(testDir);
-  
-  runner.runAll().then(results => {
-    runner.printSummary(results);
-    
-    // Exit with error code if any tests failed
-    const failed = results.filter(r => !r.passed).length;
-    process.exit(failed > 0 ? 1 : 0);
-  }).catch(error => {
-    console.error('Test runner error:', error);
-    process.exit(1);
-  });
-}

package/src/types/index.ts

@@ -1,128 +0,0 @@
-/**
- * Core types for Dirac interpreter
- * Directly based on MASK C implementation
- */
-
-export interface DiracElement {
-  tag: string;
-  attributes: Record<string, string>;
-  children: DiracElement[];
-  text?: string;
-}
-
-/**
- * Variable info - maps to VarInfo in MASK
- */
-export interface Variable {
-  name: string;
-  value: any;
-  visible: boolean;
-  boundary: number;  // scope boundary marker
-  passby: 'value' | 'ref';
-  refName?: string;  // for pass-by-reference
-}
-
-/**
- * Parameter metadata for introspection
- */
-export interface ParameterMetadata {
-  name: string;
-  type?: string;
-  required?: boolean;
-  description?: string;
-  enum?: string[];
-  example?: string;
-}
-
-/**
- * Exception info - maps to Exception in MASK
- */
-export interface Exception {
-  name: string;
-  dom: DiracElement;  // The exception content as a DOM element
-  isBoundary: number;  // Boundary marker for try/catch scope
-}
-
-/**
- * Current exception container - maps to CurrentException in MASK
- */
-export interface CurrentException {
-  size: number;
-  exceptions: DiracElement[];  // List of caught exception DOM elements
-}
-
-/**
- * Subroutine info - maps to Subroutine in MASK
- */
-export interface Subroutine {
-  name: string;
-  element: DiracElement;
-  boundary: number;  // scope boundary marker
-  extends?: string;  // parent subroutine
-  // Metadata for reflection/introspection
-  description?: string;
-  parameters?: ParameterMetadata[];
-  meta?: Record<string, string>;
-}
-
-/**
- * Execution context - maps to MaskSession in MASK
- */
-export interface DiracSession {
-  // Variable stack (all variables are on stack)
-  variables: Variable[];
-  
-  // Subroutine registry
-  subroutines: Subroutine[];
-  
-  // Scope boundaries (for cleanup)
-  varBoundary: number;
-  subBoundary: number;
-  
-  // Parameter stack (for subroutine calls)
-  parameterStack: DiracElement[][];
-  
-  // Exception handling (for try/catch/throw)
-  exceptions: Exception[];  // Exception stack
-  currentException: CurrentException;  // Currently caught exceptions
-  
-  // Output buffer
-  output: string[];
-  
-  // LLM client
-  llmClient?: any;
-  
-  // Execution limits
-  limits: {
-    maxLLMCalls: number;
-    currentLLMCalls: number;
-    maxDepth: number;
-    currentDepth: number;
-  };
-  
-  // Control flow
-  isReturn: boolean;
-  isBreak: boolean;
-  
-  // Extend mechanism
-  skipSubroutineRegistration: boolean;
-  currentSubroutineName?: string;  // Track currently executing subroutine for available-subroutines
-  
-  // Debugging
-  debug: boolean;
-  
-  // Import tracking
-  currentFile?: string;
-  importedFiles?: Set<string>;
-}
-
-export interface DiracConfig {
-  apiKey?: string;
-  model?: string;
-  debug?: boolean;
-  maxLLMCalls?: number;
-  maxDepth?: number;
-  filePath?: string;  // Current file path for imports
-  llmProvider?: string;
-  llmModel?: string;
-}

package/src/utils/llm-adapter.ts

@@ -1,113 +0,0 @@
-/**
- * LLM Adapter - Auto-generate prompts and JSON→XML converters
- * from Dirac subroutine definitions
- */
-
-import type { DiracSession } from '../types/index.js';
-import { getAvailableSubroutines } from '../runtime/session.js';
-
-export interface LLMPromptGenerator {
-  generatePrompt(userInput: string): string;
-  intentToXML(intent: any): string | null;
-}
-
-/**
- * Create LLM adapter from session's registered subroutines
- */
-export function createLLMAdapter(session: DiracSession): LLMPromptGenerator {
-  const subroutines = getAvailableSubroutines(session);
-  
-  // Build JSON schema from subroutines
-  const actions = subroutines.map(s => `"${s.name}"`).join('|');
-  
-  // Build examples
-  const examples = subroutines.slice(0, 3).map(sub => {
-    if (!sub.parameters || sub.parameters.length === 0) {
-      return `"${sub.name}" → {"action":"${sub.name}","params":{}}`;
-    }
-    
-    const firstParam = sub.parameters[0];
-    const exampleValue = firstParam.enum?.[0] || 'value';
-    return `"call ${sub.name}" → {"action":"${sub.name}","params":{"${firstParam.name}":"${exampleValue}"}}`;
-  }).join('\n');
-  
-  return {
-    generatePrompt(userInput: string): string {
-      return `You are a command parser. Convert user input to JSON.
-Return ONLY valid JSON, no other text.
-
-Format: {"action": ${actions}, "params": {}}
-
-Examples:
-${examples}
-
-User: ${userInput}
-JSON:`;
-    },
-    
-    intentToXML(intent: any): string | null {
-      if (!intent || !intent.action) return null;
-      
-      const sub = subroutines.find(s => s.name === intent.action);
-      if (!sub) return null;
-      
-      const attrs: string[] = [`name="${sub.name}"`];
-      
-      // Map params to XML attributes
-      if (sub.parameters) {
-        for (const param of sub.parameters) {
-          const value = intent.params?.[param.name];
-          
-          if (value != null) {
-            // Validate enum if present
-            if (param.enum && !param.enum.includes(value)) {
-              return null;
-            }
-            attrs.push(`${param.name}="${value}"`);
-          } else if (param.required) {
-            return null; // Missing required parameter
-          }
-        }
-      }
-      
-      return `<call ${attrs.join(' ')}/>`;
-    }
-  };
-}
-
-/**
- * Higher-level helper: execute user command via LLM
- */
-export async function executeUserCommand(
-  session: DiracSession,
-  userInput: string,
-  llmExecuteFn: (prompt: string) => Promise<string>
-): Promise<{ success: boolean; xml?: string; error?: string }> {
-  try {
-    const adapter = createLLMAdapter(session);
-    const prompt = adapter.generatePrompt(userInput);
-    
-    // Call LLM
-    const llmResponse = await llmExecuteFn(prompt);
-    
-    // Parse JSON
-    let jsonStr = llmResponse.trim();
-    jsonStr = jsonStr.replace(/```json\s*/g, '').replace(/```\s*/g, '');
-    
-    const intent = JSON.parse(jsonStr);
-    
-    // Convert to XML
-    const xml = adapter.intentToXML(intent);
-    
-    if (!xml) {
-      return { success: false, error: 'Could not convert intent to valid command' };
-    }
-    
-    return { success: true, xml };
-  } catch (error) {
-    return { 
-      success: false, 
-      error: error instanceof Error ? error.message : String(error) 
-    };
-  }
-}