Main

.antigravity/config.json

@@ -0,0 +1,21 @@
+{
+  "dreamcode": {
+    "enabled": true,
+    "sandbox": false,
+    "dream_mode": true,
+    "scoring": true,
+    "model_router": true,
+    "skills": {
+      "auto_chain": true,
+      "max_chain_length": 16
+    },
+    "sensor_gate": {
+      "enabled": true,
+      "guardian_ai": true
+    },
+    "memory": {
+      "backend": "sqlite",
+      "auto_persist": true
+    }
+  }
+}

.dreamcode/automations/prompts/prompt_engine.py

@@ -0,0 +1,74 @@
+"""NeuroPromptEngine - Builds context-aware prompts for NEURO analysis."""
+
+from pathlib import Path
+from typing import Any
+
+
+class NeuroPromptEngine:
+    """Builds prompts for NEURO AI architecture review."""
+
+    SYSTEM_PROMPTS = {
+        "full_audit": """You are an expert software architect reviewing a codebase.
+Analyze the provided code for:
+1. Architecture issues and anti-patterns
+2. Security vulnerabilities
+3. Performance bottlenecks
+4. Code quality and maintainability
+5. Testing gaps
+
+Provide specific, actionable recommendations with file:line references.""",
+
+        "security": """You are a security expert reviewing code for vulnerabilities.
+Focus on:
+1. OWASP Top 10 vulnerabilities
+2. Authentication/authorization flaws
+3. Input validation issues
+4. Secret/credential exposure
+5. Dependency vulnerabilities
+
+Provide specific fixes with code examples.""",
+
+        "bug_hunt": """You are a debugging expert analyzing code for bugs.
+Focus on:
+1. Logic errors and edge cases
+2. Race conditions
+3. Memory leaks
+4. Error handling gaps
+5. Type safety issues
+
+Provide specific fixes with file:line references.""",
+
+        "test_gap": """You are a testing expert analyzing code coverage gaps.
+Focus on:
+1. Missing unit tests
+2. Integration test gaps
+3. Edge cases not covered
+4. Error path testing
+5. Performance testing needs
+
+Provide specific test cases with examples.""",
+    }
+
+    def build(self, scan_type: str, files: list[dict], context: str = "") -> dict[str, Any]:
+        """Build a prompt for NEURO analysis."""
+        system_prompt = self.SYSTEM_PROMPTS.get(scan_type, self.SYSTEM_PROMPTS["full_audit"])
+
+        file_contents = []
+        for f in files:
+            path = f.get("path", "unknown")
+            content = f.get("content", "")
+            file_contents.append(f"## File: {path}\n```\n{content}\n```")
+
+        user_prompt = f"Analyze the following code:\n\n{chr(10).join(file_contents)}"
+        if context:
+            user_prompt += f"\n\nAdditional context: {context}"
+
+        estimated_tokens = len(system_prompt.split()) + len(user_prompt.split())
+
+        return {
+            "system_prompt": system_prompt,
+            "user_prompt": user_prompt,
+            "estimated_tokens": estimated_tokens,
+            "scan_type": scan_type,
+            "file_count": len(files),
+        }

.dreamcode/automations/timezone.py

@@ -0,0 +1,66 @@
+"""timezone.py — IST timezone utilities for all automation scripts.
+
+All timestamps in the automation system use IST (India Standard Time, UTC+5:30).
+This module provides helpers to get current IST time and convert between timezones.
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime, timedelta, timezone
+
+# IST offset: UTC+5:30
+IST = timezone(timedelta(hours=5, minutes=30))
+
+
+def now_ist() -> datetime:
+    """Get current time in IST."""
+    return datetime.now(IST)
+
+
+def now_ist_iso() -> str:
+    """Get current IST time as ISO 8601 string."""
+    return now_ist().isoformat()
+
+
+def now_ist_filesafe() -> str:
+    """Get current IST time formatted for filenames."""
+    return now_ist().strftime("%Y%m%d_%H%M%S")
+
+
+def now_ist_date() -> str:
+    """Get current IST date as YYYY-MM-DD."""
+    return now_ist().strftime("%Y-%m-%d")
+
+
+def now_ist_time() -> str:
+    """Get current IST time as HH:MM:SS."""
+    return now_ist().strftime("%H:%M:%S")
+
+
+def ist_hour() -> int:
+    """Get current IST hour (0-23)."""
+    return now_ist().hour
+
+
+def ist_minute() -> int:
+    """Get current IST minute (0-59)."""
+    return now_ist().minute
+
+
+def to_ist(dt: datetime) -> datetime:
+    """Convert any datetime to IST."""
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=UTC)
+    return dt.astimezone(IST)
+
+
+def format_duration(seconds: float) -> str:
+    """Format seconds as human-readable duration."""
+    if seconds < 60:
+        return f"{seconds:.1f}s"
+    elif seconds < 3600:
+        minutes = seconds / 60
+        return f"{minutes:.1f}m"
+    else:
+        hours = seconds / 3600
+        return f"{hours:.1f}h"

.dreamcode/requirements.txt

@@ -0,0 +1,13 @@
+# DreamCode Python Dependencies
+# Install: pip install -r .dreamcode/requirements.txt
+
+# Core dependencies for skill scripts
+httpx>=0.27.0
+pyyaml>=6.0.1
+
+# Optional: YouTube transcript support
+# yt-dlp>=2024.1.1
+
+# Optional: AI/ML dependencies for neuro harness
+# openai>=1.50.0
+# anthropic>=0.39.0

.dreamcode/skills/api/SKILL.md

@@ -0,0 +1,111 @@
+---
+name: api-design
+description: "API design patterns, REST conventions, and endpoint standards. Use when creating or modifying API endpoints. Covers routing, request/response patterns, error handling, and versioning."
+chains_with:
+  - security
+  - quality
+---
+
+# API Design Skill — Contracts First
+
+## Design Principles
+
+1. **Resource-oriented**: URLs name resources, not actions
+2. **Consistent**: Same patterns across all endpoints
+3. **Versioned**: Never break existing clients
+4. **Documented**: Every endpoint has its contract
+5. **Backward compatible**: Add fields, don't remove them
+
+## REST Conventions
+
+### URL Structure
+```
+GET    /api/assets              # List resources
+GET    /api/assets/{id}         # Get one resource
+POST   /api/assets              # Create resource
+PUT    /api/assets/{id}         # Replace resource
+PATCH  /api/assets/{id}         # Partial update
+DELETE /api/assets/{id}         # Delete resource
+```
+
+### Query Parameters
+- `?page=2&per_page=20` — Pagination
+- `?sort=date&order=desc` — Sorting
+- `?fields=id,name,value` — Field selection
+- `?filter[status]=active` — Filtering
+
+### Response Envelope
+```json
+{
+  "status": "ready",
+  "data": { ... },
+  "meta": {
+    "page": 1,
+    "total": 100,
+    "timestamp": "2026-05-27T10:30:00Z"
+  }
+}
+```
+
+### Error Response
+```json
+{
+  "error": "Human-readable message",
+  "code": "INVALID_INPUT",
+  "details": {
+    "field": "confidence_level",
+    "reason": "Must be between 0 and 1"
+  }
+}
+```
+
+## Flask Patterns (Project-Q)
+
+```python
+# Standard endpoint pattern
+@app.route("/api/resource")
+def get_resource():
+    # 1. Parse parameters
+    param = request.args.get("param", default_value, type=str)
+
+    # 2. Validate
+    if not valid(param):
+        return jsonify({"error": "Invalid param"}), 400
+
+    # 3. Process
+    result = compute(param)
+
+    # 4. Return
+    return jsonify({"status": "ready", "data": result})
+```
+
+### Cache Pattern
+```python
+_cache = {"data": None, "timestamp": 0}
+TTL = 300  # 5 minutes
+
+@app.route("/api/expensive")
+def expensive():
+    now = time.time()
+    if _cache["data"] and (now - _cache["timestamp"]) < TTL:
+        return jsonify(_cache["data"])
+
+    data = compute()
+    _cache = {"data": data, "timestamp": now}
+    return jsonify(data)
+```
+
+## Project-Q API Map
+
+| Endpoint | Method | Purpose | Cached |
+|----------|--------|---------|--------|
+| `/api/health` | GET | Health check | No |
+| `/api/kpis` | GET | Portfolio KPIs | No |
+| `/api/correlation` | GET | Correlation matrix | No |
+| `/api/regime` | GET | Current regime | No |
+| `/api/risk/metrics` | GET | Full risk metrics | 5 min |
+| `/api/risk/backtesting` | GET | Backtesting results | No |
+| `/api/quantum/summary` | GET | Quantum POC summary | No |
+| `/api/quantum/run` | POST | Run quantum layer | No |
+| `/api/monte-carlo/distribution` | GET | MC distribution | No |
+| `/api/pipeline/run` | POST | Trigger pipeline | No |

.dreamcode/skills/architecture/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: architecture
+description: "Architectural design, system patterns, and dependency management. Use when designing new modules, refactoring existing systems, or making architectural decisions. Covers layering, coupling, cohesion, and design patterns."
+chains_with:
+  - neuro
+  - code-hardener
+---
+
+# Architecture Skill — Design Before Build
+
+## Mandate
+
+Every architectural decision must be explicit, documented, and justified. Do not make implicit architectural choices.
+
+## Trigger Conditions
+
+- New module or subsystem
+- Cross-cutting concerns
+- API or data contract design
+- Performance-sensitive architecture
+- Security architecture
+- Refactoring existing architecture
+- Dependency management
+
+## Core Principles
+
+### 1. Separation of Concerns
+- One module = one responsibility
+- Business logic isolated from infrastructure
+- Data access isolated from presentation
+- Configuration externalized
+
+### 2. Dependency Rule
+- Dependencies point INWARD (toward business logic)
+- Outer layers depend on inner layers
+- Never the reverse
+
+### 3. API Design First
+- Define contracts before implementation
+- API is a contract, not an implementation detail
+- Version from day one
+- Document all endpoints with request/response schemas
+
+### 4. Data Flow Clarity
+- Every data flow has a clear source, path, and sink
+- No hidden side effects
+- Transformations are explicit and testable
+
+## Evaluation Checklist
+
+Before approving any architecture:
+
+- [ ] Each module has a single, named responsibility
+- [ ] Dependencies form a DAG (no cycles)
+- [ ] Public API is minimal and documented
+- [ ] Private implementation is hidden
+- [ ] Configuration is externalized
+- [ ] Error handling is designed (not an afterthought)
+- [ ] Testing strategy is defined
+- [ ] Performance characteristics are understood
+- [ ] Security boundaries are identified
+- [ ] Scalability limits are documented
+
+## Patterns Library
+
+### When to Use Each
+
+| Pattern | Use Case | Example |
+|---------|----------|---------|
+| Repository | Data access abstraction | Portfolio repository |
+| Factory | Complex object creation | Model factory |
+| Strategy | Interchangeable algorithms | Risk calculation |
+| Observer | Event-driven updates | Market data feed |
+| Adapter | Third-party integration | External API wrapper |
+| Decorator | Cross-cutting behavior | Logging, caching |
+| Pipeline | Sequential processing | Data transformation |
+| Bridge | Platform abstraction | Quantum backend abstraction |
+
+## Anti-Patterns to Flag
+
+- **God Module**: A module that does everything
+- **Circular Dependency**: A → B → A
+- **Leaky Abstraction**: Internal details visible in the API
+- **Shotgun Surgery**: One change requires edits everywhere
+- **Feature Envy**: Module A uses more of B's data than its own
+- **Premature Optimization**: Complex architecture before it's needed