codehava-agent-kit 1.0.1 → 2.0.0

package/templates/.agent/skills/i18n-localization/SKILL.md

@@ -1,154 +0,0 @@
----
-name: i18n-localization
-description: Internationalization and localization patterns. Detecting hardcoded strings, managing translations, locale files, RTL support.
-allowed-tools: Read, Glob, Grep
----
-
-# i18n & Localization
-
-> Internationalization (i18n) and Localization (L10n) best practices.
-
----
-
-## 1. Core Concepts
-
-| Term | Meaning |
-|------|---------|
-| **i18n** | Internationalization - making app translatable |
-| **L10n** | Localization - actual translations |
-| **Locale** | Language + Region (en-US, tr-TR) |
-| **RTL** | Right-to-left languages (Arabic, Hebrew) |
-
----
-
-## 2. When to Use i18n
-
-| Project Type | i18n Needed? |
-|--------------|--------------|
-| Public web app | ✅ Yes |
-| SaaS product | ✅ Yes |
-| Internal tool | ⚠️ Maybe |
-| Single-region app | ⚠️ Consider future |
-| Personal project | ❌ Optional |
-
----
-
-## 3. Implementation Patterns
-
-### React (react-i18next)
-
-```tsx
-import { useTranslation } from 'react-i18next';
-
-function Welcome() {
-  const { t } = useTranslation();
-  return <h1>{t('welcome.title')}</h1>;
-}
-```
-
-### Next.js (next-intl)
-
-```tsx
-import { useTranslations } from 'next-intl';
-
-export default function Page() {
-  const t = useTranslations('Home');
-  return <h1>{t('title')}</h1>;
-}
-```
-
-### Python (gettext)
-
-```python
-from gettext import gettext as _
-
-print(_("Welcome to our app"))
-```
-
----
-
-## 4. File Structure
-
-```
-locales/
-├── en/
-│   ├── common.json
-│   ├── auth.json
-│   └── errors.json
-├── tr/
-│   ├── common.json
-│   ├── auth.json
-│   └── errors.json
-└── ar/          # RTL
-    └── ...
-```
-
----
-
-## 5. Best Practices
-
-### DO ✅
-
-- Use translation keys, not raw text
-- Namespace translations by feature
-- Support pluralization
-- Handle date/number formats per locale
-- Plan for RTL from the start
-- Use ICU message format for complex strings
-
-### DON'T ❌
-
-- Hardcode strings in components
-- Concatenate translated strings
-- Assume text length (German is 30% longer)
-- Forget about RTL layout
-- Mix languages in same file
-
----
-
-## 6. Common Issues
-
-| Issue | Solution |
-|-------|----------|
-| Missing translation | Fallback to default language |
-| Hardcoded strings | Use linter/checker script |
-| Date format | Use Intl.DateTimeFormat |
-| Number format | Use Intl.NumberFormat |
-| Pluralization | Use ICU message format |
-
----
-
-## 7. RTL Support
-
-```css
-/* CSS Logical Properties */
-.container {
-  margin-inline-start: 1rem;  /* Not margin-left */
-  padding-inline-end: 1rem;   /* Not padding-right */
-}
-
-[dir="rtl"] .icon {
-  transform: scaleX(-1);
-}
-```
-
----
-
-## 8. Checklist
-
-Before shipping:
-
-- [ ] All user-facing strings use translation keys
-- [ ] Locale files exist for all supported languages
-- [ ] Date/number formatting uses Intl API
-- [ ] RTL layout tested (if applicable)
-- [ ] Fallback language configured
-- [ ] No hardcoded strings in components
-
----
-
-## Script
-
-| Script | Purpose | Command |
-|--------|---------|---------|
-| `scripts/i18n_checker.py` | Detect hardcoded strings & missing translations | `python scripts/i18n_checker.py <project_path>` |

package/templates/.agent/skills/i18n-localization/scripts/i18n_checker.py

@@ -1,241 +0,0 @@
-#!/usr/bin/env python3
-"""
-i18n Checker - Detects hardcoded strings and missing translations.
-Scans for untranslated text in React, Vue, and Python files.
-"""
-import sys
-import re
-import json
-from pathlib import Path
-
-# Fix Windows console encoding for Unicode output
-try:
-    sys.stdout.reconfigure(encoding='utf-8', errors='replace')
-    sys.stderr.reconfigure(encoding='utf-8', errors='replace')
-except AttributeError:
-    pass  # Python < 3.7
-
-# Patterns that indicate hardcoded strings (should be translated)
-HARDCODED_PATTERNS = {
-    'jsx': [
-        # Text directly in JSX: <div>Hello World</div>
-        r'>\s*[A-Z][a-zA-Z\s]{3,30}\s*</',
-        # JSX attribute strings: title="Welcome"
-        r'(title|placeholder|label|alt|aria-label)="[A-Z][a-zA-Z\s]{2,}"',
-        # Button/heading text
-        r'<(button|h[1-6]|p|span|label)[^>]*>\s*[A-Z][a-zA-Z\s!?.,]{3,}\s*</',
-    ],
-    'vue': [
-        # Vue template text
-        r'>\s*[A-Z][a-zA-Z\s]{3,30}\s*</',
-        r'(placeholder|label|title)="[A-Z][a-zA-Z\s]{2,}"',
-    ],
-    'python': [
-        # print/raise with string literals
-        r'(print|raise\s+\w+)\s*\(\s*["\'][A-Z][^"\']{5,}["\']',
-        # Flask flash messages
-        r'flash\s*\(\s*["\'][A-Z][^"\']{5,}["\']',
-    ]
-}
-
-# Patterns that indicate proper i18n usage
-I18N_PATTERNS = [
-    r't\(["\']',           # t('key') - react-i18next
-    r'useTranslation',     # React hook
-    r'\$t\(',              # Vue i18n
-    r'_\(["\']',           # Python gettext
-    r'gettext\(',          # Python gettext
-    r'useTranslations',    # next-intl
-    r'FormattedMessage',   # react-intl
-    r'i18n\.',             # Generic i18n
-]
-
-def find_locale_files(project_path: Path) -> list:
-    """Find translation/locale files."""
-    patterns = [
-        "**/locales/**/*.json",
-        "**/translations/**/*.json",
-        "**/lang/**/*.json",
-        "**/i18n/**/*.json",
-        "**/messages/*.json",
-        "**/*.po",  # gettext
-    ]
-    
-    files = []
-    for pattern in patterns:
-        files.extend(project_path.glob(pattern))
-    
-    return [f for f in files if 'node_modules' not in str(f)]
-
-def check_locale_completeness(locale_files: list) -> dict:
-    """Check if all locales have the same keys."""
-    issues = []
-    passed = []
-    
-    if not locale_files:
-        return {'passed': [], 'issues': ["[!] No locale files found"]}
-    
-    # Group by parent folder (language)
-    locales = {}
-    for f in locale_files:
-        if f.suffix == '.json':
-            try:
-                lang = f.parent.name
-                content = json.loads(f.read_text(encoding='utf-8'))
-                if lang not in locales:
-                    locales[lang] = {}
-                locales[lang][f.stem] = set(flatten_keys(content))
-            except:
-                continue
-    
-    if len(locales) < 2:
-        passed.append(f"[OK] Found {len(locale_files)} locale file(s)")
-        return {'passed': passed, 'issues': issues}
-    
-    passed.append(f"[OK] Found {len(locales)} language(s): {', '.join(locales.keys())}")
-    
-    # Compare keys across locales
-    all_langs = list(locales.keys())
-    base_lang = all_langs[0]
-    
-    for namespace in locales.get(base_lang, {}):
-        base_keys = locales[base_lang].get(namespace, set())
-        
-        for lang in all_langs[1:]:
-            other_keys = locales.get(lang, {}).get(namespace, set())
-            
-            missing = base_keys - other_keys
-            if missing:
-                issues.append(f"[X] {lang}/{namespace}: Missing {len(missing)} keys")
-            
-            extra = other_keys - base_keys
-            if extra:
-                issues.append(f"[!] {lang}/{namespace}: {len(extra)} extra keys")
-    
-    if not issues:
-        passed.append("[OK] All locales have matching keys")
-    
-    return {'passed': passed, 'issues': issues}
-
-def flatten_keys(d, prefix=''):
-    """Flatten nested dict keys."""
-    keys = set()
-    for k, v in d.items():
-        new_key = f"{prefix}.{k}" if prefix else k
-        if isinstance(v, dict):
-            keys.update(flatten_keys(v, new_key))
-        else:
-            keys.add(new_key)
-    return keys
-
-def check_hardcoded_strings(project_path: Path) -> dict:
-    """Check for hardcoded strings in code files."""
-    issues = []
-    passed = []
-    
-    # Find code files
-    extensions = {
-        '.tsx': 'jsx', '.jsx': 'jsx', '.ts': 'jsx', '.js': 'jsx',
-        '.vue': 'vue',
-        '.py': 'python'
-    }
-    
-    code_files = []
-    for ext in extensions:
-        code_files.extend(project_path.rglob(f"*{ext}"))
-    
-    code_files = [f for f in code_files if not any(x in str(f) for x in 
-                  ['node_modules', '.git', 'dist', 'build', '__pycache__', 'venv', 'test', 'spec'])]
-    
-    if not code_files:
-        return {'passed': ["[!] No code files found"], 'issues': []}
-    
-    files_with_i18n = 0
-    files_with_hardcoded = 0
-    hardcoded_examples = []
-    
-    for file_path in code_files[:50]:  # Limit
-        try:
-            content = file_path.read_text(encoding='utf-8', errors='ignore')
-            ext = file_path.suffix
-            file_type = extensions.get(ext, 'jsx')
-            
-            # Check for i18n usage
-            has_i18n = any(re.search(p, content) for p in I18N_PATTERNS)
-            if has_i18n:
-                files_with_i18n += 1
-            
-            # Check for hardcoded strings
-            patterns = HARDCODED_PATTERNS.get(file_type, [])
-            hardcoded_found = False
-            
-            for pattern in patterns:
-                matches = re.findall(pattern, content)
-                if matches and not has_i18n:
-                    hardcoded_found = True
-                    if len(hardcoded_examples) < 5:
-                        hardcoded_examples.append(f"{file_path.name}: {str(matches[0])[:40]}...")
-            
-            if hardcoded_found:
-                files_with_hardcoded += 1
-                
-        except:
-            continue
-    
-    passed.append(f"[OK] Analyzed {len(code_files)} code files")
-    
-    if files_with_i18n > 0:
-        passed.append(f"[OK] {files_with_i18n} files use i18n")
-    
-    if files_with_hardcoded > 0:
-        issues.append(f"[X] {files_with_hardcoded} files may have hardcoded strings")
-        for ex in hardcoded_examples:
-            issues.append(f"   → {ex}")
-    else:
-        passed.append("[OK] No obvious hardcoded strings detected")
-    
-    return {'passed': passed, 'issues': issues}
-
-def main():
-    target = sys.argv[1] if len(sys.argv) > 1 else "."
-    project_path = Path(target)
-    
-    print("\n" + "=" * 60)
-    print("  i18n CHECKER - Internationalization Audit")
-    print("=" * 60 + "\n")
-    
-    # Check locale files
-    locale_files = find_locale_files(project_path)
-    locale_result = check_locale_completeness(locale_files)
-    
-    # Check hardcoded strings
-    code_result = check_hardcoded_strings(project_path)
-    
-    # Print results
-    print("[LOCALE FILES]")
-    print("-" * 40)
-    for item in locale_result['passed']:
-        print(f"  {item}")
-    for item in locale_result['issues']:
-        print(f"  {item}")
-    
-    print("\n[CODE ANALYSIS]")
-    print("-" * 40)
-    for item in code_result['passed']:
-        print(f"  {item}")
-    for item in code_result['issues']:
-        print(f"  {item}")
-    
-    # Summary
-    critical_issues = sum(1 for i in locale_result['issues'] + code_result['issues'] if i.startswith("[X]"))
-    
-    print("\n" + "=" * 60)
-    if critical_issues == 0:
-        print("[OK] i18n CHECK: PASSED")
-        sys.exit(0)
-    else:
-        print(f"[X] i18n CHECK: {critical_issues} issues found")
-        sys.exit(1)
-
-if __name__ == "__main__":
-    main()

package/templates/.agent/skills/lint-and-validate/SKILL.md

@@ -1,45 +0,0 @@
----
-name: lint-and-validate
-description: Automatic quality control, linting, and static analysis procedures. Use after every code modification to ensure syntax correctness and project standards. Triggers onKeywords: lint, format, check, validate, types, static analysis.
-allowed-tools: Read, Glob, Grep, Bash
----
-
-# Lint and Validate Skill
-
-> **MANDATORY:** Run appropriate validation tools after EVERY code change. Do not finish a task until the code is error-free.
-
-### Procedures by Ecosystem
-
-#### Node.js / TypeScript
-1. **Lint/Fix:** `npm run lint` or `npx eslint "path" --fix`
-2. **Types:** `npx tsc --noEmit`
-3. **Security:** `npm audit --audit-level=high`
-
-#### Python
-1. **Linter (Ruff):** `ruff check "path" --fix` (Fast & Modern)
-2. **Security (Bandit):** `bandit -r "path" -ll`
-3. **Types (MyPy):** `mypy "path"`
-
-## The Quality Loop
-1. **Write/Edit Code**
-2. **Run Audit:** `npm run lint && npx tsc --noEmit`
-3. **Analyze Report:** Check the "FINAL AUDIT REPORT" section.
-4. **Fix & Repeat:** Submitting code with "FINAL AUDIT" failures is NOT allowed.
-
-## Error Handling
-- If `lint` fails: Fix the style or syntax issues immediately.
-- If `tsc` fails: Correct type mismatches before proceeding.
-- If no tool is configured: Check the project root for `.eslintrc`, `tsconfig.json`, `pyproject.toml` and suggest creating one.
-
----
-**Strict Rule:** No code should be committed or reported as "done" without passing these checks.
-
----
-
-## Scripts
-
-| Script | Purpose | Command |
-|--------|---------|---------|
-| `scripts/lint_runner.py` | Unified lint check | `python scripts/lint_runner.py <project_path>` |
-| `scripts/type_coverage.py` | Type coverage analysis | `python scripts/type_coverage.py <project_path>` |
-

package/templates/.agent/skills/lint-and-validate/scripts/lint_runner.py

@@ -1,184 +0,0 @@
-#!/usr/bin/env python3
-"""
-Lint Runner - Unified linting and type checking
-Runs appropriate linters based on project type.
-
-Usage:
-    python lint_runner.py <project_path>
-
-Supports:
-    - Node.js: npm run lint, npx tsc --noEmit
-    - Python: ruff check, mypy
-"""
-
-import subprocess
-import sys
-import json
-import platform
-import shutil
-from pathlib import Path
-from datetime import datetime
-
-# Fix Windows console encoding
-try:
-    sys.stdout.reconfigure(encoding='utf-8', errors='replace')
-except:
-    pass
-
-
-def detect_project_type(project_path: Path) -> dict:
-    """Detect project type and available linters."""
-    result = {
-        "type": "unknown",
-        "linters": []
-    }
-    
-    # Node.js project
-    package_json = project_path / "package.json"
-    if package_json.exists():
-        result["type"] = "node"
-        try:
-            pkg = json.loads(package_json.read_text(encoding='utf-8'))
-            scripts = pkg.get("scripts", {})
-            deps = {**pkg.get("dependencies", {}), **pkg.get("devDependencies", {})}
-            
-            # Check for lint script
-            if "lint" in scripts:
-                result["linters"].append({"name": "npm lint", "cmd": ["npm", "run", "lint"]})
-            elif "eslint" in deps:
-                result["linters"].append({"name": "eslint", "cmd": ["npx", "eslint", "."]})
-            
-            # Check for TypeScript
-            if "typescript" in deps or (project_path / "tsconfig.json").exists():
-                result["linters"].append({"name": "tsc", "cmd": ["npx", "tsc", "--noEmit"]})
-                
-        except:
-            pass
-    
-    # Python project
-    if (project_path / "pyproject.toml").exists() or (project_path / "requirements.txt").exists():
-        result["type"] = "python"
-        
-        # Check for ruff
-        result["linters"].append({"name": "ruff", "cmd": ["ruff", "check", "."]})
-        
-        # Check for mypy
-        if (project_path / "mypy.ini").exists() or (project_path / "pyproject.toml").exists():
-            result["linters"].append({"name": "mypy", "cmd": ["mypy", "."]})
-    
-    return result
-
-
-def run_linter(linter: dict, cwd: Path) -> dict:
-    """Run a single linter and return results."""
-    result = {
-        "name": linter["name"],
-        "passed": False,
-        "output": "",
-        "error": ""
-    }
-    
-    try:
-        cmd = linter["cmd"]
-        
-        # Windows compatibility for npm/npx
-        if platform.system() == "Windows":
-            if cmd[0] in ["npm", "npx"]:
-                # Force .cmd extension on Windows
-                if not cmd[0].lower().endswith(".cmd"):
-                    cmd[0] = f"{cmd[0]}.cmd"
-        
-        proc = subprocess.run(
-            cmd,
-            cwd=str(cwd),
-            capture_output=True,
-            text=True,
-            encoding='utf-8',
-            errors='replace',
-            timeout=120,
-            shell=platform.system() == "Windows" # Shell=True often helps with path resolution on Windows
-        )
-        
-        result["output"] = proc.stdout[:2000] if proc.stdout else ""
-        result["error"] = proc.stderr[:500] if proc.stderr else ""
-        result["passed"] = proc.returncode == 0
-        
-    except FileNotFoundError:
-        result["error"] = f"Command not found: {linter['cmd'][0]}"
-    except subprocess.TimeoutExpired:
-        result["error"] = "Timeout after 120s"
-    except Exception as e:
-        result["error"] = str(e)
-    
-    return result
-
-
-def main():
-    project_path = Path(sys.argv[1] if len(sys.argv) > 1 else ".").resolve()
-    
-    print(f"\n{'='*60}")
-    print(f"[LINT RUNNER] Unified Linting")
-    print(f"{'='*60}")
-    print(f"Project: {project_path}")
-    print(f"Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-    
-    # Detect project type
-    project_info = detect_project_type(project_path)
-    print(f"Type: {project_info['type']}")
-    print(f"Linters: {len(project_info['linters'])}")
-    print("-"*60)
-    
-    if not project_info["linters"]:
-        print("No linters found for this project type.")
-        output = {
-            "script": "lint_runner",
-            "project": str(project_path),
-            "type": project_info["type"],
-            "checks": [],
-            "passed": True,
-            "message": "No linters configured"
-        }
-        print(json.dumps(output, indent=2))
-        sys.exit(0)
-    
-    # Run each linter
-    results = []
-    all_passed = True
-    
-    for linter in project_info["linters"]:
-        print(f"\nRunning: {linter['name']}...")
-        result = run_linter(linter, project_path)
-        results.append(result)
-        
-        if result["passed"]:
-            print(f"  [PASS] {linter['name']}")
-        else:
-            print(f"  [FAIL] {linter['name']}")
-            if result["error"]:
-                print(f"  Error: {result['error'][:200]}")
-            all_passed = False
-    
-    # Summary
-    print("\n" + "="*60)
-    print("SUMMARY")
-    print("="*60)
-    
-    for r in results:
-        icon = "[PASS]" if r["passed"] else "[FAIL]"
-        print(f"{icon} {r['name']}")
-    
-    output = {
-        "script": "lint_runner",
-        "project": str(project_path),
-        "type": project_info["type"],
-        "checks": results,
-        "passed": all_passed
-    }
-    
-    print("\n" + json.dumps(output, indent=2))
-    
-    sys.exit(0 if all_passed else 1)
-
-
-if __name__ == "__main__":
-    main()