dirac-browser 0.1.1

package/dist/tags/expr.d.ts

@@ -0,0 +1,8 @@
+/**
+ * <expr> tag - arithmetic and logical operations
+ * Maps to mask_tag_expr in MASK
+ *
+ * Supports: plus, minus, times, divide, mod, lt, gt, eq, and, or, not
+ */
+import type { DiracSession, DiracElement } from '../types/index.js';
+export declare function executeExpr(session: DiracSession, element: DiracElement): Promise<void>;

package/dist/tags/expr.js

@@ -0,0 +1,107 @@
+/**
+ * <expr> tag - arithmetic and logical operations
+ * Maps to mask_tag_expr in MASK
+ *
+ * Supports: plus, minus, times, divide, mod, lt, gt, eq, and, or, not
+ */
+import { emit, substituteVariables } from '../runtime/session.js';
+import { integrate } from '../runtime/interpreter.js';
+export async function executeExpr(session, element) {
+    const op = element.attributes.eval || element.attributes.op;
+    if (!op) {
+        throw new Error('<expr> requires eval or op attribute');
+    }
+    // Collect arguments from <arg> children
+    const args = [];
+    const stringArgs = [];
+    for (const child of element.children) {
+        if (child.tag === 'arg') {
+            let argValue = '';
+            // Check if arg has text content directly
+            if (child.text) {
+                argValue = substituteVariables(session, child.text);
+            }
+            else {
+                // Capture output from arg children
+                const oldOutput = session.output;
+                session.output = [];
+                for (const argChild of child.children) {
+                    await integrate(session, argChild);
+                }
+                argValue = session.output.join('');
+                session.output = oldOutput;
+            }
+            stringArgs.push(argValue);
+            const numValue = parseFloat(argValue);
+            args.push(isNaN(numValue) ? 0 : numValue);
+        }
+    }
+    let result = 0;
+    switch (op.toLowerCase()) {
+        case 'plus':
+        case 'add':
+            result = args.reduce((a, b) => a + b, 0);
+            break;
+        case 'minus':
+        case 'subtract':
+            result = args.length > 0 ? args[0] - args.slice(1).reduce((a, b) => a + b, 0) : 0;
+            break;
+        case 'times':
+        case 'multiply':
+        case 'mul':
+            result = args.reduce((a, b) => a * b, 1);
+            break;
+        case 'divide':
+        case 'div':
+            if (args.length >= 2 && args[1] !== 0) {
+                result = args[0] / args[1];
+            }
+            else {
+                result = 0;
+            }
+            break;
+        case 'mod':
+        case 'modulo':
+            if (args.length >= 2 && args[1] !== 0) {
+                result = args[0] % args[1];
+            }
+            else {
+                result = 0;
+            }
+            break;
+        case 'lt':
+        case 'less':
+            result = args.length >= 2 ? args[0] < args[1] : false;
+            break;
+        case 'gt':
+        case 'greater':
+            result = args.length >= 2 ? args[0] > args[1] : false;
+            break;
+        case 'eq':
+        case 'equal':
+            result = args.length >= 2 ? args[0] === args[1] : false;
+            break;
+        case 'and':
+            result = args.every(a => a !== 0);
+            break;
+        case 'or':
+            result = args.some(a => a !== 0);
+            break;
+        case 'not':
+            result = args.length > 0 ? args[0] === 0 : true;
+            break;
+        case 'same':
+        case 'strcmp':
+            result = stringArgs.length >= 2 ? stringArgs[0] === stringArgs[1] : false;
+            break;
+        default:
+            throw new Error(`<expr> unknown operation: ${op}`);
+    }
+    // Emit result
+    if (typeof result === 'boolean') {
+        emit(session, result ? '1' : '0');
+    }
+    else {
+        emit(session, String(result));
+    }
+}

package/dist/tags/if.d.ts

@@ -0,0 +1,6 @@
+/**
+ * <if> tag - conditional execution
+ * Maps to mask_tag_if in MASK
+ */
+import type { DiracSession, DiracElement } from '../types/index.js';
+export declare function executeIf(session: DiracSession, element: DiracElement): Promise<void>;

package/dist/tags/if.js

@@ -0,0 +1,46 @@
+/**
+ * <if> tag - conditional execution
+ * Maps to mask_tag_if in MASK
+ */
+import { substituteVariables } from '../runtime/session.js';
+import { integrateChildren } from '../runtime/interpreter.js';
+export async function executeIf(session, element) {
+    const test = element.attributes.test;
+    if (!test) {
+        throw new Error('<if> requires test attribute');
+    }
+    const condition = evaluateCondition(session, test);
+    if (condition) {
+        await integrateChildren(session, element);
+    }
+}
+function evaluateCondition(session, test) {
+    // Substitute variables first
+    const substituted = substituteVariables(session, test);
+    // Simple condition evaluation (can be enhanced later)
+    // Supports: ==, !=, <, >, <=, >=
+    const operators = ['==', '!=', '<=', '>=', '<', '>'];
+    for (const op of operators) {
+        const parts = substituted.split(op);
+        if (parts.length === 2) {
+            const left = parts[0].trim();
+            const right = parts[1].trim();
+            switch (op) {
+                case '==':
+                    return left === right;
+                case '!=':
+                    return left !== right;
+                case '<':
+                    return parseFloat(left) < parseFloat(right);
+                case '>':
+                    return parseFloat(left) > parseFloat(right);
+                case '<=':
+                    return parseFloat(left) <= parseFloat(right);
+                case '>=':
+                    return parseFloat(left) >= parseFloat(right);
+            }
+        }
+    }
+    // If no operator, treat as boolean (non-empty = true)
+    return substituted.trim() !== '' && substituted.trim() !== '0' && substituted.trim() !== 'false';
+}

package/dist/tags/llm.d.ts

@@ -0,0 +1,6 @@
+/**
+ * <llm> tag - Call LLM via backend service
+ * Browser edition - makes HTTP calls to dirac-server
+ */
+import type { DiracSession, DiracElement } from '../types/index.js';
+export declare function executeLLM(session: DiracSession, element: DiracElement): Promise<void>;

package/dist/tags/llm.js

@@ -0,0 +1,73 @@
+/**
+ * <llm> tag - Call LLM via backend service
+ * Browser edition - makes HTTP calls to dirac-server
+ */
+import { setVariable, emit } from '../runtime/session.js';
+export async function executeLLM(session, element) {
+    const model = element.attributes.model || 'claude-sonnet-4-20250514';
+    const userPrompt = element.attributes.prompt || element.text || '';
+    const name = element.attributes.name;
+    const temperature = parseFloat(element.attributes.temperature || '0');
+    const maxTokens = parseInt(element.attributes['max-tokens'] || '100', 10);
+    if (!userPrompt) {
+        throw new Error('<llm> requires prompt attribute or text content');
+    }
+    // Reflect subroutines for system prompt
+    // Use getAvailableSubroutines from session
+    // (imported from ../runtime/session.js)
+    // @ts-ignore
+    const { getAvailableSubroutines } = await import('../runtime/session.js');
+    const subroutines = getAvailableSubroutines(session);
+    let systemPrompt = 'You are an expert Dirac command generator.\nAvailable subroutines:';
+    for (const sub of subroutines) {
+        systemPrompt += `\n- <${sub.name} />: ${sub.description || ''}`;
+        if (sub.parameters && sub.parameters.length > 0) {
+            systemPrompt += ' Parameters: ' + sub.parameters.map(p => `${p.name} (${p.type || 'string'})`).join(', ');
+        }
+    }
+    systemPrompt += '\nInstructions: Output only valid Dirac XML tags. Do not include explanations or extra text.';
+    // Example (optional):
+    // systemPrompt += '\nExample: User: Show me my inventory\nOutput: <inventory />';
+    // Final prompt
+    const prompt = systemPrompt + '\nUser: ' + userPrompt + '\nOutput:';
+    // Get backend URL from config
+    const backendUrl = session.config.llmBackendUrl || 'http://localhost:3000';
+    if (session.debug) {
+        console.error(`[LLM] Calling backend: ${backendUrl}/api/llm/complete`);
+        console.error(`[LLM] Model: ${model}, Prompt length: ${prompt.length}`);
+    }
+    try {
+        // Call backend LLM API
+        const response = await fetch(`${backendUrl}/api/llm/complete`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model,
+                prompt,
+                temperature,
+                maxTokens
+            })
+        });
+        if (!response.ok) {
+            throw new Error(`LLM API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        const result = data.response || '';
+        if (session.debug) {
+            console.error(`[LLM] Response length: ${result.length}`);
+        }
+        // Store result if name provided
+        if (name) {
+            setVariable(session, name, result, false);
+        }
+        // Emit result
+        emit(session, result);
+    }
+    catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        console.error('[LLM] Error:', errorMsg);
+        throw new Error(`LLM call failed: ${errorMsg}`);
+    }
+}

package/dist/tags/loop.d.ts

@@ -0,0 +1,6 @@
+/**
+ * <loop> tag - iteration
+ * Maps to mask_tag_loop in MASK
+ */
+import type { DiracSession, DiracElement } from '../types/index.js';
+export declare function executeLoop(session: DiracSession, element: DiracElement): Promise<void>;

package/dist/tags/loop.js

@@ -0,0 +1,31 @@
+/**
+ * <loop> tag - iteration
+ * Maps to mask_tag_loop in MASK
+ */
+import { setVariable, substituteVariables } from '../runtime/session.js';
+import { integrateChildren } from '../runtime/interpreter.js';
+export async function executeLoop(session, element) {
+    const countAttr = element.attributes.count;
+    const varName = element.attributes.var || 'i';
+    if (!countAttr) {
+        throw new Error('<loop> requires count attribute');
+    }
+    const count = parseInt(substituteVariables(session, countAttr), 10);
+    if (isNaN(count) || count < 0) {
+        throw new Error(`Invalid loop count: ${countAttr}`);
+    }
+    const wasBreak = session.isBreak;
+    session.isBreak = false;
+    for (let i = 0; i < count; i++) {
+        setVariable(session, varName, i, false);
+        await integrateChildren(session, element);
+        if (session.isBreak) {
+            session.isBreak = false;
+            break;
+        }
+        if (session.isReturn) {
+            break;
+        }
+    }
+    session.isBreak = wasBreak;
+}

package/dist/tags/output.d.ts

@@ -0,0 +1,6 @@
+/**
+ * <output> tag - emit content
+ * Maps to mask_tag_output in MASK
+ */
+import type { DiracSession, DiracElement } from '../types/index.js';
+export declare function executeOutput(session: DiracSession, element: DiracElement): Promise<void>;

package/dist/tags/output.js

@@ -0,0 +1,19 @@
+/**
+ * <output> tag - emit content
+ * Maps to mask_tag_output in MASK
+ */
+import { emit, substituteVariables } from '../runtime/session.js';
+import { integrateChildren } from '../runtime/interpreter.js';
+export async function executeOutput(session, element) {
+    // If has children, process them (handles mixed content)
+    if (element.children && element.children.length > 0) {
+        await integrateChildren(session, element);
+        return;
+    }
+    // If only text content, use it (with variable substitution)
+    if (element.text) {
+        const content = substituteVariables(session, element.text);
+        emit(session, content);
+        return;
+    }
+}

package/dist/tags/parameters.d.ts

@@ -0,0 +1,6 @@
+/**
+ * <parameters> tag - Access parameters passed to subroutine
+ * Maps to MASK parameter selection syntax
+ */
+import type { DiracSession, DiracElement } from '../types/index.js';
+export declare function executeParameters(session: DiracSession, element: DiracElement): Promise<void>;

package/dist/tags/parameters.js

@@ -0,0 +1,63 @@
+/**
+ * <parameters> tag - Access parameters passed to subroutine
+ * Maps to MASK parameter selection syntax
+ */
+import { getCurrentParameters, emit, setVariable } from '../runtime/session.js';
+import { integrate } from '../runtime/interpreter.js';
+export async function executeParameters(session, element) {
+    const select = element.attributes.select;
+    if (!select) {
+        throw new Error('<parameters> requires select attribute');
+    }
+    // Get parameters from current call context
+    const params = getCurrentParameters(session);
+    if (!params || params.length === 0) {
+        if (session.debug) {
+            console.error(`[PARAMETERS] No parameters available`);
+        }
+        return;
+    }
+    // The caller element is params[0] (the calling tag itself)
+    const caller = params[0];
+    if (select === '*') {
+        // Select all child elements - execute them
+        if (session.debug) {
+            console.error(`[PARAMETERS] Selecting all children (${caller.children.length} elements)`);
+        }
+        for (const child of caller.children) {
+            await integrate(session, child);
+        }
+    }
+    else if (select.startsWith('@')) {
+        // Select attribute(s)
+        const attrName = select.slice(1); // Remove '@'
+        if (attrName === '*') {
+            // Select all attributes
+            if (session.debug) {
+                console.error(`[PARAMETERS] Selecting all attributes`);
+            }
+            const attrs = Object.entries(caller.attributes)
+                .map(([key, val]) => `${key}="${val}"`)
+                .join(' ');
+            emit(session, attrs);
+        }
+        else {
+            // Select specific attribute - automatically create variable with that name
+            const value = caller.attributes[attrName];
+            if (session.debug) {
+                console.error(`[PARAMETERS] Setting variable '${attrName}' = '${value}'`);
+            }
+            if (value !== undefined) {
+                // Automatically create variable (like defvar)
+                setVariable(session, attrName, value, false);
+            }
+            // Execute children if any (for additional processing)
+            for (const child of element.children) {
+                await integrate(session, child);
+            }
+        }
+    }
+    else {
+        throw new Error(`<parameters> invalid select: ${select}`);
+    }
+}

package/dist/tags/subroutine.d.ts

@@ -0,0 +1,6 @@
+/**
+ * <subroutine> tag - define reusable code block
+ * Maps to mask_tag_subroutine in MASK
+ */
+import type { DiracSession, DiracElement } from '../types/index.js';
+export declare function executeSubroutine(session: DiracSession, element: DiracElement): void;

package/dist/tags/subroutine.js

@@ -0,0 +1,41 @@
+/**
+ * <subroutine> tag - define reusable code block
+ * Maps to mask_tag_subroutine in MASK
+ */
+import { registerSubroutine } from '../runtime/session.js';
+export function executeSubroutine(session, element) {
+    const name = element.attributes.name;
+    if (!name) {
+        throw new Error('<subroutine> requires name attribute');
+    }
+    // Extract metadata from attributes (no structural changes!)
+    const description = element.attributes.description;
+    const parameters = [];
+    // Parse param- prefixed attributes for metadata
+    // e.g., param-color="string:required:Color name:red|blue|green"
+    for (const [attrName, attrValue] of Object.entries(element.attributes)) {
+        if (attrName.startsWith('param-')) {
+            const paramName = attrName.substring(6); // Remove "param-" prefix
+            // Parse format: "type:required:description:enum1|enum2|..."
+            const parts = attrValue.split(':');
+            const paramMeta = {
+                name: paramName,
+                type: parts[0] || 'string',
+                required: parts[1] === 'required',
+                description: parts[2] || undefined,
+            };
+            // Parse enum if present (after 3rd colon)
+            if (parts[3]) {
+                paramMeta.enum = parts[3].split('|');
+            }
+            parameters.push(paramMeta);
+        }
+    }
+    // Store subroutine exactly as before (preserves nesting and extends)
+    const subroutine = {
+        tag: 'subroutine',
+        attributes: { ...element.attributes },
+        children: element.children,
+    };
+    registerSubroutine(session, name, subroutine, description, parameters.length > 0 ? parameters : undefined);
+}

package/dist/tags/variable.d.ts

@@ -0,0 +1,6 @@
+/**
+ * <variable> tag - retrieve variable value
+ * Outputs the stored variable content (text or tags)
+ */
+import type { DiracSession, DiracElement } from '../types/index.js';
+export declare function executeVariable(session: DiracSession, element: DiracElement): void;

package/dist/tags/variable.js

@@ -0,0 +1,20 @@
+/**
+ * <variable> tag - retrieve variable value
+ * Outputs the stored variable content (text or tags)
+ */
+import { getVariable, emit } from '../runtime/session.js';
+export function executeVariable(session, element) {
+    const name = element.attributes.name;
+    if (!name) {
+        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/dist/types/index.d.ts

@@ -0,0 +1,76 @@
+/**
+ * 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;
+    passby: 'value' | 'ref';
+    refName?: string;
+}
+/**
+ * Subroutine info - maps to Subroutine in MASK
+ */
+export interface Subroutine {
+    name: string;
+    element: DiracElement;
+    boundary: number;
+    extends?: string;
+    description?: string;
+    parameters?: ParameterMetadata[];
+}
+/**
+ * Parameter metadata for reflection API
+ */
+export interface ParameterMetadata {
+    name: string;
+    type: string;
+    required: boolean;
+    description?: string;
+    enum?: string[];
+}
+/**
+ * Execution context - maps to MaskSession in MASK
+ */
+export 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>;
+    config: DiracConfig;
+}
+export interface DiracConfig {
+    apiKey?: string;
+    model?: string;
+    debug?: boolean;
+    maxLLMCalls?: number;
+    maxDepth?: number;
+    filePath?: string;
+    customContext?: Record<string, any>;
+    llmBackendUrl?: string;
+}

package/dist/types/index.js

@@ -0,0 +1,5 @@
+/**
+ * Core types for Dirac interpreter
+ * Directly based on MASK C implementation
+ */
+export {};

package/dist/utils/llm-adapter.d.ts

@@ -0,0 +1,22 @@
+/**
+ * LLM Adapter - Auto-generate prompts and JSON→XML converters
+ * from Dirac subroutine definitions
+ */
+import type { DiracSession } from '../types/index.js';
+export interface LLMPromptGenerator {
+    generatePrompt(userInput: string): string;
+    intentToXML(intent: any): string | null;
+    getAvailableActions(): string[];
+}
+/**
+ * Create LLM adapter from session's registered subroutines
+ */
+export declare function createLLMAdapter(session: DiracSession): LLMPromptGenerator;
+/**
+ * Higher-level helper: execute user command via LLM
+ */
+export declare function executeUserCommand(session: DiracSession, userInput: string, llmExecuteFn: (prompt: string) => Promise<string>): Promise<{
+    success: boolean;
+    xml?: string;
+    error?: string;
+}>;

package/dist/utils/llm-adapter.js

@@ -0,0 +1,91 @@
+/**
+ * LLM Adapter - Auto-generate prompts and JSON→XML converters
+ * from Dirac subroutine definitions
+ */
+import { getAvailableSubroutines } from '../runtime/session.js';
+/**
+ * Create LLM adapter from session's registered subroutines
+ */
+export function createLLMAdapter(session) {
+    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) {
+            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) {
+            if (!intent || !intent.action)
+                return null;
+            const sub = subroutines.find(s => s.name === intent.action);
+            if (!sub)
+                return null;
+            const attrs = [`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(' ')}/>`;
+        },
+        getAvailableActions() {
+            return subroutines.map(s => s.name);
+        }
+    };
+}
+/**
+ * Higher-level helper: execute user command via LLM
+ */
+export async function executeUserCommand(session, userInput, llmExecuteFn) {
+    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)
+        };
+    }
+}