dirac-lang 0.1.97 → 0.1.99

package/dist/{tag-validator-REN6XLMT.js → tag-validator-QS7T4GFE.js}

@@ -77,6 +77,21 @@ function validateParameterType(paramName, value, expectedType) {
   }
   return { valid: true };
 }
+function validateAttributeValue(attrName, value) {
+  if (value.includes("<variable")) {
+    return {
+      valid: false,
+      error: `Attribute '${attrName}' contains <variable> tag - use \${varname} syntax in attributes instead`
+    };
+  }
+  if (/<[a-zA-Z]/.test(value) && !value.includes("${")) {
+    return {
+      valid: false,
+      warning: `Attribute '${attrName}' appears to contain XML tags - attribute values should use \${} syntax for variables`
+    };
+  }
+  return { valid: true };
+}
 async function validateNestedTags(session, element, options = {}) {
   const results = [];
   for (const child of element.children) {
@@ -94,7 +109,7 @@ async function validateNestedTags(session, element, options = {}) {
 async function validateTag(session, element, options = {}) {
   const { autocorrect = false, similarityCutoff = SIMILARITY_CUTOFF, deepValidation = false } = options;
   console.error(`[VALIDATE] Tag: <${element.tag}>, autocorrect: ${autocorrect}, attributes:`, Object.keys(element.attributes));
-  const { getAvailableSubroutines } = await import("./session-IH5LO7FS.js");
+  const { getAvailableSubroutines } = await import("./session-6WX5O74B.js");
   const subroutines = getAvailableSubroutines(session);
   const allowed = new Set(subroutines.map((s) => s.name));
   const tagName = element.tag;
@@ -107,7 +122,8 @@ async function validateTag(session, element, options = {}) {
     warnings: [],
     attributeCorrections: {},
     typeErrors: [],
-    nestedValidation: []
+    nestedValidation: [],
+    scopeValidation: void 0
   };
   if (allowed.has(tagName)) {
     console.error(`[VALIDATE] Tag <${tagName}> is valid`);
@@ -160,8 +176,16 @@ async function validateTag(session, element, options = {}) {
       }
       for (const attr in element.attributes) {
         const param = sub.parameters.find((p) => p.name === attr);
+        const attrValue = element.attributes[attr];
+        const attrValueCheck = validateAttributeValue(attr, attrValue);
+        if (!attrValueCheck.valid && attrValueCheck.error) {
+          result.errors.push(attrValueCheck.error);
+        }
+        if (attrValueCheck.warning) {
+          result.warnings.push(attrValueCheck.warning);
+        }
         if (param && param.type) {
-          const typeCheck = validateParameterType(attr, element.attributes[attr], param.type);
+          const typeCheck = validateParameterType(attr, attrValue, param.type);
           if (!typeCheck.valid && typeCheck.error) {
             result.typeErrors.push(typeCheck.error);
             result.errors.push(typeCheck.error);
@@ -176,6 +200,22 @@ async function validateTag(session, element, options = {}) {
             result.warnings.push(`Nested tag <${nestedResult.originalTag}>: ${nestedResult.errors.join(", ")}`);
           }
         }
+        const { validateSubroutineScope } = await import("./scope-validator-TVQIOEAI.js");
+        result.scopeValidation = validateSubroutineScope(element);
+        console.error(`[VALIDATE] Scope validation for <subroutine name="${element.attributes.name}">:`, {
+          errors: result.scopeValidation.errors.length,
+          warnings: result.scopeValidation.warnings.length,
+          undefinedParams: result.scopeValidation.undefinedParameters,
+          undefinedVars: result.scopeValidation.undefinedVariables,
+          unusedParams: result.scopeValidation.unusedParameters,
+          unusedVars: result.scopeValidation.unusedVariables
+        });
+        if (result.scopeValidation.warnings.length > 0) {
+          result.warnings.push(...result.scopeValidation.warnings.map((w) => `Scope: ${w}`));
+        }
+        if (result.scopeValidation.errors.length > 0) {
+          result.errors.push(...result.scopeValidation.errors.map((e) => `Scope: ${e}`));
+        }
       }
     }
     result.valid = result.errors.length === 0;
@@ -230,6 +270,49 @@ async function validateDiracCode(session, ast, options = {}) {
   const results = [];
   const errorMessages = [];
   const typeErrors = [];
+  const localSubroutineNames = /* @__PURE__ */ new Set();
+  const localSubroutineElements = /* @__PURE__ */ new Map();
+  function extractLocalSubroutines(element) {
+    if (element.tag === "subroutine" && element.attributes.name) {
+      localSubroutineNames.add(element.attributes.name);
+      localSubroutineElements.set(element.attributes.name, element);
+    }
+    for (const child of element.children) {
+      extractLocalSubroutines(child);
+    }
+  }
+  extractLocalSubroutines(ast);
+  if (localSubroutineNames.size > 0) {
+    console.error(`[VALIDATE] Found ${localSubroutineNames.size} local subroutine definitions:`, Array.from(localSubroutineNames));
+  }
+  const tempSubroutines = [];
+  for (const subName of localSubroutineNames) {
+    const subElement = localSubroutineElements.get(subName);
+    const parameters = [];
+    for (const attr in subElement.attributes) {
+      if (attr.startsWith("param-")) {
+        const paramName = attr.slice(6);
+        const paramSpec = subElement.attributes[attr];
+        const parts = paramSpec.split(":");
+        parameters.push({
+          name: paramName,
+          type: parts[0] || "string",
+          required: parts[1] === "required",
+          description: parts[2] || "",
+          example: parts[3] || ""
+        });
+      }
+    }
+    console.error(`[VALIDATE] Temp subroutine '${subName}' has ${parameters.length} parameters:`, parameters.map((p) => p.name));
+    const tempSub = {
+      name: subName,
+      element: subElement,
+      boundary: session.variables.length,
+      parameters
+    };
+    session.subroutines.push(tempSub);
+    tempSubroutines.push(tempSub);
+  }
   async function validateElement(element) {
     if (element.tag && element.tag !== "dirac" && element.tag !== "DIRAC-ROOT" && element.tag.trim() !== "") {
       const result = await validateTag(session, element, options);
@@ -246,6 +329,12 @@ async function validateDiracCode(session, ast, options = {}) {
     }
   }
   await validateElement(ast);
+  for (const tempSub of tempSubroutines) {
+    const index = session.subroutines.indexOf(tempSub);
+    if (index > -1) {
+      session.subroutines.splice(index, 1);
+    }
+  }
   return {
     valid: errorMessages.length === 0,
     results,
@@ -256,26 +345,28 @@ async function validateDiracCode(session, ast, options = {}) {
 function applyCorrectedTags(ast, results) {
   let resultIndex = 0;
   function correctElement(element) {
-    if (element.tag && element.tag !== "dirac" && element.tag !== "DIRAC-ROOT" && element.tag.trim() !== "") {
+    const shouldProcess = element.tag && element.tag !== "dirac" && element.tag !== "DIRAC-ROOT" && element.tag.trim() !== "";
+    if (shouldProcess && resultIndex < results.length) {
       const result = results[resultIndex++];
-      if (result) {
-        if (result.corrected && result.tagName !== element.tag) {
-          console.error(`[APPLY-CORRECTION] Tag: ${element.tag} \u2192 ${result.tagName}`);
-          element = { ...element, tag: result.tagName };
-        }
-        if (result.attributeCorrections && Object.keys(result.attributeCorrections).length > 0) {
-          console.error(`[APPLY-CORRECTION] Attributes on <${element.tag}>:`, result.attributeCorrections);
-          const newAttributes = {};
-          for (const [oldAttr, value] of Object.entries(element.attributes)) {
-            const newAttr = result.attributeCorrections[oldAttr] || oldAttr;
-            if (newAttr !== oldAttr) {
-              console.error(`[APPLY-CORRECTION]   ${oldAttr}="${value}" \u2192 ${newAttr}="${value}"`);
-            }
-            newAttributes[newAttr] = value;
+      console.error(`[APPLY-CORRECTION] Processing <${element.tag}> with result #${resultIndex - 1} for <${result.originalTag}>, corrected: ${result.corrected}`);
+      if (result.corrected && result.tagName !== element.tag) {
+        console.error(`[APPLY-CORRECTION] Tag: ${element.tag} \u2192 ${result.tagName}`);
+        element = { ...element, tag: result.tagName };
+      }
+      if (result.attributeCorrections && Object.keys(result.attributeCorrections).length > 0) {
+        console.error(`[APPLY-CORRECTION] Attributes on <${element.tag}>:`, result.attributeCorrections);
+        const newAttributes = {};
+        for (const [oldAttr, value] of Object.entries(element.attributes)) {
+          const newAttr = result.attributeCorrections[oldAttr] || oldAttr;
+          if (newAttr !== oldAttr) {
+            console.error(`[APPLY-CORRECTION]   ${oldAttr}="${value}" \u2192 ${newAttr}="${value}"`);
           }
-          element = { ...element, attributes: newAttributes };
+          newAttributes[newAttr] = value;
         }
+        element = { ...element, attributes: newAttributes };
       }
+    } else if (shouldProcess) {
+      console.error(`[APPLY-CORRECTION] WARNING: No result for <${element.tag}> at index ${resultIndex} (total results: ${results.length})`);
     }
     return {
       ...element,

package/dist/test-runner.js

@@ -1,15 +1,15 @@
 import {
   integrate
-} from "./chunk-4TBIVB4X.js";
-import "./chunk-ECAW4X46.js";
-import "./chunk-SLGJRZ3P.js";
+} from "./chunk-3VCKPUTQ.js";
+import "./chunk-53QJQ2CC.js";
 import {
   DiracParser
 } from "./chunk-HRHAMPOB.js";
+import "./chunk-EAM7IZWA.js";
 import {
   createSession,
   getOutput
-} from "./chunk-PPH7KYKH.js";
+} from "./chunk-ZYSWVMID.js";
 
 // src/test-runner.ts
 import fs from "fs";

package/lib/native-tags.di

@@ -219,7 +219,8 @@
   meta-hide-from-llm="true"
   description="Edit subroutine definition in external editor"
   param-name="string:required:Subroutine name to edit"
-  param-editor="string:optional:Editor command (default: $EDITOR or vi)">
+  param-editor="string:optional:Editor command (default: $EDITOR or vi)"
+  param-format="string:optional:format (braket or xml, default:braket)">
   <!-- Opens subroutine in temp file with editor (blocking) -->
   <!-- After save/exit, automatically re-imports into session -->
   <!-- Changes take effect immediately but are NOT saved to disk -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dirac-lang",
-  "version": "0.1.97",
+  "version": "0.1.99",
   "description": "LLM-Augmented Declarative Execution",
   "type": "module",
   "main": "dist/index.js",

package/dist/interpreter-4CIWAOBY.js

@@ -1,12 +0,0 @@
-import {
-  integrate,
-  integrateChildren
-} from "./chunk-4TBIVB4X.js";
-import "./chunk-ECAW4X46.js";
-import "./chunk-SLGJRZ3P.js";
-import "./chunk-HRHAMPOB.js";
-import "./chunk-PPH7KYKH.js";
-export {
-  integrate,
-  integrateChildren
-};