izanagi-ai 2.0.0

package/optimization/prompt-optimizer.md

@@ -0,0 +1,194 @@
+# Optimization: Prompt Optimizer
+
+> Version 1.0.0
+> Priority: High
+> Dependencies: Token Manager, Compression Engine
+> Compatibility: ">=1.0.0"
+
+---
+
+## Identity
+
+The Prompt Optimizer restructures incoming user prompts to be maximally efficient for the LLM. It strips noise, reformats ambiguity into clarity, extracts implicit requirements, and structures the prompt for optimal reasoning — all before the Decision Engine classifies it.
+
+---
+
+## Goals
+
+- Reduce prompt token count by 20-40% before processing.
+- Extract implicit requirements the user didn't state.
+- Structure ambiguous requests into clear, actionable tasks.
+- Remove filler, repetition, and conversational noise.
+- Preserve every meaningful piece of information.
+
+---
+
+## Optimization Passes
+
+### Pass 1: Noise Removal
+
+Remove elements that add no semantic value:
+
+- Greetings: "Hey, how are you? Hope you're doing well..."
+- Fillers: "I was wondering if maybe you could possibly..." → "Can you..."
+- Apologies: "Sorry if this is a dumb question but..."
+- Meta: "I'm not sure if this makes sense but..."
+- Repetition: Same question asked 3 different ways
+
+**Savings: 10-20%**
+
+### Pass 2: Implicit Extraction
+
+Extract requirements the user implied but didn't state:
+
+```
+Input: "Create a login page"
+Extracted:
+  - Framework: Laravel (from project context)
+  - Auth method: JWT (from project memory)
+  - DB: PostgreSQL (from project memory)
+  - Needs: registration, login, logout, password reset (implicit)
+  - Security: rate limiting, password hashing, CSRF (implied by best practice)
+```
+
+**Adds ~50-100 tokens of high-value context.**
+
+### Pass 3: Ambiguity Resolution
+
+Flag and resolve ambiguous statements:
+
+```
+Input: "Make it secure"
+→ Which aspect? Auth? Input validation? Encryption? All of the above?
+→ Resolution: "Apply OWASP security standards to all endpoints"
+```
+
+If ambiguity cannot be resolved from context:
+
+```
+→ Flag for clarification
+→ "You mentioned 'Make it secure' — should I focus on auth, input validation,
+   or a full OWASP audit?"
+```
+
+### Pass 4: Structuring
+
+Convert free-form input into structured format:
+
+```
+BEFORE:
+"I need to build an API for my blog. Users should be able to create posts and
+comment on them. Oh and I need categories too. And authentication obviously.
+Make it fast."
+
+AFTER:
+## Project: Blog API
+## Requirements:
+- Authentication (users can register, login, logout)
+- Posts CRUD (create, read, update, delete)
+- Comments (users can comment on posts)
+- Categories (posts belong to categories)
+## Constraints:
+- Performance is a priority
+```
+
+---
+
+## Optimized Prompt Format
+
+```yaml
+optimized_prompt:
+  original_length: 247
+  optimized_length: 134
+  savings: "46%"
+  
+  task:
+    type: "new_feature"
+    title: "Blog API with auth, posts, comments, categories"
+    
+  requirements:
+    - "User authentication (register, login, logout)"
+    - "Post CRUD with categories"
+    - "Comment on posts"
+    
+  constraints:
+    - "Performance is priority"
+    - "Uses Laravel + PostgreSQL (from project context)"
+    
+  implicit:
+    - "Needs input validation"
+    - "Needs authorization (user can only edit own posts)"
+    - "Needs API rate limiting"
+    - "Needs pagination for listing"
+    
+  clarifications_needed: []
+```
+
+---
+
+## Algorithm
+
+```
+function optimize_prompt(raw_input):
+    // Pass 1: Remove noise
+    cleaned = remove_noise(raw_input)
+    
+    // Pass 2: Extract implicit requirements
+    context = load_project_context()
+    implicit = extract_implicit(cleaned, context)
+    
+    // Pass 3: Detect ambiguity
+    ambiguities = detect_ambiguity(cleaned)
+    
+    // Pass 4: Structure
+    structured = structure_prompt(cleaned, implicit)
+    
+    return {
+        optimized: structured,
+        clarifications: ambiguities,
+        savings: 1 - (len(structured) / len(raw_input))
+    }
+```
+
+---
+
+## Rules
+
+### Always
+
+- ✅ Remove noise before processing.
+- ✅ Extract implicit requirements from project context.
+- ✅ Flag unresolved ambiguity for clarification.
+- ✅ Structure into machine-readable format.
+- ✅ Track token savings.
+
+### Never
+
+- ❌ Remove requirements, even if they seem implied.
+- ❌ Guess when project context is insufficient — ask.
+- ❌ Over-structure to the point of losing natural meaning.
+- ❌ Add requirements the user didn't ask for or imply.
+
+---
+
+## Metrics
+
+| Metric | Target | How to Measure |
+|--------|--------|---------------|
+| Token savings | 20-40% | Original vs optimized length |
+| Implicit extraction accuracy | ≥ 80% | Extracted items confirmed by user |
+| Clarification rate | ≤ 15% | Prompts needing user clarification |
+| Requirement completeness | 100% | All user requirements preserved in output |
+
+---
+
+## Changelog
+
+### 1.0.0 (2026-07-17)
+
+- Initial release
+- 4 optimization passes (noise, implicit, ambiguity, structure)
+- Implicit requirement extraction from project context
+- Ambiguity detection algorithm
+- Structured YAML output format
+- Token savings tracking

package/optimization/token-audit.md

@@ -0,0 +1,177 @@
+# Token Optimization Audit
+
+> Análise de consumo atual + plano de redução de 40-60%.
+
+---
+
+## 1. Diagnóstico — Onde os tokens estão sendo gastos
+
+### 1.1 Estruturas Repetidas (principal vilão)
+
+Cada uma das 98 skills repete o mesmo molde:
+
+```
+> Version X | Priority: X
+> Dependencies: ...
+> Compatibility: ...
+
+## Identity (2-3 parágrafos)
+## Goals (lista)
+## Triggers (tabela)
+## Checklist
+## Examples (before/after)
+## Changelog
+```
+
+**Custo:** ~400 tokens repetidos por skill × 98 skills = **~39.200 tokens** de boilerplate.
+
+### 1.2 YAML Frontmatter vs Formato Atual
+
+O formato atual usa markdown com cabeçalhos. YAML inline seria mais compacto.
+
+### 1.3 Descrições Prolixas
+
+Muitas skills explicam o óbvio. Exemplo real:
+
+```
+"We designed this schema with the goal of..."
+→ "Schema 3NF com índices em FK, WHERE, ORDER BY."
+```
+
+### 1.4 Checklists Duplicadas
+
+OWASP checklist aparece em `security-engineer.md` e `owasp-auditor.md`. Idem para SOLID, Clean Code, etc.
+
+---
+
+## 2. Plano de Redução por Técnica
+
+### Técnica A — Skill Template Compacto (economia: 35%)
+
+Substituir o cabeçalho verbose por YAML inline:
+
+```yaml
+# ANTES (79 tokens)
+> Version 1.0.0 | Priority: High
+> Dependencies: Software Architect, Database Engineer, Security Engineer
+> Compatibility: ">=1.0.0"
+
+## Identity
+Responsável por projetar a arquitetura...
+
+# DEPOIS (28 tokens)
+v: 1.0.0 | p: high | deps: [architect, db, security]
+```
+
+**Impacto:** 39.200 → 14.000 tokens (economia de ~25.200 tokens em carga inicial).
+
+### Técnica B — Unificar Checklists Duplicadas (economia: 15%)
+
+Checklists que aparecem em múltiplos lugares viram referências:
+
+```
+# ANTES
+skills/security-engineer.md tem OWASP checklist (150 tokens)
+security/owasp-auditor.md tem OWASP checklist (150 tokens)
+
+# DEPOIS
+security/owasp-checklist.md (única fonte)
+Referenciado por: security-engineer.md, owasp-auditor.md, pentest-reviewer.md
+```
+
+**Impacto:** elimina ~300 tokens duplicados por checklist unificada.
+
+### Técnica C — Short IDs para Skills (economia: 8%)
+
+Usar IDs curtos nas chains:
+
+```
+# ANTES
+"skills/software-architect", "skills/senior-code-reviewer"
+
+# DEPOIS
+"architect", "reviewer"
+```
+
+**Impacto:** reduz ~15 tokens por referência em agents.json.
+
+### Técnica D — Remover "Changelog" de Skills Individuais (economia: 5%)
+
+Changelog de cada skill individual raramente é lido. Manter só no CHANGELOG.md central.
+
+**Impacto:** ~30 tokens por skill × 98 = ~2.940 tokens.
+
+### Técnica E — Comprimir Descrições (economia: 20%)
+
+Reduzir identity/goals para 1 linha cada:
+
+```
+# ANTES (60 tokens)
+"Responsável por projetar a arquitetura de software antes que qualquer código seja escrito. É a primeira skill ativada em projetos novos."
+
+# DEPOIS (20 tokens)
+"Arquiteta antes de codificar. Ativada primeiro em projetos novos."
+```
+
+---
+
+## 3. Estimativa de Economia Total
+
+| Técnica | Tokens Salvos | % | Esforço |
+|---------|--------------|---|---------|
+| A — Template compacto | ~25.200 | 35% | Alto (reescrever 98 skills) |
+| B — Checklists unificadas | ~4.500 | 15% | Médio (extrair 10 checklists) |
+| C — Short IDs | ~2.000 | 8% | Baixo (sed nos agents) |
+| D — Remove changelogs | ~2.940 | 5% | Baixo (sed global) |
+| E — Descrições comprimidas | ~14.000 | 20% | Alto (revisão manual) |
+| **Total** | **~48.640** | **~55%** | — |
+
+---
+
+## 4. Ações Imediatas (baixo esforço, alto retorno)
+
+### 4.1 Template Compacto para Skills Novas
+
+Toda skill nova usa este formato:
+
+```yaml
+---
+v: 1.0.0
+p: high
+deps: [skill-a, skill-b]
+triggers: [new_project, new_feature]
+budget: 500
+---
+```
+
+### 4.2 Unificar Checklists Agora
+
+| Checklist | Dono | Skills que referenciam |
+|-----------|------|----------------------|
+| OWASP Top 10 | security/owasp-checklist.md | security-engineer, owasp-auditor, pentest-reviewer |
+| SOLID | quality/solid-checklist.md | solid-validator, clean-code-validator, code-reviewer |
+| Performance | quality/perf-checklist.md | performance-optimizer, scalability-expert |
+| Acessibilidade | quality/a11y-checklist.md | accessibility-reviewer, ux-reviewer, frontend-engineer |
+
+### 4.3 Short IDs nos Agents
+
+```json
+// agents/architect-agent.json
+"skills": ["architect", "clean-arch", "ddd", "cqrs"]
+// Resolve para skills/software-architect.md, architecture/clean-architecture.md, etc.
+```
+
+---
+
+## 5. Meta
+
+| Métrica | Atual | Alvo | Prazo |
+|---------|-------|------|-------|
+| Tokens para carregar tudo | ~88.000 | ≤ 40.000 | v2.0 |
+| Tokens por skill (média) | ~900 | ≤ 400 | v2.0 |
+| Checklists duplicadas | 12 | 0 | v1.1 |
+| Boilerplate por skill | ~400 | ~100 | v2.0 |
+
+---
+
+> "O melhor token é o que você não gasta."

package/optimization/token-reducer.md

@@ -0,0 +1,202 @@
+# Optimization: Token Reducer
+
+> Version 1.0.0
+> Priority: High
+> Dependencies: Compression Engine, Context Engine
+> Compatibility: ">=1.0.0"
+
+---
+
+## Identity
+
+The Token Reducer works alongside the Compression Engine to proactively reduce token consumption before content is generated. It applies techniques like shortening prompts, removing redundant instructions, and choosing compact output formats — all without losing meaning.
+
+---
+
+## Goals
+
+- Reduce prompt tokens by 20-40% before generation.
+- Reduce output tokens by 15-30% through format optimization.
+- Eliminate all redundant instructions and meta-commentary.
+- Choose the most token-efficient format for every output type.
+
+---
+
+## Reduction Techniques
+
+### Technique 1: Shorten Instructions
+
+Remove redundant meta-instructions that are already encoded in the skill.
+
+```
+BEFORE:
+"Now I will analyze the requirements you provided and think about what architecture would be best for your project. Let me consider the different options available..."
+
+AFTER:
+"## Architecture Analysis"
+```
+
+**Savings: ~40 tokens per occurrence.**
+
+### Technique 2: Compact Lists
+
+Use compact list format instead of verbose bullet points.
+
+```
+BEFORE:
+"- First, we need to create a migration file for the users table
+ - Second, we create the User model with the necessary relationships
+ - Third, we implement the AuthController with login and register methods"
+
+AFTER:
+"1. Users migration
+ 2. User model (relationships)
+ 3. AuthController (login, register)"
+```
+
+**Savings: ~30 tokens per list.**
+
+### Technique 3: No Meta-Commentary
+
+Eliminate sentences about what the AI is doing or about to do.
+
+```
+BEFORE: "Let me now generate the code for the controller. I'll make sure to include proper validation and error handling."
+
+AFTER: (just the code)
+```
+
+**Savings: ~20 tokens per occurrence.**
+
+### Technique 4: Use Shorthand Headers
+
+```
+BEFORE: "## Analysis of Requirements"
+AFTER:  "## Requirements"
+
+BEFORE: "## Description of the Architecture Pattern"
+AFTER:  "## Architecture"
+
+BEFORE: "## Implementation Details and Code Examples"
+AFTER:  "## Implementation"
+```
+
+**Savings: ~10 tokens per header.**
+
+### Technique 5: Remove Redundant Code Comments
+
+When code is self-explanatory, omit comments.
+
+```
+// ❌ Verbose
+$user = User::find($id); // Find the user by their ID from the database
+
+// ✅ Clean
+$user = User::find($id);
+```
+
+**Savings: ~15 tokens per comment.**
+
+### Technique 6: Compact Error Messages
+
+```
+BEFORE: "An error occurred while processing your request. Please try again later."
+AFTER:  "Error processing request. Try again later."
+```
+
+**Savings: ~10 tokens per message.**
+
+---
+
+## Format Selection
+
+Choose the most token-efficient format based on content type:
+
+| Content Type | Best Format | Token Savings vs Default |
+|-------------|-------------|------------------------|
+| Code | Code block (```) | Baseline |
+| Config | YAML | 20% vs JSON |
+| Data | JSON compact (no spaces) | 30% vs pretty-print |
+| List | Markdown list | Baseline |
+| Table | Pipe table | 30% vs HTML table |
+| Decision | YAML | 40% vs prose |
+| Report | YAML + prose mix | 25% vs all prose |
+| Teaching | Short code + explanation | 35% vs long explanation |
+
+---
+
+## Algorithm
+
+```
+function reduce_prompt(prompt):
+    techniques = [
+        shorten_instructions,
+        remove_meta_commentary,
+        compact_headers,
+        remove_redundant_examples,
+    ]
+    
+    for technique in techniques:
+        if size(prompt) > target:
+            prompt = technique(prompt)
+    
+    return prompt
+
+
+function reduce_output(output, format):
+    if format == "code":
+        output = remove_redundant_comments(output)
+        output = compact_imports(output)
+    
+    elif format == "list":
+        output = use_compact_list(output)
+    
+    elif format == "decision":
+        output = use_yaml_format(output)
+    
+    elif format == "teaching":
+        output = prioritize_code_over_explanation(output)
+    
+    return output
+```
+
+---
+
+## Rules
+
+### Always
+
+- ✅ Reduce prompt tokens before every generation.
+- ✅ Choose the most token-efficient format for the content.
+- ✅ Remove meta-commentary about what the AI is doing.
+- ✅ Use compact lists over verbose bullet points.
+
+### Never
+
+- ❌ Reduce content that would make it unclear or ambiguous.
+- ❌ Remove security-critical explanations.
+- ❌ Eliminate necessary context for understanding.
+- ❌ Sacrifice teaching quality for token savings.
+
+---
+
+## Metrics
+
+| Metric | Target | How to Measure |
+|--------|--------|---------------|
+| Prompt reduction | 20-40% | Original vs reduced size |
+| Output reduction | 15-30% | Original vs reduced size |
+| Clarity retention | ≥ 95% | User follow-up clarification rate |
+| Format efficiency | Optimal per type | Tokens per content type |
+
+---
+
+## Changelog
+
+### 1.0.0 (2026-07-17)
+
+- Initial release
+- 6 reduction techniques
+- Format selection matrix for 8 content types
+- Prompt and output reduction algorithms
+- Teaching quality preservation rules

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "izanagi-ai",
+  "version": "2.0.0",
+  "description": "Modular Skill-Oriented AI Prompt & Agent Framework for Autonomous Software Engineering",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "bin": {
+    "nexus": "./bin/nexus.js",
+    "nexusai": "./bin/nexus.js"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "agents",
+    "architecture",
+    "backend",
+    "core",
+    "database",
+    "devops",
+    "frontend",
+    "memory",
+    "optimization",
+    "security",
+    "skills",
+    "teaching",
+    "testing",
+    "SYSTEM.md",
+    "RULES.md",
+    "AGENTS.md",
+    "CHANGELOG.md",
+    "ROADMAP.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build",
+    "postinstall": "node dist/postinstall.js",
+    "start": "node bin/nexus.js",
+    "doctor": "node bin/nexus.js doctor",
+    "list": "node bin/nexus.js list"
+  },
+  "keywords": [
+    "nexusai",
+    "ai",
+    "agents",
+    "prompt-engineering",
+    "skills",
+    "cli",
+    "llm",
+    "code-generation",
+    "autonomous-agents"
+  ],
+  "author": "Pedro Henrique Sanches Leal",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.43",
+    "typescript": "^5.9.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pedrohenriquesanchesleal4-debug/NexusAi.git"
+  }
+}