@cubis/foundry 0.3.67 → 0.3.69

package/workflows/skills/game-development/web-games/SKILL.md

@@ -1,150 +0,0 @@
----
-name: web-games
-description: Web browser game development principles. Framework selection, WebGPU, optimization, PWA.
-allowed-tools: Read, Write, Edit, Glob, Grep
----
-
-# Web Browser Game Development
-
-> Framework selection and browser-specific principles.
-
----
-
-## 1. Framework Selection
-
-### Decision Tree
-
-```
-What type of game?
-│
-├── 2D Game
-│   ├── Full game engine features? → Phaser
-│   └── Raw rendering power? → PixiJS
-│
-├── 3D Game
-│   ├── Full engine (physics, XR)? → Babylon.js
-│   └── Rendering focused? → Three.js
-│
-└── Hybrid / Canvas
-    └── Custom → Raw Canvas/WebGL
-```
-
-### Comparison (2025)
-
-| Framework | Type | Best For |
-|-----------|------|----------|
-| **Phaser 4** | 2D | Full game features |
-| **PixiJS 8** | 2D | Rendering, UI |
-| **Three.js** | 3D | Visualizations, lightweight |
-| **Babylon.js 7** | 3D | Full engine, XR |
-
----
-
-## 2. WebGPU Adoption
-
-### Browser Support (2025)
-
-| Browser | Support |
-|---------|---------|
-| Chrome | ✅ Since v113 |
-| Edge | ✅ Since v113 |
-| Firefox | ✅ Since v131 |
-| Safari | ✅ Since 18.0 |
-| **Total** | **~73%** global |
-
-### Decision
-
-- **New projects**: Use WebGPU with WebGL fallback
-- **Legacy support**: Start with WebGL
-- **Feature detection**: Check `navigator.gpu`
-
----
-
-## 3. Performance Principles
-
-### Browser Constraints
-
-| Constraint | Strategy |
-|------------|----------|
-| No local file access | Asset bundling, CDN |
-| Tab throttling | Pause when hidden |
-| Mobile data limits | Compress assets |
-| Audio autoplay | Require user interaction |
-
-### Optimization Priority
-
-1. **Asset compression** - KTX2, Draco, WebP
-2. **Lazy loading** - Load on demand
-3. **Object pooling** - Avoid GC
-4. **Draw call batching** - Reduce state changes
-5. **Web Workers** - Offload heavy computation
-
----
-
-## 4. Asset Strategy
-
-### Compression Formats
-
-| Type | Format |
-|------|--------|
-| Textures | KTX2 + Basis Universal |
-| Audio | WebM/Opus (fallback: MP3) |
-| 3D Models | glTF + Draco/Meshopt |
-
-### Loading Strategy
-
-| Phase | Load |
-|-------|------|
-| Startup | Core assets, <2MB |
-| Gameplay | Stream on demand |
-| Background | Prefetch next level |
-
----
-
-## 5. PWA for Games
-
-### Benefits
-
-- Offline play
-- Install to home screen
-- Full screen mode
-- Push notifications
-
-### Requirements
-
-- Service worker for caching
-- Web app manifest
-- HTTPS
-
----
-
-## 6. Audio Handling
-
-### Browser Requirements
-
-- Audio context requires user interaction
-- Create AudioContext on first click/tap
-- Resume context if suspended
-
-### Best Practices
-
-- Use Web Audio API
-- Pool audio sources
-- Preload common sounds
-- Compress with WebM/Opus
-
----
-
-## 7. Anti-Patterns
-
-| ❌ Don't | ✅ Do |
-|----------|-------|
-| Load all assets upfront | Progressive loading |
-| Ignore tab visibility | Pause when hidden |
-| Block on audio load | Lazy load audio |
-| Skip compression | Compress everything |
-| Assume fast connection | Handle slow networks |
-
----
-
-> **Remember:** Browser is the most accessible platform. Respect its constraints.

package/workflows/skills/geo-fundamentals/scripts/geo_checker.py

@@ -1,289 +0,0 @@
-#!/usr/bin/env python3
-"""
-GEO Checker - Generative Engine Optimization Audit
-Checks PUBLIC WEB CONTENT for AI citation readiness.
-
-PURPOSE:
-    - Analyze pages that will be INDEXED by AI engines (ChatGPT, Perplexity, etc.)
-    - Check for structured data, author info, dates, FAQ sections
-    - Help content rank in AI-generated answers
-
-WHAT IT CHECKS:
-    - HTML files (actual web pages)
-    - JSX/TSX files (React page components)
-    - NOT markdown files (those are developer docs, not public content)
-
-Usage:
-    python geo_checker.py <project_path>
-"""
-import sys
-import re
-import json
-from pathlib import Path
-
-# Fix Windows console encoding
-try:
-    sys.stdout.reconfigure(encoding='utf-8', errors='replace')
-    sys.stderr.reconfigure(encoding='utf-8', errors='replace')
-except AttributeError:
-    pass
-
-
-# Directories to skip (not public content)
-SKIP_DIRS = {
-    'node_modules', '.next', 'dist', 'build', '.git', '.github',
-    '__pycache__', '.vscode', '.idea', 'coverage', 'test', 'tests',
-    '__tests__', 'spec', 'docs', 'documentation'
-}
-
-# Files to skip (not public pages)
-SKIP_FILES = {
-    'jest.config', 'webpack.config', 'vite.config', 'tsconfig',
-    'package.json', 'package-lock', 'yarn.lock', '.eslintrc',
-    'tailwind.config', 'postcss.config', 'next.config'
-}
-
-
-def is_page_file(file_path: Path) -> bool:
-    """Check if this file is likely a public-facing page."""
-    name = file_path.stem.lower()
-    
-    # Skip config/utility files
-    if any(skip in name for skip in SKIP_FILES):
-        return False
-    
-    # Skip test files
-    if name.endswith('.test') or name.endswith('.spec'):
-        return False
-    if name.startswith('test_') or name.startswith('spec_'):
-        return False
-    
-    # Likely page indicators
-    page_indicators = ['page', 'index', 'home', 'about', 'contact', 'blog', 
-                       'post', 'article', 'product', 'service', 'landing']
-    
-    # Check if it's in a pages/app directory (Next.js, etc.)
-    parts = [p.lower() for p in file_path.parts]
-    if 'pages' in parts or 'app' in parts or 'routes' in parts:
-        return True
-    
-    # Check filename indicators
-    if any(ind in name for ind in page_indicators):
-        return True
-    
-    # HTML files are usually pages
-    if file_path.suffix.lower() == '.html':
-        return True
-    
-    return False
-
-
-def find_web_pages(project_path: Path) -> list:
-    """Find public-facing web pages only."""
-    patterns = ['**/*.html', '**/*.htm', '**/*.jsx', '**/*.tsx']
-    
-    files = []
-    for pattern in patterns:
-        for f in project_path.glob(pattern):
-            # Skip excluded directories
-            if any(skip in f.parts for skip in SKIP_DIRS):
-                continue
-            
-            # Check if it's likely a page
-            if is_page_file(f):
-                files.append(f)
-    
-    return files[:30]  # Limit to 30 pages
-
-
-def check_page(file_path: Path) -> dict:
-    """Check a single web page for GEO elements."""
-    try:
-        content = file_path.read_text(encoding='utf-8', errors='ignore')
-    except Exception as e:
-        return {'file': str(file_path.name), 'passed': [], 'issues': [f"Error: {e}"], 'score': 0}
-    
-    issues = []
-    passed = []
-    
-    # 1. JSON-LD Structured Data (Critical for AI)
-    if 'application/ld+json' in content:
-        passed.append("JSON-LD structured data found")
-        if '"@type"' in content:
-            if 'Article' in content:
-                passed.append("Article schema present")
-            if 'FAQPage' in content:
-                passed.append("FAQ schema present")
-            if 'Organization' in content or 'Person' in content:
-                passed.append("Entity schema present")
-    else:
-        issues.append("No JSON-LD structured data (AI engines prefer structured content)")
-    
-    # 2. Heading Structure
-    h1_count = len(re.findall(r'<h1[^>]*>', content, re.I))
-    h2_count = len(re.findall(r'<h2[^>]*>', content, re.I))
-    
-    if h1_count == 1:
-        passed.append("Single H1 heading (clear topic)")
-    elif h1_count == 0:
-        issues.append("No H1 heading - page topic unclear")
-    else:
-        issues.append(f"Multiple H1 headings ({h1_count}) - confusing for AI")
-    
-    if h2_count >= 2:
-        passed.append(f"{h2_count} H2 subheadings (good structure)")
-    else:
-        issues.append("Add more H2 subheadings for scannable content")
-    
-    # 3. Author Attribution (E-E-A-T signal)
-    author_patterns = ['author', 'byline', 'written-by', 'contributor', 'rel="author"']
-    has_author = any(p in content.lower() for p in author_patterns)
-    if has_author:
-        passed.append("Author attribution found")
-    else:
-        issues.append("No author info (AI prefers attributed content)")
-    
-    # 4. Publication Date (Freshness signal)
-    date_patterns = ['datePublished', 'dateModified', 'datetime=', 'pubdate', 'article:published']
-    has_date = any(re.search(p, content, re.I) for p in date_patterns)
-    if has_date:
-        passed.append("Publication date found")
-    else:
-        issues.append("No publication date (freshness matters for AI)")
-    
-    # 5. FAQ Section (Highly citable)
-    faq_patterns = [r'<details', r'faq', r'frequently.?asked', r'"FAQPage"']
-    has_faq = any(re.search(p, content, re.I) for p in faq_patterns)
-    if has_faq:
-        passed.append("FAQ section detected (highly citable)")
-    
-    # 6. Lists (Structured content)
-    list_count = len(re.findall(r'<(ul|ol)[^>]*>', content, re.I))
-    if list_count >= 2:
-        passed.append(f"{list_count} lists (structured content)")
-    
-    # 7. Tables (Comparison data)
-    table_count = len(re.findall(r'<table[^>]*>', content, re.I))
-    if table_count >= 1:
-        passed.append(f"{table_count} table(s) (comparison data)")
-    
-    # 8. Entity Recognition (E-E-A-T signal) - NEW 2025
-    entity_patterns = [
-        r'"@type"\s*:\s*"Organization"',
-        r'"@type"\s*:\s*"LocalBusiness"', 
-        r'"@type"\s*:\s*"Brand"',
-        r'itemtype.*schema\.org/(Organization|Person|Brand)',
-        r'rel="author"'
-    ]
-    has_entity = any(re.search(p, content, re.I) for p in entity_patterns)
-    if has_entity:
-        passed.append("Entity/Brand recognition (E-E-A-T)")
-    
-    # 9. Original Statistics/Data (AI citation magnet) - NEW 2025
-    stat_patterns = [
-        r'\d+%',                    # Percentages
-        r'\$[\d,]+',                # Dollar amounts
-        r'study\s+(shows|found)',   # Research citations
-        r'according to',            # Source attribution
-        r'data\s+(shows|reveals)',  # Data-backed claims
-        r'\d+x\s+(faster|better|more)', # Comparison stats
-        r'(million|billion|trillion)', # Large numbers
-    ]
-    stat_matches = sum(1 for p in stat_patterns if re.search(p, content, re.I))
-    if stat_matches >= 2:
-        passed.append("Original statistics/data (citation magnet)")
-    
-    # 10. Conversational/Direct answers - NEW 2025
-    direct_answer_patterns = [
-        r'is defined as',
-        r'refers to',
-        r'means that',
-        r'the answer is',
-        r'in short,',
-        r'simply put,',
-        r'<dfn'
-    ]
-    has_direct = any(re.search(p, content, re.I) for p in direct_answer_patterns)
-    if has_direct:
-        passed.append("Direct answer patterns (LLM-friendly)")
-    
-    # Calculate score
-    total = len(passed) + len(issues)
-    score = (len(passed) / total * 100) if total > 0 else 0
-    
-    return {
-        'file': str(file_path.name),
-        'passed': passed,
-        'issues': issues,
-        'score': round(score)
-    }
-
-
-def main():
-    target = sys.argv[1] if len(sys.argv) > 1 else "."
-    target_path = Path(target).resolve()
-    
-    print("\n" + "=" * 60)
-    print("  GEO CHECKER - AI Citation Readiness Audit")
-    print("=" * 60)
-    print(f"Project: {target_path}")
-    print("-" * 60)
-    
-    # Find web pages only
-    pages = find_web_pages(target_path)
-    
-    if not pages:
-        print("\n[!] No public web pages found.")
-        print("    Looking for: HTML, JSX, TSX files in pages/app directories")
-        print("    Skipping: docs, tests, config files, node_modules")
-        output = {"script": "geo_checker", "pages_found": 0, "passed": True}
-        print("\n" + json.dumps(output, indent=2))
-        sys.exit(0)
-    
-    print(f"Found {len(pages)} public pages to analyze\n")
-    
-    # Check each page
-    results = []
-    for page in pages:
-        result = check_page(page)
-        results.append(result)
-    
-    # Print results
-    for result in results:
-        status = "[OK]" if result['score'] >= 60 else "[!]"
-        print(f"{status} {result['file']}: {result['score']}%")
-        if result['issues'] and result['score'] < 60:
-            for issue in result['issues'][:2]:  # Show max 2 issues
-                print(f"    - {issue}")
-    
-    # Average score
-    avg_score = sum(r['score'] for r in results) / len(results) if results else 0
-    
-    print("\n" + "=" * 60)
-    print(f"AVERAGE GEO SCORE: {avg_score:.0f}%")
-    print("=" * 60)
-    
-    if avg_score >= 80:
-        print("[OK] Excellent - Content well-optimized for AI citations")
-    elif avg_score >= 60:
-        print("[OK] Good - Some improvements recommended")
-    elif avg_score >= 40:
-        print("[!] Needs work - Add structured elements")
-    else:
-        print("[X] Poor - Content needs GEO optimization")
-    
-    # JSON output
-    output = {
-        "script": "geo_checker",
-        "project": str(target_path),
-        "pages_checked": len(results),
-        "average_score": round(avg_score),
-        "passed": avg_score >= 60
-    }
-    print("\n" + json.dumps(output, indent=2))
-    
-    sys.exit(0 if avg_score >= 60 else 1)
-
-
-if __name__ == "__main__":
-    main()

package/workflows/skills/git-commit/SKILL.md

@@ -1,47 +0,0 @@
----
-name: "git-commit"
-displayName: "Git Commit"
-description: "Create conventional commits with intelligent staging and message generation"
-keywords: ["git", "commit", "conventional", "stage", "push", "version control"]
----
-
-# Git Commit
-
-## Conventional Commit Format
-
-```
-<type>[scope]: <description>
-```
-
-## Types
-
-| Type       | Purpose                        |
-| ---------- | ------------------------------ |
-| `feat`     | New feature                    |
-| `fix`      | Bug fix                        |
-| `docs`     | Documentation only             |
-| `style`    | Formatting (no logic change)   |
-| `refactor` | Code refactor                  |
-| `perf`     | Performance improvement        |
-| `test`     | Add/update tests               |
-| `chore`    | Maintenance                    |
-
-## Workflow
-
-1. Check status: `git status --porcelain`
-2. View diff: `git diff --staged` or `git diff`
-3. Stage files: `git add <files>`
-4. Commit: `git commit -m "<type>[scope]: <description>"`
-
-## Rules
-
-- One logical change per commit
-- Present tense, imperative mood
-- Description under 72 characters
-- Reference issues: `Closes #123`
-
-## Safety
-
-- NEVER force push to main/master
-- NEVER skip hooks without explicit request
-- NEVER commit secrets

package/workflows/skills/gorouter-restoration/SKILL.md

@@ -1,127 +0,0 @@
----
-name: "gorouter-restoration"
-displayName: "GoRouter & State Restoration"
-description: "GoRouter guard patterns, deep links, redirect safety, tab preservation, and restoration best practices"
-keywords:
-  [
-    "gorouter",
-    "routing",
-    "navigation",
-    "guards",
-    "deep links",
-    "state restoration",
-    "statefulshellroute",
-  ]
----
-
-# GoRouter & State Restoration
-
-## Overview
-
-Use this skill for safe routing architecture with GoRouter.
-Focus: guard correctness, redirect loop prevention, deep-link safety, shell navigation preservation, and restoration.
-
-## When to Use
-
-- Adding/modifying routes
-- Implementing authentication/authorization guards
-- Handling deep links
-- Preserving tab stacks with `StatefulShellRoute`
-- Fixing redirect loops or bad back-stack behavior
-
-## Core Rules
-
-1. Keep `onEnter`/`redirect` pure and fast (no async side effects).
-2. Avoid redirect loops by checking current matched location.
-3. Use `redirectLimit` intentionally for complex guard trees.
-4. Preserve user intent with `from=` query on auth redirects.
-5. Prefer IDs/path params over large objects in `extra`.
-
-## Guard Execution Model
-
-- `onEnter` runs first.
-- If allowed, top-level `redirect` runs.
-- Route-level `GoRoute.redirect` runs last.
-
-Design guards so each stage is deterministic and idempotent.
-
-## Quick Reference
-
-### Safe redirect logic
-
-```dart
-String? redirectLogic({
-  required bool isAuthenticated,
-  required bool activationDone,
-  required String matchedLocation,
-}) {
-  final isLogin = matchedLocation == '/login';
-  final isActivation = matchedLocation == '/activation';
-
-  if (!activationDone && !isActivation) return '/activation';
-  if (activationDone && !isAuthenticated && !isLogin) {
-    return '/login?from=${Uri.encodeComponent(matchedLocation)}';
-  }
-  if (isAuthenticated && (isLogin || isActivation)) return '/home';
-
-  return null;
-}
-```
-
-### Tab/state preservation
-
-```dart
-StatefulShellRoute.indexedStack(
-  branches: [
-    StatefulShellBranch(navigatorKey: _homeKey, routes: [...]),
-    StatefulShellBranch(navigatorKey: _salesKey, routes: [...]),
-    StatefulShellBranch(navigatorKey: _settingsKey, routes: [...]),
-  ],
-  builder: (context, state, shell) => AppShell(shell: shell),
-)
-```
-
-### Restoration
-
-```dart
-final router = GoRouter(
-  restorationScopeId: 'router',
-  routes: [...],
-);
-
-MaterialApp.router(
-  restorationScopeId: 'app',
-  routerConfig: router,
-)
-```
-
-## Routing Checklist
-
-- Routes use constants and typed parameter extraction.
-- Guards do not mutate app state.
-- Redirect logic handles both anonymous and authenticated states.
-- Deep links are validated for invalid/missing IDs.
-- Logout clears sensitive stack/history as intended.
-- Tab branch stacks remain independent.
-
-## Output Format
-
-1. Route plan (paths, params, names)
-2. Guard plan (stage, conditions, outcomes)
-3. Restoration plan (what is preserved)
-4. Edge cases (deep links, logout, back-nav)
-5. Tests (guard behavior, tab preservation, invalid params)
-
-## Steering Files
-
-| File | Load when |
-| --- | --- |
-| `references/guard_patterns.md` | Designing guard logic, redirect rules, or anti-loop checks. |
-| `references/tab_preservation.md` | Preserving `StatefulShellRoute` branches and restoration state. |
-
-## Templates
-
-| File | Load when |
-| --- | --- |
-| `templates/guard_redirect.md` | Starting a redirect/guard function skeleton. |
-| `templates/stateful_shell_skeleton.md` | Starting a shell/tab restoration scaffold. |

package/workflows/skills/gorouter-restoration/references/guard_patterns.md

@@ -1,37 +0,0 @@
-# Guard patterns (safe redirects)
-
-## Hard rules
-
-- Keep guard logic synchronous, pure, and deterministic.
-- Do not trigger side effects in `onEnter`/`redirect`.
-- Ensure guards are idempotent for repeated router reevaluation.
-- Always protect against redirect loops.
-
-## Evaluation order
-
-1. `onEnter`
-2. Top-level `GoRouter.redirect`
-3. Route-level `GoRoute.redirect`
-
-Each stage should either:
-- return `null` (allow), or
-- return one stable target path.
-
-## Baseline decision set
-
-- If activation is incomplete, redirect to activation route (allow activation route).
-- If unauthenticated on protected route, redirect to login with `from=` query.
-- If authenticated user visits login/activation, redirect to app home.
-- If maintenance mode is enabled, redirect to maintenance except allowlisted routes.
-
-## Loop prevention checks
-
-- Compare target against current `matchedLocation` before redirecting.
-- Keep route allowlists explicit.
-- Set and monitor `redirectLimit` for complex chains.
-
-## Deep-link safety
-
-- Preserve original destination via encoded `from`.
-- Validate required params (path/query) before entering protected detail routes.
-- Redirect invalid params to a safe fallback (`/not-found` or list route).

package/workflows/skills/gorouter-restoration/references/tab_preservation.md

@@ -1,26 +0,0 @@
-# Tab preservation & state restoration
-
-## Recommended architecture
-
-- Use `StatefulShellRoute.indexedStack` for bottom tabs.
-- Give each branch its own `navigatorKey`.
-- Keep shell widget stable so tab switch does not rebuild branch roots.
-
-## What to preserve
-
-- active tab index,
-- each tab's navigation stack,
-- long lists scroll position where needed,
-- in-progress form drafts when required.
-
-## Restoration guidance
-
-- Enable app restoration via both `GoRouter(restorationScopeId: 'router', ...)` and `MaterialApp.router(restorationScopeId: 'app', ...)`.
-- Use `RestorationMixin` for page-local restorable state.
-- Keep critical unsaved drafts in explicit state (provider/local DB) instead of only widget memory.
-
-## Anti-patterns
-
-- Single navigator for all tabs when independent stacks are required.
-- Recreating shell/router on every auth or theme change.
-- Storing heavy objects in route extras when ID lookup is sufficient.