@wrongstack/plugins 1.0.8 → 1.0.10

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