dirac-lang 0.1.2

package/src/index.ts

@@ -0,0 +1,33 @@
+/**
+ * Main entry point for Dirac interpreter
+ */
+
+export { DiracParser } from './runtime/parser.js';
+export { createSession, getOutput, getAvailableSubroutines } from './runtime/session.js';
+export { integrate } from './runtime/interpreter.js';
+export { createLLMAdapter, executeUserCommand } from './utils/llm-adapter.js';
+export type { DiracSession, DiracConfig, DiracElement, ParameterMetadata } from './types/index.js';
+export type { LLMPromptGenerator } from './utils/llm-adapter.js';
+
+import { DiracParser } from './runtime/parser.js';
+import { createSession, getOutput } from './runtime/session.js';
+import { integrate } from './runtime/interpreter.js';
+import type { DiracConfig } from './types/index.js';
+
+/**
+ * Execute Dirac source code
+ */
+export async function execute(source: string, config: DiracConfig = {}): Promise<string> {
+  const parser = new DiracParser();
+  const session = createSession(config);
+  
+  // Set current file if provided in config
+  if (config.filePath) {
+    session.currentFile = config.filePath;
+  }
+  
+  const ast = parser.parse(source);
+  await integrate(session, ast);
+  
+  return getOutput(session);
+}

package/src/llm/ollama.ts

@@ -0,0 +1,58 @@
+
+
+export class OllamaClient {
+  baseUrl: string;
+
+  constructor({ baseUrl = 'http://localhost:11434' }: { baseUrl?: string } = {}) {
+    this.baseUrl = baseUrl;
+  }
+
+  async generate({ model, prompt, options = {} }: { model: string; prompt: string; options?: Record<string, any> }) {
+    const res = await fetch(`${this.baseUrl}/api/generate`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ model, prompt, ...options }),
+    });
+
+    let output = '';
+    for await (const chunk of res.body as any) {
+      const chunkStr = chunk.toString();
+      // console.log('[OllamaClient] Raw chunk:', chunkStr);
+      const lines = chunkStr.split('\n');
+      for (const line of lines) {
+        if (line.trim()) {
+          let jsonLine = line.trim();
+          // If line looks like comma-separated numbers, decode as ASCII
+          if (/^\d+(,\d+)*$/.test(jsonLine)) {
+            jsonLine = jsonLine.split(',').map(n => String.fromCharCode(Number(n))).join('');
+          }
+          try {
+            const obj = JSON.parse(jsonLine);
+            if (obj.response) output += obj.response;
+          } catch (err) {
+            // Silently skip lines that can't be parsed
+          }
+        }
+      }
+    }
+    return output;
+  }
+}
+
+export class OllamaProvider {
+  client: OllamaClient;
+  model: string;
+
+  constructor(options: { baseUrl?: string; model?: string } = {}) {
+    this.client = new OllamaClient(options);
+    this.model = options.model || 'llama2';
+  }
+
+  async complete(prompt: string, opts: Record<string, any> = {}) {
+    return await this.client.generate({
+      model: this.model,
+      prompt,
+      options: opts,
+    });
+  }
+}

package/src/runtime/braket-parser.ts

@@ -0,0 +1,234 @@
+/**
+ * Bra-Ket Parser - Converts bra-ket notation to XML
+ * 
+ * Syntax:
+ * - Bra (subroutine): <name| ... defines a subroutine
+ * - Ket (everything else): |tag attrs> ... can have children/content
+ * - Indentation: Defines scope (like Python/YAML)
+ * 
+ * Examples:
+ *   |output>Hello World          →  <output>Hello World</output>
+ *   |variable name=x>            →  <variable name="x"/>
+ *   <add|                        →  <subroutine name="add">
+ *     |output>test               →    <output>test</output>
+ *                                →  </subroutine>
+ */
+
+interface BraKetLine {
+  indent: number;
+  type: 'bra' | 'ket' | 'text' | 'empty';
+  tag?: string;
+  attrs?: string;
+  text?: string;
+  raw: string;
+}
+
+export class BraKetParser {
+  private lines: string[] = [];
+  private currentLine = 0;
+
+  /**
+   * Parse bra-ket notation and compile to XML
+   */
+  parse(source: string): string {
+    this.lines = source.split('\n');
+    this.currentLine = 0;
+
+    const xml: string[] = ['<dirac>'];
+    this.parseBlock(xml, -1);
+    xml.push('</dirac>');
+
+    return xml.join('\n');
+  }
+
+  /**
+   * Parse a block of lines at a given indentation level
+   */
+  private parseBlock(output: string[], parentIndent: number): void {
+    while (this.currentLine < this.lines.length) {
+      const line = this.parseLine(this.lines[this.currentLine]);
+
+      // Empty lines are preserved as-is
+      if (line.type === 'empty') {
+        this.currentLine++;
+        continue;
+      }
+
+      // If indent is less than or equal to parent, we're done with this block
+      if (line.indent <= parentIndent) {
+        break;
+      }
+
+      // Bra: <name| defines a subroutine
+      if (line.type === 'bra') {
+        const attrs = line.attrs ? ` ${this.convertAttributes(line.attrs)}` : '';
+        output.push(`${'  '.repeat(line.indent)}<subroutine name="${line.tag}"${attrs}>`);
+        this.currentLine++;
+        this.parseBlock(output, line.indent);
+        output.push(`${'  '.repeat(line.indent)}</subroutine>`);
+        continue;
+      }
+
+      // Ket: |tag attrs>
+      if (line.type === 'ket') {
+        const indent = '  '.repeat(line.indent);
+        const attrs = line.attrs ? ` ${this.convertAttributes(line.attrs)}` : '';
+        
+        // Check if next line is more indented (has children/content)
+        const nextLine = this.currentLine + 1 < this.lines.length 
+          ? this.parseLine(this.lines[this.currentLine + 1])
+          : null;
+
+        if (nextLine && nextLine.indent > line.indent && nextLine.type !== 'empty') {
+          // Has children - opening tag
+          output.push(`${indent}<${line.tag}${attrs}>`);
+          this.currentLine++;
+          this.parseBlock(output, line.indent);
+          output.push(`${indent}</${line.tag}>`);
+        } else {
+          // Self-closing or inline text
+          if (line.text) {
+            // Inline text with embedded kets
+            const content = this.convertInlineKets(line.text);
+            output.push(`${indent}<${line.tag}${attrs}>${content}</${line.tag}>`);
+          } else {
+            // Self-closing
+            output.push(`${indent}<${line.tag}${attrs}/>`);
+          }
+          this.currentLine++;
+        }
+        continue;
+      }
+
+      // Plain text content
+      if (line.type === 'text') {
+        const indent = '  '.repeat(line.indent);
+        const content = this.convertInlineKets(line.text || '');
+        output.push(`${indent}${content}`);
+        this.currentLine++;
+        continue;
+      }
+    }
+  }
+
+  /**
+   * Parse a single line into structured form
+   */
+  private parseLine(raw: string): BraKetLine {
+    // Count leading spaces for indentation
+    const match = raw.match(/^(\s*)(.*)/);
+    const indent = match ? Math.floor(match[1].length / 2) : 0;
+    const content = match ? match[2] : '';
+
+    // Empty line
+    if (!content.trim()) {
+      return { indent, type: 'empty', raw };
+    }
+
+    // Bra: <name| or <name attrs|
+    const braMatch = content.match(/^<([a-zA-Z_][a-zA-Z0-9_-]*)\s*([^|]*)\|$/);
+    if (braMatch) {
+      return {
+        indent,
+        type: 'bra',
+        tag: braMatch[1],
+        attrs: braMatch[2].trim() || undefined,
+        raw
+      };
+    }
+
+    // Ket: |tag> or |tag attrs> or |tag>text
+    const ketMatch = content.match(/^\|([a-zA-Z_][a-zA-Z0-9_-]*)\s*([^>]*?)>\s*(.*)/);
+    if (ketMatch) {
+      return {
+        indent,
+        type: 'ket',
+        tag: ketMatch[1],
+        attrs: ketMatch[2].trim() || undefined,
+        text: ketMatch[3] || undefined,
+        raw
+      };
+    }
+
+    // Plain text
+    return {
+      indent,
+      type: 'text',
+      text: content,
+      raw
+    };
+  }
+
+  /**
+   * Convert bra-ket attribute syntax to XML
+   * Examples:
+   *   name=value    → name="value"
+   *   x=5 y=10      → x="5" y="10"
+   *   select=@*     → select="@*"
+   */
+  private convertAttributes(attrs: string): string {
+    if (!attrs) return '';
+
+    // Split by spaces but respect quoted strings
+    const parts: string[] = [];
+    let current = '';
+    let inQuotes = false;
+    let quoteChar = '';
+
+    for (let i = 0; i < attrs.length; i++) {
+      const char = attrs[i];
+      
+      if ((char === '"' || char === "'") && (i === 0 || attrs[i - 1] !== '\\')) {
+        if (!inQuotes) {
+          inQuotes = true;
+          quoteChar = char;
+          current += char;
+        } else if (char === quoteChar) {
+          inQuotes = false;
+          current += char;
+        } else {
+          current += char;
+        }
+      } else if (char === ' ' && !inQuotes) {
+        if (current.trim()) {
+          parts.push(current.trim());
+          current = '';
+        }
+      } else {
+        current += char;
+      }
+    }
+    
+    if (current.trim()) {
+      parts.push(current.trim());
+    }
+
+    // Convert each attribute
+    return parts.map(part => {
+      const match = part.match(/^([a-zA-Z_][a-zA-Z0-9_-]*)=(.+)$/);
+      if (!match) return part;
+
+      const [, name, value] = match;
+      
+      // Already quoted
+      if ((value.startsWith('"') && value.endsWith('"')) ||
+          (value.startsWith("'") && value.endsWith("'"))) {
+        return `${name}=${value}`;
+      }
+
+      // Quote it
+      return `${name}="${value}"`;
+    }).join(' ');
+  }
+
+  /**
+   * Convert inline kets within text content
+   * Example: "Hello |variable name=x> world" → "Hello <variable name="x"/> world"
+   */
+  private convertInlineKets(text: string): string {
+    return text.replace(/\|([a-zA-Z_][a-zA-Z0-9_-]*)\s*([^>]*?)>/g, (match, tag, attrs) => {
+      const attrStr = attrs.trim() ? ` ${this.convertAttributes(attrs.trim())}` : '';
+      return `<${tag}${attrStr}/>`;
+    });
+  }
+}

package/src/runtime/interpreter.ts

@@ -0,0 +1,135 @@
+/**
+ * Core interpreter - maps to mask_integrate in MASK
+ */
+
+import type { DiracElement, DiracSession } from '../types/index.js';
+import { substituteVariables, emit, getSubroutine } from './session.js';
+import { executeDefvar } from '../tags/defvar.js';
+import { executeVariable } from '../tags/variable.js';
+import { executeAssign } from '../tags/assign.js';
+import { executeOutput } from '../tags/output.js';
+import { executeSubroutine } from '../tags/subroutine.js';
+import { executeCall } from '../tags/call.js';
+import { executeLoop } from '../tags/loop.js';
+import { executeIf } from '../tags/if.js';
+import { executeLLM } from '../tags/llm.js';
+import { executeEval } from '../tags/eval.js';
+import { executeExecute } from '../tags/execute.js';
+import { executeImport } from '../tags/import.js';
+import { executeParameters } from '../tags/parameters.js';
+import { executeExpr } from '../tags/expr.js';
+import { executeSystem } from '../tags/system.js';
+import { executeRequireModule } from '../tags/require_module.js';
+
+export async function integrate(session: DiracSession, element: DiracElement): Promise<void> {
+  // Check execution limits
+  if (session.limits.currentDepth >= session.limits.maxDepth) {
+    throw new Error('Maximum execution depth exceeded');
+  }
+  
+  session.limits.currentDepth++;
+  
+  try {
+    // Handle text nodes
+    if (element.text && !element.tag) {
+      const substituted = substituteVariables(session, element.text);
+      emit(session, substituted);
+      return;
+    }
+    
+    // Check control flow
+    if (session.isReturn || session.isBreak) {
+      return;
+    }
+    
+    // Dispatch to tag handlers
+    switch (element.tag.toLowerCase()) {
+      case 'defvar':
+        await executeDefvar(session, element);
+        break;
+        
+      case 'variable':
+        await executeVariable(session, element);
+        break;
+        
+      case 'assign':
+        await executeAssign(session, element);
+        break;
+        
+      case 'output':
+        await executeOutput(session, element);
+        break;
+        
+      case 'subroutine':
+        await executeSubroutine(session, element);
+        break;
+        
+      case 'call':
+        await executeCall(session, element);
+        break;
+        
+      case 'loop':
+        await executeLoop(session, element);
+        break;
+        
+      case 'if':
+        await executeIf(session, element);
+        break;
+        
+      case 'llm':
+        await executeLLM(session, element);
+        break;
+        
+      case 'eval':
+        await executeEval(session, element);
+        break;
+        
+      case 'execute':
+        await executeExecute(session, element);
+        break;
+        
+      case 'import':
+        await executeImport(session, element);
+        break;
+        
+      case 'parameters':
+        await executeParameters(session, element);
+        break;
+        
+      case 'expr':
+        await executeExpr(session, element);
+        break;
+        
+      case 'system':
+        await executeSystem(session, element);
+        break;
+        
+      case 'require_module':
+        await executeRequireModule(session, element);
+        break;
+        
+      default:
+        // Unknown tag - check if it's a subroutine name
+        const subroutine = getSubroutine(session, element.tag);
+        if (subroutine) {
+          // Treat unknown tag as subroutine call
+          await executeCall(session, element);
+        } else {
+          // Really unknown - just process children
+          for (const child of element.children) {
+            await integrate(session, child);
+            if (session.isReturn || session.isBreak) break;
+          }
+        }
+    }
+  } finally {
+    session.limits.currentDepth--;
+  }
+}
+
+export async function integrateChildren(session: DiracSession, element: DiracElement): Promise<void> {
+  for (const child of element.children) {
+    await integrate(session, child);
+    if (session.isReturn || session.isBreak) break;
+  }
+}

package/src/runtime/parser.ts

@@ -0,0 +1,151 @@
+/**
+ * XML Parser for Dirac (.di files)
+ */
+
+import { XMLParser } from 'fast-xml-parser';
+import type { DiracElement } from '../types/index.js';
+
+export class DiracParser {
+  private parser: XMLParser;
+  
+  constructor() {
+    this.parser = new XMLParser({
+      ignoreAttributes: false,
+      attributeNamePrefix: '@_',
+      trimValues: true,
+      parseAttributeValue: false,
+      parseTagValue: false,
+      textNodeName: '#text',
+      cdataPropName: '#cdata',
+      preserveOrder: true,  // Preserve element order!
+      commentPropName: '#comment',
+    });
+  }
+  
+  parse(source: string): DiracElement {
+    // Strip shebang line if present
+    if (source.startsWith('#!')) {
+      source = source.replace(/^#!.*\n/, '');
+    }
+    
+    const result = this.parser.parse(source);
+    // With preserveOrder, result is an array
+    if (!Array.isArray(result) || result.length === 0) {
+      throw new Error('Empty or invalid XML');
+    }
+    
+    // Find the first non-comment element
+    for (const item of result) {
+      if (!item['#comment']) {
+        return this.convertOrderedToElement(item);
+      }
+    }
+    
+    throw new Error('No root element found');
+  }
+  
+  private convertOrderedToElement(obj: any): DiracElement {
+    // obj is like { "tagname": [...children], ":@": {...attributes} }
+    const tagName = Object.keys(obj).find(k => k !== ':@' && k !== '#comment');
+    
+    if (!tagName) {
+      throw new Error('Invalid element structure');
+    }
+    
+    const element: DiracElement = {
+      tag: tagName,
+      attributes: {},
+      children: [],
+    };
+    
+    // Extract attributes
+    if (obj[':@']) {
+      for (const [key, value] of Object.entries(obj[':@'])) {
+        if (key.startsWith('@_')) {
+          element.attributes[key.slice(2)] = value as string;
+        }
+      }
+    }
+    
+    // Extract children
+    const children = obj[tagName];
+    if (Array.isArray(children)) {
+      for (const child of children) {
+        if (child['#text']) {
+          // Text node - add as child AND to element.text for backward compat
+          element.children.push({
+            tag: '',
+            text: child['#text'],
+            attributes: {},
+            children: []
+          });
+          // Also set element.text if not set (for simple text-only elements)
+          if (!element.text) {
+            element.text = child['#text'];
+          } else {
+            element.text += child['#text'];
+          }
+        } else if (child['#comment']) {
+          // Skip comments
+          continue;
+        } else {
+          // Child element
+          element.children.push(this.convertOrderedToElement(child));
+        }
+      }
+    }
+    
+    return element;
+  }
+  
+  // Old method - no longer used
+  private convertToElement(obj: any, tagName?: string): DiracElement {
+    if (!tagName) {
+      // Root level - find the actual tag
+      const keys = Object.keys(obj);
+      if (keys.length === 0) {
+        throw new Error('Empty XML');
+      }
+      tagName = keys[0];
+      obj = obj[tagName];
+    }
+    
+    const element: DiracElement = {
+      tag: tagName,
+      attributes: {},
+      children: [],
+    };
+    
+    if (typeof obj === 'string') {
+      element.text = obj;
+      return element;
+    }
+    
+    if (!obj) {
+      return element;
+    }
+    
+    // Extract attributes and children
+    for (const key of Object.keys(obj)) {
+      const value = obj[key];
+      
+      if (key === '#text') {
+        element.text = value;
+      } else if (key.startsWith('@_')) {
+        // Attribute
+        element.attributes[key.slice(2)] = value;
+      } else {
+        // Child element
+        if (Array.isArray(value)) {
+          for (const item of value) {
+            element.children.push(this.convertToElement(item, key));
+          }
+        } else {
+          element.children.push(this.convertToElement(value, key));
+        }
+      }
+    }
+    
+    return element;
+  }
+}