revxl-devtools 1.0.0

package/dist/registry.js

@@ -0,0 +1,13 @@
+// ---------------------------------------------------------------------------
+// Tool registry — separated to avoid circular import issues with ESM hoisting
+// ---------------------------------------------------------------------------
+const tools = new Map();
+export function registerTool(tool) {
+    tools.set(tool.name, tool);
+}
+export function getToolByName(name) {
+    return tools.get(name);
+}
+export function getAllTools() {
+    return Array.from(tools.values());
+}

package/dist/tools/base64.d.ts

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

package/dist/tools/base64.js

@@ -0,0 +1,29 @@
+import { registerTool } from "../registry.js";
+registerTool({
+    name: "base64",
+    description: "Encode or decode Base64 strings",
+    pro: false,
+    inputSchema: {
+        type: "object",
+        properties: {
+            text: { type: "string", description: "Text to encode or Base64 string to decode" },
+            action: {
+                type: "string",
+                enum: ["encode", "decode"],
+                description: "encode or decode",
+            },
+        },
+        required: ["text", "action"],
+    },
+    handler: async (args) => {
+        const text = args.text;
+        const action = args.action;
+        if (action === "encode") {
+            return Buffer.from(text, "utf-8").toString("base64");
+        }
+        // Handle URL-safe Base64 variant
+        const normalized = text.replace(/-/g, "+").replace(/_/g, "/");
+        const decoded = Buffer.from(normalized, "base64").toString("utf-8");
+        return decoded;
+    },
+});

package/dist/tools/batch.d.ts

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

package/dist/tools/batch.js

@@ -0,0 +1,56 @@
+import { registerTool, getToolByName } from "../registry.js";
+// ---------------------------------------------------------------------------
+// Batch runner — execute a free tool across multiple inputs
+// ---------------------------------------------------------------------------
+const MAX_ITEMS = 500;
+registerTool({
+    name: "batch",
+    description: "Run any free tool across multiple inputs in one call — up to 500 items. Only works with free (non-Pro) tools.",
+    pro: true,
+    inputSchema: {
+        type: "object",
+        properties: {
+            tool: {
+                type: "string",
+                description: "Name of the tool to run (must be a free tool)",
+            },
+            items: {
+                type: "array",
+                items: { type: "object" },
+                description: "Array of argument objects — each is passed to the tool's handler (max 500)",
+            },
+        },
+        required: ["tool", "items"],
+    },
+    handler: async (args) => {
+        const toolName = args.tool;
+        const items = args.items;
+        if (!Array.isArray(items) || items.length === 0) {
+            throw new Error("items must be a non-empty array");
+        }
+        if (items.length > MAX_ITEMS) {
+            throw new Error(`Maximum ${MAX_ITEMS} items per batch (got ${items.length})`);
+        }
+        const tool = getToolByName(toolName);
+        if (!tool) {
+            throw new Error(`Unknown tool: ${toolName}`);
+        }
+        if (tool.pro) {
+            throw new Error(`Batch only works with free tools. "${toolName}" is a Pro tool.`);
+        }
+        const results = [];
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const result = await tool.handler(items[i]);
+                const text = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+                results.push(`[${i}] ${text}`);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                results.push(`[${i}] ERROR: ${message}`);
+            }
+        }
+        const header = `Batch ${toolName}: ${items.length} items`;
+        return `${header}\n${"=".repeat(header.length)}\n\n${results.join("\n\n")}`;
+    },
+});

package/dist/tools/chmod.d.ts

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

package/dist/tools/chmod.js

@@ -0,0 +1,115 @@
+import { registerTool } from "../registry.js";
+// ---------------------------------------------------------------------------
+// Chmod converter — numeric ↔ symbolic with human-readable explanation
+// ---------------------------------------------------------------------------
+const PERM_MAP = {
+    0: "---",
+    1: "--x",
+    2: "-w-",
+    3: "-wx",
+    4: "r--",
+    5: "r-x",
+    6: "rw-",
+    7: "rwx",
+};
+const ROLE_NAMES = ["Owner", "Group", "Others"];
+const PERM_LABELS = {
+    r: "read",
+    w: "write",
+    x: "execute",
+};
+function numericToSymbolic(mode) {
+    const digits = mode.split("").map(Number);
+    return digits.map((d) => PERM_MAP[d]).join("");
+}
+function symbolicToNumeric(mode) {
+    // Expect 9-char symbolic like "rwxr-xr-x"
+    const clean = mode.replace(/^-/, ""); // strip leading - if present (like -rwxr-xr-x)
+    const chars = clean.length >= 9 ? clean.slice(0, 9) : clean;
+    let result = "";
+    for (let i = 0; i < 3; i++) {
+        const group = chars.slice(i * 3, i * 3 + 3);
+        let val = 0;
+        if (group[0] === "r")
+            val += 4;
+        if (group[1] === "w")
+            val += 2;
+        if (group[2] === "x")
+            val += 1;
+        result += val;
+    }
+    return result;
+}
+function describePermissions(numericMode) {
+    const digits = numericMode.split("").map(Number);
+    const descriptions = [];
+    for (let i = 0; i < 3; i++) {
+        const symbolic = PERM_MAP[digits[i]];
+        const perms = [];
+        for (const ch of symbolic) {
+            if (ch !== "-" && PERM_LABELS[ch]) {
+                perms.push(PERM_LABELS[ch]);
+            }
+        }
+        const permStr = perms.length > 0 ? perms.join(", ") : "none";
+        descriptions.push(`${ROLE_NAMES[i]}: ${permStr}`);
+    }
+    return descriptions;
+}
+function isNumericMode(mode) {
+    return /^[0-7]{3,4}$/.test(mode);
+}
+function isSymbolicMode(mode) {
+    // Accept rwxr-xr-x or -rwxr-xr-x
+    return /^-?[rwx-]{9}$/.test(mode);
+}
+registerTool({
+    name: "chmod",
+    description: "Convert between numeric (755) and symbolic (rwxr-xr-x) chmod permissions with explanation",
+    pro: true,
+    inputSchema: {
+        type: "object",
+        properties: {
+            mode: {
+                type: "string",
+                description: 'Permission mode — numeric (e.g. "755") or symbolic (e.g. "rwxr-xr-x")',
+            },
+        },
+        required: ["mode"],
+    },
+    handler: async (args) => {
+        const mode = args.mode.trim();
+        if (!mode)
+            throw new Error("mode is required");
+        if (isNumericMode(mode)) {
+            // Take last 3 digits (ignore leading 0 in 0755)
+            const digits = mode.slice(-3);
+            const symbolic = numericToSymbolic(digits);
+            const explanation = describePermissions(digits);
+            return [
+                "=== Chmod: Numeric → Symbolic ===",
+                "",
+                `Numeric:  ${digits}`,
+                `Symbolic: ${symbolic}`,
+                "",
+                "--- Permissions ---",
+                ...explanation.map((e) => `  ${e}`),
+            ].join("\n");
+        }
+        if (isSymbolicMode(mode)) {
+            const clean = mode.startsWith("-") ? mode.slice(1) : mode;
+            const numeric = symbolicToNumeric(clean);
+            const explanation = describePermissions(numeric);
+            return [
+                "=== Chmod: Symbolic → Numeric ===",
+                "",
+                `Symbolic: ${clean}`,
+                `Numeric:  ${numeric}`,
+                "",
+                "--- Permissions ---",
+                ...explanation.map((e) => `  ${e}`),
+            ].join("\n");
+        }
+        throw new Error(`Invalid mode: "${mode}". Use numeric (e.g. "755") or symbolic (e.g. "rwxr-xr-x").`);
+    },
+});

package/dist/tools/cron.d.ts

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

package/dist/tools/cron.js

@@ -0,0 +1,311 @@
+import { registerTool } from "../registry.js";
+import { generateCronCode } from "../codegen/cron-codegen.js";
+// ---------------------------------------------------------------------------
+// Cron expression explainer, generator, and next-run calculator
+// ---------------------------------------------------------------------------
+const FIELD_NAMES = ["minute", "hour", "day of month", "month", "day of week"];
+const MONTH_NAMES = [
+    "", "January", "February", "March", "April", "May", "June",
+    "July", "August", "September", "October", "November", "December",
+];
+const DOW_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+function parseField(raw, min, max) {
+    if (raw === "*")
+        return { type: "any", raw };
+    // Step: */N or N-M/S
+    if (raw.includes("/")) {
+        const [base, stepStr] = raw.split("/");
+        const step = parseInt(stepStr, 10);
+        if (base === "*") {
+            return { type: "step", raw, step, rangeStart: min, rangeEnd: max };
+        }
+        if (base.includes("-")) {
+            const [s, e] = base.split("-").map(Number);
+            return { type: "step", raw, step, rangeStart: s, rangeEnd: e };
+        }
+        return { type: "step", raw, step, rangeStart: parseInt(base, 10), rangeEnd: max };
+    }
+    // Range: N-M
+    if (raw.includes("-") && !raw.includes(",")) {
+        const [s, e] = raw.split("-").map(Number);
+        return { type: "range", raw, rangeStart: s, rangeEnd: e };
+    }
+    // List: N,M,O
+    if (raw.includes(",")) {
+        const values = raw.split(",").map(Number);
+        return { type: "list", raw, values };
+    }
+    // Single value
+    return { type: "value", raw, values: [parseInt(raw, 10)] };
+}
+function expandField(field, min, max) {
+    switch (field.type) {
+        case "any": {
+            const vals = [];
+            for (let i = min; i <= max; i++)
+                vals.push(i);
+            return vals;
+        }
+        case "value":
+        case "list":
+            return field.values;
+        case "range": {
+            const vals = [];
+            for (let i = field.rangeStart; i <= field.rangeEnd; i++)
+                vals.push(i);
+            return vals;
+        }
+        case "step": {
+            const vals = [];
+            for (let i = field.rangeStart; i <= field.rangeEnd; i += field.step)
+                vals.push(i);
+            return vals;
+        }
+    }
+}
+function describeField(field, index) {
+    const name = FIELD_NAMES[index];
+    switch (field.type) {
+        case "any":
+            return `${name}: every ${name}`;
+        case "value": {
+            const v = field.values[0];
+            if (index === 3)
+                return `${name}: ${MONTH_NAMES[v] || v}`;
+            if (index === 4)
+                return `${name}: ${DOW_NAMES[v] || v}`;
+            return `${name}: ${v}`;
+        }
+        case "list": {
+            const labels = field.values.map((v) => {
+                if (index === 3)
+                    return MONTH_NAMES[v] || String(v);
+                if (index === 4)
+                    return DOW_NAMES[v] || String(v);
+                return String(v);
+            });
+            return `${name}: ${labels.join(", ")}`;
+        }
+        case "range":
+            return `${name}: ${field.rangeStart} through ${field.rangeEnd}`;
+        case "step":
+            return `${name}: every ${field.step} starting at ${field.rangeStart}`;
+    }
+}
+// ---------------------------------------------------------------------------
+// Next run calculator
+// ---------------------------------------------------------------------------
+function fieldMatches(value, allowed) {
+    return allowed.includes(value);
+}
+function getNextRuns(expression, count, fromDate) {
+    const parts = expression.split(/\s+/);
+    if (parts.length !== 5)
+        throw new Error("Invalid cron: expected 5 fields");
+    const ranges = [[0, 59], [0, 23], [1, 31], [1, 12], [0, 6]];
+    const allowedSets = parts.map((p, i) => {
+        const field = parseField(p, ranges[i][0], ranges[i][1]);
+        return expandField(field, ranges[i][0], ranges[i][1]);
+    });
+    const [allowedMin, allowedHour, allowedDom, allowedMonth, allowedDow] = allowedSets;
+    const results = [];
+    const start = fromDate ? new Date(fromDate) : new Date();
+    // Round up to next minute
+    start.setSeconds(0, 0);
+    start.setMinutes(start.getMinutes() + 1);
+    const maxIterations = count * 1440 * 32; // generous limit
+    const current = new Date(start);
+    for (let i = 0; i < maxIterations && results.length < count; i++) {
+        const min = current.getMinutes();
+        const hour = current.getHours();
+        const dom = current.getDate();
+        const month = current.getMonth() + 1;
+        const dow = current.getDay();
+        if (fieldMatches(min, allowedMin) &&
+            fieldMatches(hour, allowedHour) &&
+            fieldMatches(dom, allowedDom) &&
+            fieldMatches(month, allowedMonth) &&
+            fieldMatches(dow, allowedDow)) {
+            results.push(new Date(current));
+        }
+        current.setMinutes(current.getMinutes() + 1);
+    }
+    return results;
+}
+// ---------------------------------------------------------------------------
+// Natural language -> cron
+// ---------------------------------------------------------------------------
+function naturalToCron(text) {
+    const lower = text.toLowerCase().trim();
+    // "every N minutes"
+    const everyMinMatch = lower.match(/every\s+(\d+)\s+minutes?/);
+    if (everyMinMatch)
+        return `*/${everyMinMatch[1]} * * * *`;
+    // "every N hours"
+    const everyHourMatch = lower.match(/every\s+(\d+)\s+hours?/);
+    if (everyHourMatch)
+        return `0 */${everyHourMatch[1]} * * *`;
+    // "every minute"
+    if (/every\s+minute/.test(lower))
+        return "* * * * *";
+    // "every hour"
+    if (/every\s+hour/.test(lower))
+        return "0 * * * *";
+    // "midnight"
+    if (/midnight/.test(lower))
+        return "0 0 * * *";
+    // "noon"
+    if (/noon/.test(lower))
+        return "0 12 * * *";
+    // "every day at Xam/pm" or "daily at X"
+    const dailyMatch = lower.match(/(?:every\s+day|daily)\s+at\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)?/);
+    if (dailyMatch) {
+        let hour = parseInt(dailyMatch[1], 10);
+        const min = dailyMatch[2] ? parseInt(dailyMatch[2], 10) : 0;
+        const ampm = dailyMatch[3];
+        if (ampm === "pm" && hour < 12)
+            hour += 12;
+        if (ampm === "am" && hour === 12)
+            hour = 0;
+        return `${min} ${hour} * * *`;
+    }
+    // "every weekday at X"
+    const weekdayMatch = lower.match(/every\s+weekday\s+at\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)?/);
+    if (weekdayMatch) {
+        let hour = parseInt(weekdayMatch[1], 10);
+        const min = weekdayMatch[2] ? parseInt(weekdayMatch[2], 10) : 0;
+        const ampm = weekdayMatch[3];
+        if (ampm === "pm" && hour < 12)
+            hour += 12;
+        if (ampm === "am" && hour === 12)
+            hour = 0;
+        return `${min} ${hour} * * 1-5`;
+    }
+    // "every monday/tuesday/..." with optional "at X"
+    const dayNames = {
+        sunday: 0, monday: 1, tuesday: 2, wednesday: 3,
+        thursday: 4, friday: 5, saturday: 6,
+    };
+    const dayMatch = lower.match(/every\s+(sunday|monday|tuesday|wednesday|thursday|friday|saturday)(?:\s+at\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)?)?/);
+    if (dayMatch) {
+        const dow = dayNames[dayMatch[1]];
+        let hour = dayMatch[2] ? parseInt(dayMatch[2], 10) : 0;
+        const min = dayMatch[3] ? parseInt(dayMatch[3], 10) : 0;
+        const ampm = dayMatch[4];
+        if (ampm === "pm" && hour < 12)
+            hour += 12;
+        if (ampm === "am" && hour === 12)
+            hour = 0;
+        return `${min} ${hour} * * ${dow}`;
+    }
+    throw new Error(`Could not parse: "${text}". Try formats like "every 5 minutes", "every day at 3pm", "every monday at 9am", "midnight", "noon"`);
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+registerTool({
+    name: "cron",
+    description: "Explain cron expressions in plain English, generate cron from natural language, and compute next run times with code snippets",
+    pro: true,
+    inputSchema: {
+        type: "object",
+        properties: {
+            action: {
+                type: "string",
+                enum: ["explain", "generate", "next_runs"],
+                description: "explain: parse and describe a cron expression | generate: natural language to cron | next_runs: compute upcoming run times",
+            },
+            expression: {
+                type: "string",
+                description: "(explain, next_runs) A 5-field cron expression like '*/5 * * * *'",
+            },
+            text: {
+                type: "string",
+                description: '(generate) Natural language schedule like "every 5 minutes" or "every monday at 9am"',
+            },
+            count: {
+                type: "number",
+                description: "(next_runs) Number of upcoming runs to compute (default: 5)",
+            },
+        },
+        required: ["action"],
+    },
+    handler: async (args) => {
+        const action = args.action;
+        if (action === "explain") {
+            const expression = args.expression;
+            if (!expression)
+                throw new Error("expression is required for explain action");
+            const parts = expression.split(/\s+/);
+            if (parts.length !== 5)
+                throw new Error("Invalid cron expression: expected 5 space-separated fields");
+            const ranges = [[0, 59], [0, 23], [1, 31], [1, 12], [0, 6]];
+            const fields = parts.map((p, i) => parseField(p, ranges[i][0], ranges[i][1]));
+            const sections = [
+                `=== Cron: ${expression} ===`,
+                "",
+                "--- Fields ---",
+                ...fields.map((f, i) => `  ${parts[i].padEnd(6)} ${describeField(f, i)}`),
+                "",
+            ];
+            // Next 3 runs
+            const nextRuns = getNextRuns(expression, 3);
+            sections.push("--- Next 3 Runs ---");
+            for (const run of nextRuns) {
+                sections.push(`  ${run.toISOString()}`);
+            }
+            sections.push("");
+            sections.push("--- Code ---");
+            sections.push(generateCronCode(expression));
+            return sections.join("\n");
+        }
+        if (action === "generate") {
+            const text = args.text;
+            if (!text)
+                throw new Error("text is required for generate action");
+            const expression = naturalToCron(text);
+            const parts = expression.split(/\s+/);
+            const ranges = [[0, 59], [0, 23], [1, 31], [1, 12], [0, 6]];
+            const fields = parts.map((p, i) => parseField(p, ranges[i][0], ranges[i][1]));
+            const sections = [
+                `=== Generated Cron ===`,
+                "",
+                `Input: "${text}"`,
+                `Expression: ${expression}`,
+                "",
+                "--- Fields ---",
+                ...fields.map((f, i) => `  ${parts[i].padEnd(6)} ${describeField(f, i)}`),
+                "",
+            ];
+            const nextRuns = getNextRuns(expression, 3);
+            sections.push("--- Next 3 Runs ---");
+            for (const run of nextRuns) {
+                sections.push(`  ${run.toISOString()}`);
+            }
+            sections.push("");
+            sections.push("--- Code ---");
+            sections.push(generateCronCode(expression));
+            return sections.join("\n");
+        }
+        if (action === "next_runs") {
+            const expression = args.expression;
+            if (!expression)
+                throw new Error("expression is required for next_runs action");
+            const count = args.count || 5;
+            const runs = getNextRuns(expression, count);
+            const sections = [
+                `=== Next ${count} Runs for: ${expression} ===`,
+                "",
+            ];
+            for (let i = 0; i < runs.length; i++) {
+                sections.push(`  ${i + 1}. ${runs[i].toISOString()}`);
+            }
+            if (runs.length < count) {
+                sections.push("");
+                sections.push(`(Only found ${runs.length} matching times within search window)`);
+            }
+            return sections.join("\n");
+        }
+        throw new Error(`Unknown action: ${action}. Use "explain", "generate", or "next_runs".`);
+    },
+});

package/dist/tools/hash.d.ts

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

package/dist/tools/hash.js

@@ -0,0 +1,25 @@
+import { createHash } from "node:crypto";
+import { registerTool } from "../registry.js";
+registerTool({
+    name: "hash_text",
+    description: "Hash text with MD5, SHA-256, or SHA-512",
+    pro: false,
+    inputSchema: {
+        type: "object",
+        properties: {
+            text: { type: "string", description: "Text to hash" },
+            algorithm: {
+                type: "string",
+                enum: ["md5", "sha256", "sha512"],
+                description: "Hash algorithm (default: sha256)",
+            },
+        },
+        required: ["text"],
+    },
+    handler: async (args) => {
+        const text = args.text;
+        const algorithm = args.algorithm || "sha256";
+        const digest = createHash(algorithm).update(text, "utf-8").digest("hex");
+        return `${algorithm}: ${digest}`;
+    },
+});

package/dist/tools/http-status.d.ts

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

package/dist/tools/http-status.js

@@ -0,0 +1,59 @@
+import { registerTool } from "../registry.js";
+const STATUS_CODES = {
+    100: ["Continue", "Informational"],
+    101: ["Switching Protocols", "Informational"],
+    200: ["OK", "Success"],
+    201: ["Created", "Success"],
+    202: ["Accepted", "Success"],
+    204: ["No Content", "Success"],
+    206: ["Partial Content", "Success"],
+    301: ["Moved Permanently", "Redirection"],
+    302: ["Found", "Redirection"],
+    303: ["See Other", "Redirection"],
+    304: ["Not Modified", "Redirection"],
+    307: ["Temporary Redirect", "Redirection"],
+    308: ["Permanent Redirect", "Redirection"],
+    400: ["Bad Request", "Client Error"],
+    401: ["Unauthorized", "Client Error"],
+    403: ["Forbidden", "Client Error"],
+    404: ["Not Found", "Client Error"],
+    405: ["Method Not Allowed", "Client Error"],
+    406: ["Not Acceptable", "Client Error"],
+    408: ["Request Timeout", "Client Error"],
+    409: ["Conflict", "Client Error"],
+    410: ["Gone", "Client Error"],
+    411: ["Length Required", "Client Error"],
+    412: ["Precondition Failed", "Client Error"],
+    413: ["Payload Too Large", "Client Error"],
+    414: ["URI Too Long", "Client Error"],
+    415: ["Unsupported Media Type", "Client Error"],
+    418: ["I'm a Teapot", "Client Error"],
+    422: ["Unprocessable Entity", "Client Error"],
+    429: ["Too Many Requests", "Client Error"],
+    500: ["Internal Server Error", "Server Error"],
+    501: ["Not Implemented", "Server Error"],
+    502: ["Bad Gateway", "Server Error"],
+    503: ["Service Unavailable", "Server Error"],
+    504: ["Gateway Timeout", "Server Error"],
+};
+registerTool({
+    name: "http_status",
+    description: "Look up HTTP status code name and category",
+    pro: false,
+    inputSchema: {
+        type: "object",
+        properties: {
+            code: { type: "number", description: "HTTP status code (e.g. 404)" },
+        },
+        required: ["code"],
+    },
+    handler: async (args) => {
+        const code = args.code;
+        const entry = STATUS_CODES[code];
+        if (!entry) {
+            return `Unknown HTTP status code: ${code}`;
+        }
+        const [name, category] = entry;
+        return `${code} ${name} (${category})`;
+    },
+});

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

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