@crewhaus/tool-validate 0.1.3 → 0.1.5

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import { CrewhausError } from "@crewhaus/errors";
+import type { RegisteredTool } from "@crewhaus/tool-catalog";
+export type ZodIssue = {
+    readonly path: ReadonlyArray<string | number>;
+    readonly message: string;
+};
+export declare class ToolValidationError extends CrewhausError {
+    readonly name = "ToolValidationError";
+    readonly issues: ReadonlyArray<ZodIssue>;
+    constructor(message: string, issues: ReadonlyArray<ZodIssue>, cause?: unknown);
+}
+export type ValidationResult = {
+    readonly ok: true;
+    readonly value: unknown;
+} | {
+    readonly ok: false;
+    readonly error: ToolValidationError;
+};
+export declare function validateToolInput(tool: RegisteredTool, rawInput: unknown): ValidationResult;

package/dist/index.js

@@ -0,0 +1,22 @@
+import { CrewhausError } from "@crewhaus/errors";
+export class ToolValidationError extends CrewhausError {
+    name = "ToolValidationError";
+    issues;
+    constructor(message, issues, cause) {
+        super("tool", message, cause);
+        this.issues = issues;
+    }
+}
+export function validateToolInput(tool, rawInput) {
+    const result = tool.inputSchema.safeParse(rawInput);
+    if (result.success)
+        return { ok: true, value: result.data };
+    const issues = result.error.issues.map((i) => ({
+        path: i.path,
+        message: i.message,
+    }));
+    return {
+        ok: false,
+        error: new ToolValidationError(`invalid input for tool "${tool.name}": ${issues.map((i) => i.message).join("; ")}`, issues, result.error),
+    };
+}

package/package.json

@@ -1,19 +1,22 @@
 {
   "name": "@crewhaus/tool-validate",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "type": "module",
   "description": "Pre-permission input validation per tool using the tool's Zod schema",
-  "main": "src/index.ts",
-  "types": "src/index.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
   },
   "scripts": {
     "test": "bun test src"
   },
   "dependencies": {
-    "@crewhaus/errors": "0.1.3",
-    "@crewhaus/tool-catalog": "0.1.3",
+    "@crewhaus/errors": "0.1.5",
+    "@crewhaus/tool-catalog": "0.1.5",
     "zod": "^3.23.8"
   },
   "license": "Apache-2.0",
@@ -34,5 +37,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "files": ["src", "README.md", "LICENSE", "NOTICE"]
+  "files": ["dist", "README.md", "LICENSE", "NOTICE"]
 }

package/src/index.test.ts

@@ -1,99 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { CrewhausError } from "@crewhaus/errors";
-import type { RegisteredTool } from "@crewhaus/tool-catalog";
-import { z } from "zod";
-import { ToolValidationError, validateToolInput } from "./index";
-
-const schema = z.object({ command: z.string(), args: z.array(z.string()).optional() });
-
-const tool: RegisteredTool = {
-  name: "Bash",
-  description: "Run shell commands",
-  inputSchema: schema as RegisteredTool["inputSchema"],
-  execute: async () => "",
-  concurrencySafe: false,
-  readOnly: false,
-  destructive: false,
-  requiresSandbox: false,
-  classifyOutput: true,
-  scope: "internal",
-  requireJustification: false,
-};
-
-describe("validateToolInput — success", () => {
-  test("returns ok:true with parsed value for valid input", () => {
-    const result = validateToolInput(tool, { command: "ls" });
-    expect(result.ok).toBe(true);
-    if (result.ok) {
-      expect((result.value as { command: string }).command).toBe("ls");
-    }
-  });
-
-  test("optional fields are present when provided", () => {
-    const result = validateToolInput(tool, { command: "git", args: ["status"] });
-    expect(result.ok).toBe(true);
-    if (result.ok) {
-      expect((result.value as { args: string[] }).args).toEqual(["status"]);
-    }
-  });
-
-  test("optional fields absent when omitted", () => {
-    const result = validateToolInput(tool, { command: "pwd" });
-    expect(result.ok).toBe(true);
-    if (result.ok) {
-      expect((result.value as { args?: unknown }).args).toBeUndefined();
-    }
-  });
-});
-
-describe("validateToolInput — failure", () => {
-  test("returns ok:false with ToolValidationError for wrong type", () => {
-    const result = validateToolInput(tool, { command: 42 });
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error).toBeInstanceOf(ToolValidationError);
-    }
-  });
-
-  test("error message includes tool name", () => {
-    const result = validateToolInput(tool, null);
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error.message).toContain("Bash");
-    }
-  });
-
-  test("error.issues contains path and message", () => {
-    const result = validateToolInput(tool, { command: 123 });
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error.issues.length).toBeGreaterThan(0);
-      expect(result.error.issues[0]).toHaveProperty("path");
-      expect(result.error.issues[0]).toHaveProperty("message");
-    }
-  });
-
-  test("ToolValidationError is instanceof CrewhausError", () => {
-    const result = validateToolInput(tool, {});
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error).toBeInstanceOf(CrewhausError);
-    }
-  });
-
-  test("ToolValidationError has code 'tool'", () => {
-    const result = validateToolInput(tool, {});
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error.code).toBe("tool");
-    }
-  });
-
-  test("ToolValidationError name is stable", () => {
-    const result = validateToolInput(tool, {});
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error.name).toBe("ToolValidationError");
-    }
-  });
-});

package/src/index.ts

@@ -1,37 +0,0 @@
-import { CrewhausError } from "@crewhaus/errors";
-import type { RegisteredTool } from "@crewhaus/tool-catalog";
-
-export type ZodIssue = { readonly path: ReadonlyArray<string | number>; readonly message: string };
-
-export class ToolValidationError extends CrewhausError {
-  override readonly name = "ToolValidationError";
-  readonly issues: ReadonlyArray<ZodIssue>;
-
-  constructor(message: string, issues: ReadonlyArray<ZodIssue>, cause?: unknown) {
-    super("tool", message, cause);
-    this.issues = issues;
-  }
-}
-
-export type ValidationResult =
-  | { readonly ok: true; readonly value: unknown }
-  | { readonly ok: false; readonly error: ToolValidationError };
-
-export function validateToolInput(tool: RegisteredTool, rawInput: unknown): ValidationResult {
-  const result = tool.inputSchema.safeParse(rawInput);
-  if (result.success) return { ok: true, value: result.data };
-
-  const issues: ZodIssue[] = result.error.issues.map((i) => ({
-    path: i.path as ReadonlyArray<string | number>,
-    message: i.message,
-  }));
-
-  return {
-    ok: false,
-    error: new ToolValidationError(
-      `invalid input for tool "${tool.name}": ${issues.map((i) => i.message).join("; ")}`,
-      issues,
-      result.error,
-    ),
-  };
-}