ata-coder 2.4.2__py3-none-any.whl

ata_coder/skills/general-coder/SKILL.md

@@ -0,0 +1,76 @@
+---
+name: general-coder
+description: General-purpose coding assistant. Writes, debugs, refactors, and explains code.
+triggers:
+  - code
+  - write
+  - implement
+  - fix
+  - add
+  - change
+  - refactor
+  - build
+  - create
+  - 写
+  - 改
+  - 修
+  - 加
+  - 实现
+tools: []
+---
+
+You are an **expert software engineer** embedded in a coding agent. Your job is to understand the user's intent, navigate the codebase, make precise changes, verify them, and communicate clearly.
+
+## Workflow
+
+1. **Understand** — read relevant files before acting. Never guess file contents.
+2. **Plan** — outline your approach before writing code. For complex tasks, break into subtasks.
+3. **Execute** — make minimal, surgical edits. One logical change per edit.
+4. **Verify** — run tests, check the build, or validate manually if applicable.
+5. **Explain** — summarize what you did, why, and any important caveats.
+
+## Code Quality
+
+- **Match existing style** — naming, indentation, comment density, import ordering
+- **Prefer readability** over cleverness. Code is read more than written.
+- **One logical change** per edit. Don't mix unrelated fixes.
+- **Add tests** when the codebase has an existing test framework.
+- **Handle edge cases** — null/empty inputs, error paths, boundary conditions.
+
+## Communication
+
+Your responses should be clear, structured, and easy to scan:
+
+- **Use `**bold**` generously** for key terms, file names, function names, and important conclusions. Bold text draws the reader's eye to what matters most.
+- **Use `file_path:line_number` references** — they're clickable and help the user jump to code.
+- **Use emojis sparingly** to mark sections: 🐛 for bugs, ⚡ for performance, 🔒 for security, ✅ for completed items.
+- **Keep it concise.** Say what you found, what you changed, and why. Don't write novels.
+- **If blocked**, say so directly and suggest next steps. Don't silently give up.
+- **Use bullet lists** for multiple points, **code blocks** for code, **tables** for comparisons.
+
+### Response Structure (for complex tasks)
+
+```
+## Summary
+**What** was done and **why**
+
+## Changes
+- `file.py:42` — **specific change** with reason
+- `other.py:10` — **another change** with reason
+
+## Verification
+**How** you confirmed it works (tests run, manual check, etc.)
+
+## Notes (optional)
+Any caveats, follow-ups, or things the user should know.
+```
+
+## Rules
+
+1. **Read before edit** — never guess file contents.
+2. **Surgical edits** — change only what's needed. Don't refactor what isn't broken.
+3. **Tool failures** — read the error, diagnose, retry with a fix. Don't just report failure.
+4. **No destructive ops** — never run `rm -rf`, `DROP TABLE`, `git push --force`, etc. unless explicitly asked.
+5. **Use dedicated tools** — prefer `grep`/`glob` over shell `find`/`grep`. Use `edit_file` for precise edits.
+6. **Verify your work** — after making changes, confirm they compile/run/pass tests.
+7. **Report faithfully** — if tests fail, show the output. If you skipped a step, say so.

ata_coder/skills/math-calculator/README.md

@@ -0,0 +1,40 @@
+# Math Calculator Skill
+
+Safely evaluate mathematical expressions with configurable precision.
+
+## Quick Start
+
+```python
+from ata_coder.skills import get_skill_manager
+
+mgr = get_skill_manager()
+result = mgr.execute_skill("math-calculator", {
+    "expression": "2 + 3 * 4",
+    "precision": 2,
+})
+print(result)  # {"success": True, "result": 14, ...}
+```
+
+## Parameters
+
+| Name | Type | Required | Default | Description |
+|------|------|----------|---------|-------------|
+| expression | string | yes | — | Math expression |
+| precision | integer | no | 6 | Decimal places |
+| format | string | no | number | `number` or `steps` |
+
+## Supported Operations
+
+- Arithmetic: `+ - * / ** %`
+- Functions: `sqrt sin cos tan log abs round`
+- Constants: `pi e`
+
+## Security
+
+Input is sanitized against code injection. Expressions over 500 chars are rejected.
+
+## Testing
+
+```bash
+pytest tests/
+```

ata_coder/skills/math-calculator/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: math-calculator
+version: "1.0.0"
+description: Safely evaluate mathematical expressions with configurable precision
+type: skill
+call:
+  function: calculate
+  parameters:
+    expression:
+      type: string
+      description: "Mathematical expression to evaluate (e.g., '2 + 3 * 4')"
+      required: true
+    precision:
+      type: integer
+      description: "Number of decimal places in result"
+      default: 6
+    format:
+      type: string
+      description: "Output format: 'number' or 'steps' (show intermediate steps)"
+      default: number
+output:
+  format: json
+  schema:
+    result:
+      type: number
+      description: "The computed result"
+    expression:
+      type: string
+      description: "The original expression"
+    precision:
+      type: integer
+      description: "Precision used"
+permissions:
+  network: false
+  filesystem: none
+  allowed_commands: []
+tags: [math, utility, calculator]
+---
+
+# Math Calculator
+
+You are a precise mathematical calculator. When asked to compute an expression:
+
+1. Parse the expression carefully, respecting operator precedence
+2. Evaluate step by step if format='steps'
+3. Return the result to the specified precision
+
+## Supported Operations
+
+- Basic: +, -, *, /, ** (power), % (modulo)
+- Functions: sqrt, sin, cos, tan, log, abs, round
+- Constants: pi, e
+
+## Important
+
+- Never execute shell commands to calculate
+- Use Python's `math` module internally
+- Sanitize input — reject expressions over 500 characters
+- For security, only allow safe mathematical expressions (no `__import__`, `eval` injection, etc.)

ata_coder/skills/math-calculator/handler.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+"""Math Calculator Skill — safe expression evaluation."""
+
+import math
+import re
+from typing import Any
+
+
+# Allowed builtins for safe evaluation
+_SAFE_BUILTINS = {
+    "abs": abs, "round": round, "int": int, "float": float,
+    "max": max, "min": min, "sum": sum, "pow": pow,
+    "len": len, "range": range, "list": list, "tuple": tuple,
+}
+_SAFE_MATH = {
+    "sqrt": math.sqrt, "sin": math.sin, "cos": math.cos,
+    "tan": math.tan, "log": math.log, "log10": math.log10,
+    "log2": math.log2, "exp": math.exp, "pi": math.pi, "e": math.e,
+    "ceil": math.ceil, "floor": math.floor, "degrees": math.degrees,
+    "radians": math.radians, "asin": math.asin, "acos": math.acos,
+    "atan": math.atan, "sinh": math.sinh, "cosh": math.cosh,
+    "tanh": math.tanh, "fabs": math.fabs, "factorial": math.factorial,
+    "gcd": math.gcd, "trunc": math.trunc, "modf": math.modf,
+    "isclose": math.isclose,
+}
+_SAFE_NAMES = {**_SAFE_BUILTINS, **_SAFE_MATH}
+
+# Regex for sanitizing expressions
+_UNSAFE_PATTERNS = [
+    r"__",           # dunder attributes
+    r"import",       # imports
+    r"exec\s*\(",    # exec()
+    r"eval\s*\(",    # recursive eval
+    r"open\s*\(",    # file open
+    r"os\.",         # os module
+    r"sys\.",        # sys module
+    r"subprocess",   # subprocess
+    r"lambda",       # lambda (can create arbitrary code)
+    r"globals?\s*\(",  # globals()
+    r"locals?\s*\(",   # locals()
+    r"getattr\s*\(",   # getattr()
+    r"setattr\s*\(",   # setattr()
+]
+
+
+def run(input_data: dict[str, Any]) -> dict[str, Any]:
+    """
+    Evaluate a mathematical expression safely.
+
+    Args:
+        input_data: {"expression": str, "precision": int = 6, "format": str = "number"}
+
+    Returns:
+        {"success": bool, "result": number|null, "expression": str, "error": str|null}
+    """
+    expression = input_data.get("expression", "").strip()
+    precision = input_data.get("precision", 6)
+    output_format = input_data.get("format", "number")
+
+    # Validate
+    if not expression:
+        return _error("No expression provided", expression, 400)
+
+    if len(expression) > 500:
+        return _error("Expression too long (>500 chars)", expression, 400)
+
+    # Sanitize — check for unsafe patterns
+    lowered = expression.lower()
+    for pattern in _UNSAFE_PATTERNS:
+        if re.search(pattern, lowered):
+            return _error(f"Unsafe pattern detected: {pattern}", expression, 403)
+
+    # Evaluate safely
+    try:
+        result = eval(expression, {"__builtins__": {}}, _SAFE_NAMES)
+    except SyntaxError as e:
+        return _error(f"Syntax error: {e}", expression, 400)
+    except ZeroDivisionError:
+        return _error("Division by zero", expression, 400)
+    except Exception as e:
+        return _error(f"Evaluation error: {type(e).__name__}: {e}", expression, 400)
+
+    # Format
+    if isinstance(result, float):
+        result = round(result, precision)
+
+    return {
+        "success": True,
+        "result": result,
+        "expression": expression,
+        "precision": precision,
+        "error": None,
+    }
+
+
+def _error(msg: str, expr: str, code: int) -> dict[str, Any]:
+    return {
+        "success": False,
+        "result": None,
+        "expression": expr,
+        "error": msg,
+        "status_code": code,
+    }

ata_coder/skills/math-calculator/prompts/system.md

@@ -0,0 +1,8 @@
+You are a precise mathematical calculator.
+
+Rules:
+- Parse expressions respecting standard operator precedence (PEMDAS)
+- Use Python's math module internally
+- Return results rounded to the requested precision
+- Reject any expression containing non-mathematical operations
+- If format='steps', show each intermediate step

ata_coder/skills/math-calculator/requirements.txt

@@ -0,0 +1,2 @@
+# Math Calculator — no external dependencies
+# Uses only Python stdlib (math, re)

ata_coder/skills/math-calculator/resources/constants.json

@@ -0,0 +1,8 @@
+{
+  "pi": 3.141592653589793,
+  "e": 2.718281828459045,
+  "golden_ratio": 1.618033988749895,
+  "speed_of_light": 299792458,
+  "planck_constant": 6.62607015e-34,
+  "avogadro": 6.02214076e23
+}

ata_coder/skills/math-calculator/tests/test_handler.py

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+"""Tests for math-calculator handler."""
+
+import sys
+from pathlib import Path
+
+# Add parent to path so we can import handler
+sys.path.insert(0, str(Path(__file__).parent.parent))
+from handler import run
+
+
+def test_basic_addition():
+    result = run({"expression": "2 + 3"})
+    assert result["success"]
+    assert result["result"] == 5
+
+
+def test_precedence():
+    result = run({"expression": "2 + 3 * 4"})
+    assert result["success"]
+    assert result["result"] == 14
+
+
+def test_sqrt():
+    result = run({"expression": "sqrt(16)"})
+    assert result["success"]
+    assert result["result"] == 4.0
+
+
+def test_empty_expression():
+    result = run({"expression": ""})
+    assert not result["success"]
+    assert result["status_code"] == 400
+
+
+def test_unsafe_import():
+    result = run({"expression": "__import__('os')"})
+    assert not result["success"]
+
+
+def test_unsafe_eval():
+    result = run({"expression": "eval('1+1')"})
+    assert not result["success"]
+
+
+def test_division_by_zero():
+    result = run({"expression": "1/0"})
+    assert not result["success"]
+
+
+def test_long_expression():
+    result = run({"expression": "1+" * 300})
+    assert not result["success"]

ata_coder/skills/security-auditor/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: security-auditor
+description: Security-focused code auditor. Finds vulnerabilities, hardcoded secrets, and unsafe patterns.
+triggers:
+  - security audit
+  - security review
+  - hardcoded key
+  - vulnerability
+  - CVE
+  - 安全
+  - 漏洞
+  - secret
+  - password
+  - token leak
+tools: []
+---
+
+You are a security engineer performing a code audit. Find real vulnerabilities, not theoretical ones.
+
+## Audit Checklist
+1. **Secrets exposure** — API keys, tokens, passwords in code or config
+2. **Injection risks** — SQL, command, code injection vectors
+3. **Authentication** — weak or missing auth, session issues
+4. **Authorization** — missing access controls, privilege escalation
+5. **Data exposure** — sensitive data in logs, errors, or client-side
+6. **Dependencies** — known vulnerable packages (check versions)
+7. **Crypto** — weak algorithms, hardcoded keys, bad random
+
+## Output Format
+For each finding:
+- **Severity**: critical / high / medium / low
+- **Location**: file:line
+- **Finding**: what the vulnerability is
+- **Exploit**: how it could be exploited
+- **Fix**: concrete remediation
+
+## Rules
+- Only report findings you can confirm from the code
+- Prioritize exploitable issues over theoretical ones
+- If no serious issues found, say so — don't invent problems

ata_coder/skills/test-writer/SKILL.md

@@ -0,0 +1,36 @@
+---
+name: test-writer
+description: Writes unit tests, integration tests, and test fixtures. Follows testing best practices.
+triggers:
+  - test
+  - unit test
+  - spec
+  - coverage
+  - pytest
+  - jest
+  - vitest
+  - 测试
+  - 写测试
+tools: []
+---
+
+You are a test engineer. Write tests that matter, not tests that inflate coverage numbers.
+
+## Principles
+- **Test behavior, not implementation** — what it does, not how
+- **AAA pattern** — Arrange, Act, Assert
+- **One concept per test** — clear failure messages
+- **Deterministic** — no flaky tests, no random without seeds
+- **Fast** — unit tests in milliseconds
+
+## Coverage Targets
+- Happy path (expected case)
+- Edge cases (empty, null, boundary)
+- Error cases (invalid input, failures)
+- Integration boundaries (DB, API, FS)
+
+## Process
+1. Detect the project's test framework
+2. Study existing test style
+3. Write tests following the same conventions
+4. Run them to confirm they pass

ata_coder/skills/weather-skill/README.md

@@ -0,0 +1,45 @@
+# Weather Skill
+
+Query real-time weather for cities worldwide using the free Open-Meteo API (no API key required).
+
+## Usage
+
+```python
+from ata_coder.skills import get_skill_manager
+mgr = get_skill_manager()
+result = mgr.execute_skill("weather-skill", {
+    "city": "Tokyo",
+    "units": "celsius",
+    "forecast_days": 3,
+})
+```
+
+## Parameters
+
+| Name | Type | Required | Default | Description |
+|------|------|----------|---------|-------------|
+| city | string | yes | — | City name |
+| units | string | no | celsius | `celsius` or `fahrenheit` |
+| forecast_days | integer | no | 1 | 1-7 days |
+
+## Response Format
+
+```json
+{
+  "success": true,
+  "result": {
+    "city": "Tokyo",
+    "country": "Japan",
+    "temperature": "22.5°C",
+    "windspeed": "12 km/h",
+    "conditions": "Clear sky",
+    "humidity": "N/A (free API limitation)"
+  }
+}
+```
+
+## Installation
+
+```bash
+pip install -r requirements.txt
+```

ata_coder/skills/weather-skill/handler.py

@@ -0,0 +1,76 @@
+"""Weather Skill — query weather via Open-Meteo API (free, no API key)."""
+
+from typing import Any
+
+try:
+    import httpx
+except ImportError:
+    httpx = None
+
+from utils import load_city_coords, format_weather_response, GEO_URL, WEATHER_URL
+
+
+def run(input_data: dict[str, Any]) -> dict[str, Any]:
+    """
+    Get weather for a city.
+
+    Args:
+        input_data: {"city": str, "units": str = "celsius", "forecast_days": int = 1}
+
+    Returns:
+        {"success": bool, "result": dict|null, "error": str|null}
+    """
+    city = input_data.get("city", "").strip()
+    units = input_data.get("units", "celsius")
+    forecast_days = min(max(int(input_data.get("forecast_days", 1)), 1), 7)
+
+    if not city:
+        return {"success": False, "result": None, "error": "City name required"}
+
+    # Look up coordinates from local resource
+    cities = load_city_coords()
+    coords = cities.get(city.lower())
+    if not coords:
+        # Try geocoding API
+        coords = _geocode_city(city)
+        if not coords:
+            return {
+                "success": False, "result": None,
+                "error": f"City not found: {city}",
+            }
+
+    lat, lon = coords["lat"], coords["lon"]
+
+    # Fetch weather
+    if httpx is None:
+        return {"success": False, "result": None, "error": "httpx not installed"}
+    try:
+        params = {
+            "latitude": lat, "longitude": lon,
+            "current_weather": "true",
+            "forecast_days": forecast_days,
+            "temperature_unit": "celsius" if units == "celsius" else "fahrenheit",
+        }
+        resp = httpx.get(WEATHER_URL, params=params, timeout=10.0)
+        resp.raise_for_status()
+        data = resp.json()
+    except Exception as e:
+        return {"success": False, "result": None, "error": f"API error: {e}"}
+
+    return format_weather_response(city, coords.get("country", ""), data, units)
+
+
+def _geocode_city(city: str) -> dict | None:
+    """Fallback: geocode city name via Open-Meteo Geocoding API."""
+    if httpx is None:
+        return None
+    try:
+        resp = httpx.get(GEO_URL, params={"name": city, "count": 1}, timeout=5.0)
+        resp.raise_for_status()
+        results = resp.json().get("results", [])
+        if results:
+            r = results[0]
+            return {"lat": r["latitude"], "lon": r["longitude"], "country": r.get("country", "")}
+    except Exception:
+        pass
+    return None

ata_coder/skills/weather-skill/manifest.json

@@ -0,0 +1,48 @@
+{
+  "name": "weather-skill",
+  "version": "1.0.0",
+  "description": "Query weather information for cities worldwide via Open-Meteo API",
+  "type": "skill",
+  "author": "ATA Coder Team",
+  "license": "MIT",
+  "call": {
+    "function": "get_weather",
+    "parameters": {
+      "city": {
+        "type": "string",
+        "description": "City name (e.g., 'Beijing', 'Tokyo', 'London')",
+        "required": true
+      },
+      "units": {
+        "type": "string",
+        "description": "Temperature unit: 'celsius' or 'fahrenheit'",
+        "default": "celsius"
+      },
+      "forecast_days": {
+        "type": "integer",
+        "description": "Number of forecast days (1-7)",
+        "default": 1
+      }
+    }
+  },
+  "output": {
+    "format": "json",
+    "schema": {
+      "city": "string",
+      "country": "string",
+      "temperature": "number",
+      "humidity": "number",
+      "conditions": "string",
+      "forecast": "array"
+    }
+  },
+  "permissions": {
+    "network": true,
+    "filesystem": "read_only",
+    "allowed_domains": ["api.open-meteo.com", "geocoding-api.open-meteo.com"],
+    "allowed_commands": []
+  },
+  "triggers": ["weather", "temperature", "forecast", "天气", "气温", "预报"],
+  "tags": ["weather", "utility", "api"],
+  "dependencies": []
+}

ata_coder/skills/weather-skill/prompts/system_prompt.txt

@@ -0,0 +1,9 @@
+You are a weather information assistant. When asked about weather:
+
+1. Use the get_weather function to query real-time data
+2. Present results in a clear, structured format
+3. Include temperature, conditions, and wind speed
+4. If the city is not found, suggest the user check spelling
+5. For forecasts, present each day clearly
+
+Always use the Open-Meteo API (free, no key required).

ata_coder/skills/weather-skill/prompts/user_prompt_template.txt

@@ -0,0 +1,3 @@
+What is the weather in {{city}}?
+
+Show temperature in {{units}} and include a {{forecast_days}}-day forecast.

ata_coder/skills/weather-skill/requirements.txt

@@ -0,0 +1 @@
+httpx>=0.27.0

ata_coder/skills/weather-skill/resources/city_list.json

@@ -0,0 +1,17 @@
+{
+  "beijing": {"lat": 39.9042, "lon": 116.4074, "country": "China"},
+  "shanghai": {"lat": 31.2304, "lon": 121.4737, "country": "China"},
+  "guangzhou": {"lat": 23.1291, "lon": 113.2644, "country": "China"},
+  "shenzhen": {"lat": 22.5431, "lon": 114.0579, "country": "China"},
+  "tokyo": {"lat": 35.6762, "lon": 139.6503, "country": "Japan"},
+  "osaka": {"lat": 34.6937, "lon": 135.5023, "country": "Japan"},
+  "seoul": {"lat": 37.5665, "lon": 126.9780, "country": "South Korea"},
+  "singapore": {"lat": 1.3521, "lon": 103.8198, "country": "Singapore"},
+  "london": {"lat": 51.5074, "lon": -0.1278, "country": "United Kingdom"},
+  "paris": {"lat": 48.8566, "lon": 2.3522, "country": "France"},
+  "new york": {"lat": 40.7128, "lon": -74.0060, "country": "United States"},
+  "san francisco": {"lat": 37.7749, "lon": -122.4194, "country": "United States"},
+  "sydney": {"lat": -33.8688, "lon": 151.2093, "country": "Australia"},
+  "berlin": {"lat": 52.5200, "lon": 13.4050, "country": "Germany"},
+  "moscow": {"lat": 55.7558, "lon": 37.6173, "country": "Russia"}
+}

ata_coder/skills/weather-skill/resources/error_messages.json

@@ -0,0 +1,7 @@
+{
+  "city_not_found": "City '{{city}}' not found. Check spelling or try a nearby major city.",
+  "api_error": "Weather service temporarily unavailable ({{detail}}). Try again later.",
+  "no_network": "Network access required for weather queries.",
+  "invalid_units": "Units must be 'celsius' or 'fahrenheit', got '{{units}}'.",
+  "forecast_range": "Forecast days must be between 1 and 7, got {{days}}."
+}

ata_coder/skills/weather-skill/tests/test_handler.py

@@ -0,0 +1,28 @@
+"""Tests for weather-skill handler (unit tests, no network)."""
+
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from handler import run
+
+
+def test_missing_city():
+    result = run({"city": ""})
+    assert not result["success"]
+    assert "City name required" in result["error"]
+
+
+def test_unknown_city_no_network():
+    """Without httpx installed, unknown cities should fail gracefully."""
+    result = run({"city": "asdfghjkl"})
+    assert not result["success"]
+
+
+def test_known_city_no_httpx():
+    """With city_list.json but no httpx, should report httpx missing."""
+    result = run({"city": "Beijing"})
+    # Either finds coords in city_list but fails on httpx,
+    # or succeeds if httpx is installed
+    if not result["success"]:
+        assert "httpx" in result.get("error", "").lower() or "city" in result.get("error", "").lower()