aiox-core 5.0.2 → 5.0.4

package/pro/squads/squad-creator-pro/scripts/refresh-registry.py

@@ -0,0 +1,270 @@
+#!/usr/bin/env python3
+"""
+Squad Registry Refresh Script
+
+Deterministic operations for updating squad-registry.yaml:
+- Scan squads/ directory
+- Count components (agents, tasks, workflows, etc.)
+- Read config.yaml metadata
+- Update registry with factual data
+
+LLM handles (non-deterministic):
+- Extract keywords from README
+- Infer domain category
+- Generate highlights
+- Generate example_use
+
+Usage:
+    python scripts/refresh-registry.py [--output json|yaml] [--squads-path PATH]
+"""
+
+import os
+import sys
+import yaml
+import json
+import glob
+from pathlib import Path
+from datetime import datetime
+from typing import Dict, List, Any, Optional
+
+
+def get_squads_path() -> Path:
+    """Get the squads directory path"""
+    # Try to find squads/ relative to script location
+    script_dir = Path(__file__).parent.parent.parent  # squads/squad-creator-pro/scripts -> squads
+    if (script_dir / "squad-creator").exists():
+        return script_dir
+
+    # Fallback to current directory
+    cwd = Path.cwd()
+    if (cwd / "squads").exists():
+        return cwd / "squads"
+    elif cwd.name == "squads":
+        return cwd
+
+    raise FileNotFoundError("Could not find squads/ directory")
+
+
+def count_files(directory: Path, patterns: List[str]) -> int:
+    """Count files matching patterns in directory"""
+    count = 0
+    for pattern in patterns:
+        count += len(list(directory.glob(pattern)))
+    return count
+
+
+def read_config_yaml(squad_path: Path) -> Optional[Dict]:
+    """Read and parse config.yaml from squad"""
+    config_file = squad_path / "config.yaml"
+    if not config_file.exists():
+        return None
+
+    try:
+        with open(config_file, 'r', encoding='utf-8') as f:
+            return yaml.safe_load(f)
+    except Exception as e:
+        print(f"Warning: Could not parse {config_file}: {e}", file=sys.stderr)
+        return None
+
+
+def list_agents(squad_path: Path) -> List[str]:
+    """List all agent names in a squad"""
+    agents_dir = squad_path / "agents"
+    if not agents_dir.exists():
+        return []
+
+    agents = []
+    for f in agents_dir.glob("*.md"):
+        # Skip templates and READMEs
+        if f.name.lower() in ['readme.md', 'template.md']:
+            continue
+        agents.append(f.stem)
+    return agents
+
+
+def scan_squad(squad_path: Path) -> Dict[str, Any]:
+    """Scan a single squad and extract deterministic data"""
+    squad_name = squad_path.name
+
+    # Read config.yaml
+    config = read_config_yaml(squad_path)
+
+    # Count components
+    counts = {
+        "agents": count_files(squad_path / "agents", ["*.md"]) if (squad_path / "agents").exists() else 0,
+        "tasks": count_files(squad_path / "tasks", ["*.md"]) if (squad_path / "tasks").exists() else 0,
+        "workflows": count_files(squad_path / "workflows", ["*.md", "*.yaml"]) if (squad_path / "workflows").exists() else 0,
+        "templates": count_files(squad_path / "templates", ["*.md", "*.yaml"]) if (squad_path / "templates").exists() else 0,
+        "checklists": count_files(squad_path / "checklists", ["*.md"]) if (squad_path / "checklists").exists() else 0,
+        "data_files": count_files(squad_path / "data", ["*.md", "*.yaml"]) if (squad_path / "data").exists() else 0,
+    }
+
+    # List agent names
+    agent_names = list_agents(squad_path)
+
+    # Check for key files
+    has_readme = (squad_path / "README.md").exists()
+    has_changelog = (squad_path / "CHANGELOG.md").exists()
+
+    # Build result
+    result = {
+        "name": squad_name,
+        "path": f"squads/{squad_name}/",
+        "has_config": config is not None,
+        "config": {
+            "name": config.get("name", squad_name) if config else squad_name,
+            "version": config.get("version", "unknown") if config else "unknown",
+            "short_title": config.get("short-title", "") if config else "",
+            "description": config.get("description", "") if config else "",
+            "slashPrefix": config.get("slashPrefix", "") if config else "",
+        },
+        "counts": counts,
+        "agent_names": agent_names,
+        "has_readme": has_readme,
+        "has_changelog": has_changelog,
+        "total_components": sum(counts.values()),
+    }
+
+    return result
+
+
+def scan_all_squads(squads_path: Path) -> Dict[str, Any]:
+    """Scan all squads in the squads/ directory"""
+    results = {
+        "metadata": {
+            "scan_date": datetime.now().isoformat(),
+            "squads_path": str(squads_path),
+            "total_squads": 0,
+        },
+        "squads": {},
+        "summary": {
+            "total_agents": 0,
+            "total_tasks": 0,
+            "total_workflows": 0,
+            "total_templates": 0,
+            "total_checklists": 0,
+            "total_data_files": 0,
+        }
+    }
+
+    # Directories to skip
+    skip_dirs = {'.DS_Store', '__pycache__', 'node_modules', '.git', 'artifacts'}
+
+    # Scan each directory in squads/
+    for item in sorted(squads_path.iterdir()):
+        if not item.is_dir():
+            continue
+        if item.name in skip_dirs:
+            continue
+        if item.name.startswith('.'):
+            continue
+
+        # Check if it's a valid squad (has config.yaml or agents/)
+        has_config = (item / "config.yaml").exists()
+        has_agents = (item / "agents").exists()
+
+        if not (has_config or has_agents):
+            continue
+
+        # Scan the squad
+        squad_data = scan_squad(item)
+        results["squads"][item.name] = squad_data
+
+        # Update summary
+        results["summary"]["total_agents"] += squad_data["counts"]["agents"]
+        results["summary"]["total_tasks"] += squad_data["counts"]["tasks"]
+        results["summary"]["total_workflows"] += squad_data["counts"]["workflows"]
+        results["summary"]["total_templates"] += squad_data["counts"]["templates"]
+        results["summary"]["total_checklists"] += squad_data["counts"]["checklists"]
+        results["summary"]["total_data_files"] += squad_data["counts"]["data_files"]
+
+    results["metadata"]["total_squads"] = len(results["squads"])
+
+    return results
+
+
+def format_for_registry(scan_results: Dict) -> Dict:
+    """Format scan results for squad-registry.yaml structure"""
+    registry = {
+        "metadata": {
+            "version": "1.0.0",
+            "last_updated": datetime.now().strftime("%Y-%m-%d"),
+            "total_squads": scan_results["metadata"]["total_squads"],
+            "maintainer": "squad-creator",
+            "generated_by": "scripts/refresh-registry.py",
+        },
+        "squads": {},
+        "summary": scan_results["summary"],
+    }
+
+    for name, data in scan_results["squads"].items():
+        registry["squads"][name] = {
+            "path": data["path"],
+            "version": data["config"]["version"],
+            "description": data["config"]["description"],
+            "slashPrefix": data["config"]["slashPrefix"],
+            "counts": data["counts"],
+            "agent_names": data["agent_names"],
+            "has_readme": data["has_readme"],
+            "has_changelog": data["has_changelog"],
+            # These fields need LLM to populate:
+            "domain": "_TO_BE_INFERRED_",
+            "keywords": [],
+            "highlights": [],
+            "example_use": "",
+        }
+
+    return registry
+
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Scan squads and generate registry data")
+    parser.add_argument("--output", choices=["json", "yaml", "summary"], default="yaml",
+                        help="Output format")
+    parser.add_argument("--squads-path", type=Path, default=None,
+                        help="Path to squads/ directory")
+    parser.add_argument("--registry-format", action="store_true",
+                        help="Output in squad-registry.yaml format")
+
+    args = parser.parse_args()
+
+    # Find squads path
+    try:
+        squads_path = args.squads_path or get_squads_path()
+    except FileNotFoundError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    # Scan all squads
+    results = scan_all_squads(squads_path)
+
+    # Format output
+    if args.registry_format:
+        results = format_for_registry(results)
+
+    # Output
+    if args.output == "json":
+        print(json.dumps(results, indent=2, ensure_ascii=False))
+    elif args.output == "yaml":
+        print(yaml.dump(results, allow_unicode=True, default_flow_style=False, sort_keys=False))
+    elif args.output == "summary":
+        print(f"Squad Registry Scan Results")
+        print(f"===========================")
+        print(f"Scan Date: {results['metadata']['scan_date']}")
+        print(f"Total Squads: {results['metadata']['total_squads']}")
+        print()
+        print(f"Component Totals:")
+        for key, value in results['summary'].items():
+            print(f"  {key}: {value}")
+        print()
+        print(f"Squads Found:")
+        for name, data in sorted(results['squads'].items()):
+            agents = data['counts']['agents']
+            tasks = data['counts']['tasks']
+            print(f"  {name}: {agents} agents, {tasks} tasks")
+
+
+if __name__ == "__main__":
+    main()

package/pro/squads/squad-creator-pro/scripts/save-session-metrics.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+"""
+Hook: Stop
+Triggered when the session ends.
+
+Actions:
+1. Calculate session metrics
+2. Update .state.json with final metrics
+3. Log session summary to MEMORY.md
+"""
+
+import json
+import sys
+from datetime import datetime
+from pathlib import Path
+
+
+STATE_FILE = Path("squads/squad-creator-pro/.state.json")
+MEMORY_FILE = Path(".claude/agent-memory/squad/MEMORY.md")
+
+
+def load_state() -> dict:
+    """Load current workflow state."""
+    if STATE_FILE.exists():
+        return json.loads(STATE_FILE.read_text())
+    return {}
+
+
+def save_state(state: dict):
+    """Save workflow state."""
+    STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
+    STATE_FILE.write_text(json.dumps(state, indent=2))
+
+
+def update_memory_stats(state: dict):
+    """Update Quick Stats in MEMORY.md."""
+    if not MEMORY_FILE.exists():
+        return
+
+    content = MEMORY_FILE.read_text()
+
+    # Calculate stats
+    metrics = state.get('metrics', {})
+    agents_created = metrics.get('agents_created', 0)
+    quality_scores = metrics.get('quality_scores', [])
+    avg_score = sum(quality_scores) / len(quality_scores) if quality_scores else 0
+
+    # Update Quick Stats section
+    # This is a simple implementation - could be more sophisticated
+    lines = content.split('\n')
+    new_lines = []
+    in_stats = False
+
+    for line in lines:
+        if line.startswith('## Quick Stats'):
+            in_stats = True
+            new_lines.append(line)
+            continue
+
+        if in_stats and line.startswith('## '):
+            in_stats = False
+
+        if in_stats and line.startswith('- '):
+            # Update stat lines
+            if 'Total squads criados:' in line:
+                # Keep existing, this should be incremented elsewhere
+                pass
+            elif 'Quality score médio:' in line and avg_score > 0:
+                line = f"- Quality score médio: {avg_score:.1f}/10"
+
+        new_lines.append(line)
+
+    MEMORY_FILE.write_text('\n'.join(new_lines))
+
+
+def append_workflow_log(state: dict):
+    """Append workflow execution to memory."""
+    if not MEMORY_FILE.exists():
+        return
+
+    workflow = state.get('workflow', 'unknown')
+    if not workflow:
+        return
+
+    started = state.get('started_at', '')
+    status = 'complete' if all(
+        s == 'complete' for s in state.get('phase_status', {}).values()
+    ) else 'incomplete'
+
+    content = MEMORY_FILE.read_text()
+
+    # Find "Workflows Executados" section
+    if "## Workflows Executados" in content:
+        timestamp = datetime.now().strftime('%Y-%m-%d')
+        entry = f"- [{timestamp}] {workflow}: {status}"
+
+        parts = content.split("## Workflows Executados")
+        if len(parts) == 2:
+            new_content = parts[0] + "## Workflows Executados\n" + entry + "\n" + parts[1].lstrip()
+            MEMORY_FILE.write_text(new_content)
+
+
+def main():
+    try:
+        # Read input from stdin (may be empty for Stop hook)
+        try:
+            input_data = json.loads(sys.stdin.read())
+        except:
+            input_data = {}
+
+        # Load state
+        state = load_state()
+
+        # Update final timestamp
+        state['last_updated'] = datetime.now().isoformat()
+
+        # Save state
+        save_state(state)
+
+        # Update memory
+        update_memory_stats(state)
+        append_workflow_log(state)
+
+        # Allow session to end
+        print(json.dumps({"decision": "allow"}))
+
+    except Exception as e:
+        # On error, allow (fail open)
+        print(json.dumps({
+            "decision": "allow",
+            "additionalContext": f"Metrics save error: {str(e)}"
+        }))
+
+
+if __name__ == "__main__":
+    main()

package/pro/squads/squad-creator-pro/scripts/scaffold-squad.cjs

@@ -0,0 +1,281 @@
+#!/usr/bin/env node
+/**
+ * Squad Scaffold - Creates directory structure for new squads.
+ *
+ * Usage:
+ *   node scaffold-squad.cjs <slug> [--name "Display Name"]
+ *   node scaffold-squad.cjs  # Uses .active-squad
+ *
+ * Creates:
+ *   squads/{slug}/
+ *   ├── agents/
+ *   ├── tasks/
+ *   ├── templates/
+ *   ├── data/
+ *   ├── checklists/
+ *   ├── docs/
+ *   ├── scripts/
+ *   ├── config.yaml
+ *   └── README.md
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// ═══════════════════════════════════════════════════════════════════════════
+// CONSTANTS
+// ═══════════════════════════════════════════════════════════════════════════
+
+const SQUADS_BASE = path.resolve(__dirname, '..', '..'); // squads/
+const ACTIVE_SQUAD_PATH = path.join(SQUADS_BASE, '.active-squad');
+
+const DIRECTORIES = [
+  'agents',
+  'tasks',
+  'templates',
+  'data',
+  'checklists',
+  'docs',
+  'scripts'
+];
+
+// ═══════════════════════════════════════════════════════════════════════════
+// TEMPLATES
+// ═══════════════════════════════════════════════════════════════════════════
+
+function getReadmeTemplate(slug, displayName, date) {
+  return `# ${displayName} Squad
+
+**Status:** 🚧 In Development
+**Created:** ${date}
+
+---
+
+## Overview
+
+*Description pending - update after research phase*
+
+---
+
+## Agents
+
+| Agent | Role | Status |
+|-------|------|--------|
+| TBD | TBD | 📋 Planned |
+
+---
+
+## Quick Start
+
+\`\`\`bash
+# Check squad state
+node squads/squad-creator-pro/scripts/squad-state-manager.cjs get ${slug}
+
+# Load context for an agent
+node squads/squad-creator-pro/scripts/squad-context-loader.cjs oalanicolas ${slug}
+\`\`\`
+
+---
+
+## Structure
+
+| Directory | Purpose |
+|-----------|---------|
+| \`agents/\` | Agent definitions |
+| \`tasks/\` | Task workflows |
+| \`templates/\` | Reusable templates |
+| \`data/\` | Knowledge base, frameworks |
+| \`checklists/\` | Validation checklists |
+| \`docs/\` | Squad documentation |
+| \`scripts/\` | Utility scripts |
+
+---
+
+## Pipeline Progress
+
+Check current state:
+
+\`\`\`bash
+node squads/squad-creator-pro/scripts/squad-state-manager.cjs get ${slug}
+\`\`\`
+
+---
+
+*Generated by squad-creator pipeline*
+`;
+}
+
+function getConfigTemplate(slug, displayName, date) {
+  return `# ${displayName} Squad Configuration
+# Generated: ${date}
+
+squad:
+  slug: ${slug}
+  display_name: "${displayName}"
+  created_at: "${date}"
+  status: in_development
+
+metadata:
+  source_mind: null
+  target_domain: null
+  description: null
+
+# Agent definitions (populated during scaffolding phase)
+agents: []
+
+# Task definitions (populated during task anatomy phase)
+tasks: []
+
+# Quality gates
+quality:
+  checkpoint_required: true
+  checkpoint_phase: quality_gate
+
+# Pipeline configuration
+pipeline:
+  workflow: create-squad
+  current_phase: init
+`;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// HELPERS
+// ═══════════════════════════════════════════════════════════════════════════
+
+function outputJson(data) {
+  console.log(JSON.stringify(data));
+}
+
+function outputError(code, message, details = {}) {
+  outputJson({ success: false, error: { code, message, details } });
+}
+
+function resolveSlug(cliSlug) {
+  if (cliSlug && !cliSlug.startsWith('-')) return cliSlug;
+  if (fs.existsSync(ACTIVE_SQUAD_PATH)) {
+    return fs.readFileSync(ACTIVE_SQUAD_PATH, 'utf8').trim();
+  }
+  return null;
+}
+
+function getStatePath(slug) {
+  return path.join(SQUADS_BASE, slug, 'metadata', 'state.json');
+}
+
+function readState(slug) {
+  const statePath = getStatePath(slug);
+  if (fs.existsSync(statePath)) {
+    try {
+      return JSON.parse(fs.readFileSync(statePath, 'utf8'));
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+function parseArg(args, flag) {
+  const idx = args.indexOf(flag);
+  if (idx === -1 || idx + 1 >= args.length) return null;
+  return args[idx + 1];
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// MAIN
+// ═══════════════════════════════════════════════════════════════════════════
+
+function main() {
+  const args = process.argv.slice(2);
+
+  if (args[0] === '--help' || args[0] === '-h') {
+    console.log(`Squad Scaffold - Creates directory structure for new squads
+
+Usage:
+  node scaffold-squad.cjs <slug> [--name "Display Name"]
+  node scaffold-squad.cjs  # Uses .active-squad
+
+Options:
+  --name "Name"    Display name for the squad (default: slug title-cased)
+
+Creates directories: ${DIRECTORIES.join(', ')}
+Creates files: README.md, config.yaml`);
+    process.exit(0);
+  }
+
+  // Resolve slug
+  const cliSlug = args[0];
+  const slug = resolveSlug(cliSlug);
+
+  if (!slug) {
+    outputError('NO_SLUG', 'No slug provided and no .active-squad file found', {
+      hint: 'Run: node squad-state-manager.cjs init <slug> first'
+    });
+    process.exit(1);
+  }
+
+  // Validate slug format
+  if (!/^[a-z0-9]+(_[a-z0-9]+)*$/.test(slug)) {
+    outputError('INVALID_SLUG', 'Slug must be snake_case', {
+      received: slug,
+      expected_pattern: '^[a-z0-9]+(_[a-z0-9]+)*$'
+    });
+    process.exit(1);
+  }
+
+  // Get display name from args or state or derive from slug
+  const state = readState(slug);
+  const argName = parseArg(args, '--name');
+  const displayName = argName ||
+    (state && state.display_name) ||
+    slug.split('_').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+
+  const date = new Date().toISOString().split('T')[0];
+  const squadDir = path.join(SQUADS_BASE, slug);
+  const created = [];
+  const skipped = [];
+
+  // Create directories
+  for (const dir of DIRECTORIES) {
+    const dirPath = path.join(squadDir, dir);
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+      // Create .gitkeep
+      fs.writeFileSync(path.join(dirPath, '.gitkeep'), '');
+      created.push(`${dir}/`);
+    } else {
+      skipped.push(`${dir}/`);
+    }
+  }
+
+  // Create README.md
+  const readmePath = path.join(squadDir, 'README.md');
+  if (!fs.existsSync(readmePath)) {
+    fs.writeFileSync(readmePath, getReadmeTemplate(slug, displayName, date));
+    created.push('README.md');
+  } else {
+    skipped.push('README.md');
+  }
+
+  // Create config.yaml
+  const configPath = path.join(squadDir, 'config.yaml');
+  if (!fs.existsSync(configPath)) {
+    fs.writeFileSync(configPath, getConfigTemplate(slug, displayName, date));
+    created.push('config.yaml');
+  } else {
+    skipped.push('config.yaml');
+  }
+
+  outputJson({
+    success: true,
+    slug,
+    display_name: displayName,
+    path: squadDir,
+    created,
+    skipped,
+    message: created.length > 0
+      ? `Created ${created.length} items`
+      : 'Structure already exists'
+  });
+}
+
+main();