aios-core 3.0.0 → 3.2.0

package/.aios-core/development/tasks/squad-creator-create.md

@@ -0,0 +1,289 @@
+---
+task: Create Squad
+responsavel: "@squad-creator"
+responsavel_type: agent
+atomic_layer: task
+Entrada: |
+  - name: Nome do squad (kebab-case, obrigatorio)
+  - description: Descricao (opcional, elicitacao)
+  - author: Autor (opcional, default: git config user.name)
+  - license: Licenca (opcional, default: MIT)
+  - template: Template base (basic | etl | agent-only)
+  - config_mode: extend | override | none
+Saida: |
+  - squad_path: Caminho do squad criado
+  - manifest: Conteudo do squad.yaml gerado
+  - next_steps: Instrucoes para proximos passos
+Checklist:
+  - "[ ] Validar nome (kebab-case, nao existe)"
+  - "[ ] Coletar informacoes via elicitacao"
+  - "[ ] Gerar estrutura de diretorios"
+  - "[ ] Gerar squad.yaml"
+  - "[ ] Gerar arquivos de config (coding-standards, etc.)"
+  - "[ ] Gerar exemplo de agent"
+  - "[ ] Gerar exemplo de task"
+  - "[ ] Executar validacao inicial"
+  - "[ ] Exibir proximos passos"
+---
+
+# *create-squad
+
+Cria um novo squad seguindo a arquitetura task-first do AIOS.
+
+## Uso
+
+```
+@squad-creator
+
+*create-squad
+# → Modo interativo, elicita todas as informacoes
+
+*create-squad meu-squad
+# → Usa defaults para o resto
+
+*create-squad meu-squad --template etl --author "Meu Nome"
+# → Especifica opcoes diretamente
+```
+
+## Parametros
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `name` | string | - | Squad name (kebab-case, required) |
+| `--description` | string | "Custom squad" | Squad description |
+| `--author` | string | git user.name | Author name |
+| `--license` | string | MIT | License type |
+| `--template` | string | basic | Template: basic, etl, agent-only |
+| `--config-mode` | string | extend | Config inheritance: extend, override, none |
+| `--skip-validation` | flag | false | Skip initial validation |
+| `--yes` | flag | false | Skip interactive prompts, use defaults |
+
+## Elicitacao Interativa
+
+```
+? Squad name: meu-dominio-squad
+? Description: Squad para automacao de processos X
+? Author: [git config user.name]
+? License: (MIT)
+  > MIT
+    Apache-2.0
+    ISC
+    UNLICENSED
+? Template:
+  > basic (estrutura minima)
+    etl (processamento de dados)
+    agent-only (apenas agentes)
+? Include example agent? (Y/n)
+? Include example task? (Y/n)
+? Config inheritance:
+  > extend (adiciona as regras do core)
+    override (substitui regras do core)
+    none (sem heranca)
+? Minimum AIOS version: (2.1.0)
+```
+
+## Templates Disponiveis
+
+| Template | Description | Components |
+|----------|-------------|------------|
+| `basic` | Estrutura minima | 1 agent, 1 task |
+| `etl` | Processamento de dados | 2 agents, 3 tasks, scripts |
+| `agent-only` | Apenas agentes | 2 agents, sem tasks |
+
+## Estrutura Gerada
+
+```
+./squads/meu-dominio-squad/
+├── squad.yaml                    # Manifest
+├── README.md                     # Documentacao
+├── config/
+│   ├── coding-standards.md      # Extends/override core
+│   ├── tech-stack.md            # Tecnologias do squad
+│   └── source-tree.md           # Estrutura documentada
+├── agents/
+│   └── example-agent.md         # Agente de exemplo
+├── tasks/
+│   └── example-agent-task.md    # Task de exemplo
+├── checklists/
+│   └── .gitkeep
+├── workflows/
+│   └── .gitkeep
+├── templates/
+│   └── .gitkeep
+├── tools/
+│   └── .gitkeep
+├── scripts/
+│   └── .gitkeep
+└── data/
+    └── .gitkeep
+```
+
+## squad.yaml Gerado
+
+```yaml
+name: meu-dominio-squad
+version: 1.0.0
+description: Squad para automacao de processos X
+author: Meu Nome
+license: MIT
+slashPrefix: meu-dominio
+
+aios:
+  minVersion: "2.1.0"
+  type: squad
+
+components:
+  tasks:
+    - example-agent-task.md
+  agents:
+    - example-agent.md
+  workflows: []
+  checklists: []
+  templates: []
+  tools: []
+  scripts: []
+
+config:
+  extends: extend
+  coding-standards: config/coding-standards.md
+  tech-stack: config/tech-stack.md
+  source-tree: config/source-tree.md
+
+dependencies:
+  node: []
+  python: []
+  squads: []
+
+tags:
+  - custom
+  - automation
+```
+
+## Flow
+
+```
+1. Parse arguments
+   ├── If name provided → validate kebab-case
+   └── If no name → prompt for name
+
+2. Check if squad exists
+   ├── If exists → error with suggestion
+   └── If not exists → continue
+
+3. Collect configuration
+   ├── If --yes flag → use all defaults
+   └── If interactive → elicit each option
+
+4. Generate squad structure
+   ├── Create directories
+   ├── Generate squad.yaml from template
+   ├── Generate config files
+   ├── Generate example agent (if requested)
+   ├── Generate example task (if requested)
+   └── Add .gitkeep to empty directories
+
+5. Run initial validation
+   ├── If --skip-validation → skip
+   └── If validation → run squad-validator
+
+6. Display success message
+   └── Show next steps
+```
+
+## Output de Sucesso
+
+```
+✅ Squad created successfully!
+
+📁 Location: ./squads/meu-dominio-squad/
+
+📋 Next steps:
+   1. cd squads/meu-dominio-squad
+   2. Customize squad.yaml with your details
+   3. Create your agents in agents/
+   4. Create tasks in tasks/ (task-first!)
+   5. Validate: @squad-creator *validate-squad meu-dominio-squad
+
+📚 Documentation:
+   - Squad Guide: docs/guides/squads-guide.md
+   - Task Format: .aios-core/docs/standards/TASK-FORMAT-SPECIFICATION-V1.md
+
+🚀 When ready to share:
+   - Local only: Keep in ./squads/ (private)
+   - Public: @squad-creator *publish-squad meu-dominio-squad
+   - API: @squad-creator *sync-squad-synkra meu-dominio-squad
+```
+
+## Error Handling
+
+| Error | Cause | Resolution |
+|-------|-------|------------|
+| `INVALID_NAME` | Name not kebab-case | Use lowercase with hyphens |
+| `SQUAD_EXISTS` | Squad already exists | Choose different name or delete existing |
+| `PERMISSION_DENIED` | Can't write to squads/ | Check directory permissions |
+| `VALIDATION_FAILED` | Generated squad invalid | Check error details, fix manually |
+
+## Implementation
+
+```javascript
+const { SquadGenerator } = require('./.aios-core/development/scripts/squad');
+const { SquadValidator } = require('./.aios-core/development/scripts/squad');
+
+async function createSquad(options) {
+  const {
+    name,
+    description,
+    author,
+    license,
+    template,
+    configMode,
+    skipValidation,
+    includeAgent,
+    includeTask,
+    aiosMinVersion
+  } = options;
+
+  // Validate name
+  if (!/^[a-z][a-z0-9-]*[a-z0-9]$/.test(name)) {
+    throw new Error('INVALID_NAME: Squad name must be kebab-case');
+  }
+
+  // Generate squad
+  const generator = new SquadGenerator();
+  const result = await generator.generate({
+    name,
+    description,
+    author,
+    license,
+    template,
+    configMode,
+    includeAgent,
+    includeTask,
+    aiosMinVersion
+  });
+
+  // Validate (unless skipped)
+  if (!skipValidation) {
+    const validator = new SquadValidator();
+    const validation = await validator.validate(result.path);
+    if (!validation.valid) {
+      console.warn('Warning: Generated squad has validation issues');
+      console.warn(validator.formatResult(validation, result.path));
+    }
+  }
+
+  // Display success
+  console.log(`\n✅ Squad created successfully!\n`);
+  console.log(`📁 Location: ${result.path}/\n`);
+  displayNextSteps(name);
+
+  return result;
+}
+```
+
+## Related
+
+- **Agent:** @squad-creator (Craft)
+- **Script:** squad-generator.js
+- **Validator:** squad-validator.js (SQS-3)
+- **Loader:** squad-loader.js (SQS-2)

package/.aios-core/development/tasks/squad-creator-design.md

@@ -0,0 +1,334 @@
+---
+task: Design Squad from Documentation
+responsavel: "@squad-creator"
+responsavel_type: agent
+atomic_layer: task
+elicit: true
+Entrada: |
+  - docs: Documentation sources (text, files, or verbal description)
+  - domain: Optional domain hint to guide analysis
+  - output_path: Where to save blueprint (default: ./squads/.designs/)
+Saida: |
+  - blueprint_path: Path to generated squad-design.yaml
+  - summary: Human-readable summary of recommendations
+  - confidence: Overall confidence score (0-1)
+Checklist:
+  - "[ ] Collect documentation input"
+  - "[ ] Analyze domain and extract concepts"
+  - "[ ] Generate agent recommendations"
+  - "[ ] Generate task recommendations"
+  - "[ ] Present recommendations for refinement"
+  - "[ ] Apply user adjustments"
+  - "[ ] Generate blueprint file"
+  - "[ ] Display next steps"
+---
+
+# *design-squad
+
+Analyzes documentation and guides the user through designing a squad structure with intelligent recommendations for agents and tasks.
+
+## Usage
+
+```bash
+@squad-creator
+
+*design-squad
+# → Interactive mode, prompts for documentation
+
+*design-squad --docs ./docs/prd/my-project.md
+# → Analyzes specific file
+
+*design-squad --docs ./docs/prd/my-project.md,./docs/specs/api.yaml
+# → Analyzes multiple files
+
+*design-squad --domain "e-commerce order management"
+# → Uses domain hint for guidance
+```
+
+## Parameters
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `--docs` | string | - | Comma-separated paths to documentation files |
+| `--domain` | string | - | Domain hint to guide analysis |
+| `--output` | string | ./squads/.designs/ | Output directory for blueprint |
+| `--quick` | flag | false | Accept all recommendations without review |
+| `--verbose` | flag | false | Show detailed analysis output |
+
+## Interactive Flow
+
+### Phase 1: Documentation Input
+
+```
+? How would you like to provide documentation?
+  1. Paste text directly
+  2. Provide file paths
+  3. Describe the domain verbally
+  > 2
+
+? Documentation file paths (comma-separated):
+  > ./docs/prd/my-project.md, ./docs/specs/api.yaml
+
+Analyzing documentation...
+```
+
+### Phase 2: Domain Confirmation
+
+```
+Based on your documentation, I identified:
+
+Domain: Order Management System
+Key Entities: Order, Customer, Product, Payment, Shipment
+Main Workflows:
+  1. order-creation
+  2. payment-processing
+  3. inventory-check
+  4. shipment-tracking
+
+Is this correct? [Y/n/Adjust]
+> Y
+```
+
+### Phase 3: Agent Review
+
+```
+Recommended Agent 1 of 3:
+
+  ID: order-manager
+  Role: Manages order lifecycle from creation to fulfillment
+  Commands: *create-order, *update-order, *cancel-order
+  Confidence: 92%
+
+  [A]ccept / [R]eject / [M]odify / [S]kip to tasks
+> A
+
+Recommended Agent 2 of 3:
+...
+```
+
+### Phase 4: Task Review
+
+```
+Tasks for order-manager:
+
+  1. create-order.md (90% confidence)
+     Entrada: customer_id, items[], payment_method
+     Saida: order_id, status, total
+
+  2. update-order.md (85% confidence)
+     Entrada: order_id, updates{}
+     Saida: updated_order, changelog
+
+  [A]ccept all / Review [1-2] / [R]eject all
+> A
+```
+
+### Phase 5: Custom Additions
+
+```
+Would you like to add any agents or tasks not recommended?
+
+  [A]dd agent / Add [T]ask / [C]ontinue to blueprint
+> C
+```
+
+### Phase 6: Blueprint Generation
+
+```
+Generating blueprint...
+
+Summary:
+  Agents: 3 (3 recommended, 0 added)
+  Tasks: 8 (7 recommended, 1 added)
+  User adjustments: 2
+  Overall confidence: 88%
+
+Saved: ./squads/.designs/order-management-squad-design.yaml
+
+Next steps:
+  1. Review blueprint: cat ./squads/.designs/order-management-squad-design.yaml
+  2. Create squad: *create-squad order-management --from-design
+  3. Or edit blueprint manually before creation
+```
+
+## Analysis Pipeline
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│                     DOMAIN ANALYSIS PIPELINE                         │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                      │
+│  1. INPUT NORMALIZATION                                              │
+│     ├── Parse markdown/yaml/json files                               │
+│     ├── Extract text content                                         │
+│     └── Merge multiple sources                                       │
+│                                                                      │
+│  2. ENTITY EXTRACTION                                                │
+│     ├── Identify nouns and proper nouns (capitalized terms)          │
+│     ├── Detect domain-specific terms (repeated concepts)             │
+│     ├── Group related concepts                                       │
+│     └── Output: entities[]                                           │
+│                                                                      │
+│  3. WORKFLOW DETECTION                                               │
+│     ├── Identify action verbs (create, update, delete, process)      │
+│     ├── Detect sequential processes (steps, flows)                   │
+│     ├── Map input → process → output patterns                        │
+│     └── Output: workflows[]                                          │
+│                                                                      │
+│  4. INTEGRATION MAPPING                                              │
+│     ├── Detect external system references (API, database, service)   │
+│     ├── Identify third-party mentions                                │
+│     └── Output: integrations[]                                       │
+│                                                                      │
+│  5. STAKEHOLDER IDENTIFICATION                                       │
+│     ├── Detect user types/roles (admin, user, manager)               │
+│     ├── Identify personas mentioned                                  │
+│     └── Output: stakeholders[]                                       │
+│                                                                      │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+## Recommendation Engine
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│                   RECOMMENDATION ENGINE                              │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                      │
+│  AGENT GENERATION:                                                   │
+│  ┌─────────────────────────────────────────────────────────────────┐│
+│  │ For each major workflow:                                        ││
+│  │   → Generate agent with matching role                           ││
+│  │   → Derive commands from workflow steps                         ││
+│  │   → Calculate confidence based on clarity                       ││
+│  │                                                                 ││
+│  │ Deduplication:                                                  ││
+│  │   → Merge similar agents (>70% overlap)                         ││
+│  │   → Consolidate commands                                        ││
+│  └─────────────────────────────────────────────────────────────────┘│
+│                                                                      │
+│  TASK GENERATION:                                                    │
+│  ┌─────────────────────────────────────────────────────────────────┐│
+│  │ For each agent command:                                         ││
+│  │   → Generate task following TASK-FORMAT-SPECIFICATION-V1        ││
+│  │   → Derive entrada from workflow inputs                         ││
+│  │   → Derive saida from workflow outputs                          ││
+│  │   → Generate checklist from workflow steps                      ││
+│  └─────────────────────────────────────────────────────────────────┘│
+│                                                                      │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+## Output: Blueprint Schema
+
+```yaml
+# squad-design.yaml
+squad:
+  name: my-domain-squad
+  description: "Generated from documentation analysis"
+  domain: domain-name
+
+analysis:
+  entities: [Entity1, Entity2, ...]
+  workflows: [workflow-1, workflow-2, ...]
+  integrations: [API1, Service2, ...]
+  stakeholders: [Role1, Role2, ...]
+
+recommendations:
+  agents:
+    - id: agent-id
+      role: "Agent role description"
+      commands: [cmd1, cmd2]
+      confidence: 0.92
+      user_added: false
+      user_modified: false
+
+  tasks:
+    - name: task-name
+      agent: agent-id
+      entrada: [input1, input2]
+      saida: [output1, output2]
+      confidence: 0.88
+
+  template: basic | etl | agent-only | custom
+  config_mode: extend | override | none
+
+metadata:
+  created_at: "2025-12-18T00:00:00Z"
+  source_docs: ["./path/to/doc1.md"]
+  user_adjustments: 2
+  overall_confidence: 0.87
+```
+
+## Integration with *create-squad
+
+After generating a blueprint, use it with *create-squad:
+
+```bash
+*create-squad my-domain-squad --from-design ./squads/.designs/my-domain-squad-design.yaml
+```
+
+This will:
+1. Load the blueprint
+2. Validate against schema
+3. Generate squad structure with custom agents/tasks from blueprint
+4. Skip interactive elicitation (uses blueprint values)
+
+## Error Handling
+
+| Error | Cause | Resolution |
+|-------|-------|------------|
+| `NO_DOCUMENTATION` | No input provided | Provide docs via --docs or interactively |
+| `PARSE_ERROR` | Cannot read/parse file | Check file format (md, yaml, json) |
+| `EMPTY_ANALYSIS` | No domain concepts extracted | Provide more detailed documentation |
+| `BLUEPRINT_EXISTS` | Blueprint already exists | Use --force to overwrite |
+
+## Implementation
+
+```javascript
+const { SquadDesigner } = require('./.aios-core/development/scripts/squad');
+
+async function designSquad(options) {
+  const designer = new SquadDesigner();
+
+  // 1. Collect documentation
+  const docs = await designer.collectDocumentation(options);
+
+  // 2. Analyze domain
+  const analysis = await designer.analyzeDomain(docs);
+
+  // 3. Generate recommendations
+  const recommendations = {
+    agents: designer.generateAgentRecommendations(analysis),
+    tasks: designer.generateTaskRecommendations(analysis)
+  };
+
+  // 4. Interactive refinement (unless --quick)
+  if (!options.quick) {
+    await designer.interactiveRefinement(recommendations);
+  }
+
+  // 5. Generate blueprint
+  const blueprint = await designer.generateBlueprint({
+    analysis,
+    recommendations,
+    metadata: {
+      source_docs: options.docs,
+      created_at: new Date().toISOString()
+    }
+  });
+
+  // 6. Save blueprint
+  const blueprintPath = await designer.saveBlueprint(blueprint, options.output);
+
+  return { blueprintPath, blueprint };
+}
+```
+
+## Related
+
+- **Agent:** @squad-creator (Craft)
+- **Script:** squad-designer.js
+- **Schema:** squad-design-schema.json
+- **Integration:** *create-squad --from-design
+- **Story:** SQS-9 (Squad Designer)

package/.aios-core/development/tasks/squad-creator-download.md

@@ -0,0 +1,65 @@
+---
+task: Download Squad
+responsavel: "@squad-creator"
+responsavel_type: agent
+atomic_layer: task
+status: placeholder
+sprint: 8
+Entrada: |
+  - name: Nome do squad para baixar
+  - source: Fonte (aios-squads | synkra-api)
+Saida: |
+  - squad_path: Caminho do squad baixado
+  - status: Sucesso ou erro
+Checklist:
+  - "[ ] Implementar em Sprint 8 (SQS-5)"
+---
+
+# *download-squad
+
+> **PLACEHOLDER** - Implementation scheduled for Sprint 8 (Story SQS-5)
+
+## Planned Functionality
+
+Downloads a public squad from the aios-squads repository or Synkra API marketplace.
+
+## Planned Usage
+
+```
+@squad-creator
+
+*download-squad etl-squad
+# → Downloads from github.com/SynkraAI/aios-squads
+
+*download-squad premium-pack --source synkra-api
+# → Downloads from api.synkra.dev/squads (requires auth)
+```
+
+## Planned Features
+
+1. **Repository Source (Default)**
+   - Clone from github.com/SynkraAI/aios-squads
+   - Support specific versions via tags
+   - Validate squad before installation
+
+2. **Synkra API Source**
+   - Download from api.synkra.dev/squads
+   - Support premium/paid squads
+   - Require authentication
+
+3. **Installation**
+   - Install to ./squads/{name}/
+   - Run validation after download
+   - Show usage instructions
+
+## Related Story
+
+- **SQS-5:** SquadSyncService (Sprint 8)
+- **SQS-6:** Registry Integration (Sprint 8)
+
+## Current Status
+
+This task is a placeholder. The full implementation will be done in Sprint 8.
+
+For now, manually clone squads from:
+- https://github.com/SynkraAI/aios-squads