@wrongstack/plugins 0.277.2 → 0.280.1

package/dist/todo-tracker.js

@@ -0,0 +1,441 @@
+import * as fsp from 'fs/promises';
+import { randomUUID } from 'crypto';
+
+// src/todo-tracker/index.ts
+function deriveFilePath(api) {
+  const raw = api.config.extensions?.["todo-tracker"];
+  const explicit = typeof raw?.["filePath"] === "string" ? raw["filePath"] : null;
+  if (explicit) {
+    const base = explicit.replace(/[\\/]+$/, "").split(/[\\/]/).pop() ?? "tracker";
+    return { filePath: explicit, projectSlug: base };
+  }
+  return { filePath: null, projectSlug: null };
+}
+var FILE_VERSION = 1;
+async function loadFile(filePath) {
+  let raw;
+  try {
+    raw = await fsp.readFile(filePath, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== FILE_VERSION || !Array.isArray(parsed.items)) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function saveFile(filePath, file) {
+  const tmp = `${filePath}.${randomUUID().slice(0, 8)}.tmp`;
+  await fsp.mkdir(filePath.replace(/[/\\][^/\\]+$/, ""), { recursive: true });
+  await fsp.writeFile(tmp, JSON.stringify(file, null, 2), { encoding: "utf8", mode: 384 });
+  await fsp.rename(tmp, filePath);
+}
+var state = {
+  filePath: null,
+  projectSlug: null,
+  file: null,
+  addCount: 0,
+  completeCount: 0,
+  dropCount: 0,
+  removeCount: 0,
+  pullCount: 0,
+  /** Most recent mutation for /diag plugins visibility. */
+  lastMutation: null
+};
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function ensureFile() {
+  if (!state.file) {
+    state.file = {
+      version: FILE_VERSION,
+      projectSlug: state.projectSlug ?? "unconfigured",
+      updatedAt: nowIso(),
+      items: []
+    };
+  }
+  return state.file;
+}
+function recordMutation(op, itemId) {
+  state.lastMutation = { op, itemId, when: nowIso() };
+  if (op === "add") state.addCount += 1;
+  else if (op === "complete") state.completeCount += 1;
+  else if (op === "drop") state.dropCount += 1;
+  else if (op === "remove") state.removeCount += 1;
+  else if (op === "pull") state.pullCount += 1;
+}
+function findItemIndex(id) {
+  return ensureFile().items.findIndex((it) => it.id === id);
+}
+function notConfiguredError() {
+  return {
+    ok: false,
+    error: 'todo-tracker: no file path configured. Set `filePath` under `config.extensions["todo-tracker"]` or run inside a session where `paths.projectDir` is provided by the host (e.g. `wstack` CLI).'
+  };
+}
+var plugin = {
+  name: "todo-tracker",
+  version: "0.1.0",
+  description: "Persistent, project-scoped todo backlog that survives across sessions",
+  apiVersion: "^0.1.10",
+  capabilities: { tools: true },
+  defaultConfig: {
+    filePath: ""
+  },
+  configSchema: {
+    type: "object",
+    properties: {
+      filePath: {
+        type: "string",
+        description: "Override the auto-derived per-project path. Defaults to <projectDir>/todo-tracker.json when `paths.projectDir` is provided by the host."
+      }
+    }
+  },
+  async setup(api) {
+    state.addCount = 0;
+    state.completeCount = 0;
+    state.dropCount = 0;
+    state.removeCount = 0;
+    state.pullCount = 0;
+    state.lastMutation = null;
+    state.file = null;
+    const derived = deriveFilePath(api);
+    if (derived.filePath === null) {
+      api.log.warn(
+        'todo-tracker: no file path configured (set `config.extensions["todo-tracker"].filePath` or wire `paths.projectDir` through PluginAPI) \u2014 tools will report a clear error'
+      );
+      return;
+    }
+    state.filePath = derived.filePath;
+    state.projectSlug = derived.projectSlug;
+    state.file = await loadFile(state.filePath);
+    if (state.file === null) {
+      state.file = {
+        version: FILE_VERSION,
+        projectSlug: state.projectSlug ?? "tracker",
+        updatedAt: nowIso(),
+        items: []
+      };
+    }
+    api.tools.register({
+      name: "todo_tracker_list",
+      description: "List persistent todo-tracker items. Filterable by status, priority, and tag. By default only pending + in_progress items are shown.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          status: {
+            type: "string",
+            enum: ["pending", "in_progress", "completed", "dropped", "all"],
+            description: "Filter by status. 'all' returns every item; default is pending+in_progress."
+          },
+          priority: { type: "string", enum: ["low", "normal", "high"] },
+          tag: { type: "string", description: "Filter by exact tag match" },
+          limit: { type: "number", description: "Max items to return (default 50, max 200)" }
+        }
+      },
+      permission: "auto",
+      mutating: false,
+      async execute(input) {
+        if (state.filePath === null) return notConfiguredError();
+        const status = input["status"] ?? "active";
+        const priority = input["priority"];
+        const tag = input["tag"];
+        const limit = Math.min(Math.max(Number(input["limit"] ?? 50) || 50, 1), 200);
+        const file = ensureFile();
+        let items = file.items;
+        if (status !== "all") {
+          if (status === "active") {
+            items = items.filter((it) => it.status === "pending" || it.status === "in_progress");
+          } else {
+            items = items.filter((it) => it.status === status);
+          }
+        }
+        if (priority) items = items.filter((it) => it.priority === priority);
+        if (tag) items = items.filter((it) => it.tags.includes(tag));
+        const total = items.length;
+        const truncated = items.slice(0, limit);
+        return {
+          ok: true,
+          total,
+          returned: truncated.length,
+          truncated: total > truncated.length,
+          items: truncated
+        };
+      }
+    });
+    api.tools.register({
+      name: "todo_tracker_add",
+      description: "Append a new item to the persistent todo-tracker backlog.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          content: { type: "string", description: "What needs doing (required)" },
+          priority: { type: "string", enum: ["low", "normal", "high"], default: "normal" },
+          tags: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional tags for filtering"
+          },
+          sourceSessionId: { type: "string", description: "Session that created this item" },
+          notes: { type: "string", description: "Optional free-form notes" }
+        },
+        required: ["content"]
+      },
+      permission: "auto",
+      mutating: true,
+      async execute(input) {
+        if (state.filePath === null) return notConfiguredError();
+        const content = typeof input["content"] === "string" ? input["content"].trim() : "";
+        if (!content) {
+          return { ok: false, error: "content is required and must be a non-empty string" };
+        }
+        const priority = input["priority"] === "low" || input["priority"] === "high" ? input["priority"] : "normal";
+        const tags = Array.isArray(input["tags"]) ? input["tags"].filter((t) => typeof t === "string") : [];
+        const sourceSessionId = typeof input["sourceSessionId"] === "string" ? input["sourceSessionId"] : null;
+        const notes = typeof input["notes"] === "string" ? input["notes"] : null;
+        const now = nowIso();
+        const item = {
+          id: randomUUID(),
+          content,
+          status: "pending",
+          priority,
+          tags,
+          createdAt: now,
+          updatedAt: now,
+          completedAt: null,
+          sourceSessionId,
+          notes
+        };
+        const file = ensureFile();
+        file.items.push(item);
+        file.updatedAt = now;
+        await saveFile(state.filePath, file);
+        recordMutation("add", item.id);
+        api.log.info("todo-tracker: added item", { id: item.id, content });
+        try {
+          await api.session.append({
+            type: "todo-tracker:add",
+            ts: now,
+            id: item.id,
+            content,
+            priority,
+            tags
+          });
+        } catch {
+        }
+        return { ok: true, item };
+      }
+    });
+    api.tools.register({
+      name: "todo_tracker_complete",
+      description: "Mark a tracked item as completed. Idempotent.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Item id" }
+        },
+        required: ["id"]
+      },
+      permission: "auto",
+      mutating: true,
+      async execute(input) {
+        if (state.filePath === null) return notConfiguredError();
+        const id = typeof input["id"] === "string" ? input["id"] : "";
+        if (!id) return { ok: false, error: "id is required" };
+        const idx = findItemIndex(id);
+        if (idx === -1) return { ok: false, error: `no item with id ${id}` };
+        const file = ensureFile();
+        const item = file.items[idx];
+        if (item.status === "completed") {
+          return { ok: true, item, message: "already completed (idempotent)" };
+        }
+        const now = nowIso();
+        item.status = "completed";
+        item.updatedAt = now;
+        item.completedAt = now;
+        file.updatedAt = now;
+        await saveFile(state.filePath, file);
+        recordMutation("complete", id);
+        api.log.info("todo-tracker: completed item", { id });
+        return { ok: true, item };
+      }
+    });
+    api.tools.register({
+      name: "todo_tracker_drop",
+      description: "Mark a tracked item as dropped (skipped/obsolete). The row is kept for audit. Idempotent.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Item id" }
+        },
+        required: ["id"]
+      },
+      permission: "auto",
+      mutating: true,
+      async execute(input) {
+        if (state.filePath === null) return notConfiguredError();
+        const id = typeof input["id"] === "string" ? input["id"] : "";
+        if (!id) return { ok: false, error: "id is required" };
+        const idx = findItemIndex(id);
+        if (idx === -1) return { ok: false, error: `no item with id ${id}` };
+        const file = ensureFile();
+        const item = file.items[idx];
+        if (item.status === "dropped") {
+          return { ok: true, item, message: "already dropped (idempotent)" };
+        }
+        const now = nowIso();
+        item.status = "dropped";
+        item.updatedAt = now;
+        item.completedAt = now;
+        file.updatedAt = now;
+        await saveFile(state.filePath, file);
+        recordMutation("drop", id);
+        return { ok: true, item };
+      }
+    });
+    api.tools.register({
+      name: "todo_tracker_remove",
+      description: "Permanently delete a tracked item by id. Use todo_tracker_drop instead if you want to keep the audit row.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Item id" }
+        },
+        required: ["id"]
+      },
+      permission: "confirm",
+      mutating: true,
+      async execute(input) {
+        if (state.filePath === null) return notConfiguredError();
+        const id = typeof input["id"] === "string" ? input["id"] : "";
+        if (!id) return { ok: false, error: "id is required" };
+        const idx = findItemIndex(id);
+        if (idx === -1) return { ok: false, error: `no item with id ${id}` };
+        const file = ensureFile();
+        const [removed] = file.items.splice(idx, 1);
+        file.updatedAt = nowIso();
+        await saveFile(state.filePath, file);
+        recordMutation("remove", id);
+        return { ok: true, removed };
+      }
+    });
+    api.tools.register({
+      name: "todo_tracker_pull",
+      description: "Return all pending + in_progress items. The LLM is expected to take this list and re-register each entry with the session-local `todo` tool (which mutates ctx.todos). After pull, the LLM may also choose to call todo_tracker_complete on items it finishes mid-session.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          limit: { type: "number", description: "Max items to return (default 50, max 200)" }
+        }
+      },
+      permission: "auto",
+      mutating: false,
+      async execute(input) {
+        if (state.filePath === null) return notConfiguredError();
+        const limit = Math.min(Math.max(Number(input["limit"] ?? 50) || 50, 1), 200);
+        const file = ensureFile();
+        const items = file.items.filter((it) => it.status === "pending" || it.status === "in_progress").slice(0, limit);
+        if (items.length > 0) {
+          recordMutation("pull", items[0].id);
+        }
+        return {
+          ok: true,
+          total: items.length,
+          items,
+          hint: "These are persistent items. To work on them this session, register each one with the built-in `todo` tool. Mark them `completed` via todo_tracker_complete when done."
+        };
+      }
+    });
+    api.tools.register({
+      name: "todo_tracker_status",
+      description: "Report todo-tracker counters (per-status totals) + the file path + last update timestamp.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      mutating: false,
+      async execute() {
+        if (state.filePath === null) return notConfiguredError();
+        const file = ensureFile();
+        const byStatus = {
+          pending: 0,
+          in_progress: 0,
+          completed: 0,
+          dropped: 0
+        };
+        for (const it of file.items) byStatus[it.status] += 1;
+        return {
+          ok: true,
+          filePath: state.filePath,
+          projectSlug: state.projectSlug,
+          updatedAt: file.updatedAt,
+          counters: byStatus,
+          total: file.items.length,
+          session: {
+            add: state.addCount,
+            complete: state.completeCount,
+            drop: state.dropCount,
+            remove: state.removeCount,
+            pull: state.pullCount
+          },
+          lastMutation: state.lastMutation
+        };
+      }
+    });
+    api.log.info("todo-tracker plugin loaded", {
+      filePath: state.filePath,
+      projectSlug: state.projectSlug,
+      initialItemCount: state.file.items.length
+    });
+  },
+  teardown(api) {
+    const finalCounts = {
+      add: state.addCount,
+      complete: state.completeCount,
+      drop: state.dropCount,
+      remove: state.removeCount,
+      pull: state.pullCount
+    };
+    state.addCount = 0;
+    state.completeCount = 0;
+    state.dropCount = 0;
+    state.removeCount = 0;
+    state.pullCount = 0;
+    state.lastMutation = null;
+    state.file = null;
+    state.filePath = null;
+    state.projectSlug = null;
+    api.log.info("todo-tracker: teardown complete", { sessionCounts: finalCounts });
+  },
+  async health() {
+    if (state.filePath === null) {
+      return {
+        ok: false,
+        message: "todo-tracker: no file path configured \u2014 tools will error"
+      };
+    }
+    const file = ensureFile();
+    return {
+      ok: true,
+      message: `todo-tracker: ${file.items.length} item(s) at ${state.filePath}`,
+      filePath: state.filePath,
+      projectSlug: state.projectSlug,
+      total: file.items.length,
+      sessionCounts: {
+        add: state.addCount,
+        complete: state.completeCount,
+        drop: state.dropCount,
+        remove: state.removeCount,
+        pull: state.pullCount
+      },
+      lastMutation: state.lastMutation
+    };
+  }
+};
+var todo_tracker_default = plugin;
+
+export { todo_tracker_default as default };

package/dist/token-budget.d.ts

@@ -0,0 +1,40 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * token-budget plugin — Enforces a per-session token budget.
+ *
+ * Complements cost-tracker (which tracks but does not enforce).
+ * When token usage crosses the warning threshold, injects a "wrap up"
+ * signal into the LLM's context. When it crosses the hard limit,
+ * triggers a Stop hook to end the agent loop.
+ *
+ * Tools registered:
+ * - token_budget_status : Show budget limit, current usage, percent
+ *                          consumed, and whether the warning/stop
+ *                          threshold has been crossed.
+ *
+ * Hooks registered:
+ * - Stop : checks whether the budget is exhausted; if so, returns
+ *          `decision: 'block'` with a reason so the agent loop does
+ *          not continue.
+ *
+ * Events subscribed:
+ * - provider.response : accumulates prompt + completion tokens.
+ *
+ * Config surface (`config.extensions['token-budget']`):
+ *
+ * ```jsonc
+ * {
+ *   "limit": 500000,       // hard token limit (prompt + completion)
+ *   "warnPercent": 80,     // inject "wrap up" at this % of limit
+ *   "stopPercent": 100,    // trigger Stop at this % of limit
+ *   "model": null          // null = all models; or restrict to one
+ * }
+ * ```
+ *
+ * @public
+ */
+
+declare const plugin: Plugin;
+
+export { plugin as default };