dirac-lang 0.1.74 → 0.1.77

package/README.md

@@ -258,7 +258,7 @@ npm install -g dirac-lang
 
 ## PAUL: The Human-Friendly Dirac Dialect
 
-Dirac’s XML-based language is designed for robust machine execution and symbolic reasoning. For human authors, we introduce **PAUL** (Programming AI Utility Language)—a concise, bra/ket-inspired notation for writing Dirac programs quickly and intuitively.
+Dirac's XML-based language is designed for robust machine execution and symbolic reasoning. For human authors, we introduce **PAUL** (Pattern Action Utility Language)—a concise, bra/ket-inspired notation for writing Dirac programs quickly and intuitively.
 
 - PAUL uses bra/ket syntax and positional arguments for readability.
 - It is ideal for human editing, rapid prototyping, and LLM prompts.

package/dist/{agent-TC34E2DB.js → agent-VAFUNYDM.js}

@@ -2,10 +2,11 @@ import {
   SessionServer,
   getSocketPath,
   isSessionRunning
-} from "./chunk-KIIETJFM.js";
-import "./chunk-YCUHRNXQ.js";
-import "./chunk-HRHAMPOB.js";
+} from "./chunk-CLGQYGHT.js";
+import "./chunk-TYIDNAZ7.js";
 import "./chunk-VC23AJJJ.js";
+import "./chunk-FPDW535D.js";
+import "./chunk-HRHAMPOB.js";
 import "./chunk-M57VI7KL.js";
 
 // src/agent.ts

package/dist/{chunk-KIIETJFM.js → chunk-CLGQYGHT.js}

@@ -1,6 +1,6 @@
 import {
   integrate
-} from "./chunk-YCUHRNXQ.js";
+} from "./chunk-TYIDNAZ7.js";
 import {
   DiracParser
 } from "./chunk-HRHAMPOB.js";

package/dist/chunk-FPDW535D.js

@@ -0,0 +1,305 @@
+import {
+  DiracParser
+} from "./chunk-HRHAMPOB.js";
+import {
+  emit,
+  setVariable
+} from "./chunk-M57VI7KL.js";
+
+// src/runtime/subroutine-registry.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+var SubroutineRegistry = class {
+  indexPath;
+  index;
+  constructor(indexPath) {
+    this.indexPath = indexPath || path.join(os.homedir(), ".dirac", "subroutine-index.json");
+    this.index = this.loadIndex();
+  }
+  /**
+   * Load index from disk
+   */
+  loadIndex() {
+    if (fs.existsSync(this.indexPath)) {
+      try {
+        const data = fs.readFileSync(this.indexPath, "utf-8");
+        return JSON.parse(data);
+      } catch (err) {
+        console.error("Error loading subroutine index:", err);
+      }
+    }
+    return {
+      subroutines: [],
+      lastUpdated: Date.now()
+    };
+  }
+  /**
+   * Save index to disk
+   */
+  saveIndex() {
+    const dir = path.dirname(this.indexPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    this.index.lastUpdated = Date.now();
+    fs.writeFileSync(this.indexPath, JSON.stringify(this.index, null, 2), "utf-8");
+  }
+  /**
+   * Scan a directory for .di files and index all subroutines
+   */
+  async indexDirectory(dirPath) {
+    let count = 0;
+    const absoluteDirPath = path.isAbsolute(dirPath) ? dirPath : path.resolve(process.cwd(), dirPath);
+    const scanDir = (dir) => {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          scanDir(fullPath);
+        } else if (entry.isFile() && entry.name.endsWith(".di")) {
+          count += this.indexFile(fullPath);
+        }
+      }
+    };
+    scanDir(absoluteDirPath);
+    this.saveIndex();
+    return count;
+  }
+  /**
+   * Index a single .di file
+   */
+  indexFile(filePath) {
+    try {
+      const content = fs.readFileSync(filePath, "utf-8");
+      const parser = new DiracParser();
+      const ast = parser.parse(content);
+      this.index.subroutines = this.index.subroutines.filter((s) => s.filePath !== filePath);
+      const subroutines = this.extractSubroutines(ast, filePath);
+      this.index.subroutines.push(...subroutines);
+      this.saveIndex();
+      return subroutines.length;
+    } catch (err) {
+      if (process.env.DEBUG_REGISTRY === "1") {
+        console.error(`Error indexing ${filePath}:`, err);
+      }
+      return 0;
+    }
+  }
+  /**
+   * Extract subroutines from AST
+   */
+  extractSubroutines(element, filePath) {
+    const subroutines = [];
+    if (element.tag === "subroutine") {
+      const name = element.attributes.name;
+      if (name) {
+        const metadata = {
+          name,
+          description: element.attributes.description,
+          parameters: [],
+          filePath
+        };
+        for (const [attrName, attrValue] of Object.entries(element.attributes)) {
+          if (attrName.startsWith("param-")) {
+            const paramName = attrName.substring(6);
+            const parts = attrValue.split(":");
+            metadata.parameters.push({
+              name: paramName,
+              type: parts[0] || "any",
+              required: parts[1] === "required",
+              description: parts[2]
+            });
+          }
+        }
+        subroutines.push(metadata);
+      }
+    }
+    if (element.children) {
+      for (const child of element.children) {
+        subroutines.push(...this.extractSubroutines(child, filePath));
+      }
+    }
+    return subroutines;
+  }
+  /**
+   * Simple text search (will be replaced with vector search)
+   * Supports multi-word queries by tokenizing and matching individual words
+   */
+  search(query, limit = 10) {
+    const lowerQuery = query.toLowerCase();
+    const queryTokens = lowerQuery.split(/[\s\-_]+/).filter((t) => t.length > 0);
+    const results = this.index.subroutines.map((sub) => {
+      let score = 0;
+      const lowerName = sub.name.toLowerCase();
+      const lowerDesc = (sub.description || "").toLowerCase();
+      const nameTokens = lowerName.split(/[\s\-_]+/);
+      if (lowerName === lowerQuery) {
+        score += 100;
+      } else if (lowerName.includes(lowerQuery)) {
+        score += 50;
+      } else if (lowerDesc.includes(lowerQuery)) {
+        score += 30;
+      }
+      let tokenMatchCount = 0;
+      for (const queryToken of queryTokens) {
+        if (queryToken.length <= 2) {
+          continue;
+        }
+        if (nameTokens.some((nt) => nt === queryToken)) {
+          score += 40;
+          tokenMatchCount++;
+        } else if (nameTokens.some((nt) => nt.startsWith(queryToken))) {
+          score += 20;
+          tokenMatchCount++;
+        }
+        const descWords = lowerDesc.split(/[\s\-_]+/);
+        if (descWords.some((w) => w === queryToken || w.startsWith(queryToken))) {
+          score += 15;
+          tokenMatchCount++;
+        }
+        for (const param of sub.parameters) {
+          const lowerParamName = param.name.toLowerCase();
+          if (lowerParamName === queryToken) {
+            score += 10;
+            tokenMatchCount++;
+          } else if (lowerParamName.startsWith(queryToken)) {
+            score += 5;
+          }
+        }
+      }
+      if (queryTokens.length > 1 && tokenMatchCount >= queryTokens.length * 0.5) {
+        score += 25;
+      }
+      return { sub, score };
+    }).filter((r) => r.score > 0).sort((a, b) => b.score - a.score).slice(0, limit).map((r) => r.sub);
+    return results;
+  }
+  /**
+   * Get all subroutines
+   */
+  getAll() {
+    return this.index.subroutines;
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    const files = new Set(this.index.subroutines.map((s) => s.filePath));
+    return {
+      totalSubroutines: this.index.subroutines.length,
+      totalFiles: files.size,
+      lastUpdated: new Date(this.index.lastUpdated)
+    };
+  }
+  /**
+   * Auto-index stdlib if index is empty (first run)
+   * Returns true if indexing was performed
+   */
+  async autoIndexStdlib() {
+    if (this.index.subroutines.length > 0) {
+      return false;
+    }
+    try {
+      const { createRequire } = await import("module");
+      const require2 = createRequire(import.meta.url);
+      const stdlibPackagePath = require2.resolve("dirac-stdlib/package.json");
+      const stdlibLibPath = path.join(path.dirname(stdlibPackagePath), "lib");
+      if (fs.existsSync(stdlibLibPath)) {
+        console.log("First run detected. Indexing standard library...");
+        const count = await this.indexDirectory(stdlibLibPath);
+        console.log(`Indexed ${count} subroutines from dirac-stdlib`);
+        console.log("You can now use |load-context> to find and load subroutines!\n");
+        return true;
+      }
+    } catch (err) {
+    }
+    return false;
+  }
+};
+
+// src/tags/subroutine-index.ts
+var registry = new SubroutineRegistry();
+async function executeIndexSubroutines(session, element) {
+  const pathAttr = element.attributes.path;
+  if (!pathAttr) {
+    throw new Error("<index-subroutines> requires path attribute");
+  }
+  const count = await registry.indexDirectory(pathAttr);
+  if (session.debug) {
+    emit(session, `Indexed ${count} subroutines from ${pathAttr}
+`);
+  }
+}
+async function executeSearchSubroutines(session, element) {
+  const query = element.attributes.query;
+  const limitAttr = element.attributes.limit;
+  const outputVar = element.attributes.output;
+  const format = element.attributes.format || "text";
+  if (!query) {
+    throw new Error("<search-subroutines> requires query attribute");
+  }
+  const limit = limitAttr ? parseInt(limitAttr, 10) : 10;
+  const results = registry.search(query, limit);
+  let output = "";
+  switch (format) {
+    case "json":
+      output = JSON.stringify(results, null, 2);
+      break;
+    case "xml":
+      output = "<subroutines>\n";
+      for (const sub of results) {
+        const params = sub.parameters.map((p) => `param-${p.name}="${p.type}"`).join(" ");
+        output += `  <subroutine name="${sub.name}" ${params} file="${sub.filePath}"/>
+`;
+        if (sub.description) {
+          output += `    <!-- ${sub.description} -->
+`;
+        }
+      }
+      output += "</subroutines>";
+      break;
+    case "text":
+    default:
+      if (results.length === 0) {
+        output = "No subroutines found.\n";
+      } else {
+        output = `Found ${results.length} subroutine(s):
+
+`;
+        for (const sub of results) {
+          output += `${sub.name}(${sub.parameters.map((p) => p.name).join(", ")})
+`;
+          if (sub.description) {
+            output += `  ${sub.description}
+`;
+          }
+          output += `  File: ${sub.filePath}
+
+`;
+        }
+      }
+      break;
+  }
+  if (outputVar) {
+    setVariable(session, outputVar, output, false);
+  } else {
+    emit(session, output);
+  }
+}
+async function executeRegistryStats(session, element) {
+  const stats = registry.getStats();
+  const output = `Subroutine Registry Statistics:
+  Total Subroutines: ${stats.totalSubroutines}
+  Total Files: ${stats.totalFiles}
+  Last Updated: ${stats.lastUpdated.toLocaleString()}
+`;
+  emit(session, output);
+}
+
+export {
+  registry,
+  executeIndexSubroutines,
+  executeSearchSubroutines,
+  executeRegistryStats
+};