@wrongstack/plugins 1.0.8 → 1.0.11

package/dist/template-engine.js

@@ -15,6 +15,7 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 // src/template-engine/index.ts
 import { readFile, writeFile } from "node:fs/promises";
 import { isAbsolute } from "node:path";
+import { ToolValidationError } from "@wrongstack/core/types";
 
 // src/runtime/index.ts
 var runtime_exports = {};
@@ -183,24 +184,26 @@ var plugin = {
         const output_path = typeof rawOutputPath === "string" && rawOutputPath.trim().length > 0 ? rawOutputPath.trim() : void 0;
         const raw = input["raw"] ?? false;
         if (!template || typeof template !== "string") {
-          return { ok: false, error: "template is required and must be a string" };
+          throw new ToolValidationError({
+            message: "template is required and must be a string",
+            field: "template"
+          });
         }
         if (!variables || typeof variables !== "object") {
-          return { ok: false, error: "variables is required and must be an object" };
-        }
-        let result;
-        try {
-          result = raw ? renderTemplateRaw(template, variables) : renderTemplate(template, variables, autoEscapeHtml);
-        } catch (err) {
-          return { ok: false, error: String(err) };
+          throw new ToolValidationError({
+            message: "variables is required and must be an object",
+            field: "variables"
+          });
         }
+        const result = raw ? renderTemplateRaw(template, variables) : renderTemplate(template, variables, autoEscapeHtml);
         if (output_path) {
           const pathError = validateWritableTemplateTarget("output_path", output_path);
-          if (pathError) return { ok: false, error: pathError };
+          if (pathError)
+            throw new ToolValidationError({ message: pathError, field: "output_path" });
           try {
             await writeFile(output_path, result, "utf-8");
           } catch (err) {
-            return { ok: false, error: `Could not write ${output_path}: ${String(err)}` };
+            throw new Error(`Could not write ${output_path}: ${String(err)}`, { cause: err });
           }
           return {
             ok: true,
@@ -251,32 +254,36 @@ var plugin = {
         const output_path = typeof rawOutputPath === "string" && rawOutputPath.trim().length > 0 ? rawOutputPath.trim() : void 0;
         const raw = input["raw"] ?? false;
         if (!template_path || typeof template_path !== "string") {
-          return { ok: false, error: "template_path is required and must be a string" };
+          throw new ToolValidationError({
+            message: "template_path is required and must be a string",
+            field: "template_path"
+          });
         }
         const templatePathError = validateRelativeTemplatePath("template_path", template_path);
-        if (templatePathError) return { ok: false, error: templatePathError };
+        if (templatePathError) {
+          throw new ToolValidationError({ message: templatePathError, field: "template_path" });
+        }
         if (!variables || typeof variables !== "object") {
-          return { ok: false, error: "variables is required and must be an object" };
+          throw new ToolValidationError({
+            message: "variables is required and must be an object",
+            field: "variables"
+          });
         }
         let content;
         try {
           content = await readFile(template_path, "utf-8");
         } catch (err) {
-          return { ok: false, error: `Could not read template file: ${err}` };
-        }
-        let result;
-        try {
-          result = raw ? renderTemplateRaw(content, variables) : renderTemplate(content, variables, autoEscapeHtml);
-        } catch (err) {
-          return { ok: false, error: `Template rendering failed: ${err}` };
+          throw new Error(`Could not read template file: ${String(err)}`, { cause: err });
         }
+        const result = raw ? renderTemplateRaw(content, variables) : renderTemplate(content, variables, autoEscapeHtml);
         if (output_path) {
           const pathError = validateWritableTemplateTarget("output_path", output_path);
-          if (pathError) return { ok: false, error: pathError };
+          if (pathError)
+            throw new ToolValidationError({ message: pathError, field: "output_path" });
           try {
             await writeFile(output_path, result, "utf-8");
           } catch (err) {
-            return { ok: false, error: `Could not write ${output_path}: ${String(err)}` };
+            throw new Error(`Could not write ${output_path}: ${String(err)}`, { cause: err });
           }
           return {
             ok: true,
@@ -327,30 +334,39 @@ var plugin = {
         const rawDesc = input["description"] ?? input["desc"] ?? input["summary"];
         const description = typeof rawDesc === "string" ? rawDesc : void 0;
         if (!name || typeof name !== "string" || name.trim() === "") {
-          return { ok: false, error: "name is required and must be a non-empty string" };
+          throw new ToolValidationError({
+            message: "name is required and must be a non-empty string",
+            field: "name"
+          });
         }
         if (!content || typeof content !== "string") {
-          return { ok: false, error: "content is required and must be a string" };
+          throw new ToolValidationError({
+            message: "content is required and must be a string",
+            field: "content"
+          });
         }
         if (name.length > MAX_TEMPLATE_NAME_CHARS) {
-          return { ok: false, error: `name exceeds ${MAX_TEMPLATE_NAME_CHARS} characters` };
+          throw new ToolValidationError({
+            message: `name exceeds ${MAX_TEMPLATE_NAME_CHARS} characters`,
+            field: "name"
+          });
         }
         if (content.length > MAX_TEMPLATE_CONTENT_CHARS) {
-          return {
-            ok: false,
-            error: `content exceeds ${MAX_TEMPLATE_CONTENT_CHARS} characters`
-          };
+          throw new ToolValidationError({
+            message: `content exceeds ${MAX_TEMPLATE_CONTENT_CHARS} characters`,
+            field: "content"
+          });
         }
         if (description && description.length > MAX_TEMPLATE_DESCRIPTION_CHARS) {
-          return {
-            ok: false,
-            error: `description exceeds ${MAX_TEMPLATE_DESCRIPTION_CHARS} characters`
-          };
+          throw new ToolValidationError({
+            message: `description exceeds ${MAX_TEMPLATE_DESCRIPTION_CHARS} characters`,
+            field: "description"
+          });
         }
         const now = (/* @__PURE__ */ new Date()).toISOString();
         const existing = templates.get(name);
         if (!existing && templates.size >= MAX_TEMPLATES) {
-          return { ok: false, error: `template limit reached (${MAX_TEMPLATES})` };
+          throw new Error(`template limit reached (${MAX_TEMPLATES})`);
         }
         const tmpl = {
           name,
@@ -363,10 +379,7 @@ var plugin = {
         for (const stored of templates.values()) retainedChars += templateChars(stored);
         const nextChars = retainedChars - (existing ? templateChars(existing) : 0) + templateChars(tmpl);
         if (nextChars > MAX_TOTAL_TEMPLATE_CHARS) {
-          return {
-            ok: false,
-            error: `template store exceeds ${MAX_TOTAL_TEMPLATE_CHARS} retained characters`
-          };
+          throw new Error(`template store exceeds ${MAX_TOTAL_TEMPLATE_CHARS} retained characters`);
         }
         templates.set(name, tmpl);
         api.metrics.gauge("template_count", templates.size);

package/dist/test-flake-detector/index.d.ts

@@ -19,7 +19,7 @@
  *
  * @public
  */
-import type { Plugin } from '@wrongstack/core/types';
+import { type Plugin } from '@wrongstack/core/types';
 declare const plugin: Plugin;
 export default plugin;
 //# sourceMappingURL=index.d.ts.map

package/dist/test-flake-detector.js

@@ -17,6 +17,7 @@ import { execFile } from "node:child_process";
 import { readFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { ToolValidationError } from "@wrongstack/core/types";
 
 // src/runtime/index.ts
 var runtime_exports = {};
@@ -274,7 +275,7 @@ var plugin = {
       mutating: false,
       async execute(input) {
         if (!cfg.enabled) {
-          return { ok: false, error: "test-flake-detector is disabled" };
+          throw new Error("test-flake-detector is disabled");
         }
         const raw = input;
         const rawPattern = input.testPattern ?? raw["pattern"] ?? raw["path"] ?? raw["file"] ?? raw["filePath"] ?? raw["TargetFile"] ?? raw["targetFile"];
@@ -285,10 +286,10 @@ var plugin = {
         const requestedRuns = typeof rawRuns === "number" && rawRuns >= 1 ? Math.min(Math.floor(rawRuns), cfg.maxRuns) : 5;
         const command = resolveTestCommand(commandString, testPattern);
         if (!command) {
-          return {
-            ok: false,
-            error: "Unsupported test command or unsafe testPattern. Use vitest, jest, or mocha through a supported package runner, and keep patterns inside the project."
-          };
+          throw new ToolValidationError({
+            message: "Unsupported test command or unsafe testPattern. Use vitest, jest, or mocha through a supported package runner, and keep patterns inside the project.",
+            field: "command"
+          });
         }
         state.invocationCount += 1;
         const start = Date.now();
@@ -316,6 +317,11 @@ var plugin = {
           }
         }
         const all = Array.from(records.values());
+        if (all.length === 0 && runErrors.length === requestedRuns) {
+          throw new Error(
+            `test command produced no test results in ${requestedRuns} run(s): ${runErrors.slice(0, 3).join("; ")}`
+          );
+        }
         const flakyTests = all.filter((r) => r.passCount > 0 && r.failCount > 0);
         const alwaysFailing = all.filter((r) => r.passCount === 0 && r.failCount > 0);
         const alwaysPassing = all.filter((r) => r.passCount > 0 && r.failCount === 0);

package/dist/test-generator/index.d.ts

@@ -22,7 +22,7 @@
  *
  * @public
  */
-import type { Plugin } from '@wrongstack/core/types';
+import { type Plugin } from '@wrongstack/core/types';
 interface TestGeneratorConfig {
     enabled: boolean;
     framework: TestFramework;

package/dist/test-generator.js

@@ -1,6 +1,7 @@
 // src/test-generator/index.ts
 import { readFileSync } from "node:fs";
 import { isAbsolute, relative, resolve } from "node:path";
+import { ToolValidationError } from "@wrongstack/core/types";
 
 // src/runtime/llm.ts
 import {
@@ -299,7 +300,7 @@ var plugin = {
       category: "Development",
       mutating: false,
       async execute(input, _ctx, execOpts) {
-        if (!cfg.enabled) return { ok: false, error: "test-generator is disabled" };
+        if (!cfg.enabled) throw new Error("test-generator is disabled");
         execOpts?.signal?.throwIfAborted();
         const inp = input ?? {};
         const rawFramework = inp["framework"];
@@ -310,16 +311,19 @@ var plugin = {
         };
         const rawPath = inp["path"] ?? inp["filePath"] ?? inp["file_path"] ?? inp["TargetFile"] ?? inp["targetFile"] ?? inp["file"];
         if (!rawPath || typeof rawPath !== "string") {
-          return { ok: false, error: "path is required" };
+          throw new ToolValidationError({ message: "path is required", field: "path" });
         }
         if (!withinProject(rawPath)) {
-          return { ok: false, error: "path is outside the project root" };
+          throw new ToolValidationError({
+            message: "path is outside the project root",
+            field: "path"
+          });
         }
         if (!SOURCE_EXTENSIONS.some((ext) => rawPath.toLowerCase().endsWith(ext))) {
-          return {
-            ok: false,
-            error: `test generation only reads source files (${SOURCE_EXTENSIONS.join(", ")}); refusing "${rawPath}"`
-          };
+          throw new ToolValidationError({
+            message: `test generation only reads source files (${SOURCE_EXTENSIONS.join(", ")}); refusing "${rawPath}"`,
+            field: "path"
+          });
         }
         const resolved = resolve(process.cwd(), rawPath);
         state.generateCount += 1;
@@ -328,7 +332,7 @@ var plugin = {
           result = generateForFile(resolved, effectiveCfg);
         } catch (err) {
           state.errorCount += 1;
-          return { ok: false, error: String(err) };
+          throw new Error(`Could not read ${rawPath}: ${String(err)}`, { cause: err });
         }
         state.exportCount += result.exports.length;
         const raw = input ?? {};

package/dist/todo-tracker/index.d.ts

@@ -26,8 +26,75 @@
  *                             into the session's ctx.todos via the
  *                             built-in `todo` tool
  *   - todo_tracker_status   : Counters + last update timestamp
+ *
+ * Durability contract (the file is the source of truth, memory is a cache):
+ *   - A file that cannot be parsed or validated is QUARANTINED (renamed to
+ *     `<file>.corrupt-<timestamp>`), never silently overwritten. If the
+ *     rename fails the store goes read-only.
+ *   - A file written by a newer format version is never written to.
+ *   - Every mutation runs under the shared file lock, re-reads the file,
+ *     applies the change to a clone, writes atomically, and only then
+ *     updates memory. Two sessions on one project therefore merge instead of
+ *     erasing each other, and a failed write leaves memory and disk unchanged.
+ *   - Read tools re-read the file so another process's changes are visible.
+ */
+import { type Plugin } from '@wrongstack/core/types';
+type Status = 'pending' | 'in_progress' | 'completed' | 'dropped';
+type Priority = 'low' | 'normal' | 'high';
+interface TrackedItem {
+    id: string;
+    content: string;
+    status: Status;
+    priority: Priority;
+    tags: string[];
+    createdAt: string;
+    updatedAt: string;
+    completedAt: string | null;
+    /** Session that first created the item (if known). */
+    sourceSessionId: string | null;
+    /** Optional free-form note attached to the item. */
+    notes: string | null;
+}
+interface TodoTrackerFile {
+    version: 1;
+    projectSlug: string;
+    updatedAt: string;
+    items: TrackedItem[];
+}
+/**
+ * Filesystem/persistence seam. Production uses the real primitives; tests
+ * inject faults here instead of module-mocking `@wrongstack/core/utils`
+ * (which is flaky under parallel vitest — see context-pins-extra.test.ts).
  */
-import type { Plugin } from '@wrongstack/core/types';
+export interface TodoTrackerDeps {
+    readFile(path: string): Promise<string>;
+    rename(from: string, to: string): Promise<void>;
+    atomicWrite(path: string, content: string, opts?: {
+        mode?: number;
+    }): Promise<void>;
+    withFileLock<T>(path: string, fn: () => Promise<T>): Promise<T>;
+    ensureDir(dir: string): Promise<void>;
+}
+/** Basename without its extension; dotfiles like `.todos` keep their name. */
+export declare function deriveProjectSlug(filePath: string): string;
+type LoadResult = {
+    kind: 'missing';
+} | {
+    kind: 'ok';
+    file: TodoTrackerFile;
+} | {
+    kind: 'corrupt';
+    reason: string;
+} | {
+    kind: 'unsupportedVersion';
+    version: unknown;
+} | {
+    kind: 'invalidItems';
+    reason: string;
+};
+/** Pure classification of raw file bytes. Exported for tests. */
+export declare function parseTrackerFile(rawText: string): LoadResult;
+export declare function createTodoTrackerPlugin(overrides?: Partial<TodoTrackerDeps>): Plugin;
 declare const plugin: Plugin;
 export default plugin;
 //# sourceMappingURL=index.d.ts.map