augure 0.7.1 → 0.9.0

package/dist/chunk-3BGYMW62.js

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+import {
+  noopLogger
+} from "./chunk-62OPINAX.js";
+
+// ../scheduler/dist/cron.js
+import { createTask, validate } from "node-cron";
+var CronScheduler = class {
+  jobs = /* @__PURE__ */ new Map();
+  tasks = /* @__PURE__ */ new Map();
+  timers = /* @__PURE__ */ new Map();
+  handlers = [];
+  persistChain = Promise.resolve();
+  running = false;
+  store;
+  log;
+  constructor(storeOrOpts) {
+    if (storeOrOpts && "save" in storeOrOpts) {
+      this.store = storeOrOpts;
+      this.log = noopLogger;
+    } else if (storeOrOpts) {
+      const opts = storeOrOpts;
+      this.store = opts.store;
+      this.log = opts.logger ?? noopLogger;
+    } else {
+      this.log = noopLogger;
+    }
+  }
+  onJobTrigger(handler) {
+    this.handlers.push(handler);
+  }
+  addJob(job) {
+    if (!job.cron && !job.runAt) {
+      throw new Error(`Job ${job.id} must have either cron or runAt`);
+    }
+    if (job.cron && !validate(job.cron)) {
+      throw new Error(`Invalid cron expression: ${job.cron}`);
+    }
+    if (job.runAt && isNaN(Date.parse(job.runAt))) {
+      throw new Error(`Invalid runAt date: ${job.runAt}`);
+    }
+    this.jobs.set(job.id, job);
+    this.log.info(`Added job ${job.id} (${job.cron ? `cron: ${job.cron}` : `runAt: ${job.runAt}`})`);
+    if (job.enabled && job.cron) {
+      const task = createTask(job.cron, () => {
+        this.log.info(`Cron fired for job ${job.id}`);
+        this.executeHandlers(job).catch((err) => this.log.error(`Cron job ${job.id} handler failed:`, err));
+      });
+      if (this.running) {
+        task.start();
+        this.log.debug(`Started cron task for ${job.id} immediately (scheduler already running)`);
+      }
+      this.tasks.set(job.id, task);
+    }
+    if (job.enabled && job.runAt && !job.cron) {
+      if (this.running) {
+        this.scheduleOneShot(job);
+      } else {
+        this.log.warn(`Scheduler not running \u2014 one-shot job ${job.id} will be scheduled on start()`);
+      }
+    }
+    this.persist();
+  }
+  removeJob(id) {
+    const task = this.tasks.get(id);
+    if (task) {
+      task.stop();
+      this.tasks.delete(id);
+    }
+    const timer = this.timers.get(id);
+    if (timer) {
+      clearTimeout(timer);
+      this.timers.delete(id);
+    }
+    this.jobs.delete(id);
+    this.log.debug(`Removed job ${id}`);
+    this.persist();
+  }
+  listJobs() {
+    return Array.from(this.jobs.values());
+  }
+  async triggerJob(id) {
+    const job = this.jobs.get(id);
+    if (!job) {
+      throw new Error(`Job not found: ${id}`);
+    }
+    await this.executeHandlers(job);
+  }
+  async loadPersistedJobs() {
+    if (!this.store)
+      return;
+    const jobs = await this.store.load();
+    this.log.info(`Loading ${jobs.length} persisted jobs`);
+    for (const job of jobs) {
+      if (job.runAt && Date.parse(job.runAt) <= Date.now()) {
+        this.log.debug(`Skipping expired one-shot job ${job.id} (runAt: ${job.runAt})`);
+        continue;
+      }
+      this.addJob(job);
+    }
+  }
+  start() {
+    this.running = true;
+    this.log.info(`Starting with ${this.tasks.size} cron tasks and ${this.handlers.length} handlers`);
+    for (const [id, task] of this.tasks) {
+      task.start();
+      this.log.debug(`Started cron task: ${id}`);
+    }
+    for (const job of this.jobs.values()) {
+      if (job.enabled && job.runAt && !job.cron) {
+        this.scheduleOneShot(job);
+      }
+    }
+  }
+  stop() {
+    this.log.info("Scheduler stopped");
+    this.running = false;
+    for (const task of this.tasks.values()) {
+      task.stop();
+    }
+    for (const timer of this.timers.values()) {
+      clearTimeout(timer);
+    }
+    this.timers.clear();
+  }
+  scheduleOneShot(job) {
+    const delayMs = Date.parse(job.runAt) - Date.now();
+    if (delayMs <= 0) {
+      this.log.warn(`One-shot job ${job.id} already expired (delay: ${delayMs}ms), skipping`);
+      return;
+    }
+    this.log.info(`Scheduled one-shot job ${job.id} in ${Math.round(delayMs / 1e3)}s (${job.runAt})`);
+    const timer = setTimeout(() => {
+      this.log.info(`One-shot job ${job.id} firing now`);
+      this.timers.delete(job.id);
+      this.executeHandlers(job).then(() => this.removeJob(job.id)).catch((err) => this.log.error(`One-shot job ${job.id} handler failed:`, err));
+    }, delayMs);
+    this.timers.set(job.id, timer);
+  }
+  persist() {
+    if (!this.store)
+      return;
+    const jobs = this.listJobs();
+    this.persistChain = this.persistChain.then(() => this.store.save(jobs));
+  }
+  async executeHandlers(job) {
+    this.log.debug(`Executing ${this.handlers.length} handlers for job ${job.id}`);
+    for (const handler of this.handlers) {
+      await handler(job);
+    }
+  }
+};
+
+// ../scheduler/dist/jobs.js
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { dirname } from "path";
+var JobStore = class {
+  filePath;
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  async load() {
+    try {
+      const raw = await readFile(this.filePath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return [];
+    }
+  }
+  async save(jobs) {
+    await mkdir(dirname(this.filePath), { recursive: true });
+    await writeFile(this.filePath, JSON.stringify(jobs, null, 2), "utf-8");
+  }
+};
+
+// ../scheduler/dist/heartbeat.js
+var HEARTBEAT_PROMPT = `You are a monitoring agent. Your job is to review the user's memory and decide if any proactive action is needed right now.
+
+Review the memory context below and determine:
+1. Are there any time-sensitive tasks or reminders?
+2. Should the user be notified about something?
+3. Are there any scheduled checks that need to run?
+
+If action is needed, respond with:
+ACTION: <description of what to do>
+
+If no action is needed, respond with:
+ACTION: none
+
+Be concise. Only suggest actions that are clearly needed based on the memory context.`;
+var Heartbeat = class {
+  config;
+  timer;
+  log;
+  constructor(config) {
+    this.config = config;
+    this.log = config.logger ?? noopLogger;
+  }
+  async tick() {
+    this.log.debug("Heartbeat tick");
+    const memoryContent = await this.loadMemory();
+    const messages = [
+      { role: "system", content: HEARTBEAT_PROMPT },
+      {
+        role: "user",
+        content: `Current time: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+## Memory
+${memoryContent}`
+      }
+    ];
+    const response = await this.config.llm.chat(messages);
+    const action = this.parseAction(response.content);
+    if (action && action.toLowerCase() !== "none") {
+      this.log.debug(`Heartbeat action: ${action}`);
+      await this.config.onAction(action);
+    } else {
+      this.log.debug("Heartbeat: no action needed");
+    }
+  }
+  start() {
+    this.timer = setInterval(() => {
+      this.tick().catch((err) => this.log.error("Heartbeat error:", err));
+    }, this.config.intervalMs);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+    }
+  }
+  parseAction(content) {
+    const match = content.match(/ACTION:\s*(.+)/i);
+    return match?.[1]?.trim();
+  }
+  async loadMemory() {
+    try {
+      const exists = await this.config.memory.exists("observations.md");
+      if (exists) {
+        return this.config.memory.read("observations.md");
+      }
+    } catch {
+    }
+    return "(no memory available)";
+  }
+};
+
+// ../scheduler/dist/interval.js
+var UNITS = {
+  s: 1e3,
+  m: 6e4,
+  h: 36e5
+};
+function parseInterval(input) {
+  const match = input.match(/^(\d+)([smh])$/);
+  if (!match) {
+    throw new Error(`Invalid interval format: "${input}". Expected: <number><s|m|h> (e.g. "30m")`);
+  }
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+  if (value <= 0) {
+    throw new Error(`Interval must be positive, got: ${value}`);
+  }
+  return value * UNITS[unit];
+}
+
+export {
+  CronScheduler,
+  JobStore,
+  Heartbeat,
+  parseInterval
+};

package/dist/chunk-62OPINAX.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+
+// ../types/dist/logger.js
+var noop = () => {
+};
+var noopLogger = {
+  debug: noop,
+  info: noop,
+  warn: noop,
+  error: noop,
+  child: () => noopLogger
+};
+
+export {
+  noopLogger
+};