dirac-lang 0.1.59 → 0.1.61

package/dist/session-client-3VTC5MLO.js

@@ -0,0 +1,177 @@
+// src/session-client.ts
+import net from "net";
+import { EventEmitter } from "events";
+var SessionClient = class extends EventEmitter {
+  socket = null;
+  buffer = "";
+  connected = false;
+  options;
+  constructor(options) {
+    super();
+    this.options = {
+      autoReconnect: false,
+      reconnectDelay: 1e3,
+      ...options
+    };
+  }
+  async connect() {
+    return new Promise((resolve, reject) => {
+      this.socket = net.connect(this.options.socketPath);
+      this.socket.on("connect", () => {
+        this.emit("socket-connected");
+      });
+      this.socket.on("data", (data) => {
+        this.buffer += data.toString();
+        const lines = this.buffer.split("\n");
+        this.buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const message = JSON.parse(line);
+            this.handleMessage(message);
+          } catch (error) {
+            this.emit("error", new Error(`Invalid message: ${error}`));
+          }
+        }
+      });
+      this.socket.on("end", () => {
+        this.connected = false;
+        this.emit("disconnected");
+        if (this.options.autoReconnect) {
+          setTimeout(() => this.connect(), this.options.reconnectDelay);
+        }
+      });
+      this.socket.on("error", (error) => {
+        this.connected = false;
+        reject(error);
+        this.emit("error", error);
+      });
+      this.once("welcome", () => {
+        this.connected = true;
+        resolve();
+      });
+    });
+  }
+  handleMessage(message) {
+    const { type, data, message: msg } = message;
+    switch (type) {
+      case "welcome":
+        this.emit("welcome", msg);
+        break;
+      case "output":
+        this.emit("output", data);
+        break;
+      case "error":
+        this.emit("error", new Error(msg || data));
+        break;
+      case "vars":
+        this.emit("vars", data);
+        break;
+      case "state":
+        this.emit("state", data);
+        break;
+      case "shutdown":
+        this.emit("shutdown");
+        break;
+      default:
+        this.emit("message", message);
+    }
+  }
+  async execute(command) {
+    return new Promise((resolve, reject) => {
+      if (!this.socket) {
+        reject(new Error("Not connected to session: socket is null"));
+        return;
+      }
+      if (!this.connected) {
+        reject(new Error("Not connected to session: connected flag is false"));
+        return;
+      }
+      this.send({ type: "execute", data: { command } });
+      const timeout = setTimeout(() => {
+        reject(new Error("Execution timeout"));
+      }, 3e4);
+      const onOutput = (output) => {
+        clearTimeout(timeout);
+        this.off("error", onError);
+        resolve(output);
+      };
+      const onError = (error) => {
+        clearTimeout(timeout);
+        this.off("output", onOutput);
+        reject(error);
+      };
+      this.once("output", onOutput);
+      this.once("error", onError);
+    });
+  }
+  async getVars() {
+    return new Promise((resolve, reject) => {
+      if (!this.connected || !this.socket) {
+        reject(new Error("Not connected to session"));
+        return;
+      }
+      this.send({ type: "getVars" });
+      const timeout = setTimeout(() => {
+        reject(new Error("Timeout getting variables"));
+      }, 5e3);
+      const onVars = (vars) => {
+        clearTimeout(timeout);
+        resolve(vars);
+      };
+      this.once("vars", onVars);
+    });
+  }
+  async getState() {
+    return new Promise((resolve, reject) => {
+      if (!this.socket) {
+        reject(new Error("Not connected to session: socket is null"));
+        return;
+      }
+      if (!this.connected) {
+        reject(new Error("Not connected to session: connected flag is false"));
+        return;
+      }
+      this.send({ type: "getState" });
+      const timeout = setTimeout(() => {
+        reject(new Error("Timeout getting state"));
+      }, 5e3);
+      const onState = (state) => {
+        clearTimeout(timeout);
+        resolve(state);
+      };
+      this.once("state", onState);
+    });
+  }
+  async shutdown() {
+    return new Promise((resolve) => {
+      if (!this.connected || !this.socket) {
+        resolve();
+        return;
+      }
+      this.send({ type: "shutdown" });
+      this.once("shutdown", () => {
+        resolve();
+      });
+    });
+  }
+  send(message) {
+    if (!this.socket || !this.connected) {
+      throw new Error("Not connected to session");
+    }
+    this.socket.write(JSON.stringify(message) + "\n");
+  }
+  disconnect() {
+    if (this.socket) {
+      this.socket.end();
+      this.socket = null;
+    }
+    this.connected = false;
+  }
+  isConnected() {
+    return this.connected;
+  }
+};
+export {
+  SessionClient
+};

package/dist/session-server-QZN2RMYD.js

@@ -0,0 +1,14 @@
+import {
+  SessionServer,
+  getSocketPath,
+  isSessionRunning
+} from "./chunk-AU3YU63U.js";
+import "./chunk-ZAA6R2TC.js";
+import "./chunk-HRHAMPOB.js";
+import "./chunk-NKA6ZJDV.js";
+import "./chunk-3UW6GWYQ.js";
+export {
+  SessionServer,
+  getSocketPath,
+  isSessionRunning
+};

package/dist/{shell-LPNBQPXC.js → shell-OFBL57OA.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-AJSYOXXZ.js";
 import {
   integrate
-} from "./chunk-RDVNX3JG.js";
+} from "./chunk-ZAA6R2TC.js";
 import {
   DiracParser
 } from "./chunk-HRHAMPOB.js";
@@ -23,6 +23,7 @@ var HISTORY_FILE = path.join(os.homedir(), ".dirac_history");
 var MAX_HISTORY = 1e3;
 var DiracShell = class {
   session;
+  client = null;
   braketParser;
   xmlParser;
   rl;
@@ -45,6 +46,12 @@ var DiracShell = class {
     this.loadHistory();
     this.setupHandlers();
   }
+  /**
+   * Set client for daemon mode
+   */
+  setClient(client) {
+    this.client = client;
+  }
   completer(line) {
     const attrMatch = line.match(/\|([a-z0-9_-]+)\s+.*?([a-z0-9_-]*)$/i);
     if (attrMatch) {
@@ -150,7 +157,10 @@ var DiracShell = class {
     });
     this.rl.on("close", () => {
       this.saveHistory();
-      import("./schedule-2NDGR5S5.js").then(({ stopAllScheduledTasks }) => {
+      if (this.client) {
+        this.client.disconnect();
+      }
+      import("./schedule-QZ5U3YBS.js").then(({ stopAllScheduledTasks }) => {
         stopAllScheduledTasks();
         console.log("\nGoodbye!");
         process.exit(0);
@@ -249,6 +259,17 @@ var DiracShell = class {
     this.inputBuffer = [];
     this.baseIndent = null;
     try {
+      if (this.client) {
+        const xml2 = this.braketParser.parse(input);
+        if (this.config.debug) {
+          console.log("[Debug] Sending to agent:\n", xml2);
+        }
+        const output = await this.client.execute(xml2);
+        if (output) {
+          console.log(output);
+        }
+        return;
+      }
       this.session.output = [];
       const xml = this.braketParser.parse(input);
       if (this.config.debug) {
@@ -291,6 +312,12 @@ Commands:
   :tasks          List all scheduled tasks
   :stop <name>    Stop a scheduled task
   :stopall        Stop all scheduled tasks
+  :crons          List all cron jobs
+  :stopcron <name> Stop a cron job
+  :stopallcrons   Stop all cron jobs
+  :scheduled      List all scheduled runs (run-at)
+  :cancel <name>  Cancel a scheduled run
+  :cancelall      Cancel all scheduled runs
   :exit           Exit shell
 
 Syntax:
@@ -315,29 +342,56 @@ Examples:
 `);
         break;
       case "vars":
-        if (this.session.variables.length === 0) {
-          console.log("No variables defined");
-        } else {
-          console.log("Variables:");
-          for (const v of this.session.variables) {
-            if (v.visible) {
-              console.log(`  ${v.name} = ${JSON.stringify(v.value)}`);
+        try {
+          let variables;
+          if (this.client) {
+            const state = await this.client.getState();
+            variables = state.variables || [];
+          } else {
+            variables = this.session.variables;
+          }
+          if (variables.length === 0) {
+            console.log("No variables defined");
+          } else {
+            console.log("Variables:");
+            for (const v of variables) {
+              if (v.visible) {
+                console.log(`  ${v.name} = ${JSON.stringify(v.value)}`);
+              }
             }
           }
+        } catch (error) {
+          console.error("Error getting variables:", error instanceof Error ? error.message : String(error));
         }
         break;
       case "subs":
-        if (this.session.subroutines.length === 0) {
-          console.log("No subroutines defined");
-        } else {
-          console.log("Subroutines:");
-          for (const s of this.session.subroutines) {
-            const params = s.parameters?.map((p) => p.name).join(", ") || "";
-            console.log(`  ${s.name}(${params})`);
-            if (s.description) {
-              console.log(`    ${s.description}`);
+        try {
+          let subroutines;
+          if (this.client) {
+            const state = await this.client.getState();
+            console.log("State received:", JSON.stringify(state, null, 2).substring(0, 500));
+            subroutines = state.subroutines || [];
+          } else {
+            subroutines = this.session.subroutines;
+          }
+          if (!Array.isArray(subroutines)) {
+            console.error("Error: subroutines is not an array, it is:", typeof subroutines);
+            break;
+          }
+          if (subroutines.length === 0) {
+            console.log("No subroutines defined");
+          } else {
+            console.log("Subroutines:");
+            for (const s of subroutines) {
+              const params = s.parameters?.map((p) => p.name).join(", ") || "";
+              console.log(`  ${s.name}(${params})`);
+              if (s.description) {
+                console.log(`    ${s.description}`);
+              }
             }
           }
+        } catch (error) {
+          console.error("Error getting subroutines:", error instanceof Error ? error.message : String(error));
         }
         break;
       case "clear":
@@ -471,7 +525,7 @@ Examples:
         break;
       case "tasks":
         try {
-          const { listScheduledTasks } = await import("./schedule-2NDGR5S5.js");
+          const { listScheduledTasks } = await import("./schedule-QZ5U3YBS.js");
           const tasks = listScheduledTasks();
           if (tasks.length === 0) {
             console.log("No scheduled tasks running.");
@@ -490,7 +544,7 @@ Examples:
           console.log("Usage: :stop <task-name>");
         } else {
           try {
-            const { stopScheduledTask } = await import("./schedule-2NDGR5S5.js");
+            const { stopScheduledTask } = await import("./schedule-QZ5U3YBS.js");
             const taskName = args[0];
             const stopped = stopScheduledTask(taskName);
             if (stopped) {
@@ -505,13 +559,101 @@ Examples:
         break;
       case "stopall":
         try {
-          const { stopAllScheduledTasks } = await import("./schedule-2NDGR5S5.js");
+          const { stopAllScheduledTasks } = await import("./schedule-QZ5U3YBS.js");
           stopAllScheduledTasks();
           console.log("All scheduled tasks stopped.");
         } catch (error) {
           console.error("Error stopping tasks:", error instanceof Error ? error.message : String(error));
         }
         break;
+      case "crons":
+        try {
+          const { listCronJobs } = await import("./cron-BQIWLGQY.js");
+          const jobs = listCronJobs();
+          if (jobs.length === 0) {
+            console.log("No cron jobs running.");
+          } else {
+            console.log("\nCron Jobs:");
+            for (const job of jobs) {
+              const status = job.isRunning ? "(running)" : "";
+              console.log(`  - ${job.name}: ${job.cronExpression} ${status}`);
+            }
+          }
+        } catch (error) {
+          console.error("Error listing cron jobs:", error instanceof Error ? error.message : String(error));
+        }
+        break;
+      case "stopcron":
+        if (args.length === 0) {
+          console.log("Usage: :stopcron <job-name>");
+        } else {
+          try {
+            const { stopCronJob } = await import("./cron-BQIWLGQY.js");
+            const jobName = args[0];
+            const stopped = stopCronJob(jobName);
+            if (stopped) {
+              console.log(`Stopped cron job: ${jobName}`);
+            } else {
+              console.log(`Cron job not found: ${jobName}`);
+            }
+          } catch (error) {
+            console.error("Error stopping cron job:", error instanceof Error ? error.message : String(error));
+          }
+        }
+        break;
+      case "stopallcrons":
+        try {
+          const { stopAllCronJobs } = await import("./cron-BQIWLGQY.js");
+          stopAllCronJobs();
+          console.log("All cron jobs stopped.");
+        } catch (error) {
+          console.error("Error stopping cron jobs:", error instanceof Error ? error.message : String(error));
+        }
+        break;
+      case "scheduled":
+        try {
+          const { listScheduledRuns } = await import("./run-at-KDJYTEOD.js");
+          const runs = listScheduledRuns();
+          if (runs.length === 0) {
+            console.log("No scheduled runs pending.");
+          } else {
+            console.log("\nScheduled Runs:");
+            for (const run of runs) {
+              const status = run.isRunning ? "(running)" : "";
+              console.log(`  - ${run.name}: ${run.scheduledTime.toLocaleString()} ${status}`);
+            }
+          }
+        } catch (error) {
+          console.error("Error listing scheduled runs:", error instanceof Error ? error.message : String(error));
+        }
+        break;
+      case "cancel":
+        if (args.length === 0) {
+          console.log("Usage: :cancel <run-name>");
+        } else {
+          try {
+            const { cancelScheduledRun } = await import("./run-at-KDJYTEOD.js");
+            const runName = args[0];
+            const cancelled = cancelScheduledRun(runName);
+            if (cancelled) {
+              console.log(`Cancelled scheduled run: ${runName}`);
+            } else {
+              console.log(`Scheduled run not found: ${runName}`);
+            }
+          } catch (error) {
+            console.error("Error cancelling run:", error instanceof Error ? error.message : String(error));
+          }
+        }
+        break;
+      case "cancelall":
+        try {
+          const { cancelAllScheduledRuns } = await import("./run-at-KDJYTEOD.js");
+          cancelAllScheduledRuns();
+          console.log("All scheduled runs cancelled.");
+        } catch (error) {
+          console.error("Error cancelling runs:", error instanceof Error ? error.message : String(error));
+        }
+        break;
       case "exit":
       case "quit":
         this.rl.close();
@@ -542,6 +684,7 @@ Examples:
   }
   /**
    * Execute a Unix shell command
+   * If command is not found, fallback to treating it as an AI query
    */
   async executeShellCommand(command) {
     const trimmed = command.trim();
@@ -558,14 +701,29 @@ Examples:
     }
     const { spawn } = await import("child_process");
     this.rl.pause();
-    return new Promise((resolve2) => {
+    return new Promise(async (resolve2) => {
       const shell = process.env.SHELL || "/bin/sh";
       const child = spawn(shell, ["-c", command], {
-        stdio: "inherit",
+        stdio: ["inherit", "inherit", "pipe"],
         cwd: process.cwd()
       });
-      child.on("close", () => {
+      let stderrData = "";
+      child.stderr?.on("data", (data) => {
+        stderrData += data.toString();
+        process.stderr.write(data);
+      });
+      child.on("close", async (code) => {
         this.rl.resume();
+        const commandNotFound = code === 127 || stderrData.includes("command not found");
+        if (commandNotFound) {
+          console.log(`\u{1F4A1} Command not found, trying as AI query...`);
+          if (this.config.debug) {
+            console.log(`[executing: |ai>${trimmed}]`);
+          }
+          const aiInput = `|ai>${trimmed}`;
+          this.inputBuffer = [aiInput];
+          await this.executeBuffer();
+        }
         resolve2();
       });
       child.on("error", (err) => {
@@ -599,9 +757,14 @@ Examples:
       }
       console.log(`Loading init script: ${scriptPath}`);
       const scriptContent = fs.readFileSync(resolvedPath, "utf-8");
-      const xml = this.braketParser.parse(scriptContent);
-      const ast = this.xmlParser.parse(xml);
-      await integrate(this.session, ast);
+      if (this.client) {
+        const xml = this.braketParser.parse(scriptContent);
+        await this.client.execute(xml);
+      } else {
+        const xml = this.braketParser.parse(scriptContent);
+        const ast = this.xmlParser.parse(xml);
+        await integrate(this.session, ast);
+      }
       console.log(`Init script loaded.
 `);
     } catch (err) {

package/dist/test-runner.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dirac-lang",
-  "version": "0.1.59",
+  "version": "0.1.61",
   "description": "LLM-Augmented Declarative Execution",
   "type": "module",
   "main": "dist/index.js",
@@ -30,16 +30,19 @@
   "license": "MIT",
   "dependencies": {
     "@anthropic-ai/sdk": "^0.30.1",
+    "dirac-lang": "^0.1.59",
     "dirac-stdlib": "^0.1.0",
     "dotenv": "^17.2.3",
     "fast-xml-parser": "^4.3.5",
     "js-yaml": "^4.1.1",
     "mongodb": "^7.0.0",
+    "node-cron": "^4.2.1",
     "openai": "^6.16.0"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.11.0",
+    "@types/node-cron": "^3.0.11",
     "tsup": "^8.0.1",
     "tsx": "^4.7.0",
     "typescript": "^5.3.3",