safe-try-with-ai 1.3.0 → 1.3.2

package/README.md

@@ -1,3 +1,5 @@
+---
+
 # safe-try-with-ai
 
 A lightweight JavaScript utility for **clean error handling** with optional **AI-style runtime suggestions**, without repetitive try/catch blocks.
@@ -10,6 +12,8 @@ A lightweight JavaScript utility for **clean error handling** with optional **AI
 npm install safe-try-with-ai
 ```
 
+---
+
 ## Usage
 
 ### Synchronous example
@@ -20,51 +24,167 @@ const { safeTry } = require("safe-try-with-ai");
 const [err, result] = safeTry(() => JSON.parse('{"x":1}'));
 
 if (err) {
-  console.error(err); // Original error
+  console.error(err);
 } else {
   console.log(result); // { x: 1 }
 }
 ```
 
+---
+
+### Asynchronous example
+
+```js
+const { safeTryAsync } = require("safe-try-with-ai");
+
+const [err, data] = await safeTryAsync(async () => {
+  return await fetchData();
+});
+
+if (err) {
+  console.error(err);
+}
+```
+
+---
+
 ## Optional AI Runtime Suggestions
 
 Enable AI-style runtime suggestions by passing `{ analyze: true }` as the second argument.
 
-### Synchronous example
+```js
+const { safeTry } = require("safe-try-with-ai");
+
+const [err] = safeTry(() => JSON.parse("invalid"), { analyze: true });
+
+if (err) {
+  console.error("Error:", err.message);
+  console.log("Suggestion:", err.suggestion);
+  console.log("Fix:", err.fix);
+}
+```
+
+> AI-style suggestions are **rule-based and local**.
+> No real AI model, no network calls, no data collection.
+
+---
+
+## Default Fallback Value
+
+Use `safeTryDefault` to return a fallback value when an error occurs.
 
 ```js
-const [err, result] = safeTry(() => JSON.parse("invalid"), { analyze: true });
+const { safeTryDefault } = require("safe-try-with-ai");
+
+const result = safeTryDefault(
+  () => JSON.parse("invalid"),
+  {},
+  { analyze: true }
+);
+
+console.log(result); // {}
+```
+
+---
+
+## Safe JSON Parsing
+
+```js
+const { safeTryJson } = require("safe-try-with-ai");
+
+const [err, data] = safeTryJson('{"x":1}', { analyze: true });
 
 if (err) {
-  console.error("Error:", err.message);       // Original error
-  console.log("Suggestion:", err.suggestion); // AI suggestion
-  console.log("Fix:", err.fix);               // Suggested fix
+  console.error(err);
 }
 ```
 
-## Features
+---
 
-- Works with synchronous and asynchronous functions  
-- Eliminates repetitive try/catch blocks  
-- Optional AI-style runtime error suggestions  
-- Zero dependencies  
-- Lightweight and fast
+## CLI Usage
 
+## CLI Usage
 
-## License
+Validate JSON files from the terminal:
 
-MIT
+npx safe-try-with-ai example.json
+npx safe-try-with-ai example.json --analyze
+
+✔ = JSON valid (green)
+✖ = JSON invalid (red)
+Suggestions (blue)
+Fix (green)
+
+Exit codes:
+0 = valid JSON
+1 = invalid JSON or runtime error
+
+
+
+```bash
+npx safe-try-with-ai example.json
+```
+
+Example output:
+
+```
+Error: Unexpected token
+Suggestion: Check JSON formatting
+Fix: Ensure commas and brackets are correct
+```
+
+---
+
+## TypeScript Support
+
+Built-in TypeScript definitions included.
+
+```ts
+import { safeTry } from "safe-try-with-ai";
 
+const [err, result] = safeTry(() => JSON.parse(data));
+```
+
+No configuration required.
+
+---
+
+## Features
+
+* Works with synchronous and asynchronous functions
+* Eliminates repetitive try/catch blocks
+* Optional AI-style runtime suggestions
+* Default fallback handling
+* Safe JSON parsing helper
+* CLI support via `npx`
+* Built-in TypeScript definitions
+* Zero dependencies
+* Lightweight and fast
+
+---
 
 ## Changelog
 
+### v1.3.0
+
+* Added TypeScript definitions
+* Added CLI support
+* Documentation improvements
+
 ### v1.2.0
-- Added `safeTryDefault` for fallback values
-- Added `safeTryJson` for safe JSON parsing
-- Improved AI-style runtime suggestions
-- No breaking changes
+
+* Added `safeTryDefault`
+* Added `safeTryJson`
+* Improved AI-style suggestions
 
 ### v1.1.1
-- Improved JSON error suggestions
+
+* Improved JSON error suggestions
+
+---
+
+## License
+
+MIT
 
 ---

package/bin/safe-try.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const { safeTryJson } = require("../src/index.js");
+
+// ANSI color codes
+const COLORS = {
+    reset: "\x1b[0m",
+    green: "\x1b[32m",
+    red: "\x1b[31m",
+    blue: "\x1b[34m",
+    white: "\x1b[37m",
+};
+
+const green = (text) => COLORS.green + text + COLORS.reset;
+const red = (text) => COLORS.red + text + COLORS.reset;
+const blue = (text) => COLORS.blue + text + COLORS.reset;
+const white = (text) => COLORS.white + text + COLORS.reset;
+
+// CLI Args
+const args = process.argv.slice(2);
+if (args.length === 0) {
+    console.log(red("✖ No file specified"));
+    console.log("Usage: npx safe-try-with-ai <file.json> [--analyze]");
+    process.exit(1);
+}
+
+const filePath = path.resolve(args[0]);
+const analyze = args.includes("--analyze");
+
+// Read and validate JSON
+const [err] = safeTryJson(() => fs.readFileSync(filePath, "utf8"), { analyze });
+
+if (err) {
+    console.log(red("✖ JSON is invalid"));
+    console.log(white(`  └─ Error: ${err.message}`));
+    if (analyze && err.suggestion) {
+        console.log(blue(`  ├─ Suggestion: ${err.suggestion}`));
+        if (err.fix) console.log(green(`  └─ Fix: ${err.fix}`));
+    }
+    process.exit(1);
+} else {
+    console.log(green("✔ JSON is valid"));
+    process.exit(0);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "safe-try-with-ai",
-    "version": "1.3.0",
+    "version": "1.3.2",
     "description": "Clean error handling for JavaScript",
     "keywords": [
         "error-handling",
@@ -8,6 +8,9 @@
         "functional",
         "AI"
     ],
+    "bin": {
+        "safe-try-with-ai": "./bin/safe-try.js"
+    },
     "license": "MIT",
     "author": "madhuka2002",
     "type": "commonjs",

package/index.d.ts

@@ -1,39 +0,0 @@
-export interface AISuggestion {
-  name: string;
-  message: string;
-  suggestion?: string;
-  fix?: string;
-}
-
-export interface SafeTryOptions {
-  analyze?: boolean;
-}
-
-export type SafeTryResult<T> = [null, T] | [Error | AISuggestion, null];
-
-export function safeTry<T>(
-  fn: () => T,
-  options?: SafeTryOptions
-): SafeTryResult<T>;
-
-export function safeTryAsync<T>(
-  fn: () => Promise<T>,
-  options?: SafeTryOptions
-): Promise<SafeTryResult<T>>;
-
-/**
- * Safely parse JSON with AI-style error suggestions
- */
-export function safeTryJson<T = unknown>(
-  json: string,
-  options?: SafeTryOptions
-): SafeTryResult<T>;
-
-/**
- * Execute with a default fallback value on error
- */
-export function safeTryDefault<T>(
-  fn: () => T,
-  defaultValue: T,
-  options?: SafeTryOptions
-): T;