dhar_mcptools 0.1.0__py3-none-any.whl

dhar_mcptools/main.py

@@ -0,0 +1,11 @@
+#from dhar_mcptools.tools import mcp
+from tools import mcp
+
+
+
+def main():
+
+    mcp.run(transport="stdio")
+    
+if __name__ == "__main__":
+    main()

dhar_mcptools/tools.py

@@ -0,0 +1,351 @@
+"""
+Everyday MCP Toolkit
+=====================
+
+An MCP server exposing small, dependency-free utility tools useful for both
+everyday tasks (password generation, unit conversion, date math) and
+developer tasks (hashing, base64, UUIDs, case conversion, text stats).
+
+Everything here uses only the Python standard library, so this server has
+no runtime dependency beyond the `mcp` package itself — nothing to break,
+no API keys, no network calls.
+"""
+
+import base64
+import hashlib
+import re
+import secrets
+import string
+import uuid
+from datetime import date, timedelta
+
+from fastmcp import FastMCP
+
+mcp = FastMCP()
+
+
+# ---------------------------------------------------------------------------
+# Unit conversion data (used by convert_units)
+# ---------------------------------------------------------------------------
+
+_LENGTH_ALIASES = {
+    "mm": "mm", "millimeter": "mm", "millimeters": "mm", "millimetre": "mm", "millimetres": "mm",
+    "cm": "cm", "centimeter": "cm", "centimeters": "cm", "centimetre": "cm", "centimetres": "cm",
+    "m": "m", "meter": "m", "meters": "m", "metre": "m", "metres": "m",
+    "km": "km", "kilometer": "km", "kilometers": "km", "kilometre": "km", "kilometres": "km",
+    "in": "in", "inch": "in", "inches": "in",
+    "ft": "ft", "foot": "ft", "feet": "ft",
+    "yd": "yd", "yard": "yd", "yards": "yd",
+    "mi": "mi", "mile": "mi", "miles": "mi",
+}
+_LENGTH_TO_METERS = {
+    "mm": 0.001, "cm": 0.01, "m": 1.0, "km": 1000.0,
+    "in": 0.0254, "ft": 0.3048, "yd": 0.9144, "mi": 1609.344,
+}
+
+_WEIGHT_ALIASES = {
+    "mg": "mg", "milligram": "mg", "milligrams": "mg",
+    "g": "g", "gram": "g", "grams": "g",
+    "kg": "kg", "kilogram": "kg", "kilograms": "kg",
+    "oz": "oz", "ounce": "oz", "ounces": "oz",
+    "lb": "lb", "lbs": "lb", "pound": "lb", "pounds": "lb",
+    "t": "t", "ton": "t", "tons": "t", "tonne": "t", "tonnes": "t",
+}
+_WEIGHT_TO_GRAMS = {
+    "mg": 0.001, "g": 1.0, "kg": 1000.0,
+    "oz": 28.349523125, "lb": 453.59237, "t": 1_000_000.0,
+}
+
+_VOLUME_ALIASES = {
+    "ml": "ml", "milliliter": "ml", "milliliters": "ml", "millilitre": "ml", "millilitres": "ml",
+    "l": "l", "liter": "l", "liters": "l", "litre": "l", "litres": "l",
+    "gal": "gal", "gallon": "gal", "gallons": "gal",
+    "qt": "qt", "quart": "qt", "quarts": "qt",
+    "pt": "pt", "pint": "pt", "pints": "pt",
+    "cup": "cup", "cups": "cup",
+    "floz": "floz", "fl oz": "floz", "fluidounce": "floz", "fluidounces": "floz",
+    "tbsp": "tbsp", "tablespoon": "tbsp", "tablespoons": "tbsp",
+    "tsp": "tsp", "teaspoon": "tsp", "teaspoons": "tsp",
+}
+_VOLUME_TO_LITERS = {
+    "ml": 0.001, "l": 1.0, "gal": 3.785411784, "qt": 0.946352946,
+    "pt": 0.473176473, "cup": 0.236588236, "floz": 0.0295735296,
+    "tbsp": 0.0147867648, "tsp": 0.0049289216,
+}
+
+_TEMPERATURE_ALIASES = {
+    "c": "c", "celsius": "c", "centigrade": "c",
+    "f": "f", "fahrenheit": "f",
+    "k": "k", "kelvin": "k",
+}
+
+_UNIT_TABLES = {
+    "length": (_LENGTH_ALIASES, _LENGTH_TO_METERS),
+    "weight": (_WEIGHT_ALIASES, _WEIGHT_TO_GRAMS),
+    "volume": (_VOLUME_ALIASES, _VOLUME_TO_LITERS),
+}
+
+
+def _resolve_unit(unit: str):
+    """Return (category, canonical_unit) for a unit string, or None if unrecognized."""
+    key = unit.strip().lower()
+    if key in _TEMPERATURE_ALIASES:
+        return "temperature", _TEMPERATURE_ALIASES[key]
+    for category, (aliases, _factors) in _UNIT_TABLES.items():
+        if key in aliases:
+            return category, aliases[key]
+    return None
+
+
+def _convert_temperature(value: float, from_unit: str, to_unit: str) -> float:
+    if from_unit == "c":
+        celsius = value
+    elif from_unit == "f":
+        celsius = (value - 32) * 5 / 9
+    else:  # "k"
+        celsius = value - 273.15
+
+    if to_unit == "c":
+        return celsius
+    if to_unit == "f":
+        return celsius * 9 / 5 + 32
+    return celsius + 273.15  # "k"
+
+
+@mcp.tool()
+def convert_units(value: float, from_unit: str, to_unit: str) -> str:
+    """Convert a numeric value between common units of length, weight, temperature, or volume.
+
+    Examples: km<->mi, kg<->lb, celsius<->fahrenheit, liter<->gallon.
+
+    Args:
+        value: The numeric value to convert.
+        from_unit: Unit to convert from, e.g. "km", "lb", "celsius", "gallon".
+        to_unit: Unit to convert to, e.g. "mi", "kg", "fahrenheit", "liter".
+    """
+    from_resolved = _resolve_unit(from_unit)
+    to_resolved = _resolve_unit(to_unit)
+
+    if from_resolved is None:
+        return f"Error: unrecognized unit '{from_unit}'."
+    if to_resolved is None:
+        return f"Error: unrecognized unit '{to_unit}'."
+
+    from_category, from_key = from_resolved
+    to_category, to_key = to_resolved
+
+    if from_category != to_category:
+        return (
+            f"Error: '{from_unit}' is a {from_category} unit but "
+            f"'{to_unit}' is a {to_category} unit — can't convert between them."
+        )
+
+    if from_category == "temperature":
+        result = _convert_temperature(value, from_key, to_key)
+    else:
+        _aliases, to_base = _UNIT_TABLES[from_category]
+        result = value * to_base[from_key] / to_base[to_key]
+
+    return f"{value} {from_unit} = {round(result, 6)} {to_unit}"
+
+
+@mcp.tool()
+def generate_password(length: int = 16, use_symbols: bool = True, count: int = 1) -> str:
+    """Generate one or more cryptographically secure random passwords.
+
+    Args:
+        length: Length of each password, between 4 and 128 (default 16).
+        use_symbols: Whether to include symbols like !@#$%^&* (default True).
+        count: How many passwords to generate, between 1 and 20 (default 1).
+    """
+    if not (4 <= length <= 128):
+        return "Error: length must be between 4 and 128."
+    if not (1 <= count <= 20):
+        return "Error: count must be between 1 and 20."
+
+    rng = secrets.SystemRandom()
+    pools = [string.ascii_lowercase, string.ascii_uppercase, string.digits]
+    if use_symbols:
+        pools.append("!@#$%^&*()-_=+[]{}")
+    all_chars = "".join(pools)
+
+    passwords = []
+    for _ in range(count):
+        # Guarantee at least one character from each selected pool, then fill
+        # the rest randomly, then shuffle so the guaranteed characters aren't
+        # always in the same positions.
+        chars = [rng.choice(pool) for pool in pools]
+        chars += [rng.choice(all_chars) for _ in range(length - len(pools))]
+        rng.shuffle(chars)
+        passwords.append("".join(chars))
+
+    return "\n".join(passwords)
+
+
+@mcp.tool()
+def date_calculator(operation: str, date1: str, date2: str = "", days: int = 0) -> str:
+    """Calculate the difference between two dates, or add/subtract days from a date.
+
+    Args:
+        operation: One of "difference", "add", or "subtract".
+        date1: The starting date, in YYYY-MM-DD format.
+        date2: The second date, in YYYY-MM-DD format. Required for "difference".
+        days: Number of days to add or subtract. Required for "add" or "subtract".
+    """
+    try:
+        d1 = date.fromisoformat(date1.strip())
+    except ValueError:
+        return f"Error: '{date1}' is not a valid date. Use YYYY-MM-DD format."
+
+    op = operation.strip().lower()
+
+    if op == "difference":
+        if not date2:
+            return "Error: 'difference' requires date2 (YYYY-MM-DD)."
+        try:
+            d2 = date.fromisoformat(date2.strip())
+        except ValueError:
+            return f"Error: '{date2}' is not a valid date. Use YYYY-MM-DD format."
+        delta = abs((d2 - d1).days)
+        return f"{delta} day(s) between {date1} and {date2}."
+
+    if op in ("add", "subtract"):
+        offset = timedelta(days=days if op == "add" else -days)
+        result = (d1 + offset).isoformat()
+        sign = "plus" if op == "add" else "minus"
+        return f"{date1} {sign} {days} day(s) = {result}."
+
+    return "Error: operation must be 'difference', 'add', or 'subtract'."
+
+
+@mcp.tool()
+def hash_text(text: str, algorithm: str = "sha256") -> str:
+    """Generate a hash digest of the given text.
+
+    Args:
+        text: The text to hash.
+        algorithm: One of "md5", "sha1", "sha256", "sha512" (default "sha256").
+    """
+    algo = algorithm.strip().lower()
+    valid = {"md5", "sha1", "sha256", "sha512"}
+    if algo not in valid:
+        return f"Error: algorithm must be one of {sorted(valid)}."
+    digest = hashlib.new(algo, text.encode("utf-8")).hexdigest()
+    return f"{algo}: {digest}"
+
+
+@mcp.tool()
+def base64_convert(text: str, operation: str = "encode") -> str:
+    """Encode text to Base64, or decode a Base64 string back to text.
+
+    Args:
+        text: Plain text to encode, or a Base64 string to decode.
+        operation: "encode" or "decode" (default "encode").
+    """
+    op = operation.strip().lower()
+    if op == "encode":
+        return base64.b64encode(text.encode("utf-8")).decode("ascii")
+    if op == "decode":
+        try:
+            decoded = base64.b64decode(text, validate=True)
+        except Exception:
+            return "Error: input is not valid Base64."
+        try:
+            return decoded.decode("utf-8")
+        except UnicodeDecodeError:
+            return f"Decoded bytes are not valid UTF-8 text: {decoded!r}"
+    return "Error: operation must be 'encode' or 'decode'."
+
+
+@mcp.tool()
+def generate_uuid(count: int = 1, uppercase: bool = False) -> str:
+    """Generate one or more random UUIDs (version 4).
+
+    Args:
+        count: How many UUIDs to generate, between 1 and 50 (default 1).
+        uppercase: Whether to return them uppercase (default False).
+    """
+    if not (1 <= count <= 50):
+        return "Error: count must be between 1 and 50."
+    ids = [str(uuid.uuid4()) for _ in range(count)]
+    if uppercase:
+        ids = [i.upper() for i in ids]
+    return "\n".join(ids)
+
+
+def _split_words(text: str):
+    spaced = re.sub(r"(?<=[a-z0-9])(?=[A-Z])", " ", text)
+    spaced = re.sub(r"[_\-]+", " ", spaced)
+    return [w for w in spaced.split(" ") if w]
+
+
+@mcp.tool()
+def convert_case(text: str, target_case: str) -> str:
+    """Convert text between naming styles: snake_case, camelCase, PascalCase,
+    kebab-case, CONSTANT_CASE, Title Case, or Sentence case.
+
+    Args:
+        text: The text to convert (any of the above styles, or plain words).
+        target_case: One of "snake", "camel", "pascal", "kebab", "constant", "title", "sentence".
+    """
+    words = _split_words(text)
+    if not words:
+        return "Error: no words found in input."
+
+    style = target_case.strip().lower()
+    if style == "snake":
+        return "_".join(w.lower() for w in words)
+    if style == "camel":
+        return words[0].lower() + "".join(w.capitalize() for w in words[1:])
+    if style == "pascal":
+        return "".join(w.capitalize() for w in words)
+    if style == "kebab":
+        return "-".join(w.lower() for w in words)
+    if style == "constant":
+        return "_".join(w.upper() for w in words)
+    if style == "title":
+        return " ".join(w.capitalize() for w in words)
+    if style == "sentence":
+        sentence = " ".join(w.lower() for w in words)
+        return sentence[0].upper() + sentence[1:]
+
+    return (
+        "Error: target_case must be one of: snake, camel, pascal, kebab, "
+        "constant, title, sentence."
+    )
+
+
+@mcp.tool()
+def text_stats(text: str) -> str:
+    """Get statistics about a piece of text: character, word, sentence, and
+    paragraph counts, plus an estimated reading time.
+
+    Args:
+        text: The text to analyze.
+    """
+    char_count = len(text)
+    char_count_no_spaces = len(re.sub(r"\s", "", text))
+    words = text.split()
+    word_count = len(words)
+    sentence_count = len([s for s in re.split(r"[.!?]+", text) if s.strip()])
+    paragraphs = [p for p in re.split(r"\n\s*\n", text) if p.strip()]
+    paragraph_count = len(paragraphs) if paragraphs else (1 if text.strip() else 0)
+    reading_minutes = word_count / 200
+    reading_time = "< 1 min" if reading_minutes < 1 else f"~{round(reading_minutes)} min"
+
+    return (
+        f"Characters: {char_count} ({char_count_no_spaces} without whitespace)\n"
+        f"Words: {word_count}\n"
+        f"Sentences: {sentence_count}\n"
+        f"Paragraphs: {paragraph_count}\n"
+        f"Estimated reading time: {reading_time}"
+    )
+
+
+def main() -> None:
+    """Entry point for the `everyday-mcp-toolkit` console script."""
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

dhar_mcptools-0.1.0.dist-info/METADATA

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: dhar_mcptools
+Version: 0.1.0
+Summary: few useful mcp tools
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: fastmcp>=3.4.5

dhar_mcptools-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+dhar_mcptools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dhar_mcptools/main.py,sha256=Kd-N7l0s9yxdH0RHZB7Ds62XfSE9ZAgtu7pFtBBqTNQ,158
+dhar_mcptools/tools.py,sha256=AltMFQy6tKMq34TcVeBe9v9WZhNHx-J1nFUxzED3Bnc,12701
+dhar_mcptools-0.1.0.dist-info/METADATA,sha256=6ikeQZ3P_fy78U9bwlFhHwt08FYqEo1UgVDiwqger1A,188
+dhar_mcptools-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+dhar_mcptools-0.1.0.dist-info/entry_points.txt,sha256=LD29FLajPNUeFviiscOb_kkntlvUgXa9GbbduxakrhY,58
+dhar_mcptools-0.1.0.dist-info/top_level.txt,sha256=XSEJ2yEUtrt3tbzyn30YJ6rdtlkBw7InblGpjv0JPNg,14
+dhar_mcptools-0.1.0.dist-info/RECORD,,

dhar_mcptools-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dhar_mcptools-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dhar_mcptools = dhar_mcptools.main:main

dhar_mcptools-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dhar_mcptools