@cubis/foundry 0.3.67 → 0.3.69

package/workflows/workflows/agent-environment-setup/platforms/windsurf/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/workflows/workflows/agent-environment-setup/platforms/windsurf/skills/intelligent-routing/SKILL.md

@@ -1,335 +0,0 @@
----
-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/windsurf/skills/java-pro/SKILL.md

@@ -1,64 +0,0 @@
----
-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/windsurf/skills/java-pro/references/operational-baseline.md

@@ -1,9 +0,0 @@
-## 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.