@wrongstack/plugins 0.277.1 → 0.280.0

package/dist/config-validator.js

@@ -0,0 +1,347 @@
+import { statSync, readFileSync } from 'fs';
+
+// src/config-validator/index.ts
+var state = {
+  invocations: 0,
+  filesChecked: 0,
+  problemsFound: 0,
+  lastProblem: null,
+  hookUnregister: null
+};
+var DEFAULT_EXTENSIONS = [".json", ".jsonc", ".yaml", ".yml", ".toml"];
+var DEFAULTS = {
+  enabled: true,
+  extensions: DEFAULT_EXTENSIONS,
+  maxFileBytes: 1048576
+};
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS, extensions: [...DEFAULT_EXTENSIONS] };
+  const r = raw;
+  return {
+    enabled: r["enabled"] !== false,
+    extensions: Array.isArray(r["extensions"]) ? r["extensions"].filter((e) => typeof e === "string" && e.startsWith(".")).map((e) => e.toLowerCase()) : [...DEFAULT_EXTENSIONS],
+    maxFileBytes: typeof r["maxFileBytes"] === "number" && r["maxFileBytes"] >= 1024 ? r["maxFileBytes"] : DEFAULTS.maxFileBytes
+  };
+}
+function stripJsonc(text) {
+  let out = "";
+  let inString = false;
+  let inLine = false;
+  let inBlock = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    const next = text[i + 1];
+    if (inLine) {
+      if (ch === "\n") {
+        inLine = false;
+        out += ch;
+      }
+      continue;
+    }
+    if (inBlock) {
+      if (ch === "*" && next === "/") {
+        inBlock = false;
+        i += 1;
+      }
+      continue;
+    }
+    if (inString) {
+      out += ch;
+      if (ch === "\\") {
+        out += next ?? "";
+        i += 1;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      out += ch;
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      inLine = true;
+      i += 1;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      inBlock = true;
+      i += 1;
+      continue;
+    }
+    out += ch;
+  }
+  return out.replace(/,\s*([}\]])/g, "$1");
+}
+function positionToLineCol(text, pos) {
+  const upTo = text.slice(0, pos);
+  const line = upTo.split("\n").length;
+  const col = pos - upTo.lastIndexOf("\n");
+  return { line, col };
+}
+function validateJson(text, isJsonc, fileName) {
+  const source = isJsonc ? stripJsonc(text) : text;
+  try {
+    const parsed = JSON.parse(source);
+    if (/(^|[/\\])package\.json$/i.test(fileName) && parsed && typeof parsed === "object") {
+      const p = parsed;
+      const problems = [];
+      if (typeof p["name"] !== "string" || !p["name"]) {
+        problems.push('package.json: "name" is missing or not a string');
+      }
+      if ("version" in p && typeof p["version"] !== "string") {
+        problems.push('package.json: "version" is not a string');
+      }
+      for (const key of ["dependencies", "devDependencies", "peerDependencies"]) {
+        if (key in p && (typeof p[key] !== "object" || p[key] === null || Array.isArray(p[key]))) {
+          problems.push(`package.json: "${key}" must be an object`);
+        }
+      }
+      return problems;
+    }
+    return [];
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const posMatch = /position (\d+)/.exec(message);
+    if (posMatch?.[1]) {
+      const { line, col } = positionToLineCol(source, Number(posMatch[1]));
+      return [`JSON parse error at line ${line}, column ${col}: ${message}`];
+    }
+    const snippetMatch = /(?:\.\.\.)?"([\s\S]{4,120})" is not valid JSON/.exec(message);
+    if (snippetMatch?.[1]) {
+      const idx = source.indexOf(snippetMatch[1]);
+      if (idx >= 0) {
+        const { line } = positionToLineCol(source, idx);
+        return [`JSON parse error near line ${line}: ${message.split("\n")[0]}`];
+      }
+    }
+    return [`JSON parse error: ${message.split("\n")[0]}`];
+  }
+}
+function validateYaml(text) {
+  const problems = [];
+  const lines = text.split("\n");
+  const stack = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNo = i + 1;
+    if (/^\s*(#|$)/.test(line)) continue;
+    const indent = /^([ \t]*)/.exec(line)?.[1] ?? "";
+    if (indent.includes("	")) {
+      problems.push(`YAML: tab character in indentation at line ${lineNo} (YAML requires spaces)`);
+      continue;
+    }
+    if (/^---\s*$/.test(line.trim())) {
+      stack.length = 0;
+      continue;
+    }
+    const level = indent.length;
+    if (line.trim().startsWith("-")) {
+      while (stack.length > 0 && stack[stack.length - 1].level > level) {
+        stack.pop();
+      }
+      continue;
+    }
+    const keyMatch = /^ *([^\s#][^:]*?):(?:\s|$)/.exec(line);
+    if (keyMatch) {
+      const key = (keyMatch[1] ?? "").trim();
+      while (stack.length > 0 && stack[stack.length - 1].level > level) {
+        stack.pop();
+      }
+      let top = stack[stack.length - 1];
+      if (!top || top.level < level) {
+        top = { level, keys: /* @__PURE__ */ new Set() };
+        stack.push(top);
+      }
+      if (top.keys.has(key)) {
+        problems.push(`YAML: duplicate key "${key}" at line ${lineNo}`);
+      }
+      top.keys.add(key);
+    }
+    const doubleQuotes = (line.match(/(?<!\\)"/g) ?? []).length;
+    if (doubleQuotes % 2 === 1) {
+      problems.push(`YAML: possibly unclosed double quote at line ${lineNo}`);
+    }
+  }
+  return problems;
+}
+function validateToml(text) {
+  const problems = [];
+  const lines = text.split("\n");
+  const tables = /* @__PURE__ */ new Set();
+  const keysInTable = /* @__PURE__ */ new Map();
+  let currentTable = "";
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    const lineNo = i + 1;
+    if (line === "" || line.startsWith("#")) continue;
+    const tableMatch = /^\[\[?([^\]]+)\]\]?$/.exec(line);
+    if (tableMatch) {
+      const isArrayTable = line.startsWith("[[");
+      currentTable = (tableMatch[1] ?? "").trim();
+      if (isArrayTable) {
+        keysInTable.set(currentTable, /* @__PURE__ */ new Set());
+      } else {
+        if (tables.has(currentTable)) {
+          problems.push(`TOML: duplicate table [${currentTable}] at line ${lineNo}`);
+        }
+        tables.add(currentTable);
+      }
+      continue;
+    }
+    const keyMatch = /^([A-Za-z0-9_."'-]+)\s*=/.exec(line);
+    if (keyMatch?.[1]) {
+      const key = keyMatch[1];
+      const seen = keysInTable.get(currentTable) ?? /* @__PURE__ */ new Set();
+      if (seen.has(key)) {
+        problems.push(
+          `TOML: duplicate key "${key}" in [${currentTable || "root"}] at line ${lineNo}`
+        );
+      }
+      seen.add(key);
+      keysInTable.set(currentTable, seen);
+    }
+  }
+  return problems;
+}
+function validateFile(path, text) {
+  const lower = path.toLowerCase();
+  if (lower.endsWith(".json")) return validateJson(text, false, path);
+  if (lower.endsWith(".jsonc")) return validateJson(text, true, path);
+  if (lower.endsWith(".yaml") || lower.endsWith(".yml")) return validateYaml(text);
+  if (lower.endsWith(".toml")) return validateToml(text);
+  return [];
+}
+var plugin = {
+  name: "config-validator",
+  version: "0.1.0",
+  description: "Validates JSON/JSONC/YAML/TOML files right after write/edit and reports syntax problems in the same turn",
+  apiVersion: "^0.1.10",
+  capabilities: { tools: true, hooks: true },
+  defaultConfig: { ...DEFAULTS },
+  configSchema: {
+    type: "object",
+    properties: {
+      enabled: { type: "boolean", default: true, description: "Master switch." },
+      extensions: {
+        type: "array",
+        items: { type: "string" },
+        default: DEFAULT_EXTENSIONS,
+        description: "File extensions to validate (with leading dot)."
+      },
+      maxFileBytes: {
+        type: "number",
+        minimum: 1024,
+        default: 1048576,
+        description: "Files larger than this are skipped."
+      }
+    }
+  },
+  setup(api) {
+    state.invocations = 0;
+    state.filesChecked = 0;
+    state.problemsFound = 0;
+    state.lastProblem = null;
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    const cfg = readConfig(api.config.extensions?.["config-validator"]);
+    const hook = (input) => {
+      if (!cfg.enabled) return;
+      state.invocations += 1;
+      const ti = input.toolInput ?? {};
+      const raw = ti["path"] ?? ti["file_path"] ?? ti["filePath"];
+      if (typeof raw !== "string" || raw.length === 0) return;
+      const lower = raw.toLowerCase();
+      if (!cfg.extensions.some((ext) => lower.endsWith(ext))) return;
+      let text;
+      try {
+        if (statSync(raw).size > cfg.maxFileBytes) return;
+        text = readFileSync(raw, "utf-8");
+      } catch {
+        return;
+      }
+      state.filesChecked += 1;
+      api.metrics.counter("files_checked");
+      const problems = validateFile(raw, text);
+      if (problems.length === 0) return;
+      state.problemsFound += problems.length;
+      state.lastProblem = {
+        path: raw,
+        problem: problems[0],
+        when: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      api.metrics.counter("problems", problems.length);
+      return {
+        additionalContext: `config-validator: "${raw}" has ${problems.length} problem(s) after this ${input.toolName ?? "edit"}:
+` + problems.slice(0, 10).map((p) => `  - ${p}`).join("\n") + (problems.length > 10 ? `
+  \u2026 and ${problems.length - 10} more` : "") + "\nFix these before moving on \u2014 downstream tools will fail on this file."
+      };
+    };
+    state.hookUnregister = api.registerHook("PostToolUse", "write|edit", hook);
+    api.tools.register({
+      name: "config_validator_status",
+      description: "Reports config-validator state: watched extensions and counters (files checked, problems found).",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      category: "Diagnostics",
+      mutating: false,
+      async execute() {
+        return {
+          ok: true,
+          enabled: cfg.enabled,
+          extensions: cfg.extensions,
+          counters: {
+            invocations: state.invocations,
+            filesChecked: state.filesChecked,
+            problemsFound: state.problemsFound
+          },
+          lastProblem: state.lastProblem
+        };
+      }
+    });
+    api.log.info("config-validator plugin loaded", {
+      version: "0.1.0",
+      enabled: cfg.enabled,
+      extensions: cfg.extensions
+    });
+  },
+  teardown(api) {
+    if (state.hookUnregister) {
+      try {
+        state.hookUnregister();
+      } catch {
+      }
+      state.hookUnregister = null;
+    }
+    const final = {
+      invocations: state.invocations,
+      filesChecked: state.filesChecked,
+      problemsFound: state.problemsFound
+    };
+    state.invocations = 0;
+    state.filesChecked = 0;
+    state.problemsFound = 0;
+    state.lastProblem = null;
+    api.log.info("config-validator: teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: true,
+      message: `config-validator: ${state.filesChecked} file(s) checked, ${state.problemsFound} problem(s) found`,
+      counters: {
+        invocations: state.invocations,
+        filesChecked: state.filesChecked,
+        problemsFound: state.problemsFound
+      }
+    };
+  }
+};
+var config_validator_default = plugin;
+
+export { config_validator_default as default, validateFile, validateJson, validateToml, validateYaml };

package/dist/context-pins.d.ts

@@ -0,0 +1,45 @@
+import { Plugin } from '@wrongstack/core';
+
+/**
+ * context-pins plugin — pin durable facts into the system prompt.
+ *
+ * Long sessions lose important constraints to compaction ("the API
+ * base URL is X", "never touch the legacy folder", "the user prefers
+ * Turkish"). This plugin gives the agent (and the user) three tools:
+ *
+ *  - `pin_add`    — pin a short fact (optionally with a label)
+ *  - `pin_remove` — remove a pin by id or label
+ *  - `pin_list`   — list all pins
+ *
+ * Every pinned fact is injected into the system prompt on every
+ * request via a `SystemPromptContributor`, so pins survive context
+ * compaction by construction. Pins persist across sessions in a JSON
+ * file (default: `<projectDir>/context-pins.json`, seeded by the CLI
+ * host the same way `todo-tracker` gets its path).
+ *
+ * Config (`config.extensions['context-pins']`):
+ *
+ * ```jsonc
+ * {
+ *   "enabled": true,
+ *   "filePath": "",        // where pins persist; empty = in-memory only
+ *   "maxPins": 20,          // hard cap so the prompt block stays small
+ *   "maxPinChars": 500      // per-pin length cap
+ * }
+ * ```
+ *
+ * Toggle off with `{ "name": "context-pins", "enabled": false }` in
+ * `config.plugins`, or `"enabled": false` in the options above.
+ *
+ * @public
+ */
+
+interface Pin {
+    id: string;
+    label: string | null;
+    text: string;
+    createdAt: string;
+}
+declare const plugin: Plugin;
+
+export { type Pin, plugin as default };

package/dist/context-pins.js

@@ -0,0 +1,240 @@
+import { readFileSync, mkdirSync, writeFileSync } from 'fs';
+import { dirname } from 'path';
+
+// src/context-pins/index.ts
+var state = {
+  pins: [],
+  nextId: 1,
+  adds: 0,
+  removals: 0,
+  persistErrors: 0,
+  contributorUnregister: null
+};
+var DEFAULTS = {
+  enabled: true,
+  filePath: "",
+  maxPins: 20,
+  maxPinChars: 500
+};
+function readConfig(raw) {
+  if (!raw || typeof raw !== "object") return { ...DEFAULTS };
+  const r = raw;
+  return {
+    enabled: r["enabled"] !== false,
+    filePath: typeof r["filePath"] === "string" ? r["filePath"] : DEFAULTS.filePath,
+    maxPins: typeof r["maxPins"] === "number" && r["maxPins"] >= 1 && r["maxPins"] <= 100 ? r["maxPins"] : DEFAULTS.maxPins,
+    maxPinChars: typeof r["maxPinChars"] === "number" && r["maxPinChars"] >= 20 ? r["maxPinChars"] : DEFAULTS.maxPinChars
+  };
+}
+function loadPins(filePath) {
+  if (!filePath) return { pins: [], nextId: 1 };
+  try {
+    const raw = JSON.parse(readFileSync(filePath, "utf-8"));
+    const pins = Array.isArray(raw.pins) ? raw.pins.filter(
+      (p) => !!p && typeof p === "object" && typeof p.id === "string" && typeof p.text === "string"
+    ) : [];
+    const nextId = typeof raw.nextId === "number" && raw.nextId >= 1 ? raw.nextId : pins.length + 1;
+    return { pins, nextId };
+  } catch {
+    return { pins: [], nextId: 1 };
+  }
+}
+function persistPins(filePath) {
+  if (!filePath) return true;
+  try {
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, JSON.stringify({ pins: state.pins, nextId: state.nextId }, null, 2));
+    return true;
+  } catch {
+    state.persistErrors += 1;
+    return false;
+  }
+}
+var plugin = {
+  name: "context-pins",
+  version: "0.1.0",
+  description: "Pin durable facts into the system prompt (pin_add/pin_remove/pin_list) \u2014 pins survive compaction and persist across sessions",
+  apiVersion: "^0.1.10",
+  capabilities: { tools: true },
+  defaultConfig: { ...DEFAULTS },
+  configSchema: {
+    type: "object",
+    properties: {
+      enabled: { type: "boolean", default: true, description: "Master switch." },
+      filePath: {
+        type: "string",
+        default: "",
+        description: "JSON file where pins persist across sessions. Empty = in-memory only. Seeded by the host to <projectDir>/context-pins.json."
+      },
+      maxPins: {
+        type: "number",
+        minimum: 1,
+        maximum: 100,
+        default: 20,
+        description: "Maximum number of concurrent pins."
+      },
+      maxPinChars: {
+        type: "number",
+        minimum: 20,
+        default: 500,
+        description: "Per-pin text length cap (chars)."
+      }
+    }
+  },
+  setup(api) {
+    state.adds = 0;
+    state.removals = 0;
+    state.persistErrors = 0;
+    if (state.contributorUnregister) {
+      try {
+        state.contributorUnregister();
+      } catch {
+      }
+      state.contributorUnregister = null;
+    }
+    const cfg = readConfig(api.config.extensions?.["context-pins"]);
+    const loaded = loadPins(cfg.filePath);
+    state.pins = loaded.pins.slice(0, cfg.maxPins);
+    state.nextId = loaded.nextId;
+    if (cfg.enabled) {
+      state.contributorUnregister = api.registerSystemPromptContributor(async () => {
+        if (state.pins.length === 0) return [];
+        const lines = state.pins.map((p) => `- ${p.label ? `[${p.label}] ` : ""}${p.text}`);
+        return [
+          {
+            type: "text",
+            text: "[pinned_context]\nThe user or agent pinned these facts \u2014 they remain true regardless of conversation age:\n" + lines.join("\n")
+          }
+        ];
+      });
+    }
+    api.tools.register({
+      name: "pin_add",
+      description: "Pin a short durable fact into the system prompt so it survives context compaction. Use for constraints, decisions, and preferences that must not be forgotten.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          text: { type: "string", description: "The fact to pin (short and declarative)." },
+          label: { type: "string", description: 'Optional short label, e.g. "api" or "style".' }
+        },
+        required: ["text"]
+      },
+      permission: "auto",
+      category: "Memory",
+      mutating: true,
+      async execute(input) {
+        if (!cfg.enabled) return { ok: false, error: "context-pins is disabled" };
+        const text = String(input.text ?? "").trim();
+        if (!text) return { ok: false, error: "pin text must not be empty" };
+        if (state.pins.length >= cfg.maxPins) {
+          return {
+            ok: false,
+            error: `pin limit reached (${cfg.maxPins}). Remove a pin first with pin_remove.`
+          };
+        }
+        const pin = {
+          id: `pin-${state.nextId++}`,
+          label: typeof input.label === "string" && input.label.trim() ? input.label.trim() : null,
+          text: text.slice(0, cfg.maxPinChars),
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        state.pins.push(pin);
+        state.adds += 1;
+        api.metrics.counter("adds");
+        const persisted = persistPins(cfg.filePath);
+        return { ok: true, pin, persisted, totalPins: state.pins.length };
+      }
+    });
+    api.tools.register({
+      name: "pin_remove",
+      description: "Remove a pinned fact by its id (pin-N) or label.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "Pin id (pin-N) or label to remove." }
+        },
+        required: ["id"]
+      },
+      permission: "auto",
+      category: "Memory",
+      mutating: true,
+      async execute(input) {
+        if (!cfg.enabled) return { ok: false, error: "context-pins is disabled" };
+        const key = String(input.id ?? "").trim();
+        const before = state.pins.length;
+        state.pins = state.pins.filter((p) => p.id !== key && p.label !== key);
+        const removed = before - state.pins.length;
+        if (removed === 0) return { ok: false, error: `no pin matches "${key}"` };
+        state.removals += removed;
+        api.metrics.counter("removals", removed);
+        const persisted = persistPins(cfg.filePath);
+        return { ok: true, removed, persisted, totalPins: state.pins.length };
+      }
+    });
+    api.tools.register({
+      name: "pin_list",
+      description: "List all pinned facts currently injected into the system prompt.",
+      inputSchema: { type: "object", properties: {} },
+      permission: "auto",
+      category: "Memory",
+      mutating: false,
+      async execute() {
+        return {
+          ok: true,
+          enabled: cfg.enabled,
+          pins: state.pins,
+          totalPins: state.pins.length,
+          maxPins: cfg.maxPins,
+          filePath: cfg.filePath || null,
+          counters: {
+            adds: state.adds,
+            removals: state.removals,
+            persistErrors: state.persistErrors
+          }
+        };
+      }
+    });
+    api.log.info("context-pins plugin loaded", {
+      version: "0.1.0",
+      enabled: cfg.enabled,
+      pinsLoaded: state.pins.length,
+      filePath: cfg.filePath || null
+    });
+  },
+  teardown(api) {
+    if (state.contributorUnregister) {
+      try {
+        state.contributorUnregister();
+      } catch {
+      }
+      state.contributorUnregister = null;
+    }
+    const final = {
+      pins: state.pins.length,
+      adds: state.adds,
+      removals: state.removals,
+      persistErrors: state.persistErrors
+    };
+    state.pins = [];
+    state.nextId = 1;
+    state.adds = 0;
+    state.removals = 0;
+    state.persistErrors = 0;
+    api.log.info("context-pins: teardown complete", { final });
+  },
+  async health() {
+    return {
+      ok: state.persistErrors === 0,
+      message: `context-pins: ${state.pins.length} pin(s) active, ${state.adds} add(s), ${state.removals} removal(s), ${state.persistErrors} persist error(s)`,
+      counters: {
+        pins: state.pins.length,
+        adds: state.adds,
+        removals: state.removals,
+        persistErrors: state.persistErrors
+      }
+    };
+  }
+};
+var context_pins_default = plugin;
+
+export { context_pins_default as default };

package/dist/cost-tracker.d.ts

@@ -3,12 +3,51 @@ import { Plugin } from '@wrongstack/core';
 /**
  * cost-tracker plugin — Tracks LLM token usage and cost per session.
  *
+ * Config surface (`config.extensions['cost-tracker']`):
+ *
+ * ```jsonc
+ * {
+ *   "budgetLimit": 10,            // USD; 0 = no limit
+ *   "warningThreshold": 80,       // percent of budget before warning
+ *   "pricingOverrides": {         // user-supplied per-model rates (USD/1M tokens)
+ *     "gpt-4o":              { "input": 5.0,  "output": 15.0 },
+ *     "claude-3-5-sonnet":   { "input": 3.0,  "output": 15.0 }
+ *   }
+ * }
+ * ```
+ *
+ * Pricing lookup chain (first match wins, all keys lowercased):
+ *
+ * | Priority | Source                              | Populated by                         |
+ * |----------|-------------------------------------|--------------------------------------|
+ * | 1        | `pricingOverrides[model]`           | User config (highest priority)       |
+ * | 2        | `bundledFromRegistry[model]`        | `api.modelsRegistry` (models.dev)    |
+ * | 3        | `PRICING[model]`                    | Bundled baseline (updated per release)|
+ * | 4        | `DEFAULT_PRICING`                   | Last-resort fallback for unknown models |
+ *
  * Tools registered:
  * - cost_summary: Show token usage breakdown by model
  * - cost_reset: Reset tracking counters
  * - cost_export: Export cost report as JSON or CSV
+ *
+ * @public
  */
 
+/**
+ * Per-model pricing in USD per 1 million tokens.
+ *
+ * Used by `pricingOverrides` (user config), `bundledFromRegistry`
+ * (models.dev), and the bundled `PRICING` table. All three share
+ * the same shape so the lookup chain can fall through uniformly.
+ *
+ * @public
+ */
+interface ModelPricing {
+    /** Cost per 1M input (prompt) tokens in USD. */
+    input: number;
+    /** Cost per 1M output (completion) tokens in USD. */
+    output: number;
+}
 declare const plugin: Plugin;
 
-export { plugin as default };
+export { type ModelPricing, plugin as default };