aiox-core 5.0.3 → 5.0.5

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

@@ -1,270 +0,0 @@
-#!/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

@@ -1,136 +0,0 @@
-#!/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

@@ -1,281 +0,0 @@
-#!/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();