@wrongstack/tools 1.0.7 → 1.0.9

package/dist/{chunk-EGT5QLCB.js → chunk-D6RQZMZS.js}

@@ -8,7 +8,8 @@ import {
 
 // src/json.ts
 import * as fs from "node:fs/promises";
-import { deepMerge as deepMergeCore } from "@wrongstack/core/utils";
+import { deepMerge as deepMergeCore, toErrorMessage } from "@wrongstack/core/utils";
+import { ToolValidationError } from "@wrongstack/core/types";
 var MAX_JSON_FILE_BYTES = 16 * 1024 * 1024;
 var MAX_JSON_FILE_BYTES_HUMAN = "16 MiB";
 var JsonFileTooLargeError = class extends Error {
@@ -39,8 +40,8 @@ async function readJsonFileBounded(filePath, ctx) {
 var jsonTool = {
   name: "json",
   category: "Data",
-  description: "Parse, pretty-print, query, validate, transform, and merge JSON/JSON5/YAML (read-only \u2014 does not write files). Use `action` to select the operation: parse (default), query, validate, transform, or merge.",
-  usageHint: 'VERY USEFUL FOR DATA INSPECTION:\n\n- `action: "parse"` (default): read/pretty-print/convert JSON, JSON5, or YAML from `file` or `data`.\n- `action: "query"`: JMESPath-like query (`a.b[0].c`, `items[*].name`, filters, functions).\n- `action: "validate"`: validate data against a JSON Schema (`schema` param).\n- `action: "transform"`: chain multiple JMESPath transforms (`transforms` param).\n- `action: "merge"`: deep merge `base` and `patch` objects (`conflictResolution` param).\nPrefer this over raw `read` + manual parsing when dealing with configuration or data files.',
+  description: "Parse, pretty-print, query, validate, transform, and merge JSON (read-only \u2014 does not write files). Input must be strict JSON; results can be rendered as JSON, JSON5-style, or YAML via `format`. Use `action` to select the operation: parse (default), query, validate, transform, or merge.",
+  usageHint: 'VERY USEFUL FOR DATA INSPECTION:\n\n- `action: "parse"` (default): read/pretty-print JSON from `file` or `data` (output as JSON, JSON5-style, or YAML via `format`).\n- `action: "query"`: JMESPath-like query (`a.b[0].c`, `items[*].name`, filters, functions).\n- `action: "validate"`: validate data against a JSON Schema (`schema` param).\n- `action: "transform"`: chain multiple JMESPath transforms (`transforms` param).\n- `action: "merge"`: deep merge `base` and `patch` objects (`conflictResolution` param).\nPrefer this over raw `read` + manual parsing when dealing with configuration or data files.',
   permission: "auto",
   mutating: false,
   maxOutputBytes: 262144,
@@ -55,10 +56,10 @@ var jsonTool = {
         enum: ["parse", "query", "validate", "transform", "merge"],
         description: "Operation (default: parse). parse=read/pretty-print, query=JMESPath, validate=schema, transform=chained queries, merge=deep merge."
       },
-      file: { type: "string", description: "Path to JSON/JSON5/YAML file (parse/query/validate)" },
+      file: { type: "string", description: "Path to a JSON file (parse/query/validate/transform)" },
       data: {
         type: "string",
-        description: "JSON/JSON5/YAML string (parse/query/validate, alternative to file)"
+        description: "JSON string (parse/query/validate/transform, alternative to file)"
       },
       format: {
         type: "string",
@@ -103,13 +104,10 @@ var jsonTool = {
       "merge"
     ]);
     if (input.action !== void 0 && !ALLOWED_ACTIONS.has(input.action)) {
-      return {
-        data: null,
-        formatted: "",
-        type: "unknown",
-        action: String(input.action),
-        error: `Unknown action "${input.action}". Allowed actions: parse, query, validate, transform, merge`
-      };
+      throw new ToolValidationError({
+        message: `json: unknown action "${input.action}". Allowed actions: parse, query, validate, transform, merge`,
+        field: "action"
+      });
     }
     switch (action) {
       case "query":
@@ -125,54 +123,61 @@ var jsonTool = {
     }
   }
 };
+async function readSource(input, ctx, action) {
+  if (input.file) {
+    try {
+      return await readJsonFileBounded(input.file, ctx);
+    } catch (error) {
+      if (error instanceof JsonFileTooLargeError || error instanceof JsonFileIsDirectoryError) {
+        throw error;
+      }
+      throw new Error(`json: could not read file "${input.file}": ${toErrorMessage(error)}`, {
+        cause: error
+      });
+    }
+  }
+  if (input.data) return input.data;
+  throw new ToolValidationError({
+    message: `json: provide \`file\` or \`data\` for action: ${action}`,
+    field: "file"
+  });
+}
+function parseSource(raw, input) {
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    const message = `json: parse failed${input.file ? ` for "${input.file}"` : ""}: ${toErrorMessage(error)}`;
+    if (input.file) throw new Error(message, { cause: error });
+    throw new ToolValidationError({ message, field: "data", cause: error });
+  }
+}
 async function executeParse(input, ctx) {
   const format = input.format ?? "json";
-  let parsed;
-  let raw;
-  if (input.file) {
+  const raw = await readSource(input, ctx, "parse");
+  if (input.validate) {
+    let checked;
     try {
-      raw = await readJsonFileBounded(input.file, ctx);
+      checked = JSON.parse(raw);
     } catch (error) {
       return {
         data: null,
-        formatted: "",
+        formatted: "invalid",
         type: "unknown",
         action: "parse",
-        error: error instanceof JsonFileTooLargeError || error instanceof JsonFileIsDirectoryError ? error.message : "Could not read file"
+        valid: false,
+        errors: [`Parse failed: ${toErrorMessage(error)}`]
       };
     }
-  } else if (input.data) {
-    raw = input.data;
-  } else {
     return {
-      data: null,
-      formatted: "",
-      type: "unknown",
-      action: "parse",
-      error: "Provide file or data"
-    };
-  }
-  try {
-    parsed = JSON.parse(raw);
-  } catch (e) {
-    return {
-      data: null,
-      formatted: "",
-      type: "unknown",
-      action: "parse",
-      /* v8 ignore next -- JSON.parse only throws SyntaxError (an Error); the String(e) side is defensive. */
-      error: `Parse failed: ${e instanceof Error ? e.message : String(e)}`
-    };
-  }
-  if (input.validate) {
-    return {
-      data: parsed,
+      data: checked,
       formatted: "valid",
-      type: Array.isArray(parsed) ? "array" : typeof parsed,
+      type: Array.isArray(checked) ? "array" : typeof checked,
       action: "parse",
-      keys: typeof parsed === "object" && parsed !== null ? Object.keys(parsed) : void 0
+      valid: true,
+      keys: typeof checked === "object" && checked !== null ? Object.keys(checked) : void 0
     };
   }
+  const parsed = parseSource(raw, input);
   if (input.query) {
     const queryResult = simpleQuery(parsed, input.query);
     const formatted2 = formatOutput(queryResult, format);
@@ -196,239 +201,102 @@ async function executeParse(input, ctx) {
 }
 async function executeQuery(input, ctx) {
   if (!input.query) {
-    return {
-      data: null,
-      formatted: "",
-      type: "unknown",
-      action: "query",
-      error: "query is required for action: query"
-    };
-  }
-  let parsed;
-  if (input.file) {
-    try {
-      const raw = await readJsonFileBounded(input.file, ctx);
-      parsed = JSON.parse(raw);
-    } catch (error) {
-      return {
-        data: null,
-        formatted: "",
-        type: "unknown",
-        action: "query",
-        error: error instanceof JsonFileTooLargeError || error instanceof JsonFileIsDirectoryError ? error.message : "Could not read/parse file"
-      };
-    }
-  } else if (input.data) {
-    try {
-      parsed = JSON.parse(input.data);
-    } catch {
-      return {
-        data: null,
-        formatted: "",
-        type: "unknown",
-        action: "query",
-        error: "Could not parse data string"
-      };
-    }
-  } else {
-    return {
-      data: null,
-      formatted: "",
-      type: "unknown",
-      action: "query",
-      error: "Provide file or data"
-    };
+    throw new ToolValidationError({
+      message: "json: query is required for action: query",
+      field: "query"
+    });
   }
+  const parsed = parseSource(await readSource(input, ctx, "query"), input);
+  let result;
   try {
-    const result = jmespathSearch(parsed, input.query);
-    const format = input.format ?? "json";
-    return {
-      data: parsed,
-      formatted: formatOutput(result, format),
-      type: result === null ? "null" : Array.isArray(result) ? "array" : typeof result,
-      action: "query",
-      query_result: result
-    };
-  } catch (e) {
-    return {
-      data: null,
-      formatted: "",
-      type: "unknown",
-      action: "query",
-      /* v8 ignore next -- defensive String(e) */
-      error: `Query failed: ${e instanceof Error ? e.message : String(e)}`
-    };
+    result = jmespathSearch(parsed, input.query);
+  } catch (error) {
+    throw new Error(`json: query failed: ${toErrorMessage(error)}`, { cause: error });
   }
+  const format = input.format ?? "json";
+  return {
+    data: parsed,
+    formatted: formatOutput(result, format),
+    type: result === null ? "null" : Array.isArray(result) ? "array" : typeof result,
+    action: "query",
+    query_result: result
+  };
 }
 async function executeValidate(input, ctx) {
   if (!input.schema) {
-    return {
-      data: null,
-      formatted: "",
-      type: "unknown",
-      action: "validate",
-      error: "schema is required for action: validate"
-    };
-  }
-  let parsed;
-  if (input.file) {
-    try {
-      const raw = await readJsonFileBounded(input.file, ctx);
-      parsed = JSON.parse(raw);
-    } catch (error) {
-      return {
-        data: null,
-        formatted: "",
-        type: "unknown",
-        action: "validate",
-        error: error instanceof JsonFileTooLargeError || error instanceof JsonFileIsDirectoryError ? error.message : "Could not read/parse file"
-      };
-    }
-  } else if (input.data) {
-    try {
-      parsed = JSON.parse(input.data);
-    } catch {
-      return {
-        data: null,
-        formatted: "",
-        type: "unknown",
-        action: "validate",
-        error: "Could not parse data string"
-      };
-    }
-  } else {
-    return {
-      data: null,
-      formatted: "",
-      type: "unknown",
-      action: "validate",
-      error: "Provide file or data"
-    };
+    throw new ToolValidationError({
+      message: "json: schema is required for action: validate",
+      field: "schema"
+    });
   }
+  const parsed = parseSource(await readSource(input, ctx, "validate"), input);
+  let outcome;
   try {
-    const { valid, errors } = validateJsonSchema(parsed, input.schema);
-    return {
-      data: parsed,
-      formatted: valid ? "valid" : "invalid",
-      type: Array.isArray(parsed) ? "array" : typeof parsed,
-      action: "validate",
-      valid,
-      errors
-    };
-  } catch (e) {
-    return {
-      data: null,
-      formatted: "",
-      type: "unknown",
-      action: "validate",
-      /* v8 ignore next -- defensive String(e) */
-      error: `Validation failed: ${e instanceof Error ? e.message : String(e)}`
-    };
+    outcome = validateJsonSchema(parsed, input.schema);
+  } catch (error) {
+    throw new Error(`json: schema validation failed to run: ${toErrorMessage(error)}`, {
+      cause: error
+    });
   }
+  return {
+    data: parsed,
+    formatted: outcome.valid ? "valid" : "invalid",
+    type: Array.isArray(parsed) ? "array" : typeof parsed,
+    action: "validate",
+    valid: outcome.valid,
+    errors: outcome.errors
+  };
 }
 async function executeTransform(input, ctx) {
   if (!input.transforms || input.transforms.length === 0) {
-    return {
-      data: null,
-      formatted: "",
-      type: "unknown",
-      action: "transform",
-      error: "transforms array is required for action: transform"
-    };
+    throw new ToolValidationError({
+      message: "json: transforms array is required for action: transform",
+      field: "transforms"
+    });
   }
-  let parsed;
-  if (input.file) {
-    try {
-      const raw = await readJsonFileBounded(input.file, ctx);
-      parsed = JSON.parse(raw);
-    } catch (error) {
-      return {
-        data: null,
-        formatted: "",
-        type: "unknown",
-        action: "transform",
-        error: error instanceof JsonFileTooLargeError || error instanceof JsonFileIsDirectoryError ? error.message : "Could not read/parse file"
-      };
-    }
-  } else if (input.data) {
+  const parsed = parseSource(await readSource(input, ctx, "transform"), input);
+  let current = parsed;
+  const steps = [];
+  for (const t of input.transforms) {
     try {
-      parsed = JSON.parse(input.data);
-    } catch {
-      return {
-        data: null,
-        formatted: "",
-        type: "unknown",
-        action: "transform",
-        error: "Could not parse data string"
-      };
-    }
-  } else {
-    return {
-      data: null,
-      formatted: "",
-      type: "unknown",
-      action: "transform",
-      error: "Provide file or data"
-    };
-  }
-  try {
-    let current = parsed;
-    const steps = [];
-    for (const t of input.transforms) {
       current = jmespathSearch(current, t);
-      steps.push({ transform: t, result: current });
+    } catch (error) {
+      throw new Error(`json: transform "${t}" failed: ${toErrorMessage(error)}`, { cause: error });
     }
-    const format = input.format ?? "json";
-    return {
-      data: parsed,
-      formatted: formatOutput(current, format),
-      type: current === null ? "null" : Array.isArray(current) ? "array" : typeof current,
-      action: "transform",
-      result: current,
-      steps
-    };
-  } catch (e) {
-    return {
-      data: null,
-      formatted: "",
-      type: "unknown",
-      action: "transform",
-      /* v8 ignore next -- defensive String(e) */
-      error: `Transform failed: ${e instanceof Error ? e.message : String(e)}`
-    };
+    steps.push({ transform: t, result: current });
   }
+  const format = input.format ?? "json";
+  return {
+    data: parsed,
+    formatted: formatOutput(current, format),
+    type: current === null ? "null" : Array.isArray(current) ? "array" : typeof current,
+    action: "transform",
+    result: current,
+    steps
+  };
 }
 async function executeMerge(input) {
   if (input.base === void 0 || input.patch === void 0) {
-    return {
-      data: null,
-      formatted: "",
-      type: "unknown",
-      action: "merge",
-      error: "base and patch are required for action: merge"
-    };
+    throw new ToolValidationError({
+      message: "json: base and patch are required for action: merge",
+      field: input.base === void 0 ? "base" : "patch"
+    });
   }
   const conflictResolution = input.conflictResolution ?? "prefer-patch";
+  let result;
   try {
-    const result = deepMergeCore(input.base, input.patch, { conflictResolution });
-    const format = input.format ?? "json";
-    return {
-      data: result,
-      formatted: formatOutput(result, format),
-      type: result === null ? "null" : Array.isArray(result) ? "array" : typeof result,
-      action: "merge",
-      result
-    };
-  } catch (e) {
-    return {
-      data: null,
-      formatted: "",
-      type: "unknown",
-      action: "merge",
-      /* v8 ignore next -- defensive String(e) */
-      error: `Merge failed: ${e instanceof Error ? e.message : String(e)}`
-    };
+    result = deepMergeCore(input.base, input.patch, { conflictResolution });
+  } catch (error) {
+    throw new Error(`json: merge failed: ${toErrorMessage(error)}`, { cause: error });
   }
+  const format = input.format ?? "json";
+  return {
+    data: result,
+    formatted: formatOutput(result, format),
+    type: result === null ? "null" : Array.isArray(result) ? "array" : typeof result,
+    action: "merge",
+    result
+  };
 }
 function jmespathSearch(data, query) {
   if (!query || query === "@") return data;
@@ -704,4 +572,4 @@ ${toYaml(v, indent + 1)}`;
 export {
   jsonTool
 };
-//# sourceMappingURL=chunk-EGT5QLCB.js.map
+//# sourceMappingURL=chunk-D6RQZMZS.js.map

package/dist/{chunk-S6CGSFLX.js → chunk-DBG7UQGK.js}

@@ -1,6 +1,6 @@
 import {
   kanbanTool
-} from "./chunk-2NTHMZV3.js";
+} from "./chunk-VMJY6FYJ.js";
 import {
   applyManagedKanbanBoardToTodos,
   blockingTitles,
@@ -118,7 +118,14 @@ async function synchronizeManagedKanban(items, board, ctx, signal) {
   const warnings = [];
   const actor = ctx.agentId?.trim() || ctx.agentName?.trim() || "kanban-agent";
   const execute = async (input) => {
-    const result = await kanbanTool.execute(input, ctx, { signal });
+    let result;
+    try {
+      result = await kanbanTool.execute(input, ctx, { signal });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      warnings.push(message);
+      return { ok: false, message };
+    }
     if (!result.ok) warnings.push(result.message);
     else {
       synced++;
@@ -487,4 +494,4 @@ var todoTool = {
 export {
   todoTool
 };
-//# sourceMappingURL=chunk-S6CGSFLX.js.map
+//# sourceMappingURL=chunk-DBG7UQGK.js.map

package/dist/{chunk-2W4XTULI.js → chunk-DLZCOEVG.js}

@@ -18,6 +18,7 @@ import {
 import { spawn } from "node:child_process";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+import { StringDecoder } from "node:string_decoder";
 import { ToolValidationError } from "@wrongstack/core/types";
 import {
   buildChildEnv,
@@ -31,6 +32,13 @@ var NATIVE_READ_CHUNK_BYTES = 64 * 1024;
 var NATIVE_MAX_FILE_BYTES = 1e6;
 var RG_MAX_QUEUE_CHUNKS = 128;
 var RG_MAX_QUEUE_CHARS = 8 * 1024 * 1024;
+function isInsideDefaultIgnoredDirectory(target, root) {
+  const relative2 = path.relative(root, target);
+  if (!relative2 || relative2 === ".." || relative2.startsWith(`..${path.sep}`) || path.isAbsolute(relative2)) {
+    return false;
+  }
+  return relative2.split(path.sep).some((segment) => DEFAULT_IGNORE.has(segment));
+}
 var grepTool = {
   name: "grep",
   category: "Search",
@@ -99,6 +107,14 @@ var grepTool = {
       });
     }
     const base = input.path ? await safeResolveReal(input.path, ctx) : ctx.cwd;
+    if (input.path && !await fs.stat(base).catch(() => null)) {
+      throw new ToolValidationError({
+        message: `grep: path "${input.path}" does not exist`,
+        field: "path"
+      });
+    }
+    const ignoreRoot = await fs.realpath(ctx.projectRoot ?? ctx.cwd).catch(() => path.resolve(ctx.projectRoot ?? ctx.cwd));
+    const ignoreTarget = await fs.realpath(base).catch(() => path.resolve(base));
     const mode = input.output_mode ?? "content";
     const rawLimit = typeof input.limit === "number" && Number.isFinite(input.limit) ? input.limit : 200;
     const limit = Math.max(1, Math.min(Math.floor(rawLimit), 2e3));
@@ -112,6 +128,18 @@ var grepTool = {
     const signal = opts?.signal ?? ctx.signal ?? new AbortController().signal;
     const relativize = makeRootRelativizer(ctx.cwd);
     const rgAvailable = await detectRg();
+    if (isInsideDefaultIgnoredDirectory(ignoreTarget, ignoreRoot)) {
+      yield {
+        type: "final",
+        output: {
+          matches: [],
+          count: 0,
+          truncated: false,
+          used: rgAvailable ? "rg" : "native"
+        }
+      };
+      return;
+    }
     if (rgAvailable) {
       try {
         yield* runRgStream(input, base, mode, limit, signal, relativize);
@@ -132,7 +160,7 @@ function __setRgAvailableForTests(available) {
   rgAvailabilityCache = available !== void 0 ? Promise.resolve(available) : void 0;
 }
 function detectRg() {
-  rgAvailabilityCache ??= new Promise((resolve) => {
+  rgAvailabilityCache ??= new Promise((resolve2) => {
     try {
       const p = spawn("rg", ["--version"], {
         env: buildChildEnv(),
@@ -140,10 +168,10 @@ function detectRg() {
         signal: AbortSignal.timeout(1e4),
         windowsHide: true
       });
-      p.on("error", () => resolve(false));
-      p.on("close", (code) => resolve(code === 0));
+      p.on("error", () => resolve2(false));
+      p.on("close", (code) => resolve2(code === 0));
     } catch {
-      resolve(false);
+      resolve2(false);
     }
   });
   return rgAvailabilityCache;
@@ -206,6 +234,7 @@ async function* runRgStream(input, base, mode, limit, signal, relativize) {
     windowsHide: true
   });
   const queue = [];
+  const stdoutDecoder = new StringDecoder("utf8");
   let queuedChars = 0;
   let waiter;
   let paused = false;
@@ -227,7 +256,8 @@ async function* runRgStream(input, base, mode, limit, signal, relativize) {
     child.stdout?.resume();
   };
   const onStdoutData = (c) => {
-    const data = c.toString();
+    const data = stdoutDecoder.write(c);
+    if (data.length === 0) return;
     queue.push({ kind: "out", data });
     queuedChars += data.length;
     wake();
@@ -237,7 +267,14 @@ async function* runRgStream(input, base, mode, limit, signal, relativize) {
     queue.push({ kind: "error", data: e.message });
     wake();
   };
-  const onClose = () => {
+  let rgExitCode = null;
+  const onClose = (code) => {
+    rgExitCode = code;
+    const tail = stdoutDecoder.end();
+    if (tail.length > 0) {
+      queue.push({ kind: "out", data: tail });
+      queuedChars += tail.length;
+    }
     queue.push({ kind: "close", data: "" });
     wake();
   };
@@ -319,6 +356,9 @@ async function* runRgStream(input, base, mode, limit, signal, relativize) {
       };
     }
     if (errored) throw new Error("rg: spawn error");
+    if (rgExitCode === 2 && totalLines === 0 && !bufOverflow) {
+      throw new Error("rg: exited with an error and produced no matches");
+    }
     yield {
       type: "final",
       output: {
@@ -398,6 +438,7 @@ async function runNative(input, base, mode, limit, signal, relativize) {
         let lineNumber = 0;
         let fileHits = 0;
         let leftover = "";
+        const decoder = new StringDecoder("utf8");
         let binaryChecked = false;
         const buffer = Buffer.allocUnsafe(Math.min(NATIVE_READ_CHUNK_BYTES, maxBytes));
         while (!stopped && !signal.aborted && bytesReadTotal < maxBytes) {
@@ -415,7 +456,7 @@ async function runNative(input, base, mode, limit, signal, relativize) {
             if (isBinaryBuffer(chunk)) return;
           }
           bytesReadTotal += bytesRead;
-          const text = leftover + chunk.toString("utf8");
+          const text = leftover + decoder.write(chunk);
           const lines = text.split(/\r?\n/);
           leftover = lines.pop() ?? "";
           for (const rawLine of lines) {
@@ -439,6 +480,7 @@ async function runNative(input, base, mode, limit, signal, relativize) {
           }
           if (mode === "files_with_matches" && fileHits > 0) break;
         }
+        leftover += decoder.end();
         if (!stopped && !signal.aborted && leftover.length > 0) {
           lineNumber++;
           const ln = leftover.length > 4096 ? capSubject(leftover) : leftover;
@@ -526,4 +568,4 @@ export {
   __resetRgDetectionForTests,
   __setRgAvailableForTests
 };
-//# sourceMappingURL=chunk-2W4XTULI.js.map
+//# sourceMappingURL=chunk-DLZCOEVG.js.map