dirac-lang 0.1.2

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,261 @@
+#!/usr/bin/env node
+import {
+  execute
+} from "./chunk-S625X7ME.js";
+import "./chunk-NDIRTD3D.js";
+
+// src/cli.ts
+import "dotenv/config";
+import fs from "fs";
+import yaml from "js-yaml";
+import { resolve, extname } from "path";
+
+// src/runtime/braket-parser.ts
+var BraKetParser = class {
+  lines = [];
+  currentLine = 0;
+  /**
+   * Parse bra-ket notation and compile to XML
+   */
+  parse(source) {
+    this.lines = source.split("\n");
+    this.currentLine = 0;
+    const xml = ["<dirac>"];
+    this.parseBlock(xml, -1);
+    xml.push("</dirac>");
+    return xml.join("\n");
+  }
+  /**
+   * Parse a block of lines at a given indentation level
+   */
+  parseBlock(output, parentIndent) {
+    while (this.currentLine < this.lines.length) {
+      const line = this.parseLine(this.lines[this.currentLine]);
+      if (line.type === "empty") {
+        this.currentLine++;
+        continue;
+      }
+      if (line.indent <= parentIndent) {
+        break;
+      }
+      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;
+      }
+      if (line.type === "ket") {
+        const indent = "  ".repeat(line.indent);
+        const attrs = line.attrs ? ` ${this.convertAttributes(line.attrs)}` : "";
+        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") {
+          output.push(`${indent}<${line.tag}${attrs}>`);
+          this.currentLine++;
+          this.parseBlock(output, line.indent);
+          output.push(`${indent}</${line.tag}>`);
+        } else {
+          if (line.text) {
+            const content = this.convertInlineKets(line.text);
+            output.push(`${indent}<${line.tag}${attrs}>${content}</${line.tag}>`);
+          } else {
+            output.push(`${indent}<${line.tag}${attrs}/>`);
+          }
+          this.currentLine++;
+        }
+        continue;
+      }
+      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
+   */
+  parseLine(raw) {
+    const match = raw.match(/^(\s*)(.*)/);
+    const indent = match ? Math.floor(match[1].length / 2) : 0;
+    const content = match ? match[2] : "";
+    if (!content.trim()) {
+      return { indent, type: "empty", raw };
+    }
+    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() || void 0,
+        raw
+      };
+    }
+    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() || void 0,
+        text: ketMatch[3] || void 0,
+        raw
+      };
+    }
+    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="@*"
+   */
+  convertAttributes(attrs) {
+    if (!attrs) return "";
+    const parts = [];
+    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());
+    }
+    return parts.map((part) => {
+      const match = part.match(/^([a-zA-Z_][a-zA-Z0-9_-]*)=(.+)$/);
+      if (!match) return part;
+      const [, name, value] = match;
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        return `${name}=${value}`;
+      }
+      return `${name}="${value}"`;
+    }).join(" ");
+  }
+  /**
+   * Convert inline kets within text content
+   * Example: "Hello |variable name=x> world" → "Hello <variable name="x"/> world"
+   */
+  convertInlineKets(text) {
+    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}/>`;
+    });
+  }
+};
+
+// src/cli.ts
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    console.error("Usage: dirac <file.di|file.bk>");
+    console.error("");
+    console.error("File formats:");
+    console.error("  .di               XML notation (verbose)");
+    console.error("  .bk               Bra-ket notation (compact)");
+    console.error("");
+    console.error("Options:");
+    console.error("  --debug           Enable debug output");
+    console.error("  --emit-xml        Output intermediate XML (for .bk files)");
+    console.error("  --model <name>    Set default LLM model");
+    console.error("  --max-llm <n>     Maximum LLM calls (default: 100)");
+    console.error("  --max-depth <n>   Maximum recursion depth (default: 50)");
+    process.exit(1);
+  }
+  const config = {};
+  let filePath;
+  let emitXml = false;
+  let configFile;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--debug") {
+      config.debug = true;
+    } else if (arg === "--emit-xml") {
+      emitXml = true;
+    } else if (arg === "--model" && i + 1 < args.length) {
+      config.model = args[++i];
+    } else if (arg === "--provider" && i + 1 < args.length) {
+      config.llmProvider = args[++i];
+    } else if ((arg === "-f" || arg === "--config") && i + 1 < args.length) {
+      configFile = args[++i];
+    } else if (arg === "--max-llm" && i + 1 < args.length) {
+      config.maxLLMCalls = parseInt(args[++i], 10);
+    } else if (arg === "--max-depth" && i + 1 < args.length) {
+      config.maxDepth = parseInt(args[++i], 10);
+    } else if (!arg.startsWith("--")) {
+      filePath = arg;
+    }
+  }
+  if (configFile) {
+    try {
+      const loadedConfig = yaml.load(fs.readFileSync(resolve(configFile), "utf8")) || {};
+      Object.assign(config, loadedConfig);
+    } catch (err) {
+      console.error("Failed to load config file:", err);
+      process.exit(1);
+    }
+  }
+  if (!filePath) {
+    console.error("Error: No input file specified");
+    process.exit(1);
+  }
+  try {
+    const fullPath = resolve(process.cwd(), filePath);
+    let source = fs.readFileSync(fullPath, "utf-8");
+    const ext = extname(fullPath);
+    if (ext === ".bk") {
+      if (config.debug) {
+        console.error(`[Dirac] Compiling bra-ket notation to XML`);
+      }
+      const braketParser = new BraKetParser();
+      const xml = braketParser.parse(source);
+      if (emitXml) {
+        console.log(xml);
+        return;
+      }
+      source = xml;
+    }
+    if (config.debug) {
+      console.error(`[Dirac] Executing ${fullPath}`);
+    }
+    config.filePath = fullPath;
+    const result = await execute(source, config);
+    process.stdout.write(result);
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : String(error));
+    if (config.debug && error instanceof Error && error.stack) {
+      console.error(error.stack);
+    }
+    process.exit(1);
+  }
+}
+main();

package/dist/index.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Core types for Dirac interpreter
+ * Directly based on MASK C implementation
+ */
+interface DiracElement {
+    tag: string;
+    attributes: Record<string, string>;
+    children: DiracElement[];
+    text?: string;
+}
+/**
+ * Variable info - maps to VarInfo in MASK
+ */
+interface Variable {
+    name: string;
+    value: any;
+    visible: boolean;
+    boundary: number;
+    passby: 'value' | 'ref';
+    refName?: string;
+}
+/**
+ * Parameter metadata for introspection
+ */
+interface ParameterMetadata {
+    name: string;
+    type?: string;
+    required?: boolean;
+    description?: string;
+    enum?: string[];
+}
+/**
+ * Subroutine info - maps to Subroutine in MASK
+ */
+interface Subroutine {
+    name: string;
+    element: DiracElement;
+    boundary: number;
+    extends?: string;
+    description?: string;
+    parameters?: ParameterMetadata[];
+}
+/**
+ * Execution context - maps to MaskSession in MASK
+ */
+interface DiracSession {
+    variables: Variable[];
+    subroutines: Subroutine[];
+    varBoundary: number;
+    subBoundary: number;
+    parameterStack: DiracElement[][];
+    output: string[];
+    llmClient?: any;
+    limits: {
+        maxLLMCalls: number;
+        currentLLMCalls: number;
+        maxDepth: number;
+        currentDepth: number;
+    };
+    isReturn: boolean;
+    isBreak: boolean;
+    debug: boolean;
+    currentFile?: string;
+    importedFiles?: Set<string>;
+}
+interface DiracConfig {
+    apiKey?: string;
+    model?: string;
+    debug?: boolean;
+    maxLLMCalls?: number;
+    maxDepth?: number;
+    filePath?: string;
+    llmProvider?: string;
+    llmModel?: string;
+}
+
+/**
+ * XML Parser for Dirac (.di files)
+ */
+
+declare class DiracParser {
+    private parser;
+    constructor();
+    parse(source: string): DiracElement;
+    private convertOrderedToElement;
+    private convertToElement;
+}
+
+/**
+ * Session management - maps to MASK session functions
+ */
+
+declare function createSession(config?: DiracConfig): DiracSession;
+declare function getOutput(session: DiracSession): string;
+declare function getAvailableSubroutines(session: DiracSession): Array<{
+    name: string;
+    description?: string;
+    parameters?: Array<{
+        name: string;
+        type?: string;
+        required?: boolean;
+        description?: string;
+        enum?: string[];
+    }>;
+}>;
+
+/**
+ * Core interpreter - maps to mask_integrate in MASK
+ */
+
+declare function integrate(session: DiracSession, element: DiracElement): Promise<void>;
+
+/**
+ * LLM Adapter - Auto-generate prompts and JSON→XML converters
+ * from Dirac subroutine definitions
+ */
+
+interface LLMPromptGenerator {
+    generatePrompt(userInput: string): string;
+    intentToXML(intent: any): string | null;
+}
+/**
+ * Create LLM adapter from session's registered subroutines
+ */
+declare function createLLMAdapter(session: DiracSession): LLMPromptGenerator;
+/**
+ * Higher-level helper: execute user command via LLM
+ */
+declare function executeUserCommand(session: DiracSession, userInput: string, llmExecuteFn: (prompt: string) => Promise<string>): Promise<{
+    success: boolean;
+    xml?: string;
+    error?: string;
+}>;
+
+/**
+ * Main entry point for Dirac interpreter
+ */
+
+/**
+ * Execute Dirac source code
+ */
+declare function execute(source: string, config?: DiracConfig): Promise<string>;
+
+export { type DiracConfig, type DiracElement, DiracParser, type DiracSession, type LLMPromptGenerator, type ParameterMetadata, createLLMAdapter, createSession, execute, executeUserCommand, getAvailableSubroutines, getOutput, integrate };

package/dist/index.js

@@ -0,0 +1,22 @@
+import {
+  DiracParser,
+  createLLMAdapter,
+  execute,
+  executeUserCommand,
+  integrate
+} from "./chunk-S625X7ME.js";
+import {
+  createSession,
+  getAvailableSubroutines,
+  getOutput
+} from "./chunk-NDIRTD3D.js";
+export {
+  DiracParser,
+  createLLMAdapter,
+  createSession,
+  execute,
+  executeUserCommand,
+  getAvailableSubroutines,
+  getOutput,
+  integrate
+};

package/dist/session-4QG7OERD.js

@@ -0,0 +1,42 @@
+import {
+  cleanSubroutinesToBoundary,
+  cleanToBoundary,
+  createSession,
+  emit,
+  getAvailableSubroutines,
+  getCurrentParameters,
+  getOutput,
+  getSubroutine,
+  getVariable,
+  hasVariable,
+  popParameters,
+  popSubroutinesToBoundary,
+  popToBoundary,
+  pushParameters,
+  registerSubroutine,
+  setBoundary,
+  setSubroutineBoundary,
+  setVariable,
+  substituteVariables
+} from "./chunk-NDIRTD3D.js";
+export {
+  cleanSubroutinesToBoundary,
+  cleanToBoundary,
+  createSession,
+  emit,
+  getAvailableSubroutines,
+  getCurrentParameters,
+  getOutput,
+  getSubroutine,
+  getVariable,
+  hasVariable,
+  popParameters,
+  popSubroutinesToBoundary,
+  popToBoundary,
+  pushParameters,
+  registerSubroutine,
+  setBoundary,
+  setSubroutineBoundary,
+  setVariable,
+  substituteVariables
+};

package/examples/add-demo.di

@@ -0,0 +1,74 @@
+#!/usr/bin/env dirac
+<dirac>
+  <!-- 
+    Method 1: Using <expr> tag (clean, declarative)
+  -->
+  <subroutine name="ADD">
+    <expr eval="plus">
+      <arg><parameters select="@x"/></arg>
+      <arg><parameters select="@y"/></arg>
+    </expr>
+  </subroutine>
+
+  <output>Method 1 (expr tag):&#10;</output>
+  <output>  1 + 2 = </output>
+  <ADD x="1" y="2"/>
+  <output>&#10;</output>
+
+  <output>  5 + 7 = </output>
+  <ADD x="5" y="7"/>
+  <output>&#10;</output>
+
+  <output>  100 + 200 = </output>
+  <ADD x="100" y="200"/>
+  <output>&#10;</output>
+
+  <!-- 
+    Method 2: Using getParams() in eval (programmatic)
+  -->
+  <subroutine name="MULTIPLY">
+    <eval>
+      const caller = getParams();
+      if (caller && caller.attributes) {
+        const x = parseInt(caller.attributes.x || 0);
+        const y = parseInt(caller.attributes.y || 0);
+        console.log(x * y);
+      }
+    </eval>
+  </subroutine>
+
+  <output>&#10;Method 2 (eval with getParams):&#10;</output>
+  <output>3 * 4 = </output>
+  <MULTIPLY x="3" y="4"/>
+  <output>&#10;</output>
+
+  <output>5 * 6 = </output>
+  <MULTIPLY x="5" y="6"/>
+  <output>&#10;</output>
+
+  <!-- More expr examples -->
+  <output>&#10;More operations:&#10;</output>
+  <output>10 - 3 = </output>
+  <expr eval="minus"><arg>10</arg><arg>3</arg></expr>
+  <output>&#10;</output>
+  
+  <output>7 * 8 = </output>
+  <expr eval="times"><arg>7</arg><arg>8</arg></expr>
+  <output>&#10;</output>
+  
+  <output>20 / 4 = </output>
+  <expr eval="divide"><arg>20</arg><arg>4</arg></expr>
+  <output>&#10;</output>
+  
+  <output>17 mod 5 = </output>
+  <expr eval="mod"><arg>17</arg><arg>5</arg></expr>
+  <output>&#10;</output>
+  
+  <output>5 &lt; 10 = </output>
+  <expr eval="lt"><arg>5</arg><arg>10</arg></expr>
+  <output>&#10;</output>
+  
+  <output>5 &gt; 10 = </output>
+  <expr eval="gt"><arg>5</arg><arg>10</arg></expr>
+  <output>&#10;</output>
+</dirac>

package/examples/add.bk

@@ -0,0 +1,11 @@
+<add|
+  |parameters select=@x>
+  |parameters select=@y>
+  |expr op=plus>
+    |arg>
+      |variable name=x>
+    |arg>
+      |variable name=y>
+
+|output>5 + 3 = 
+|add x=5 y=3>

package/examples/advanced-math-demo.di

@@ -0,0 +1,53 @@
+#!/usr/bin/env dirac
+<dirac>
+  <!-- Import advanced math library -->
+  <import src="./lib/advanced-math.di"/>
+
+  <output>Advanced Math Library Demo&#10;&#10;</output>
+
+  <!-- Square root -->
+  <output>Square root of 16: </output>
+  <MATH_SQRT n="16"/>
+  <output>&#10;</output>
+
+  <output>Square root of 2: </output>
+  <MATH_SQRT n="2"/>
+  <output>&#10;</output>
+
+  <!-- Factorial -->
+  <output>Factorial of 5: </output>
+  <MATH_FACTORIAL n="5"/>
+  <output>&#10;</output>
+
+  <output>Factorial of 10: </output>
+  <MATH_FACTORIAL n="10"/>
+  <output>&#10;</output>
+
+  <!-- GCD -->
+  <output>GCD(48, 18): </output>
+  <MATH_GCD a="48" b="18"/>
+  <output>&#10;</output>
+
+  <output>GCD(100, 35): </output>
+  <MATH_GCD a="100" b="35"/>
+  <output>&#10;</output>
+
+  <!-- Prime check -->
+  <output>Is 17 prime? </output>
+  <MATH_PRIME n="17"/>
+  <output>&#10;</output>
+
+  <output>Is 20 prime? </output>
+  <MATH_PRIME n="20"/>
+  <output>&#10;</output>
+
+  <!-- Random number -->
+  <output>Random number [0-100]: </output>
+  <MATH_RANDOM min="0" max="100"/>
+  <output>&#10;</output>
+
+  <!-- Statistics -->
+  <output>&#10;Statistics for [1,2,3,4,5,10,100]:&#10;</output>
+  <MATH_STATS data="[1,2,3,4,5,10,100]"/>
+  <output>&#10;</output>
+</dirac>

package/examples/calculator.di

@@ -0,0 +1,32 @@
+```xml
+<?xml version="1.0"?>
+<!-- Basic Arithmetic Calculator -->
+<dirac>
+    <!-- Declaration of variables -->
+    <defvar name="num1" value="0" />
+    <defvar name="num2" value="0" />
+    <defvar name="result" value="0" />
+    <defvar name="operation" value="" />
+
+    <!-- User input for first number -->
+    <LLM output="num1">Please enter the first number:</LLM>
+    
+    <!-- User input for second number -->
+    <LLM output="num2">Please enter the second number:</LLM>
+    
+    <!-- User input for the operation -->
+    <LLM output="operation">Please choose the operation (+, -, *, /):</LLM>
+    
+    <!-- Perform selected operation -->
+    <if test="${operation} == '+'">
+        <set var="result" value="${num1} + ${num2}" />
+    </if>
+    <if test="${operation} == '-'">
+        <set var="result" value="${num1} - ${num2}" />
+    </if>
+    <if test="${operation} == '*'">
+        <set var="result" value="${num1} * ${num2}" />
+    </if>
+    <if test="${operation} == '/'">
+        <if test="${num2} == 0">
+            <output>Division by zero is not allowed.</output>

package/examples/comprehensive.bk

@@ -0,0 +1,29 @@
+|output>Bra-Ket Notation Demo
+
+<factorial|
+  |parameters select=@n>
+    |variable name=n>
+  |if>
+    |expr op=eq>
+      |arg>
+        |variable name=n>
+      |arg>1
+    |output>1
+    |expr op=times>
+      |arg>
+        |variable name=n>
+      |arg>
+        |factorial>
+          |expr op=minus>
+            |arg>
+              |variable name=n>
+            |arg>1
+
+|output>Factorial of 5 = 
+|factorial n=5>
+|output>
+
+<format|
+  |output>Name: |variable name=name>, Age: |variable name=age>
+
+|format name=Alice age=30>

package/examples/defvar-variable-demo.di

@@ -0,0 +1,18 @@
+<dirac>
+  <!-- Simple example: defvar sets, variable gets -->
+  <defvar name="greeting">Hello, World!</defvar>
+  <output><variable name="greeting"/></output>
+  <output>&#10;</output>
+  
+  <!-- Subroutine with parameter -->
+  <subroutine name="greet">
+    <parameters select="@name">
+      <defvar name="localname"/>
+    </parameters>
+    <output>Greetings, <variable name="localname"/>!</output>
+  </subroutine>
+  
+  <greet name="Alice"/>
+  <output>&#10;</output>
+  <greet name="Bob"/>
+</dirac>