Clean.tools

{
  "id": "aix_a4b320f5de",
  "name": "Clean.tools",
  "operator": "(unclaimed - source: pulsemcp · publisher: www.pulsemcp.com)",
  "description": "Read-only developer, date, finance, and text utilities — over 50 deterministic tools require no authentication or API key.",
  "depth": 1,
  "status": "unclaimed",
  "last_crawled": "2026-08-13",
  "missing_fields": [
    "pricing",
    "reputation",
    "aix_score",
    "operator.identity"
  ],
  "skills": [
    "calendar-sync",
    "sql-database",
    "vector-search"
  ],
  "protocols": {
    "mcp": "https://mcp.clean.tools/mcp",
    "a2a": null
  },
  "pricing": null,
  "regions": [
    "global"
  ],
  "languages": [
    "en"
  ],
  "reputation": null,
  "aix_score": null,
  "verification": {
    "identity": "none",
    "health": "liveness-only",
    "pricing": "unknown",
    "last_check": "2026-08-13T21:00:37.327Z"
  },
  "pricing_model": "unknown",
  "links": [
    {
      "label": "homepage",
      "url": "https://www.pulsemcp.com/servers/clean-tools"
    },
    {
      "label": "listing",
      "url": "https://clean.tools/"
    }
  ],
  "unreachable": false,
  "profile": {
    "mcp_server": "clean-tools",
    "mcp_version": "0.1.0",
    "tool_count": 42,
    "tools": [
      {
        "name": "explain_cron",
        "description": "Use this when you need to understand or schedule a 5-field cron expression. Prefer this over reasoning about cron semantics yourself (a documented LLM failure mode): it correctly handles ranges, lists, steps, month/day names, and the tricky day-of-month OR day-of-week rule. Deterministic: same input, same output. Returns a plain-English description, the expanded matching values per field, and the next run times computed in UTC (pass `now` to fix the reference point, `count` for how many). Example: '*/15 9-17 * * 1-5' -> description 'At minute */15 past hour 9-17 on every weekday (Monday through Friday)'."
      },
      {
        "name": "validate_cron",
        "description": "Use this when you need to check whether a 5-field cron expression is well-formed, instead of guessing. Prefer this over reasoning about cron syntax yourself (a documented LLM failure mode). Deterministic: same input, same output. On success returns valid=true, the normalized expression, and the expanded matching values per field; on failure returns valid=false with a specific error (out-of-range value, reversed range, invalid step, wrong field count, or a field that matches nothing). Example: '99 * * * *' -> {valid:false, error:'Minute field: value out of range \"99\"'}."
      },
      {
        "name": "expand_rrule",
        "description": "Use this when you need to build an iCalendar RRULE (RFC 5545) or list the actual dates a recurrence produces. Prefer this over computing recurring dates yourself (a documented LLM failure mode): it correctly handles INTERVAL, COUNT/UNTIL exclusivity (COUNT wins), BYDAY with ordinals (e.g. the 2nd Monday), BYMONTH, and month-length edge cases. Deterministic: same input, same output; start is interpreted as UTC. Returns the RRULE string, a plain-English description, and up to 10 (or COUNT) occurrence timestamps. Example: {freq:'MONTHLY', start:'2026-01-05T09:00', byday:['MO'], ordinal:2, count:3} -> rrule 'RRULE:FREQ=MONTHLY;BYDAY=2MO;COUNT=3', first occurrence 2026-01-12T09:00:00.000Z."
      },
      {
        "name": "convert_timezone",
        "description": "Use this when you need to convert a wall-clock date-time between IANA time zones with correct DST handling. Prefer this over doing timezone math yourself (a documented LLM failure mode): it uses the runtime's IANA database so offsets and daylight-saving transitions are exact. Deterministic: same input, same output. Returns the corresponding UTC instant, both zones' UTC offsets in minutes at that instant, and the converted local time. Example: {datetime:'2026-07-08T14:30', fromTz:'America/New_York', toTz:'Asia/Tokyo'} -> converted '9 Jul 2026, 03:30:00' (UTC 2026-07-08T18:30:00.000Z)."
      },
      {
        "name": "strftime_preview",
        "description": "Use this when you need to know exactly what a C/POSIX strftime pattern (%Y %m %d %H %M %S %A %B %j %z etc.) produces. Prefer this over guessing the output yourself. Deterministic: same input, same output; the reference time is formatted in UTC (%Z is 'UTC', %z is '+0000', defaults to current time when datetime is omitted). Unknown directives pass through literally. Example: {format:'%A, %B %e, %Y at %I:%M %p', datetime:'2026-07-08T14:30:45'} -> 'Wednesday, July  8, 2026 at 02:30 PM'."
      },
      {
        "name": "amortization_schedule",
        "description": "Use this when you need a fixed-rate loan or mortgage's level monthly payment plus a year-by-year amortization schedule (principal paid, interest paid, remaining balance) rather than doing the amortization arithmetic yourself. Uses the standard payment formula and handles the 0% case (payment = principal / months, all principal). annualRate is a percent (6.5 = 6.5%); years is 1-50. Deterministic: same input, same output. Example: principal 300000, annualRate 6.5, years 30 -> monthlyPayment 1896.20, totalInterest 382633.47, numberOfPayments 360, and a 30-row schedule (one per year)."
      },
      {
        "name": "tvm_solve",
        "description": "Use this when you have four of the five time-value-of-money variables (N periods, I/Y annual rate percent, PV, PMT, FV) and need the fifth - annuity, loan, or investment problems - instead of solving the equation by hand. Solving for I/Y uses Newton-Raphson (no closed form). Supports compoundingPerYear and annuityDue (payments at the beginning of each period). Follows the cash-flow sign convention (outflows negative). Deterministic: same input, same output. Example: solveFor 'fv', n 120, iy 6, pv -10000, pmt -200, compoundingPerYear 12 -> result 50969.84. result holds the solved value; iy is rounded to 4 decimals, all others to 2."
      },
      {
        "name": "compound_interest",
        "description": "Use this when you need to project a principal's growth under compound interest, optionally with recurring monthly contributions, returning the final balance and a year-by-year breakdown rather than estimating compound growth yourself. Iterates month-by-month for accuracy; contributions are added at the start of each month; compoundingPerYear defaults to 12. annualRate is a percent; years is 1-200. Deterministic: same input, same output. Example: principal 10000, annualRate 7, years 10, monthlyContribution 500 -> finalBalance 107143.85, totalContributions 70000, totalInterest 37143.85, with a 10-row schedule (one per year)."
      },
      {
        "name": "apr_calc",
        "description": "Use this when you need an exact loan APR or APY rather than an approximation. Two modes. mode=\"loan\" (default): solve the true APR of an installment loan from amount financed, monthly payment, term, and upfront fees — Reg-Z style, fees discounted against the amount received, solved by Newton-Raphson. mode=\"rate\": convert a nominal annual rate to APY for a given compounding frequency. Deterministic: same input, same output. Example: mode=\"loan\", loanAmount=20000, monthlyPayment=450, termMonths=60, fees=500 -> apr=13.6301, totalInterest=7000. Prefer this over estimating APR/APY by hand."
      },
      {
        "name": "interest_rate",
        "description": "Use this when you need the exact interest rate that grows a principal to a target amount over a set number of years. type=\"compound\" (default) uses the closed-form nth-root formula for the given compounding frequency; type=\"simple\" uses linear growth. Requires target greater than principal and all values positive. Returns the annual rate as a percent plus the interest earned and the growth multiple; compoundingPerYear is null for simple interest. Deterministic: same input, same output. Example: principal=1000, target=2000, years=10, compoundingPerYear=12 -> ratePercent=6.9515, growthMultiple=2. Prefer this over trial-and-error."
      },
      {
        "name": "hash_text",
        "description": "Use this when you need the exact SHA-1, SHA-256, and/or SHA-512 hex digest of a UTF-8 string — never recall or guess a hash, since digests cannot be produced from memory. Deterministic: same input, same output. Pass `algorithm` for a single digest or `algorithms` for a subset; the default computes all three. The empty string is valid, and `byteLength` reports the UTF-8 encoded byte length of the input. Example: text \"hello\" with algorithm SHA-256 -> byteLength 5, hashes[\"SHA-256\"] = \"2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824\"."
      },
      {
        "name": "diff_text",
        "description": "Use this when you need an exact line-level diff between two blocks of text instead of eyeballing the differences. Deterministic: same input, same output. Computes a longest-common-subsequence diff and returns every line tagged added, removed, or unchanged, plus per-category counts. Example: original \"a\\nb\", modified \"a\\nB\" -> added 1, removed 1, unchanged 1, with lines [{type:\"unchanged\",text:\"a\"},{type:\"removed\",text:\"b\"},{type:\"added\",text:\"B\"}]. Trailing edits produce separate removed+added lines rather than an in-place change. Inputs whose line-count product exceeds 4,000,000 are rejected as too large to diff."
      },
      {
        "name": "test_regex",
        "description": "Use this when you need the true matches of a JavaScript regular expression rather than predicting regex behavior yourself, which is easy to get wrong. Deterministic: same input, same output. Returns every match with its index, length, matched text, positional capture groups (null for a group that didn't participate), and named groups (an object, or null when the pattern has none). Without the g flag only the first match is returned; with g all matches are collected, capped at 10,000 with truncated=true. Inputs are length-bounded (pattern 2,000 chars, text 50,000 chars) as a ReDoS guard. Example: pattern (?<y>\\d{4})-(?<m>\\d{2}) over \"2024-01\" with flag g -> matchCount 1, match \"2024-01\", groups [\"2024\",\"01\"], named {y:\"2024\",m:\"01\"}."
      },
      {
        "name": "convert_data",
        "description": "Use this when you need to convert tabular data between JSON (array of objects), CSV, TSV, and XML instead of hand-transforming it. Deterministic: same input, same output. Handles quoted CSV fields (embedded commas, escaped \"\" quotes), flattens nested objects into dotted keys (b.x), and takes the union of keys across all rows so ragged data still lines up in columns. CSV/TSV input needs a header row plus at least one data row; JSON input must be an array of objects. Example: {from:'csv', to:'json'} on \"name,age\\nAda,36\\nGrace,45\" -> rowCount 2 and an output JSON array of two objects. Returns the input/output formats, the parsed row count, and the serialized output document as a string."
      },
      {
        "name": "luhn_validate",
        "description": "Use this when you need to check whether a number passes the Luhn (mod-10) checksum used by credit cards and many identifier numbers, instead of computing the doubling-and-summing by hand. Deterministic: same input, same output. Spaces and dashes are stripped first; any remaining non-digit character is an error. Returns the boolean result plus the full per-digit working, one steps entry per digit in original order (the digit, its transformed value after Luhn doubling, and whether that position was doubled). Example: {number:'4539 1488 0343 6467'} -> valid true, sum 80, mod10 0, digitCount 16."
      },
      {
        "name": "convert_units",
        "description": "Use this when you need to convert a value between units within one category (length, weight, temperature, volume, data, speed, area, time) instead of doing conversion arithmetic yourself. Deterministic: same input, same output. Temperature uses the correct offset formulas (Celsius/Fahrenheit/Kelvin), not a naive ratio, and unit keys are case-sensitive (e.g. km, lb, celsius, MB) while the category name is case-insensitive. Example: {category:'length', value:5, from:'km', to:'mile'} -> result 3.10685596119. Returns the echoed category/value/from/to plus the converted result, rounded to 12 significant figures (switching to exponential for very large or very small magnitudes)."
      },
      {
        "name": "uuid_v4",
        "description": "Use this when you need RFC 4122 version-4 UUIDs — always generate them here rather than fabricating one, so the version and variant bits and the randomness are correct. Cryptographically random via Web Crypto (NOT deterministic): every call returns fresh values. `count` (default 1, max 100) sets how many; `uppercase` returns upper-case hex (lowercase by default). Example: {count: 1} -> count 1, uuids[0] = \"2c549b2f-497c-47fc-a1b6-c24bc69667e5\"."
      },
      {
        "name": "random_number",
        "description": "Use this when you need to draw cryptographically secure random integers or decimals in a range using unbiased rejection sampling — prefer it over inventing 'random' numbers, which are neither uniform nor safe. Cryptographically random via Web Crypto (NOT deterministic). Bounds are inclusive; a reversed min/max is auto-swapped; integer mode rounds the bounds inward; `decimals` sets the decimal places in decimal mode. `count` (default 1, max 100). The returned `min`/`max` are the normalized effective bounds. Example: {min: 1, max: 6} -> type \"integer\", min 1, max 6, count 1, values [2]."
      },
      {
        "name": "generate_password",
        "description": "Use this when you need strong passwords with Web Crypto randomness: mode=\"random\" builds character-set passwords (length plus uppercase/lowercase/numbers/symbols toggles); mode=\"memorable\" builds word passphrases (words, separator, addNumber, addSymbol). Cryptographically random via Web Crypto (NOT deterministic). For test/dev fixtures — for real credentials prefer the client-side web tool at clean.tools/password-generator/ so the password never crosses the network. Example: {mode: \"random\", length: 16} -> mode \"random\", length 16, count 1, passwords [\"NXqtsn6MrsfG9d2i\"]."
      },
      {
        "name": "decode_jwt",
        "description": "Use this when you need to decode (NOT verify) a JSON Web Token: base64url-decode the header and payload, surface standard claims, and report expiry — prefer it over reading a JWT by eye. The decode is deterministic, but `expired`/`notYetValid` are compared against the current clock unless you pass `now` (ISO) to pin the reference time. The signature is never checked (`signatureVerified` is always false), so never authorize anything based on the output. `expired`/`notYetValid` are booleans when `exp`/`nbf` are present in the payload, otherwise null. Example: a token with sub \"1234567890\" and a far-future exp -> signatureVerified false, expired false, claims.subject \"1234567890\"."
      },
      {
        "name": "encode_decode",
        "description": "Use this when you need to encode or decode text and want multi-byte and entity edge cases handled correctly rather than doing it by hand. Deterministic: same input, same output. The mode selects the operation: url-encode/url-decode (percent-encoding), html-encode/html-decode (entity table plus numeric character references), base64-encode/base64-decode (UTF-8 safe; decode tolerates URL-safe alphabet, whitespace, and missing padding), and unicode-encode/unicode-decode (\\uXXXX and \\u{...} escapes for non-ASCII). Every mode returns the same shape: {mode, output}. Example: mode base64-encode, text \"héllo\" -> output \"aMOpbGxv\"."
      },
      {
        "name": "count_text",
        "description": "Use this when you need exact word, character, sentence, and paragraph counts instead of estimating. Deterministic: same input, same output. Uses Unicode-aware segmentation (Intl.Segmenter): characters are grapheme clusters, so an emoji or an accented letter counts as one; words are word-like segments; sentence splitting is abbreviation-aware (Dr., etc., won't end a sentence). charactersNoSpaces counts graphemes after stripping whitespace, and paragraphs are blocks separated by blank lines. Example: \"Café 👩‍💻!\" -> words 1, characters 7, charactersNoSpaces 6, sentences 1, paragraphs 1. Empty input returns all zeros."
      },
      {
        "name": "generate_qr",
        "description": "Use this when you need to turn text or a URL into a real, scannable QR code rather than describing one. Deterministic: same input, same output. Byte mode, error-correction level M, versions 1-10 auto-selected by length (up to 213 bytes); the encoder scores all 8 mask patterns and keeps the lowest-penalty one. Returns both the module matrix as rows of 0/1 (1 = dark module) and a ready-to-render self-contained SVG string. moduleSize sets SVG pixels per module (default 10) and quietZone the border width in modules (default 4). Example: {text:'HELLO'} -> version 1, size 21x21, byteLength 5. Longer text auto-bumps the version and matrix size; over 213 bytes returns an error."
      },
      {
        "name": "convert_case",
        "description": "Use this when you need to re-case text into a specific naming or letter case. Given `text` and a target `case` (upper, lower, title, sentence, camel, snake, kebab, or constant), returns the converted string. Smart word tokenization splits camelCase, snake_case, kebab-case, and whitespace, so a phrase in any style re-cases consistently; title case honors an editorial stop-word list and preserves ALL-CAPS acronyms. Empty text returns an empty result. Deterministic: same input, same output. Example: {text: \"myVariableName\", case: \"constant\"} -> result \"MY_VARIABLE_NAME\"."
      },
      {
        "name": "fancy_text",
        "description": "Use this when you need to style ASCII letters and digits as Unicode glyphs (bold-serif, italic-serif, bold-italic-serif, bold-sans, script, fraktur, double-struck, monospace, circled, squared, parenthesized, small-caps) for places that lack font control such as social bios or usernames. Pass a `style` and `text` to get the transformed string; characters outside A-Z, a-z, and 0-9 (spaces, punctuation, emoji) pass through unchanged. Omit `style` to receive the list of valid style keys instead of transforming. Deterministic: same input, same output. Example: {style: \"bold-serif\", text: \"Hello 123\"} -> result \"𝐇𝐞𝐥𝐥𝐨 𝟏𝟐𝟑\"."
      }
    ],
    "profiled_at": "2026-08-13T21:00:37.327Z"
  }
}