@tpmjs/official-hash-text 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2025 TPMJS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,104 @@
+# @tpmjs/official-hash-text
+
+Hash text using cryptographic algorithms (MD5, SHA-1, SHA-256, SHA-512).
+
+## Installation
+
+```bash
+npm install @tpmjs/official-hash-text
+```
+
+## Usage
+
+```typescript
+import { hashTextTool } from '@tpmjs/official-hash-text';
+import { generateText } from 'ai';
+
+const result = await generateText({
+  model: yourModel,
+  tools: {
+    hashText: hashTextTool,
+  },
+  prompt: 'Hash "Hello, World!" using SHA-256',
+});
+```
+
+## Parameters
+
+- `text` (string, required): The text to hash
+- `algorithm` (string, required): Hash algorithm to use
+  - Options: `'md5'`, `'sha1'`, `'sha256'`, `'sha512'`
+
+## Returns
+
+```typescript
+{
+  hash: string;          // The hexadecimal hash digest
+  algorithm: string;     // The algorithm used
+  inputLength: number;   // The length of the input text
+}
+```
+
+## Examples
+
+### SHA-256 hash
+
+```typescript
+const result = await hashTextTool.execute({
+  text: 'Hello, World!',
+  algorithm: 'sha256',
+});
+// {
+//   hash: 'dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f',
+//   algorithm: 'sha256',
+//   inputLength: 13
+// }
+```
+
+### MD5 hash
+
+```typescript
+const result = await hashTextTool.execute({
+  text: 'Hello, World!',
+  algorithm: 'md5',
+});
+// {
+//   hash: '65a8e27d8879283831b664bd8b7f0ad4',
+//   algorithm: 'md5',
+//   inputLength: 13
+// }
+```
+
+### SHA-512 hash
+
+```typescript
+const result = await hashTextTool.execute({
+  text: 'password123',
+  algorithm: 'sha512',
+});
+// Returns 128-character hexadecimal hash
+```
+
+## Use Cases
+
+- Generating content fingerprints for deduplication
+- Creating checksums for data integrity verification
+- Hashing user input for comparison (note: use proper password hashing for credentials)
+- Generating cache keys
+- Creating unique identifiers from content
+- File integrity checks
+
+## Algorithm Guide
+
+| Algorithm | Output Length | Use Case |
+|-----------|--------------|----------|
+| `md5`     | 32 hex chars (128 bits) | Legacy systems, checksums (not cryptographically secure) |
+| `sha1`    | 40 hex chars (160 bits) | Git commits, legacy systems (weakened security) |
+| `sha256`  | 64 hex chars (256 bits) | General purpose, recommended for most use cases |
+| `sha512`  | 128 hex chars (512 bits) | High security requirements, larger hash space |
+
+**Note:** MD5 and SHA-1 are not recommended for security-critical applications. Use SHA-256 or SHA-512 for cryptographic purposes.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+import * as ai from 'ai';
+
+/**
+ * Hash Text Tool for TPMJS
+ * Hash text using various cryptographic algorithms
+ */
+/**
+ * Supported hash algorithms
+ */
+type HashAlgorithm = 'md5' | 'sha1' | 'sha256' | 'sha512';
+/**
+ * Input interface for text hashing
+ */
+interface HashTextInput {
+    text: string;
+    algorithm: HashAlgorithm;
+}
+/**
+ * Output interface for hash text result
+ */
+interface HashTextResult {
+    hash: string;
+    algorithm: string;
+    inputLength: number;
+}
+/**
+ * Hash Text Tool
+ * Creates cryptographic hashes from text input
+ */
+declare const hashTextTool: ai.Tool<HashTextInput, HashTextResult>;
+
+export { type HashTextResult, hashTextTool as default, hashTextTool };

package/dist/index.js

@@ -0,0 +1,51 @@
+import { createHash } from 'crypto';
+import { tool, jsonSchema } from 'ai';
+
+// src/index.ts
+var hashTextTool = tool({
+  description: "Hash text using cryptographic algorithms (MD5, SHA-1, SHA-256, SHA-512). Returns the hexadecimal hash digest, the algorithm used, and the input text length. Useful for generating checksums, content fingerprints, or data integrity verification.",
+  inputSchema: jsonSchema({
+    type: "object",
+    properties: {
+      text: {
+        type: "string",
+        description: "The text to hash"
+      },
+      algorithm: {
+        type: "string",
+        enum: ["md5", "sha1", "sha256", "sha512"],
+        description: "Hash algorithm to use"
+      }
+    },
+    required: ["text", "algorithm"],
+    additionalProperties: false
+  }),
+  execute: async ({ text, algorithm }) => {
+    if (typeof text !== "string") {
+      throw new Error("Text must be a string");
+    }
+    const validAlgorithms = ["md5", "sha1", "sha256", "sha512"];
+    if (!validAlgorithms.includes(algorithm)) {
+      throw new Error(
+        `Invalid algorithm: ${algorithm}. Must be one of: ${validAlgorithms.join(", ")}`
+      );
+    }
+    try {
+      const hash = createHash(algorithm);
+      hash.update(text, "utf8");
+      const digest = hash.digest("hex");
+      return {
+        hash: digest,
+        algorithm,
+        inputLength: text.length
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to hash text: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+});
+var index_default = hashTextTool;
+
+export { index_default as default, hashTextTool };

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@tpmjs/official-hash-text",
+  "version": "0.1.0",
+  "description": "Hash text using cryptographic algorithms (MD5, SHA-1, SHA-256, SHA-512)",
+  "type": "module",
+  "keywords": [
+    "tpmjs",
+    "data",
+    "hash",
+    "crypto",
+    "md5",
+    "sha256"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "tsup": "^8.3.5",
+    "typescript": "^5.9.3",
+    "@tpmjs/tsconfig": "0.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anthropics/tpmjs.git",
+    "directory": "packages/tools/official/hash-text"
+  },
+  "homepage": "https://tpmjs.com",
+  "license": "MIT",
+  "tpmjs": {
+    "category": "data",
+    "frameworks": [
+      "vercel-ai"
+    ],
+    "tools": [
+      {
+        "name": "hashTextTool",
+        "description": "Hash text using cryptographic algorithms (MD5, SHA-1, SHA-256, SHA-512)",
+        "parameters": [
+          {
+            "name": "text",
+            "type": "string",
+            "description": "The text to hash",
+            "required": true
+          },
+          {
+            "name": "algorithm",
+            "type": "string",
+            "description": "Hash algorithm (md5, sha1, sha256, sha512)",
+            "required": true
+          }
+        ],
+        "returns": {
+          "type": "HashTextResult",
+          "description": "Object with hash digest, algorithm used, and input length"
+        }
+      }
+    ]
+  },
+  "dependencies": {
+    "ai": "6.0.0-beta.124"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "type-check": "tsc --noEmit",
+    "clean": "rm -rf dist .turbo"
+  }
+}