izanagi-ai 2.0.0

package/architecture/unit-of-work.md

@@ -0,0 +1,92 @@
+# Architecture: Unit of Work
+
+> Version 1.0.0 | Priority: Medium
+> Dependencies: Repository Pattern
+> Compatibility: ">=1.0.0"
+
+---
+
+## Identity
+
+Unit of Work maintains a list of objects affected by a business transaction and coordinates writing changes as a single atomic unit. Ensures all changes succeed or fail together.
+
+---
+
+## Implementation
+
+```php
+class UnitOfWork
+{
+    private array $new = [];
+    private array $dirty = [];
+    private array $deleted = [];
+
+    public function registerNew(object $entity): void
+    {
+        $this->new[] = $entity;
+    }
+
+    public function registerDirty(object $entity): void
+    {
+        if (!in_array($entity, $this->dirty, true)) {
+            $this->dirty[] = $entity;
+        }
+    }
+
+    public function registerDeleted(object $entity): void
+    {
+        $this->deleted[] = $entity;
+    }
+
+    public function commit(): void
+    {
+        $this->beginTransaction();
+        try {
+            foreach ($this->new as $entity) { $this->insert($entity); }
+            foreach ($this->dirty as $entity) { $this->update($entity); }
+            foreach ($this->deleted as $entity) { $this->delete($entity); }
+            $this->commitTransaction();
+            $this->clear();
+        } catch (\Exception $e) {
+            $this->rollbackTransaction();
+            throw $e;
+        }
+    }
+
+    public function clear(): void
+    {
+        $this->new = [];
+        $this->dirty = [];
+        $this->deleted = [];
+    }
+}
+```
+
+---
+
+## Usage with Repository
+
+```php
+class OrderService
+{
+    public function __construct(
+        private UnitOfWork $uow,
+        private OrderRepository $repo,
+        private EventDispatcher $events,
+    ) {}
+
+    public function placeOrder(Cart $cart): void
+    {
+        $order = Order::place($cart);
+        $this->repo->add($order);  // registers in UoW
+        // More changes...
+        $this->uow->commit();      // all or nothing
+    }
+}
+```
+
+---
+
+## Changelog
+
+### 1.0.0 — Initial release. Implementation, usage pattern.

package/backend/README.md

@@ -0,0 +1,29 @@
+# Backend Skills
+
+> Skills de desenvolvimento backend estão em `coding/`:
+
+| Skill | Arquivo |
+|-------|---------|
+| Backend Engineer (geral) | `coding/backend-engineer.md` |
+| Laravel Specialist | `coding/laravel-specialist.md` |
+| PHP Specialist | `coding/php-specialist.md` |
+| Python Specialist | `coding/python-specialist.md` |
+| Node.js Specialist | `coding/nodejs-specialist.md` |
+| Java Specialist | `coding/java-specialist.md` |
+| C# Specialist | `coding/csharp-specialist.md` |
+| API Designer | `coding/api-designer.md` |
+
+---
+
+## Sugestão de Reorganização
+
+Para versão futura (2.0), mover:
+
+```
+backend/backend-engineer.md          ← de coding/backend-engineer.md
+backend/laravel-specialist.md        ← de coding/laravel-specialist.md
+backend/api-designer.md              ← de coding/api-designer.md
+frontend/frontend-engineer.md        ← de coding/frontend-engineer.md
+frontend/react-specialist.md         ← de coding/react-specialist.md
+frontend/vue-specialist.md           ← de coding/vue-specialist.md
+```

package/bin/nexus.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+import { runCLI } from '../src/cli/index.js';
+
+runCLI(process.argv.slice(2)).catch((err) => {
+  console.error('\x1b[31m[NexusAI Error]:\x1b[0m', err.message || err);
+  process.exit(1);
+});

package/core/compression-engine.md

@@ -0,0 +1,194 @@
+# Core: Compression Engine
+
+> Version 1.0.0
+> Priority: High
+> Dependencies: Token Manager
+> Compatibility: ">=1.0.0"
+
+---
+
+## Identity
+
+The Compression Engine is activated when the Token Manager detects that usage exceeds 70% of the budget. It applies lossy and lossless compression strategies to reduce token count while preserving semantic meaning and critical information.
+
+---
+
+## Goals
+
+- Reduce token count by 30-50% when activated.
+- Preserve 100% of decisions, security items, and action items.
+- Eliminate 100% of redundancy, filler, and repetition.
+- Complete compression in under 200ms.
+
+---
+
+## Compression Levels
+
+| Level | Reduction | When Used | Risk |
+|-------|-----------|-----------|------|
+| **Lossless** | 10-20% | Budget at 70-80% | None — removes whitespace, shortens identifiers |
+| **Light** | 20-35% | Budget at 80-90% | Low — summarizes examples, drops verbose explanations |
+| **Aggressive** | 35-50% | Budget at 90-100% | Medium — drops non-critical examples, shortens code blocks |
+| **Emergency** | 50-70% | Budget exceeded | High — keeps only decisions, security items, and action items |
+
+---
+
+## Compression Strategies
+
+### 1. Remove Filler (Lossless)
+
+```
+Before: "I would recommend that you consider using..."
+After:  "Use..."
+
+Before: "In order to achieve this goal, we need to..."
+After:  "To do this..."
+
+Before: "It is important to note that the system should..."
+After:  "The system must..."
+```
+
+### 2. Condense Lists (Light)
+
+```
+Before:
+- First, create a new controller
+- Second, add the validation rules
+- Third, implement the service layer
+
+After:
+1. Create controller
+2. Add validation
+3. Implement service
+```
+
+### 3. Summarize Code (Light)
+
+```
+Before:
+public function store(Request $request)
+{
+    $validated = $request->validate([
+        'name' => 'required|string|max:255',
+        'email' => 'required|email|unique:users',
+        'password' => 'required|min:8|confirmed',
+    ]);
+    
+    $user = User::create($validated);
+    
+    return response()->json($user, 201);
+}
+
+After:
+// UserController::store — validates name, email, password → creates user → returns 201
+```
+
+### 4. Drop Repetition (Aggressive)
+
+Remove content that has appeared verbatim in the last 3 responses. Track using a rolling hash of content blocks.
+
+### 5. Keyword-Only Memory (Emergency)
+
+```
+Before:
+"We decided to use JWT tokens stored in httpOnly cookies for authentication because it provides better XSS protection compared to localStorage. The refresh token endpoint is rate-limited to 5 requests per minute."
+
+After:
+"Auth: JWT in httpOnly cookies (XSS protection). Refresh rate-limited: 5/min."
+```
+
+---
+
+## Decision Preservation
+
+The following content types are **never** compressed below their minimum viable form:
+
+| Content Type | Minimum Form |
+|-------------|-------------|
+| Security decision | Full — must remain readable |
+| Vulnerability finding | Full — including severity and location |
+| Action item | Full — including owner and deadline |
+| Breaking change | Full — including migration path |
+| Error explanation | Cause + fix (can remove stack trace) |
+| User preference | Full — exact wording |
+
+---
+
+## Algorithm
+
+```
+function compress(content, target_level):
+    if target_level == "lossless":
+        content = remove_filler(content)
+        content = shorten_markdown_headers(content)
+        content = remove_trailing_whitespace(content)
+    
+    elif target_level == "light":
+        content = compress_lossless(content)
+        content = condense_lists(content)
+        content = summarize_examples(content, keep=2)
+        content = shorten_code_blocks(content, keep_signatures=true)
+    
+    elif target_level == "aggressive":
+        content = compress_light(content)
+        content = drop_redundant_blocks(content)
+        content = summarize_code_blocks(content)
+        content = keep_only_first_sentence_of_explanations(content)
+    
+    elif target_level == "emergency":
+        content = extract_decisions(content)
+        content = extract_security_items(content)
+        content = extract_action_items(content)
+        content = drop_everything_else(content)
+    
+    return content
+```
+
+---
+
+## Quality Check After Compression
+
+1. ✅ All decisions preserved?
+2. ✅ All security items preserved?
+3. ✅ All action items preserved?
+4. ✅ No grammatical errors introduced?
+5. ✅ Still understandable to the user?
+
+If any check fails, revert to the previous level and retry.
+
+---
+
+## Metrics
+
+| Metric | Target | How to Measure |
+|--------|--------|---------------|
+| Compression ratio | ≥ 2:1 (aggressive) | original size / compressed size |
+| Decision loss rate | 0% | Count lost decisions |
+| User comprehension | ≥ 95% | Follow-up user clarification rate |
+| Compression speed | < 200ms | Execution time |
+
+---
+
+## Memory Hooks
+
+```yaml
+on_compress:
+  - save: compression_log (level, ratio, items_dropped)
+  - save: preserved_decisions
+
+on_failure:
+  - notify: Token Manager
+  - revert: to previous compression level
+```
+
+---
+
+## Changelog
+
+### 1.0.0 (2026-07-17)
+
+- Initial release
+- 4 compression levels: lossless, light, aggressive, emergency
+- Content-type preservation rules
+- Rolling hash for repetition detection
+- Quality check after every compression

package/core/context-engine.md

@@ -0,0 +1,239 @@
+# Core: Context Engine
+
+> Version 1.0.0
+> Priority: Critical
+> Dependencies: Memory Manager, Token Manager
+> Compatibility: ">=1.0.0"
+
+---
+
+## Identity
+
+The Context Engine builds the minimal, high-signal context window for every task. It loads only what is relevant, compresses what is verbose, and discards what is noise. It is the gatekeeper of the token budget.
+
+---
+
+## Goals
+
+- Load only relevant context (no waste).
+- Compress verbose history without losing signal.
+- Respect strict token limits per task.
+- Provide the agent with everything needed, nothing extra.
+
+---
+
+## Context Window Structure
+
+```
+┌────────────────────────────────────────────┐
+│              CONTEXT WINDOW                │
+│                                            │
+│  1. SYSTEM CONTEXT (200 tokens max)       │
+│     - Identity                            │
+│     - Current task                        │
+│     - Active skill chain                  │
+│                                            │
+│  2. PROJECT CONTEXT (400 tokens max)      │
+│     - Project type                        │
+│     - Tech stack                          │
+│     - Architecture (from Software Arch.)  │
+│     - Conventions                         │
+│                                            │
+│  3. MEMORY CONTEXT (300 tokens max)       │
+│     - Relevant decisions                  │
+│     - Relevant errors                     │
+│     - Relevant patterns                   │
+│                                            │
+│  4. TASK CONTEXT (remaining budget)       │
+│     - User input                          │
+│     - File contents (if referenced)       │
+│     - Previous output (if continuation)   │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+## Workflow
+
+```
+1. Receive task and classification
+    ↓
+2. Load SYSTEM_CONTEXT
+    - Identity: who the agent is
+    - Task: what the user asked
+    - Chain: which skills will execute
+    ↓
+3. Load PROJECT_CONTEXT
+    - Query Project Memory for relevant data
+    - Load tech stack, architecture, conventions
+    ↓
+4. Load MEMORY_CONTEXT
+    - Query Long Term Memory for relevant patterns
+    - Query Knowledge Graph for related decisions
+    ↓
+5. Load TASK_CONTEXT
+    - User input (cleaned)
+    - Relevant files (truncated if > budget)
+    ↓
+6. COMPRESS if total > budget
+    - Apply priority-based compression
+    - Remove redundancy
+    - Summarize verbose sections
+    ↓
+7. DELIVER to Skill Executor
+```
+
+---
+
+## Load Prioritization
+
+When the context window is full, items are dropped in this order (last = kept):
+
+1. User input history (oldest first)
+2. Previous outputs (except last one)
+3. Memory context (lowest relevance score)
+4. Project context (general vs specific)
+5. Task context (current task)
+6. System context (never dropped)
+
+---
+
+## Compression Algorithm
+
+```
+function compress(context, budget):
+    while size(context) > budget:
+        section = find_lowest_priority_section()
+        
+        if section.type == "memory":
+            section = summarize(section)
+            // "We decided to use JWT instead of sessions"
+            // → "Decision: JWT > sessions"
+        
+        elif section.type == "history":
+            section = drop_oldest_50_percent()
+        
+        elif section.type == "file_content":
+            section = truncate_to_signature_lines()
+            // Keep: class declaration, method signatures
+            // Drop: implementation details
+        
+        elif section.type == "project":
+            section = keep_only_active_tokens()
+            // Keep: current stack, relevant patterns
+            // Drop: inactive modules, old decisions
+        
+        else:
+            section = remove_verbose_markdown()
+    
+    return context
+```
+
+---
+
+## Relevance Scoring
+
+Each memory item is scored before loading:
+
+```
+relevance = (keyword_match_count * 0.4) 
+          + (recency_factor * 0.3) 
+          + (task_type_match * 0.2) 
+          + (frequency_factor * 0.1)
+
+if relevance < 0.3:
+    skip loading (low signal)
+elif relevance < 0.6:
+    load as compressed summary
+else:
+    load in full
+```
+
+---
+
+## Rules
+
+### Always
+
+- ✅ Load minimal context for the task.
+- ✅ Compress before delivering if budget exceeded.
+- ✅ Prioritize current task over history.
+- ✅ Keep system identity in every context window.
+
+### Never
+
+- ❌ Load full conversation history.
+- ❌ Load files not referenced by the task.
+- ❌ Exceed the token budget.
+- ❌ Drop system identity.
+
+---
+
+## Metrics
+
+| Metric | Target | How to Measure |
+|--------|--------|---------------|
+| Context size vs budget | ≤ 100% | Compare window size to budget |
+| Relevance of loaded memory | ≥ 0.6 | Average relevance score of loaded items |
+| Compression ratio | ≥ 2:1 | Original size / compressed size |
+| Dropped items rate | ≤ 20% | Items dropped vs total attempted |
+
+---
+
+## Token Budget
+
+| Operation | Tokens |
+|-----------|--------|
+| Load system context | 50 |
+| Load project context | 100 |
+| Query memory | 80 |
+| Score relevance | 40 |
+| Compress (if needed) | 150 |
+| **Total per build** | **~420** |
+
+---
+
+## Memory Hooks
+
+```yaml
+on_build:
+  - load: system_identity
+  - load: project_tech_stack
+  - query: relevant_decisions
+
+on_compress:
+  - save: compression_log
+  - notify: Token Manager
+
+on_deliver:
+  - save: context_window_snapshot
+```
+
+---
+
+## Reflection
+
+### Pre-delivery
+
+- [ ] Is the context window minimal?
+- [ ] Is any loaded item irrelevant?
+- [ ] Can I compress further without losing signal?
+
+### Post-delivery
+
+- [ ] Did the agent need context that was not loaded?
+- [ ] Was any loaded context unused?
+- [ ] Should relevance scoring be adjusted?
+
+---
+
+## Changelog
+
+### 1.0.0 (2026-07-17)
+
+- Initial release
+- 4-section context window structure
+- Priority-based compression algorithm
+- Relevance scoring for memory loading
+- Budget enforcement before delivery