@wrongstack/plugins 0.1.0

package/dist/cron.js

@@ -0,0 +1,223 @@
+// src/cron/index.ts
+var API_VERSION = "^0.1.10";
+function formatNextRun(intervalMs) {
+  const ms = isNaN(intervalMs) || intervalMs <= 0 ? 6e4 : intervalMs;
+  return new Date(Date.now() + ms).toISOString();
+}
+var plugin = {
+  name: "cron",
+  version: "0.1.0",
+  description: "Schedules recurring tasks using beforeIteration/afterIteration extension hooks",
+  apiVersion: API_VERSION,
+  capabilities: { tools: true },
+  defaultConfig: {
+    maxConcurrentJobs: 5,
+    timezone: "UTC",
+    persistSchedules: false
+  },
+  configSchema: {
+    type: "object",
+    properties: {
+      maxConcurrentJobs: { type: "number", default: 5 },
+      timezone: { type: "string", default: "UTC" },
+      persistSchedules: { type: "boolean", default: false }
+    }
+  },
+  setup(api) {
+    const state = {
+      jobs: /* @__PURE__ */ new Map(),
+      timers: /* @__PURE__ */ new Map(),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const maxConcurrent = api.config.extensions?.["cron"]?.["maxConcurrentJobs"] ?? 5;
+    function scheduleNextRun(name) {
+      const job = state.jobs.get(name);
+      if (!job || !job.enabled) return;
+      const existing = state.timers.get(name);
+      if (existing) clearTimeout(existing);
+      const delay = Math.max(0, new Date(job.nextRun).getTime() - Date.now());
+      const timer = setTimeout(() => {
+        job.runCount++;
+        job.lastRun = (/* @__PURE__ */ new Date()).toISOString();
+        job.nextRun = formatNextRun(job.intervalMs);
+        api.emitCustom("cron:job_fired", {
+          name,
+          action: job.action,
+          runCount: job.runCount,
+          ts: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        api.metrics.counter("cron_job_fired", 1, { job: name });
+        api.metrics.histogram("cron_job_interval_ms", job.intervalMs, { job: name });
+        scheduleNextRun(name);
+      }, delay);
+      state.timers.set(name, timer);
+    }
+    function cancelJob(name) {
+      const timer = state.timers.get(name);
+      if (timer) {
+        clearTimeout(timer);
+        state.timers.delete(name);
+      }
+      state.jobs.delete(name);
+    }
+    api.extensions.register({
+      name: "cron-iteration-hooks",
+      owner: "cron",
+      beforeIteration: async (_ctx, _idx) => {
+        const now = Date.now();
+        let activeJobs = 0;
+        const promises = [];
+        for (const [name, job] of state.jobs) {
+          if (!job.enabled) continue;
+          if (activeJobs >= maxConcurrent) break;
+          if (new Date(job.nextRun).getTime() <= now) {
+            activeJobs++;
+            promises.push(
+              (async () => {
+                await api.session.append({
+                  type: "cron:scheduled_trigger",
+                  ts: (/* @__PURE__ */ new Date()).toISOString(),
+                  jobName: name,
+                  action: job.action,
+                  runCount: job.runCount + 1
+                });
+                api.emitCustom("cron:job_due", {
+                  name,
+                  action: job.action,
+                  dueAt: (/* @__PURE__ */ new Date()).toISOString()
+                });
+              })()
+            );
+          }
+        }
+        await Promise.all(promises);
+      },
+      afterIteration: async (_ctx, _idx) => {
+        for (const job of state.jobs.values()) {
+          if (!job.enabled) continue;
+          if (new Date(job.nextRun).getTime() <= Date.now()) {
+            job.nextRun = formatNextRun(job.intervalMs);
+          }
+        }
+      }
+    });
+    api.tools.register({
+      name: "cron_schedule",
+      description: "Schedule a recurring action to fire at a fixed interval (in milliseconds). The action is emitted as a custom event for downstream handlers.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: "Unique name for this cron job" },
+          intervalMs: { type: "number", description: "Interval between runs in milliseconds (minimum 1000)" },
+          action: { type: "string", description: "Action identifier or description of what to run" },
+          enabled: { type: "boolean", default: true }
+        },
+        required: ["name", "intervalMs", "action"]
+      },
+      permission: "confirm",
+      mutating: false,
+      async execute(input) {
+        const name = input["name"];
+        const intervalMs = Math.max(1e3, Number(input["intervalMs"]));
+        const action = input["action"];
+        const enabled = input["enabled"] ?? true;
+        if (!name || typeof name !== "string" || name.trim() === "") {
+          return { ok: false, error: "name is required and must be a non-empty string" };
+        }
+        if (isNaN(intervalMs)) {
+          return { ok: false, error: "intervalMs must be a number >= 1000" };
+        }
+        if (state.jobs.has(name)) {
+          return { ok: false, error: `Cron job '${name}' already exists. Use cron_cancel first.` };
+        }
+        if (state.jobs.size >= maxConcurrent) {
+          return { ok: false, error: `Maximum concurrent jobs (${maxConcurrent}) reached.` };
+        }
+        const job = {
+          name,
+          intervalMs,
+          action,
+          enabled,
+          lastRun: null,
+          nextRun: formatNextRun(intervalMs),
+          runCount: 0
+        };
+        state.jobs.set(name, job);
+        scheduleNextRun(name);
+        api.metrics.gauge("cron_active_jobs", state.jobs.size);
+        return {
+          ok: true,
+          name,
+          intervalMs,
+          nextRun: job.nextRun,
+          message: `Scheduled '${name}' every ${intervalMs}ms.`
+        };
+      }
+    });
+    api.tools.register({
+      name: "cron_list",
+      description: "List all registered cron jobs with their intervals, next run times, and execution counts.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      mutating: false,
+      async execute() {
+        const jobs = Array.from(state.jobs.values()).map((j) => ({
+          name: j.name,
+          intervalMs: j.intervalMs,
+          action: j.action,
+          enabled: j.enabled,
+          lastRun: j.lastRun,
+          nextRun: j.nextRun,
+          runCount: j.runCount,
+          overdue: new Date(j.nextRun).getTime() < Date.now()
+        }));
+        return {
+          ok: true,
+          count: jobs.length,
+          maxConcurrent,
+          jobs
+        };
+      }
+    });
+    api.tools.register({
+      name: "cron_cancel",
+      description: "Cancel and remove a cron job by name.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          name: { type: "string", description: "Name of the cron job to cancel" }
+        },
+        required: ["name"]
+      },
+      permission: "auto",
+      mutating: false,
+      async execute(input) {
+        const name = input["name"];
+        if (!state.jobs.has(name)) {
+          return { ok: false, error: `No cron job named '${name}'` };
+        }
+        cancelJob(name);
+        api.metrics.gauge("cron_active_jobs", state.jobs.size);
+        return {
+          ok: true,
+          name,
+          message: `Cancelled cron job '${name}'.`
+        };
+      }
+    });
+    api.log.info("cron plugin loaded", { version: "0.1.0", maxConcurrent });
+  },
+  teardown(api) {
+    const { jobs, timers } = api._state ?? { jobs: /* @__PURE__ */ new Map(), timers: /* @__PURE__ */ new Map() };
+    for (const name of jobs.keys()) {
+      const timer = timers.get(name);
+      if (timer) clearTimeout(timer);
+    }
+    jobs.clear();
+    timers.clear();
+    api.log.info("cron plugin unloaded");
+  }
+};
+var cron_default = plugin;
+
+export { cron_default as default };

package/dist/file-watcher.d.ts

@@ -0,0 +1,14 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * file-watcher plugin — Watches project files and triggers actions on changes.
+ *
+ * Tools registered:
+ * - watch_start: Start watching paths for file changes
+ * - watch_stop: Stop a watch by ID
+ * - watch_list: List all active watches
+ */
+
+declare const plugin: Plugin;
+
+export { plugin as default };

package/dist/file-watcher.js

@@ -0,0 +1,192 @@
+import { watch } from 'fs';
+
+// src/file-watcher/index.ts
+var API_VERSION = "^0.1.10";
+var watchIdCounter = 0;
+function nextId() {
+  return `watch_${++watchIdCounter}_${Date.now().toString(36)}`;
+}
+var plugin = {
+  name: "file-watcher",
+  version: "0.1.0",
+  description: "Watches project files and emits events when changes occur (add, change, delete)",
+  apiVersion: API_VERSION,
+  capabilities: { tools: true },
+  defaultConfig: {
+    debounceMs: 500,
+    watchOnStartup: [],
+    autoUnwatchOnExit: true
+  },
+  configSchema: {
+    type: "object",
+    properties: {
+      debounceMs: { type: "number", default: 500 },
+      watchOnStartup: { type: "array", items: { type: "string" }, default: [] },
+      autoUnwatchOnExit: { type: "boolean", default: true }
+    }
+  },
+  setup(api) {
+    const watches = /* @__PURE__ */ new Map();
+    let debounceMs = api.config.extensions?.["file-watcher"]?.["debounceMs"] ?? 500;
+    const debounceTimers = /* @__PURE__ */ new Map();
+    function debounceEvent(key, fn, ms) {
+      const existing = debounceTimers.get(key);
+      if (existing) clearTimeout(existing);
+      debounceTimers.set(key, setTimeout(() => {
+        debounceTimers.delete(key);
+        fn();
+      }, ms));
+    }
+    function safeWatchDir(dirPath, recursive, handle) {
+      try {
+        const watcher = watch(dirPath, { recursive }, (eventType, filename) => {
+          if (!filename) return;
+          const fullPath = `${dirPath}/${filename}`;
+          const key = `${handle.id}:${fullPath}:${eventType}`;
+          debounceEvent(key, () => {
+            api.emitCustom("file-watcher:changed", {
+              watchId: handle.id,
+              path: fullPath,
+              event: eventType,
+              filename,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+            api.metrics.counter("file_change", 1, { event: eventType ?? "unknown" });
+            api.log.debug(`file-watcher: ${eventType} ${fullPath} (watch=${handle.id})`);
+          }, debounceMs);
+        });
+        watcher.on("error", (err) => {
+          api.log.warn(`file-watcher: error on ${dirPath}: ${err}`);
+        });
+        handle.watcher = watcher;
+      } catch (err) {
+        api.log.warn(`file-watcher: could not watch ${dirPath}: ${err}`);
+      }
+    }
+    api.tools.register({
+      name: "watch_start",
+      description: "Start watching one or more file paths for changes (add, change, delete). Returns a watch ID for stopping the watch later.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          paths: {
+            type: "array",
+            items: { type: "string" },
+            description: "File or directory paths to watch"
+          },
+          events: {
+            type: "array",
+            items: { type: "string" },
+            default: ["change", "add", "delete"],
+            description: "Event types to watch for"
+          },
+          recursive: {
+            type: "boolean",
+            default: true,
+            description: "Watch directories recursively"
+          }
+        },
+        required: ["paths"]
+      },
+      permission: "confirm",
+      mutating: false,
+      async execute(input) {
+        const rawPaths = input["paths"];
+        if (!rawPaths || typeof rawPaths !== "object" || !Array.isArray(rawPaths)) {
+          return { ok: false, error: "paths must be an array of file/directory paths", watchId: null };
+        }
+        const paths = rawPaths;
+        if (paths.length === 0) {
+          return { ok: false, error: "paths array is empty \u2014 provide at least one path", watchId: null };
+        }
+        const events = input["events"] ?? ["change", "add", "delete"];
+        const recursive = input["recursive"] ?? true;
+        const id = nextId();
+        const handle = {
+          id,
+          paths,
+          recursive,
+          events,
+          watcher: { close: () => {
+          } },
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        for (const p of paths) {
+          safeWatchDir(p, recursive, handle);
+        }
+        watches.set(id, handle);
+        api.metrics.gauge("active_watches", watches.size);
+        return {
+          ok: true,
+          watchId: id,
+          paths,
+          events,
+          recursive,
+          message: `Started watching ${paths.length} path(s). Use watch_stop to cancel.`
+        };
+      }
+    });
+    api.tools.register({
+      name: "watch_stop",
+      description: "Stop a file watch by its ID. Releases all resources.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          watchId: { type: "string", description: "Watch ID returned by watch_start" }
+        },
+        required: ["watchId"]
+      },
+      permission: "auto",
+      mutating: false,
+      async execute(input) {
+        const watchId = input["watchId"];
+        const handle = watches.get(watchId);
+        if (!handle) {
+          return { ok: false, error: `No active watch with ID: ${watchId}` };
+        }
+        try {
+          handle.watcher.close();
+        } catch {
+        }
+        watches.delete(watchId);
+        api.metrics.gauge("active_watches", watches.size);
+        return {
+          ok: true,
+          watchId,
+          message: `Stopped watch ${watchId}. ${watches.size} watch(es) remaining.`
+        };
+      }
+    });
+    api.tools.register({
+      name: "watch_list",
+      description: "List all currently active file watches with their IDs, paths, and creation times.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      mutating: false,
+      async execute() {
+        const list = Array.from(watches.values()).map((w) => ({
+          id: w.id,
+          paths: w.paths,
+          events: w.events,
+          recursive: w.recursive,
+          createdAt: w.createdAt,
+          age: `${Date.now() - new Date(w.createdAt).getTime()}ms`
+        }));
+        return {
+          ok: true,
+          count: list.length,
+          watches: list
+        };
+      }
+    });
+    api.log.info("file-watcher plugin loaded", { version: "0.1.0" });
+  },
+  teardown(api) {
+    {
+      api.log.info("file-watcher: teardown complete");
+    }
+  }
+};
+var file_watcher_default = plugin;
+
+export { file_watcher_default as default };

package/dist/git-autocommit.d.ts

@@ -0,0 +1,14 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * git-autocommit plugin — AI-powered git staging and commit message generation.
+ *
+ * Tools registered:
+ * - git_autocommit: Generate and create a commit with AI-written messages
+ * - git_stage: Stage specific files for commit
+ * - git_status_summary: Show a summary of current git status
+ */
+
+declare const plugin: Plugin;
+
+export { plugin as default };