@cubis/foundry 0.3.64 → 0.3.65

package/workflows/workflows/agent-environment-setup/platforms/claude/skills/i18n-localization/scripts/i18n_checker.py

@@ -0,0 +1,241 @@
+#!/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/workflows/workflows/agent-environment-setup/platforms/claude/skills/intelligent-routing/SKILL.md

@@ -0,0 +1,335 @@
+---
+name: intelligent-routing
+description: Automatic agent selection and intelligent task routing. Analyzes user requests and automatically selects the best specialist agent(s) without requiring explicit user mentions.
+version: 1.0.0
+---
+
+# Intelligent Agent Routing
+
+**Purpose**: Automatically analyze user requests and route them to the most appropriate specialist agent(s) without requiring explicit user mentions.
+
+## Core Principle
+
+> **The AI should act as an intelligent Project Manager**, analyzing each request and automatically selecting the best specialist(s) for the job.
+
+## How It Works
+
+### 1. Request Analysis
+
+Before responding to ANY user request, perform automatic analysis:
+
+```mermaid
+graph TD
+    A[User Request: Add login] --> B[ANALYZE]
+    B --> C[Keywords]
+    B --> D[Domains]
+    B --> E[Complexity]
+    C --> F[SELECT AGENT]
+    D --> F
+    E --> F
+    F --> G[security-auditor + backend-specialist]
+    G --> H[AUTO-INVOKE with context]
+```
+
+### 2. Agent Selection Matrix
+
+**Use this matrix to automatically select agents:**
+
+| User Intent         | Keywords                                   | Selected Agent(s)                           | Auto-invoke? |
+| ------------------- | ------------------------------------------ | ------------------------------------------- | ------------ |
+| **Authentication**  | "login", "auth", "signup", "password"      | `security-auditor` + `backend-specialist`   | ✅ YES       |
+| **UI Component**    | "button", "card", "layout", "style"        | `frontend-specialist`                       | ✅ YES       |
+| **Mobile UI**       | "screen", "navigation", "touch", "gesture" | `mobile-developer`                          | ✅ YES       |
+| **API Endpoint**    | "endpoint", "route", "API", "POST", "GET"  | `backend-specialist`                        | ✅ YES       |
+| **Database**        | "schema", "migration", "query", "table"    | `database-architect` + `backend-specialist` | ✅ YES       |
+| **Bug Fix**         | "error", "bug", "not working", "broken"    | `debugger`                                  | ✅ YES       |
+| **Test**            | "test", "coverage", "unit", "e2e"          | `test-engineer`                             | ✅ YES       |
+| **Deployment**      | "deploy", "production", "CI/CD", "docker"  | `devops-engineer`                           | ✅ YES       |
+| **Security Review** | "security", "vulnerability", "exploit"     | `security-auditor` + `penetration-tester`   | ✅ YES       |
+| **Performance**     | "slow", "optimize", "performance", "speed" | `performance-optimizer`                     | ✅ YES       |
+| **Product Def**     | "requirements", "user story", "backlog", "MVP" | `product-owner`                             | ✅ YES       |
+| **New Feature**     | "build", "create", "implement", "new app"  | `orchestrator` → multi-agent                | ⚠️ ASK FIRST |
+| **Complex Task**    | Multiple domains detected                  | `orchestrator` → multi-agent                | ⚠️ ASK FIRST |
+
+### 3. Automatic Routing Protocol
+
+## TIER 0 - Automatic Analysis (ALWAYS ACTIVE)
+
+Before responding to ANY request:
+
+```javascript
+// Pseudo-code for decision tree
+function analyzeRequest(userMessage) {
+    // 1. Classify request type
+    const requestType = classifyRequest(userMessage);
+
+    // 2. Detect domains
+    const domains = detectDomains(userMessage);
+
+    // 3. Determine complexity
+    const complexity = assessComplexity(domains);
+
+    // 4. Select agent(s)
+    if (complexity === "SIMPLE" && domains.length === 1) {
+        return selectSingleAgent(domains[0]);
+    } else if (complexity === "MODERATE" && domains.length <= 2) {
+        return selectMultipleAgents(domains);
+    } else {
+        return "orchestrator"; // Complex task
+    }
+}
+```
+
+## 4. Response Format
+
+**When auto-selecting an agent, inform the user concisely:**
+
+```markdown
+🤖 **Applying knowledge of `@security-auditor` + `@backend-specialist`...**
+
+[Proceed with specialized response]
+```
+
+**Benefits:**
+
+- ✅ User sees which expertise is being applied
+- ✅ Transparent decision-making
+- ✅ Still automatic (no /commands needed)
+
+## Domain Detection Rules
+
+### Single-Domain Tasks (Auto-invoke Single Agent)
+
+| Domain          | Patterns                                   | Agent                   |
+| --------------- | ------------------------------------------ | ----------------------- |
+| **Security**    | auth, login, jwt, password, hash, token    | `security-auditor`      |
+| **Frontend**    | component, react, vue, css, html, tailwind | `frontend-specialist`   |
+| **Backend**     | api, server, express, fastapi, node        | `backend-specialist`    |
+| **Mobile**      | react native, flutter, ios, android, expo  | `mobile-developer`      |
+| **Database**    | prisma, sql, mongodb, schema, migration    | `database-architect`    |
+| **Testing**     | test, jest, vitest, playwright, cypress    | `test-engineer`         |
+| **DevOps**      | docker, kubernetes, ci/cd, pm2, nginx      | `devops-engineer`       |
+| **Debug**       | error, bug, crash, not working, issue      | `debugger`              |
+| **Performance** | slow, lag, optimize, cache, performance    | `performance-optimizer` |
+| **SEO**         | seo, meta, analytics, sitemap, robots      | `seo-specialist`        |
+| **Game**        | unity, godot, phaser, game, multiplayer    | `game-developer`        |
+
+### Multi-Domain Tasks (Auto-invoke Orchestrator)
+
+If request matches **2+ domains from different categories**, automatically use `orchestrator`:
+
+```text
+Example: "Create a secure login system with dark mode UI"
+→ Detected: Security + Frontend
+→ Auto-invoke: orchestrator
+→ Orchestrator will handle: security-auditor, frontend-specialist, test-engineer
+```
+
+## Complexity Assessment
+
+### SIMPLE (Direct agent invocation)
+
+- Single file edit
+- Clear, specific task
+- One domain only
+- Example: "Fix the login button style"
+
+**Action**: Auto-invoke respective agent
+
+### MODERATE (2-3 agents)
+
+- 2-3 files affected
+- Clear requirements
+- 2 domains max
+- Example: "Add API endpoint for user profile"
+
+**Action**: Auto-invoke relevant agents sequentially
+
+### COMPLEX (Orchestrator required)
+
+- Multiple files/domains
+- Architectural decisions needed
+- Unclear requirements
+- Example: "Build a social media app"
+
+**Action**: Auto-invoke `orchestrator` → will ask Socratic questions
+
+## Implementation Rules
+
+### Rule 1: Silent Analysis
+
+#### DO NOT announce "I'm analyzing your request..."
+
+- ✅ Analyze silently
+- ✅ Inform which agent is being applied
+- ❌ Avoid verbose meta-commentary
+
+### Rule 2: Inform Agent Selection
+
+**DO inform which expertise is being applied:**
+
+```markdown
+🤖 **Applying knowledge of `@frontend-specialist`...**
+
+I will create the component with the following characteristics:
+[Continue with specialized response]
+```
+
+### Rule 3: Seamless Experience
+
+**The user should not notice a difference from talking to the right specialist directly.**
+
+### Rule 4: Override Capability
+
+**User can still explicitly mention agents:**
+
+```text
+User: "Use @backend-specialist to review this"
+→ Override auto-selection
+→ Use explicitly mentioned agent
+```
+
+## Edge Cases
+
+### Case 1: Generic Question
+
+```text
+User: "How does React work?"
+→ Type: QUESTION
+→ No agent needed
+→ Respond directly with explanation
+```
+
+### Case 2: Extremely Vague Request
+
+```text
+User: "Make it better"
+→ Complexity: UNCLEAR
+→ Action: Ask clarifying questions first
+→ Then route to appropriate agent
+```
+
+### Case 3: Contradictory Patterns
+
+```text
+User: "Add mobile support to the web app"
+→ Conflict: mobile vs web
+→ Action: Ask: "Do you want responsive web or native mobile app?"
+→ Then route accordingly
+```
+
+## Integration with Existing Workflows
+
+### With /orchestrate Command
+
+- **User types `/orchestrate`**: Explicit orchestration mode
+- **AI detects complex task**: Auto-invoke orchestrator (same result)
+
+**Difference**: User doesn't need to know the command exists.
+
+### With Socratic Gate
+
+- **Auto-routing does NOT bypass Socratic Gate**
+- If task is unclear, still ask questions first
+- Then route to appropriate agent
+
+### With GEMINI.md Rules
+
+- **Priority**: GEMINI.md rules > intelligent-routing
+- If GEMINI.md specifies explicit routing, follow it
+- Intelligent routing is the DEFAULT when no explicit rule exists
+
+## Testing the System
+
+### Test Cases
+
+#### Test 1: Simple Frontend Task
+
+```text
+User: "Create a dark mode toggle button"
+Expected: Auto-invoke frontend-specialist
+Verify: Response shows "Using @frontend-specialist"
+```
+
+#### Test 2: Security Task
+
+```text
+User: "Review the authentication flow for vulnerabilities"
+Expected: Auto-invoke security-auditor
+Verify: Security-focused analysis
+```
+
+#### Test 3: Complex Multi-Domain
+
+```text
+User: "Build a chat application with real-time notifications"
+Expected: Auto-invoke orchestrator
+Verify: Multiple agents coordinated (backend, frontend, test)
+```
+
+#### Test 4: Bug Fix
+
+```text
+User: "Login is not working, getting 401 error"
+Expected: Auto-invoke debugger
+Verify: Systematic debugging approach
+```
+
+## Performance Considerations
+
+### Token Usage
+
+- Analysis adds ~50-100 tokens per request
+- Tradeoff: Better accuracy vs slight overhead
+- Overall SAVES tokens by reducing back-and-forth
+
+### Response Time
+
+- Analysis is instant (pattern matching)
+- No additional API calls required
+- Agent selection happens before first response
+
+## User Education
+
+### Optional: First-Time Explanation
+
+If this is the first interaction in a project:
+
+```markdown
+💡 **Tip**: I am configured with automatic specialist agent selection.
+I will always choose the most suitable specialist for your task. You can
+still mention agents explicitly with `@agent-name` if you prefer.
+```
+
+## Debugging Agent Selection
+
+### Enable Debug Mode (for development)
+
+Add to GEMINI.md temporarily:
+
+```markdown
+## DEBUG: Intelligent Routing
+
+Show selection reasoning:
+
+- Detected domains: [list]
+- Selected agent: [name]
+- Reasoning: [why]
+```
+
+## Summary
+
+**intelligent-routing skill enables:**
+
+✅ Zero-command operation (no need for `/orchestrate`)  
+✅ Automatic specialist selection based on request analysis  
+✅ Transparent communication of which expertise is being applied  
+✅ Seamless integration with existing workflows  
+✅ Override capability for explicit agent mentions  
+✅ Fallback to orchestrator for complex tasks
+
+**Result**: User gets specialist-level responses without needing to know the system architecture.
+
+---
+
+**Next Steps**: Integrate this skill into GEMINI.md TIER 0 rules.

package/workflows/workflows/agent-environment-setup/platforms/claude/skills/java-pro/SKILL.md

@@ -0,0 +1,64 @@
+---
+name: "java-pro"
+description: "Use for modern Java backend and platform engineering with Java 25-era language/runtime practices."
+license: MIT
+metadata:
+  version: "1.0.0"
+  domain: "language"
+  role: "specialist"
+  stack: "java"
+  baseline: "Java SE 25"
+---
+
+# Java Pro
+
+## When to use
+
+- Building or modernizing Java backend services.
+- Designing JVM architecture for high-throughput systems.
+- Improving reliability, observability, and maintainability.
+
+## When not to use
+
+- Frontend-only tasks with no JVM component.
+- Pure schema/index work better handled as database design or optimization.
+- Low-level native systems work where Rust/Go is the actual project stack.
+
+## Core workflow
+
+1. Clarify runtime target and deployment constraints.
+2. Define module boundaries and API contracts.
+3. Implement with clear domain/service/infrastructure separation.
+4. Add tests and performance checks for critical paths.
+
+## Baseline standards
+
+- Use current LTS/JDK baseline approved by project policy.
+- Prefer records/sealed hierarchies where they simplify modeling.
+- Keep null-handling explicit; avoid silent NPE pathways.
+- Use structured logging and trace propagation.
+- Enforce dependency and API compatibility checks in CI.
+
+## Debugging and observability
+
+- Capture request/job correlation IDs in logs and traces.
+- Keep exception handling consistent between transport, service, and persistence layers.
+- Reproduce performance or memory issues with focused benchmarks/profilers before redesigning.
+
+## Performance and reliability
+
+- Prefer explicit timeouts, bulkheads, and retry budgets at I/O boundaries.
+- Keep thread/virtual-thread usage bounded and observable.
+- Separate transport DTOs from domain and persistence models to reduce cascade failures.
+
+## References
+
+| File | Load when |
+| --- | --- |
+| `references/operational-baseline.md` | You need current Java service guardrails for logging, testing, dependency hygiene, and runtime operations. |
+
+## Avoid
+
+- Monolithic service classes with mixed responsibilities.
+- Reflection-heavy magic when explicit code is clearer.
+- Leaking persistence entities directly into API contracts.

package/workflows/workflows/agent-environment-setup/platforms/claude/skills/java-pro/references/operational-baseline.md

@@ -0,0 +1,9 @@
+## Operational baseline
+
+Load when: JVM service reliability, logging, dependency hygiene, or runtime guardrails need explicit guidance.
+
+- Use structured logging and trace propagation at service boundaries.
+- Keep timeout/retry budgets explicit for external I/O.
+- Separate API contracts from persistence entities.
+- Prefer focused benchmark/profiler evidence before redesigning hot paths.
+- Validate with tests and compatibility checks in CI.