revxl-devtools 1.0.2 → 1.0.3

package/src/tools/cron.ts

@@ -1,365 +0,0 @@
-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"] as const;
-
-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"];
-
-// ---------------------------------------------------------------------------
-// Parsing helpers
-// ---------------------------------------------------------------------------
-
-interface CronField {
-  type: "any" | "value" | "range" | "list" | "step";
-  raw: string;
-  values?: number[];
-  step?: number;
-  rangeStart?: number;
-  rangeEnd?: number;
-}
-
-function parseField(raw: string, min: number, max: number): CronField {
-  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: CronField, min: number, max: number): number[] {
-  switch (field.type) {
-    case "any": {
-      const vals: number[] = [];
-      for (let i = min; i <= max; i++) vals.push(i);
-      return vals;
-    }
-    case "value":
-    case "list":
-      return field.values!;
-    case "range": {
-      const vals: number[] = [];
-      for (let i = field.rangeStart!; i <= field.rangeEnd!; i++) vals.push(i);
-      return vals;
-    }
-    case "step": {
-      const vals: number[] = [];
-      for (let i = field.rangeStart!; i <= field.rangeEnd!; i += field.step!) vals.push(i);
-      return vals;
-    }
-  }
-}
-
-function describeField(field: CronField, index: number): string {
-  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: number, allowed: number[]): boolean {
-  return allowed.includes(value);
-}
-
-function getNextRuns(expression: string, count: number, fromDate?: Date): Date[] {
-  const parts = expression.split(/\s+/);
-  if (parts.length !== 5) throw new Error("Invalid cron: expected 5 fields");
-
-  const ranges: [number, number][] = [[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: Date[] = [];
-  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: string): string {
-  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: Record<string, number> = {
-    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 as string;
-
-    if (action === "explain") {
-      const expression = args.expression as string | undefined;
-      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: [number, number][] = [[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: string[] = [
-        `=== 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 as string | undefined;
-      if (!text) throw new Error("text is required for generate action");
-
-      const expression = naturalToCron(text);
-
-      const parts = expression.split(/\s+/);
-      const ranges: [number, number][] = [[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: string[] = [
-        `=== 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 as string | undefined;
-      if (!expression) throw new Error("expression is required for next_runs action");
-
-      const count = (args.count as number) || 5;
-      const runs = getNextRuns(expression, count);
-
-      const sections: string[] = [
-        `=== 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/src/tools/hash.ts

@@ -1,26 +0,0 @@
-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 as string;
-    const algorithm = (args.algorithm as string) || "sha256";
-    const digest = createHash(algorithm).update(text, "utf-8").digest("hex");
-    return `${algorithm}: ${digest}`;
-  },
-});

package/src/tools/http-status.ts

@@ -1,63 +0,0 @@
-import { registerTool } from "../registry.js";
-
-const STATUS_CODES: Record<number, [string, string]> = {
-  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 as number;
-    const entry = STATUS_CODES[code];
-
-    if (!entry) {
-      return `Unknown HTTP status code: ${code}`;
-    }
-
-    const [name, category] = entry;
-    return `${code} ${name} (${category})`;
-  },
-});

package/src/tools/json-diff.ts

@@ -1,153 +0,0 @@
-import { registerTool } from "../registry.js";
-
-// ---------------------------------------------------------------------------
-// Deep JSON diff — compares two JSON values recursively
-// ---------------------------------------------------------------------------
-
-interface DiffEntry {
-  path: string;
-  type: "added" | "removed" | "changed";
-  oldValue?: unknown;
-  newValue?: unknown;
-}
-
-function deepDiff(a: unknown, b: unknown, path: string, results: DiffEntry[]): void {
-  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 as Record<string, unknown>;
-  const bObj = b as Record<string, unknown>;
-  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: unknown): string {
-  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 as string;
-    const bStr = args.b as string;
-
-    let aVal: unknown;
-    let bVal: unknown;
-    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: DiffEntry[] = [];
-    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: string[] = [
-      `=== 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/src/tools/json-format.ts

@@ -1,43 +0,0 @@
-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 as string;
-    const action = (args.action as string) || "format";
-    const indent = (args.indent as number) || 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);
-  },
-});