revxl-devtools 1.0.0

package/dist/tools/json-diff.js

@@ -0,0 +1,131 @@
+import { registerTool } from "../registry.js";
+function deepDiff(a, b, path, results) {
+    if (a === b)
+        return;
+    // Both null/undefined
+    if (a == null && b == null)
+        return;
+    // Type mismatch or primitive change
+    if (typeof a !== typeof b ||
+        a === null ||
+        b === null ||
+        typeof a !== "object" ||
+        typeof b !== "object") {
+        results.push({ path: path || "$", type: "changed", oldValue: a, newValue: b });
+        return;
+    }
+    const aIsArray = Array.isArray(a);
+    const bIsArray = Array.isArray(b);
+    // Array vs object mismatch
+    if (aIsArray !== bIsArray) {
+        results.push({ path: path || "$", type: "changed", oldValue: a, newValue: b });
+        return;
+    }
+    if (aIsArray && bIsArray) {
+        const maxLen = Math.max(a.length, b.length);
+        for (let i = 0; i < maxLen; i++) {
+            const itemPath = `${path}[${i}]`;
+            if (i >= a.length) {
+                results.push({ path: itemPath, type: "added", newValue: b[i] });
+            }
+            else if (i >= b.length) {
+                results.push({ path: itemPath, type: "removed", oldValue: a[i] });
+            }
+            else {
+                deepDiff(a[i], b[i], itemPath, results);
+            }
+        }
+        return;
+    }
+    // Both objects
+    const aObj = a;
+    const bObj = b;
+    const allKeys = new Set([...Object.keys(aObj), ...Object.keys(bObj)]);
+    for (const key of allKeys) {
+        const keyPath = path ? `${path}.${key}` : key;
+        if (!(key in aObj)) {
+            results.push({ path: keyPath, type: "added", newValue: bObj[key] });
+        }
+        else if (!(key in bObj)) {
+            results.push({ path: keyPath, type: "removed", oldValue: aObj[key] });
+        }
+        else {
+            deepDiff(aObj[key], bObj[key], keyPath, results);
+        }
+    }
+}
+function formatValue(val) {
+    if (typeof val === "string")
+        return JSON.stringify(val);
+    if (val === undefined)
+        return "undefined";
+    return JSON.stringify(val);
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+registerTool({
+    name: "json_diff",
+    description: "Deep-compare two JSON objects and show all differences — added, removed, and changed values with paths",
+    pro: true,
+    inputSchema: {
+        type: "object",
+        properties: {
+            a: {
+                type: "string",
+                description: "First JSON string",
+            },
+            b: {
+                type: "string",
+                description: "Second JSON string",
+            },
+        },
+        required: ["a", "b"],
+    },
+    handler: async (args) => {
+        const aStr = args.a;
+        const bStr = args.b;
+        let aVal;
+        let bVal;
+        try {
+            aVal = JSON.parse(aStr);
+        }
+        catch {
+            throw new Error("Invalid JSON in 'a'");
+        }
+        try {
+            bVal = JSON.parse(bStr);
+        }
+        catch {
+            throw new Error("Invalid JSON in 'b'");
+        }
+        const diffs = [];
+        deepDiff(aVal, bVal, "", diffs);
+        if (diffs.length === 0) {
+            return "No differences — the two JSON values are identical.";
+        }
+        const added = diffs.filter((d) => d.type === "added").length;
+        const removed = diffs.filter((d) => d.type === "removed").length;
+        const changed = diffs.filter((d) => d.type === "changed").length;
+        const lines = [
+            `=== JSON Diff: ${diffs.length} difference${diffs.length === 1 ? "" : "s"} ===`,
+            `${added} added, ${removed} removed, ${changed} changed`,
+            "",
+        ];
+        for (const diff of diffs) {
+            const p = diff.path || "$";
+            switch (diff.type) {
+                case "added":
+                    lines.push(`+ ${p}: ${formatValue(diff.newValue)}`);
+                    break;
+                case "removed":
+                    lines.push(`- ${p}: ${formatValue(diff.oldValue)}`);
+                    break;
+                case "changed":
+                    lines.push(`~ ${p}: ${formatValue(diff.oldValue)} → ${formatValue(diff.newValue)}`);
+                    break;
+            }
+        }
+        return lines.join("\n");
+    },
+});

package/dist/tools/json-format.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/json-format.js

@@ -0,0 +1,38 @@
+import { registerTool } from "../registry.js";
+registerTool({
+    name: "json_format",
+    description: "Format, minify, or validate JSON strings",
+    pro: false,
+    inputSchema: {
+        type: "object",
+        properties: {
+            text: { type: "string", description: "JSON string to process" },
+            action: {
+                type: "string",
+                enum: ["format", "minify", "validate"],
+                description: "Action to perform (default: format)",
+            },
+            indent: {
+                type: "number",
+                description: "Number of spaces for indentation (default: 2)",
+            },
+        },
+        required: ["text"],
+    },
+    handler: async (args) => {
+        const text = args.text;
+        const action = args.action || "format";
+        const indent = args.indent || 2;
+        const parsed = JSON.parse(text);
+        if (action === "validate") {
+            const type = Array.isArray(parsed)
+                ? `array[${parsed.length}]`
+                : `object{${Object.keys(parsed).length} keys}`;
+            return `Valid JSON: ${type}`;
+        }
+        if (action === "minify") {
+            return JSON.stringify(parsed);
+        }
+        return JSON.stringify(parsed, null, indent);
+    },
+});

package/dist/tools/json-query.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/json-query.js

@@ -0,0 +1,114 @@
+import { registerTool } from "../registry.js";
+// ---------------------------------------------------------------------------
+// Simple JSON path query — supports dot notation, [N] indexing, * wildcard
+// ---------------------------------------------------------------------------
+function queryPath(data, segments) {
+    if (segments.length === 0)
+        return [data];
+    const [head, ...rest] = segments;
+    if (data === null || data === undefined || typeof data !== "object") {
+        return [];
+    }
+    // Wildcard: expand all array items or object values
+    if (head === "*") {
+        const values = Array.isArray(data) ? data : Object.values(data);
+        const results = [];
+        for (const val of values) {
+            results.push(...queryPath(val, rest));
+        }
+        return results;
+    }
+    // Array index: [N]
+    const indexMatch = head.match(/^\[(\d+)]$/);
+    if (indexMatch) {
+        const idx = parseInt(indexMatch[1], 10);
+        if (Array.isArray(data) && idx < data.length) {
+            return queryPath(data[idx], rest);
+        }
+        return [];
+    }
+    // Object key
+    const obj = data;
+    if (head in obj) {
+        return queryPath(obj[head], rest);
+    }
+    return [];
+}
+function parseQuery(query) {
+    const segments = [];
+    let current = "";
+    for (let i = 0; i < query.length; i++) {
+        const ch = query[i];
+        if (ch === ".") {
+            if (current)
+                segments.push(current);
+            current = "";
+        }
+        else if (ch === "[") {
+            if (current)
+                segments.push(current);
+            current = "";
+            const end = query.indexOf("]", i);
+            if (end === -1)
+                throw new Error(`Unmatched '[' at position ${i}`);
+            segments.push(query.slice(i, end + 1));
+            i = end;
+        }
+        else {
+            current += ch;
+        }
+    }
+    if (current)
+        segments.push(current);
+    return segments;
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+registerTool({
+    name: "json_query",
+    description: "Query JSON data with dot-path expressions — supports nested keys, array indices [N], and wildcard * expansion",
+    pro: true,
+    inputSchema: {
+        type: "object",
+        properties: {
+            json: {
+                type: "string",
+                description: "JSON string to query",
+            },
+            query: {
+                type: "string",
+                description: 'Dot-path query like "data.users[0].name" or "items.*.id" — use * for wildcard, [N] for array index',
+            },
+        },
+        required: ["json", "query"],
+    },
+    handler: async (args) => {
+        const jsonStr = args.json;
+        const query = args.query;
+        let data;
+        try {
+            data = JSON.parse(jsonStr);
+        }
+        catch {
+            throw new Error("Invalid JSON input");
+        }
+        const segments = parseQuery(query);
+        const results = queryPath(data, segments);
+        if (results.length === 0) {
+            return `No results for query: ${query}`;
+        }
+        const sections = [
+            `=== Query: ${query} ===`,
+            `${results.length} result${results.length === 1 ? "" : "s"}`,
+            "",
+        ];
+        if (results.length === 1) {
+            sections.push(JSON.stringify(results[0], null, 2));
+        }
+        else {
+            sections.push(JSON.stringify(results, null, 2));
+        }
+        return sections.join("\n");
+    },
+});

package/dist/tools/jwt.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/jwt.js

@@ -0,0 +1,177 @@
+import { createHmac } from "node:crypto";
+import { registerTool } from "../registry.js";
+// ---------------------------------------------------------------------------
+// Base64url helpers
+// ---------------------------------------------------------------------------
+function base64urlDecode(input) {
+    let base64 = input.replace(/-/g, "+").replace(/_/g, "/");
+    const pad = base64.length % 4;
+    if (pad === 2)
+        base64 += "==";
+    else if (pad === 3)
+        base64 += "=";
+    return Buffer.from(base64, "base64").toString("utf-8");
+}
+function base64urlEncode(input) {
+    const buf = typeof input === "string" ? Buffer.from(input, "utf-8") : input;
+    return buf.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+// ---------------------------------------------------------------------------
+// Known JWT claims
+// ---------------------------------------------------------------------------
+const CLAIM_NAMES = {
+    iss: "Issuer",
+    sub: "Subject",
+    aud: "Audience",
+    exp: "Expiration Time",
+    nbf: "Not Before",
+    iat: "Issued At",
+    jti: "JWT ID",
+};
+function describeClaims(payload) {
+    const lines = [];
+    for (const [key, label] of Object.entries(CLAIM_NAMES)) {
+        if (key in payload) {
+            const val = payload[key];
+            if (["exp", "nbf", "iat"].includes(key) && typeof val === "number") {
+                const date = new Date(val * 1000);
+                lines.push(`  ${key} (${label}): ${val} — ${date.toISOString()}`);
+            }
+            else {
+                lines.push(`  ${key} (${label}): ${JSON.stringify(val)}`);
+            }
+        }
+    }
+    return lines;
+}
+function expiryStatus(payload) {
+    if (typeof payload.exp !== "number")
+        return "No expiration set";
+    const now = Math.floor(Date.now() / 1000);
+    const diff = payload.exp - now;
+    if (diff <= 0) {
+        const mins = Math.abs(Math.round(diff / 60));
+        return `EXPIRED ${mins} minute${mins === 1 ? "" : "s"} ago`;
+    }
+    const mins = Math.round(diff / 60);
+    return `Valid for ${mins} minute${mins === 1 ? "" : "s"}`;
+}
+// ---------------------------------------------------------------------------
+// HMAC signing
+// ---------------------------------------------------------------------------
+function sign(header, payload, secret, algorithm) {
+    const algoMap = {
+        HS256: "sha256",
+        HS384: "sha384",
+        HS512: "sha512",
+    };
+    const hashAlgo = algoMap[algorithm];
+    if (!hashAlgo)
+        throw new Error(`Unsupported algorithm: ${algorithm}`);
+    const data = `${header}.${payload}`;
+    const hmac = createHmac(hashAlgo, secret).update(data).digest();
+    return base64urlEncode(hmac);
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+registerTool({
+    name: "jwt",
+    description: "Decode a JWT to inspect header/payload/expiry, or create a new HMAC-signed JWT",
+    pro: true,
+    inputSchema: {
+        type: "object",
+        properties: {
+            action: {
+                type: "string",
+                enum: ["decode", "create"],
+                description: "decode: inspect a JWT | create: generate a new JWT",
+            },
+            token: {
+                type: "string",
+                description: "(decode) The JWT string to decode",
+            },
+            payload: {
+                type: "object",
+                description: "(create) Claims object for the JWT payload",
+            },
+            secret: {
+                type: "string",
+                description: "(create) HMAC secret for signing",
+            },
+            algorithm: {
+                type: "string",
+                enum: ["HS256", "HS384", "HS512"],
+                description: "(create) Signing algorithm, default HS256",
+            },
+            expires_in: {
+                type: "number",
+                description: "(create) Seconds until expiration",
+            },
+        },
+        required: ["action"],
+    },
+    handler: async (args) => {
+        const action = args.action;
+        if (action === "decode") {
+            const token = args.token;
+            if (!token)
+                throw new Error("token is required for decode action");
+            const parts = token.split(".");
+            if (parts.length !== 3)
+                throw new Error("Invalid JWT: expected 3 dot-separated parts");
+            const header = JSON.parse(base64urlDecode(parts[0]));
+            const payload = JSON.parse(base64urlDecode(parts[1]));
+            const lines = [
+                "=== JWT Decoded ===",
+                "",
+                "--- Header ---",
+                JSON.stringify(header, null, 2),
+                "",
+                "--- Payload ---",
+                JSON.stringify(payload, null, 2),
+                "",
+                "--- Known Claims ---",
+                ...describeClaims(payload),
+                "",
+                `--- Expiry: ${expiryStatus(payload)} ---`,
+                "",
+                "(Signature not verified — provide secret separately if needed)",
+            ];
+            return lines.join("\n");
+        }
+        if (action === "create") {
+            const payloadObj = args.payload || {};
+            const secret = args.secret;
+            if (!secret)
+                throw new Error("secret is required for create action");
+            const algorithm = args.algorithm || "HS256";
+            const expiresIn = args.expires_in;
+            const now = Math.floor(Date.now() / 1000);
+            const claims = { ...payloadObj, iat: now };
+            if (expiresIn)
+                claims.exp = now + expiresIn;
+            const headerB64 = base64urlEncode(JSON.stringify({ alg: algorithm, typ: "JWT" }));
+            const payloadB64 = base64urlEncode(JSON.stringify(claims));
+            const signature = sign(headerB64, payloadB64, secret, algorithm);
+            const token = `${headerB64}.${payloadB64}.${signature}`;
+            const lines = [
+                "=== JWT Created ===",
+                "",
+                token,
+                "",
+                "--- Header ---",
+                JSON.stringify({ alg: algorithm, typ: "JWT" }, null, 2),
+                "",
+                "--- Payload ---",
+                JSON.stringify(claims, null, 2),
+                "",
+                `Algorithm: ${algorithm}`,
+            ];
+            if (expiresIn)
+                lines.push(`Expires in: ${expiresIn} seconds`);
+            return lines.join("\n");
+        }
+        throw new Error(`Unknown action: ${action}. Use "decode" or "create".`);
+    },
+});

package/dist/tools/regex.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools/regex.js

@@ -0,0 +1,116 @@
+import { registerTool } from "../registry.js";
+import { generateRegexCode } from "../codegen/regex-codegen.js";
+registerTool({
+    name: "regex",
+    description: "Test a regex pattern against a string (with match details, groups, indices) and generate working code in JS/Python/Go/Rust/Java",
+    pro: true,
+    inputSchema: {
+        type: "object",
+        properties: {
+            pattern: {
+                type: "string",
+                description: "Regular expression pattern (without delimiters)",
+            },
+            test_string: {
+                type: "string",
+                description: "String to test against (omit to just validate the pattern)",
+            },
+            flags: {
+                type: "string",
+                description: "Regex flags, e.g. 'gi' for global+case-insensitive (default: 'g')",
+            },
+            generate_code: {
+                type: "boolean",
+                description: "Generate code snippets in multiple languages (default: false)",
+            },
+            languages: {
+                type: "array",
+                items: { type: "string" },
+                description: "Languages for code generation: javascript, python, go, rust, java (default: all)",
+            },
+        },
+        required: ["pattern"],
+    },
+    handler: async (args) => {
+        const pattern = args.pattern;
+        const testString = args.test_string;
+        const flags = args.flags || "g";
+        const generateCode = args.generate_code || false;
+        const languages = args.languages;
+        // Validate the pattern first
+        let regex;
+        try {
+            regex = new RegExp(pattern, flags);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return `Invalid regex pattern: ${msg}`;
+        }
+        const sections = [
+            `=== Regex: /${pattern}/${flags} ===`,
+        ];
+        if (testString !== undefined) {
+            const matches = [];
+            if (flags.includes("g")) {
+                // Global: iterate all matches
+                let m;
+                while ((m = regex.exec(testString)) !== null) {
+                    matches.push({
+                        match: m[0],
+                        index: m.index,
+                        groups: m.groups ? { ...m.groups } : null,
+                    });
+                    // Safety: avoid infinite loop on zero-length matches
+                    if (m[0].length === 0)
+                        regex.lastIndex++;
+                }
+            }
+            else {
+                // Non-global: single match with capture groups
+                const m = regex.exec(testString);
+                if (m) {
+                    matches.push({
+                        match: m[0],
+                        index: m.index,
+                        groups: m.groups ? { ...m.groups } : null,
+                    });
+                    // Show capture groups
+                    if (m.length > 1) {
+                        sections.push("");
+                        sections.push("--- Capture Groups ---");
+                        for (let i = 1; i < m.length; i++) {
+                            sections.push(`  Group ${i}: ${JSON.stringify(m[i])}`);
+                        }
+                    }
+                }
+            }
+            sections.push("");
+            if (matches.length === 0) {
+                sections.push("No matches found.");
+            }
+            else {
+                sections.push(`${matches.length} match${matches.length === 1 ? "" : "es"} found:`);
+                sections.push("");
+                for (const match of matches) {
+                    sections.push(`  [${match.index}] "${match.match}"`);
+                    if (match.groups) {
+                        for (const [name, value] of Object.entries(match.groups)) {
+                            sections.push(`        ${name}: "${value}"`);
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            sections.push("");
+            sections.push("Pattern is valid. Provide test_string to see matches.");
+        }
+        if (generateCode) {
+            sections.push("");
+            sections.push("=== Code Snippets ===");
+            sections.push("");
+            sections.push(generateRegexCode(pattern, flags, languages));
+        }
+        return sections.join("\n");
+    },
+});

package/dist/tools/secrets-scan.d.ts

@@ -0,0 +1 @@
+export {};