nexusforge-cli 1.0.0__py3-none-any.whl

nexusforge_cli/__init__.py

@@ -0,0 +1,2 @@
+"""NexusForge CLI — Enterprise AI Agent Orchestration Setup."""
+__version__ = "1.0.0"

nexusforge_cli/agents.py

@@ -0,0 +1,210 @@
+"""Agent experience profiles — accumulated knowledge from NexusForge agents."""
+
+AGENT_PROFILES = {
+    "ClassifierAgent": {
+        "model": "gemma3:4b",
+        "role": "Classifies text into categories (ticket type, urgency, intent)",
+        "strengths": ["Fast classification", "Multi-label support", "Urgency detection"],
+        "best_for": ["Ticket triage", "Email routing", "Document categorization"],
+        "experience": {
+            "total_executions": 150,
+            "success_rate": 0.97,
+            "avg_latency_ms": 800,
+            "learned_patterns": [
+                "Urgency keywords: 'urgente', 'critico', 'inmediato' → high priority",
+                "Invoice patterns: montos, fechas, RFC → type: factura",
+                "Complaint patterns: 'queja', 'problema', 'no funciona' → type: complaint",
+            ],
+        },
+    },
+    "ExtractorAgent": {
+        "model": "qwen2.5-coder:7b",
+        "role": "Extracts structured data from unstructured text (entities, fields, values)",
+        "strengths": ["JSON output", "Multi-field extraction", "Table parsing"],
+        "best_for": ["Invoice processing", "Form extraction", "Data normalization"],
+        "experience": {
+            "total_executions": 120,
+            "success_rate": 0.94,
+            "avg_latency_ms": 1200,
+            "learned_patterns": [
+                "Invoice fields: monto, fecha, proveedor, RFC, numero_factura",
+                "Email fields: from, subject, body_summary, intent, urgency",
+                "Nested JSON extraction works better with explicit schema in prompt",
+            ],
+        },
+    },
+    "SummarizerAgent": {
+        "model": "llama3.1:8b",
+        "role": "Generates concise summaries of documents and conversations",
+        "strengths": ["Natural language", "Multi-document", "Executive summaries"],
+        "best_for": ["Report generation", "Email summaries", "Meeting notes"],
+        "experience": {
+            "total_executions": 100,
+            "success_rate": 0.96,
+            "avg_latency_ms": 1500,
+            "learned_patterns": [
+                "Executive summaries: 3-5 bullet points max",
+                "Report summaries: include KPIs, trends, anomalies",
+                "Multi-doc: synthesize common themes across documents",
+            ],
+        },
+    },
+    "AnalyzerAgent": {
+        "model": "qwen2.5-coder:7b",
+        "role": "Analyzes data for trends, anomalies, and patterns",
+        "strengths": ["Trend detection", "Anomaly flagging", "Statistical analysis"],
+        "best_for": ["Financial analysis", "Performance metrics", "Data quality"],
+        "experience": {
+            "total_executions": 80,
+            "success_rate": 0.92,
+            "avg_latency_ms": 1800,
+            "learned_patterns": [
+                "Financial: flag transactions > 2 std deviations from mean",
+                "Trends: compare current period vs previous period",
+                "Quality: check for nulls, duplicates, format inconsistencies",
+            ],
+        },
+    },
+    "SentimentAgent": {
+        "model": "gemma3:4b",
+        "role": "Analyzes emotional tone and urgency in text",
+        "strengths": ["Fast sentiment", "Urgency scoring", "Tone detection"],
+        "best_for": ["Customer feedback", "Ticket prioritization", "Social monitoring"],
+        "experience": {
+            "total_executions": 90,
+            "success_rate": 0.95,
+            "avg_latency_ms": 600,
+            "learned_patterns": [
+                "Urgency scale: critical (immediate), high (same day), medium (48h), low (week)",
+                "Negative sentiment + high urgency = escalate immediately",
+                "Sarcasm detection improves with context from previous messages",
+            ],
+        },
+    },
+    "ValidatorAgent": {
+        "model": "qwen2.5-coder:7b",
+        "role": "Validates data quality, consistency, and business rules",
+        "strengths": ["Rule-based validation", "Duplicate detection", "Format checking"],
+        "best_for": ["Invoice validation", "Data quality", "Compliance checks"],
+        "experience": {
+            "total_executions": 70,
+            "success_rate": 0.98,
+            "avg_latency_ms": 900,
+            "learned_patterns": [
+                "Duplicate detection: compare hash of key fields (monto+fecha+proveedor)",
+                "Format validation: RFC pattern, email format, phone format",
+                "Business rules: montos > threshold require approval flag",
+            ],
+        },
+    },
+    "ReporterAgent": {
+        "model": "llama3.1:8b",
+        "role": "Generates formatted reports from analyzed data",
+        "strengths": ["Executive reports", "HTML/PDF formatting", "KPI dashboards"],
+        "best_for": ["Weekly reports", "Financial summaries", "Status updates"],
+        "experience": {
+            "total_executions": 60,
+            "success_rate": 0.93,
+            "avg_latency_ms": 2000,
+            "learned_patterns": [
+                "Executive report structure: summary → KPIs → details → recommendations",
+                "Include visual indicators: arrows for trends, colors for status",
+                "Always include period comparison (vs previous week/month)",
+            ],
+        },
+    },
+    "ComplianceAgent": {
+        "model": "claude",
+        "role": "Checks regulatory rules and flags violations",
+        "strengths": ["Regulatory knowledge", "Risk assessment", "Audit trail"],
+        "best_for": ["Financial compliance", "Data privacy", "Policy enforcement"],
+        "experience": {
+            "total_executions": 40,
+            "success_rate": 0.99,
+            "avg_latency_ms": 3000,
+            "learned_patterns": [
+                "Transactions > $10,000 require human approval (anti-money laundering)",
+                "PII detection: mask SSN, credit cards, addresses in outputs",
+                "Compliance reports must include timestamp, auditor, and decision rationale",
+            ],
+        },
+    },
+    "OCRAgent": {
+        "model": "qwen2.5-coder:7b",
+        "role": "Extracts text from images and scanned documents",
+        "strengths": ["PDF parsing", "Image text extraction", "Table recognition"],
+        "best_for": ["Invoice scanning", "Document digitization", "Receipt processing"],
+        "experience": {
+            "total_executions": 50,
+            "success_rate": 0.88,
+            "avg_latency_ms": 2500,
+            "learned_patterns": [
+                "PDF text extraction > image OCR for quality",
+                "Tables: extract as structured JSON, not plain text",
+                "Low-quality scans: preprocess with contrast enhancement",
+            ],
+        },
+    },
+    "JudgeAgent": {
+        "model": "qwen2.5-coder:7b",
+        "role": "Evaluates and scores outputs from multiple agents using Weighted Borda Count",
+        "strengths": ["Consensus evaluation", "Multi-criteria scoring", "Conflict resolution"],
+        "best_for": ["Second opinions", "Quality assurance", "Multi-agent voting"],
+        "experience": {
+            "total_executions": 30,
+            "success_rate": 0.95,
+            "avg_latency_ms": 1000,
+            "learned_patterns": [
+                "Weighted Borda Count works best with 3+ agent outputs",
+                "Criteria weights: accuracy (0.4), completeness (0.3), relevance (0.3)",
+                "Tie-breaking: prefer the agent with higher historical success rate",
+            ],
+        },
+    },
+}
+
+# Model routing map
+AGENT_MODEL_MAP = {
+    # Gemma3:4b — fast classification/routing
+    "ClassifierAgent": "gemma3:4b",
+    "RouterAgent": "gemma3:4b",
+    "SentimentAgent": "gemma3:4b",
+    "MonitorAgent": "gemma3:4b",
+    # Qwen2.5-coder:7b — structured output/code
+    "ExtractorAgent": "qwen2.5-coder:7b",
+    "AnalyzerAgent": "qwen2.5-coder:7b",
+    "ValidatorAgent": "qwen2.5-coder:7b",
+    "NormalizerAgent": "qwen2.5-coder:7b",
+    "OCRAgent": "qwen2.5-coder:7b",
+    "JudgeAgent": "qwen2.5-coder:7b",
+    "SchedulerAgent": "qwen2.5-coder:7b",
+    "WebhookAgent": "qwen2.5-coder:7b",
+    # Llama3.1:8b — natural language/synthesis
+    "SummarizerAgent": "llama3.1:8b",
+    "ReporterAgent": "llama3.1:8b",
+    "TranslatorAgent": "llama3.1:8b",
+    "EnricherAgent": "llama3.1:8b",
+    "KnowledgeAgent": "llama3.1:8b",
+    "ResearcherAgent": "llama3.1:8b",
+    "ScraperAgent": "llama3.1:8b",
+    # Cloud-only
+    "ComplianceAgent": "claude",
+    "PlannerAgent": "groq",
+    "CriticAgent": "groq",
+}
+
+# Swarm topologies
+TOPOLOGIES = {
+    "sequential": "Pipeline ordered step by step — each agent depends on the previous",
+    "parallel": "Multiple agents working simultaneously — for independent tasks",
+    "hierarchical": "Supervisor coordinates sub-tasks — for complex orchestration",
+    "debate": "Agents argue to improve results — for quality-critical analysis",
+    "consensus": "Multiple agents vote on decisions — for high-stakes choices",
+    "adaptive": "Selects topology automatically based on input complexity",
+}
+
+LLM_FALLBACK_CHAIN = [
+    {"provider": "ollama", "model": "deepseek-r1:8b", "role": "Chat + thinking", "cost": "free"},
+    {"provider": "groq", "model": "llama-3.3-70b-versatile", "role": "Cloud fallback", "cost": "free"},
+    {"provider": "anthropic", "model": "claude-sonnet-4", "role": "Last resort", "cost": "paid"},
+]

nexusforge_cli/kiro_specs.py

@@ -0,0 +1,223 @@
+"""Kiro specs generator — creates steering, memory, and hooks for NexusForge projects."""
+
+import os
+import json
+
+# ── Kiro Steering Rules ─────────────────────────────────────────────────────
+
+STEERING_PRODUCT = """# Product Context — NexusForge AI
+
+## What is this?
+Enterprise-grade AI Agent Orchestration Platform with:
+- 24 specialized AI agents with dedicated local LLMs
+- Chat-first interface with visible thinking (deepseek-r1)
+- 6 swarm topologies for complex workflows
+- Google OAuth + Stripe billing
+- 12 integrations (Email, Slack, Notion, Drive, Sheets, Gmail, Webhook, API)
+- Orchestrator memory system (agents learn from experience)
+- LLM fallback chain: local (Ollama) → Groq (free) → Claude (paid)
+
+## Target Users
+- Business operators automating repetitive processes
+- Teams processing tickets, invoices, emails, reports
+- Enterprises needing compliance + audit trail
+
+## Key Principles
+1. Users should NEVER see technical details (JSON, agent names, topologies)
+2. The chat guides step by step — ONE question at a time
+3. Everything runs locally first (privacy), cloud as fallback
+4. Every agent execution is recorded as experience for future learning
+"""
+
+STEERING_TECH = """# Tech Context — NexusForge AI
+
+## Stack
+- Backend: Python 3.12, FastAPI, asyncpg, asyncio
+- Frontend: React 18, Vite 8, vanilla CSS (no Tailwind)
+- Database: PostgreSQL 16 + pgvector, MongoDB 7 (episodic memory)
+- Cache: Redis 7
+- LLM: Ollama (5 models), Groq API, Claude API
+- Embeddings: Voyage AI (512d) + nomic-embed-text (local)
+- Deploy: Vercel (frontend), Render (backend)
+
+## Architecture
+- DAG-based workflow execution engine
+- Per-agent model routing (gemma→routing, qwen→code, llama→language)
+- 3-tier memory: working (Redis), episodic (MongoDB), semantic (pgvector)
+- Circuit breaker pattern for agent health
+- ExperienceCollector for agent learning
+- OrchestratorMemory for system-wide knowledge
+
+## Conventions
+- English for code, Spanish for user-facing strings
+- Pydantic v2 for all models
+- Type hints on all functions
+- Never modify existing encapsulated components — add new ones alongside
+"""
+
+STEERING_STRUCTURE = """# Project Structure
+
+```
+backend/
+  app/
+    agents/          — 24 agent implementations (base.py, capabilities.py)
+    auth/            — JWT, OAuth, middleware, billing
+    config.py        — Settings (Pydantic v2)
+    db/              — PostgreSQL client, migrations
+    engine/          — DAG execution, state machine, retry
+    healing/         — Circuit breaker, self-healing
+    integrations/    — Email, Slack, Notion, Drive, Gmail
+    llm/             — Router, providers (Ollama, Groq, Claude)
+    main.py          — FastAPI app, middleware stack
+    memory/          — Manager, episodic, semantic, working, orchestrator
+    models/          — Pydantic schemas
+    rag/             — Embeddings, indexer, retriever
+    routes/          — API endpoints
+    swarms/          — Topologies (sequential, parallel, etc.)
+  tests/             — 260+ pytest tests
+
+frontend/
+  src/
+    features/
+      chat-first/    — Main chat interface (ChatPanel, PreviewPanel)
+      chat/          — Floating guide chat (ChatAssistant)
+      dashboard/     — KPIs, metrics
+      automations/   — Automation management
+      wizard/        — Step-by-step wizard (legacy)
+      workflows/     — Workflow builder
+    shared/
+      components/    — Layout, Toast, ErrorBoundary
+      hooks/         — useLanguage, useToast, useRefreshOnFocus
+      i18n/          — Translations (es/en)
+    services/
+      api.js         — fetchAPI, getApiUrl
+```
+"""
+
+# ── Work Rules ───────────────────────────────────────────────────────────────
+
+WORK_RULES = """# Work Rules — Christian Hernandez
+
+## Critical Rules (NEVER break these)
+1. NEVER use PUT on Render env-vars API without including ALL existing vars
+2. NEVER modify existing encapsulated components — add new ones alongside
+3. ALWAYS verify destructive API calls before executing
+4. ALWAYS update memory after mistakes and key decisions
+5. Quality over speed — do it right, not fast
+6. ALWAYS build locally and verify before pushing
+
+## Development Flow
+1. Read ALL affected files before changing anything
+2. Plan the change mentally before writing code
+3. Make the minimum change needed
+4. Build locally to verify (vite build, pytest)
+5. Commit with descriptive message
+6. Push and verify deploy
+
+## LLM Architecture
+- deepseek-r1:8b → Chat interface (native thinking)
+- qwen2.5-coder:7b → Code agents, JSON generation
+- llama3.1:8b → Language agents, summaries, reports
+- gemma3:4b → Fast classification, routing
+- Groq → Cloud fallback (free, 24/7)
+- Claude → Last resort (paid)
+
+## Render/Vercel Deploy
+- Service ID: srv-d75b2575r7bs73b22gp0
+- DB: dpg-d75b1cpr0fns73blrtdg-a (nexusforge-db)
+- Frontend: nexusforge-two.vercel.app (auto-deploy from master)
+- Backend: nexusforge-api.onrender.com (auto-deploy from master)
+- PUT /env-vars REPLACES ALL — always GET first, then PUT full list
+
+## Agent Model Assignment
+- Gemma3:4b → ClassifierAgent, RouterAgent, SentimentAgent, MonitorAgent
+- Qwen2.5-coder:7b → ExtractorAgent, AnalyzerAgent, ValidatorAgent, OCRAgent, JudgeAgent
+- Llama3.1:8b → SummarizerAgent, ReporterAgent, TranslatorAgent, ResearcherAgent
+- Claude (cloud) → ComplianceAgent (regulatory, high-stakes)
+- Groq (cloud) → PlannerAgent, CriticAgent (need large context)
+"""
+
+# ── Kiro Hooks ───────────────────────────────────────────────────────────────
+
+KIRO_HOOKS = {
+    "pre-commit-lint": {
+        "description": "Run linting before commit",
+        "trigger": "pre-commit",
+        "command": "cd backend && python -m py_compile app/main.py",
+    },
+    "test-on-agent-change": {
+        "description": "Run agent tests when agent files change",
+        "trigger": "on-save",
+        "pattern": "backend/app/agents/*.py",
+        "command": "cd backend && pytest tests/test_agents.py -x -q",
+    },
+    "build-check-frontend": {
+        "description": "Verify frontend builds on change",
+        "trigger": "on-save",
+        "pattern": "frontend/src/**/*.jsx",
+        "command": "cd frontend && npx vite build --mode production",
+    },
+}
+
+# ── Kiro Memory Templates ────────────────────────────────────────────────────
+
+KIRO_MEMORY = {
+    "product_context": STEERING_PRODUCT,
+    "tech_context": STEERING_TECH,
+    "architecture_context": STEERING_STRUCTURE,
+    "known_risks": """# Known Risks
+- Render PUT /env-vars replaces ALL variables (caused outage 2026-04-06)
+- Ollama needs OLLAMA_ORIGINS=* and OLLAMA_HOST=0.0.0.0 for tunnel access
+- deepseek-r1 thinking comes in message.thinking field, NOT <think> tags
+- JSX files in React must use .jsx extension, not .js (Vite 8 strict)
+- Frontend .env.local is NOT committed — env vars must be set in Vercel dashboard
+- sessionStorage used for chat persistence (not localStorage to avoid cross-tab issues)
+""",
+    "recent_decisions": """# Recent Decisions
+- Chat-first dashboard as default view (inspired by Hercules.app)
+- Two chat roles: builder (deepseek-r1) and guide (always Groq)
+- Preview panel shows step progress during automation creation
+- System prompt instructs AI to be friendly, ONE question at a time, no JSON
+- Publish confirmation triggers real workflow + automation creation via API
+""",
+    "active_workstream": """# Active Workstream
+- Chat-first interface deployed and functional
+- Thinking display shows compact real-time reasoning
+- Chat history persists in sessionStorage
+- Publish creates real automations via /wizard/generate + /workflows/ + /automations/
+- Next: improve preview panel reactivity, add more quick actions
+""",
+}
+
+
+def generate_kiro_specs(project_dir: str):
+    """Generate Kiro steering, memory, and hooks for a NexusForge project."""
+    kiro_dir = os.path.join(project_dir, ".kiro")
+    steering_dir = os.path.join(kiro_dir, "steering")
+    memory_dir = os.path.join(kiro_dir, "memory")
+    hooks_dir = os.path.join(kiro_dir, "hooks")
+
+    for d in [steering_dir, memory_dir, hooks_dir]:
+        os.makedirs(d, exist_ok=True)
+
+    # Steering files
+    with open(os.path.join(steering_dir, "product.md"), "w", encoding="utf-8") as f:
+        f.write(STEERING_PRODUCT)
+    with open(os.path.join(steering_dir, "tech.md"), "w", encoding="utf-8") as f:
+        f.write(STEERING_TECH)
+    with open(os.path.join(steering_dir, "structure.md"), "w", encoding="utf-8") as f:
+        f.write(STEERING_STRUCTURE)
+    with open(os.path.join(steering_dir, "work-rules.md"), "w", encoding="utf-8") as f:
+        f.write(WORK_RULES)
+
+    # Memory files
+    for name, content in KIRO_MEMORY.items():
+        with open(os.path.join(memory_dir, f"{name}.md"), "w", encoding="utf-8") as f:
+            f.write(content)
+
+    # Hooks
+    for name, hook in KIRO_HOOKS.items():
+        with open(os.path.join(hooks_dir, f"{name}.json"), "w", encoding="utf-8") as f:
+            json.dump(hook, f, indent=2)
+
+    return kiro_dir

nexusforge_cli/main.py

@@ -0,0 +1,342 @@
+"""NexusForge CLI — setup, configure, and manage your AI orchestration platform."""
+
+import os
+import sys
+import json
+import subprocess
+import platform
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+console = Console()
+
+REPO_URL = "https://github.com/christianescamilla15-cell/nexusforge-ai.git"
+OLLAMA_MODELS = [
+    ("deepseek-r1:8b", "Chat inteligente (thinking nativo)", "4.9GB"),
+    ("qwen2.5-coder:7b", "Agentes de codigo/JSON", "4.7GB"),
+    ("llama3.1:8b", "Agentes de lenguaje", "4.9GB"),
+    ("gemma3:4b", "Clasificacion/routing rapido", "3.3GB"),
+    ("nomic-embed-text", "Embeddings RAG", "274MB"),
+]
+
+
+def run(cmd, check=False, capture=True):
+    """Run a shell command."""
+    try:
+        result = subprocess.run(cmd, shell=True, capture_output=capture, text=True, timeout=600)
+        return result.returncode == 0, result.stdout.strip()
+    except Exception as e:
+        return False, str(e)
+
+
+@click.group()
+@click.version_option(version="1.0.0")
+def cli():
+    """NexusForge AI — Enterprise Agent Orchestration Platform CLI."""
+    pass
+
+
+@cli.command()
+@click.option("--skip-models", is_flag=True, help="Skip downloading Ollama models")
+@click.option("--skip-deps", is_flag=True, help="Skip installing project dependencies")
+def setup(skip_models, skip_deps):
+    """Full environment setup — installs everything from scratch."""
+    console.print(Panel.fit(
+        "[bold cyan]NexusForge AI — Full Environment Setup[/bold cyan]\n"
+        "This will install Python deps, Node deps, Ollama, LLMs, and Kiro specs.",
+        border_style="cyan",
+    ))
+
+    # 1. Check prerequisites
+    console.print("\n[bold yellow][1/6] Checking prerequisites...[/bold yellow]")
+
+    ok, ver = run("python --version")
+    if ok:
+        console.print(f"  [green]OK[/green] Python: {ver}")
+    else:
+        console.print("  [red]MISSING[/red] Python — install from python.org")
+        return
+
+    ok, ver = run("node --version")
+    if ok:
+        console.print(f"  [green]OK[/green] Node.js: {ver}")
+    else:
+        console.print("  [yellow]WARN[/yellow] Node.js not found — frontend won't build")
+
+    ok, ver = run("git --version")
+    if ok:
+        console.print(f"  [green]OK[/green] Git: {ver}")
+    else:
+        console.print("  [red]MISSING[/red] Git — install from git-scm.com")
+        return
+
+    # 2. Ollama
+    console.print("\n[bold yellow][2/6] Setting up Ollama...[/bold yellow]")
+    ok, _ = run("ollama --version")
+    if ok:
+        console.print("  [green]OK[/green] Ollama installed")
+    else:
+        console.print("  [yellow]WARN[/yellow] Ollama not installed — download from ollama.com")
+        console.print("  [dim]Local LLMs won't be available until Ollama is installed[/dim]")
+
+    # Set env vars for tunnel support
+    if platform.system() == "Windows":
+        os.system('setx OLLAMA_ORIGINS "*" >nul 2>&1')
+        os.system('setx OLLAMA_HOST "0.0.0.0" >nul 2>&1')
+        console.print("  [green]OK[/green] OLLAMA_ORIGINS=* and OLLAMA_HOST=0.0.0.0 set")
+
+    # 3. Pull models
+    if not skip_models:
+        console.print("\n[bold yellow][3/6] Pulling AI models...[/bold yellow]")
+        ok, _ = run("ollama --version")
+        if ok:
+            for model, desc, size in OLLAMA_MODELS:
+                console.print(f"  [dim]Pulling {model} ({size}) — {desc}[/dim]")
+                run(f"ollama pull {model}")
+                console.print(f"  [green]OK[/green] {model}")
+        else:
+            console.print("  [yellow]SKIP[/yellow] Ollama not available")
+    else:
+        console.print("\n[bold yellow][3/6] Skipping model downloads[/bold yellow]")
+
+    # 4. Clone/update repo
+    console.print("\n[bold yellow][4/6] Setting up NexusForge project...[/bold yellow]")
+    project_dir = os.path.join(os.path.expanduser("~"), "Desktop", "portafolio-completo", "proyectos", "07-nexusforge-ai")
+
+    if os.path.exists(os.path.join(project_dir, ".git")):
+        console.print("  [green]OK[/green] Repo exists — pulling latest")
+        run(f"cd {project_dir} && git pull origin master")
+    else:
+        console.print(f"  [dim]Cloning to {project_dir}...[/dim]")
+        os.makedirs(os.path.dirname(project_dir), exist_ok=True)
+        run(f"git clone {REPO_URL} {project_dir}")
+        console.print("  [green]OK[/green] Repo cloned")
+
+    # 5. Install dependencies
+    if not skip_deps:
+        console.print("\n[bold yellow][5/6] Installing dependencies...[/bold yellow]")
+        backend_dir = os.path.join(project_dir, "backend")
+        frontend_dir = os.path.join(project_dir, "frontend")
+
+        if os.path.exists(os.path.join(backend_dir, "requirements.txt")):
+            console.print("  [dim]Installing backend deps...[/dim]")
+            run(f"cd {backend_dir} && pip install -r requirements.txt -q")
+            console.print("  [green]OK[/green] Backend dependencies")
+
+        if os.path.exists(os.path.join(frontend_dir, "package.json")):
+            console.print("  [dim]Installing frontend deps...[/dim]")
+            run(f"cd {frontend_dir} && npm install --silent")
+            console.print("  [green]OK[/green] Frontend dependencies")
+    else:
+        console.print("\n[bold yellow][5/6] Skipping dependency install[/bold yellow]")
+
+    # 6. Generate Kiro specs
+    console.print("\n[bold yellow][6/6] Generating Kiro specs + agent memory...[/bold yellow]")
+    from .kiro_specs import generate_kiro_specs
+    kiro_dir = generate_kiro_specs(project_dir)
+    console.print(f"  [green]OK[/green] Kiro specs at {kiro_dir}")
+
+    # Also init AIOS if available
+    ok, _ = run("aios --version")
+    if ok:
+        run(f"cd {project_dir} && aios init")
+        console.print("  [green]OK[/green] AIOS initialized")
+
+    # Summary
+    console.print("\n")
+    console.print(Panel.fit(
+        "[bold green]Setup Complete![/bold green]\n\n"
+        "[cyan]Installed:[/cyan]\n"
+        "  5 local LLMs (deepseek-r1, qwen, llama, gemma, nomic)\n"
+        "  Kiro steering + memory + hooks\n"
+        "  Backend + frontend dependencies\n\n"
+        "[cyan]Next steps:[/cyan]\n"
+        "  nexusforge status     — Check everything is running\n"
+        "  nexusforge dev        — Start dev environment\n"
+        "  nexusforge tunnel     — Expose Ollama to Render\n"
+        "  nexusforge agents     — View agent profiles\n",
+        border_style="green",
+    ))
+
+
+@cli.command()
+def status():
+    """Check status of all NexusForge services."""
+    console.print(Panel.fit("[bold cyan]NexusForge AI — System Status[/bold cyan]", border_style="cyan"))
+
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("Service", style="cyan")
+    table.add_column("Status")
+    table.add_column("Details", style="dim")
+
+    # Python
+    ok, ver = run("python --version")
+    table.add_row("Python", "[green]OK[/green]" if ok else "[red]MISSING[/red]", ver if ok else "Install python.org")
+
+    # Node
+    ok, ver = run("node --version")
+    table.add_row("Node.js", "[green]OK[/green]" if ok else "[yellow]WARN[/yellow]", ver if ok else "Install nodejs.org")
+
+    # Ollama
+    ok, _ = run("ollama --version")
+    table.add_row("Ollama", "[green]OK[/green]" if ok else "[red]DOWN[/red]", "Local LLM server")
+
+    # Models
+    if ok:
+        ok2, tags = run("ollama list")
+        if ok2:
+            model_count = len([l for l in tags.split("\n") if l.strip() and not l.startswith("NAME")])
+            table.add_row("Local Models", f"[green]{model_count}[/green]", f"{model_count} models loaded")
+
+    # Render backend
+    try:
+        import httpx
+        r = httpx.get("https://nexusforge-api.onrender.com/api/health", timeout=10)
+        data = r.json()
+        db = data.get("components", {}).get("database", "?")
+        table.add_row("Render Backend", "[green]OK[/green]", f"DB: {db}, Agents: {data.get('agent_count', '?')}")
+    except Exception:
+        table.add_row("Render Backend", "[yellow]SLEEPING[/yellow]", "Free tier — wakes on request")
+
+    # Vercel frontend
+    try:
+        import httpx
+        r = httpx.get("https://nexusforge-two.vercel.app/", timeout=10)
+        table.add_row("Vercel Frontend", "[green]OK[/green]" if r.status_code == 200 else "[red]DOWN[/red]", "nexusforge-two.vercel.app")
+    except Exception:
+        table.add_row("Vercel Frontend", "[yellow]UNKNOWN[/yellow]", "Could not check")
+
+    console.print(table)
+
+
+@cli.command()
+def agents():
+    """View all agent profiles with experience data."""
+    from .agents import AGENT_PROFILES
+
+    console.print(Panel.fit("[bold cyan]NexusForge AI — Agent Profiles[/bold cyan]", border_style="cyan"))
+
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("Agent", style="cyan", width=20)
+    table.add_column("Model", style="yellow", width=18)
+    table.add_column("Role", width=35)
+    table.add_column("Success", justify="center", width=8)
+    table.add_column("Runs", justify="center", width=6)
+
+    for name, profile in AGENT_PROFILES.items():
+        exp = profile.get("experience", {})
+        rate = f"{exp.get('success_rate', 0) * 100:.0f}%"
+        runs = str(exp.get("total_executions", 0))
+        table.add_row(name, profile["model"], profile["role"][:35], rate, runs)
+
+    console.print(table)
+
+
+@cli.command()
+def models():
+    """Show LLM fallback chain and local model status."""
+    from .agents import LLM_FALLBACK_CHAIN
+
+    console.print(Panel.fit("[bold cyan]LLM Fallback Chain[/bold cyan]", border_style="cyan"))
+
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("Priority", justify="center", width=8)
+    table.add_column("Provider", style="cyan", width=12)
+    table.add_column("Model", style="yellow", width=25)
+    table.add_column("Role", width=20)
+    table.add_column("Cost", width=6)
+
+    for i, entry in enumerate(LLM_FALLBACK_CHAIN, 1):
+        table.add_row(str(i), entry["provider"], entry["model"], entry["role"], entry["cost"])
+
+    console.print(table)
+
+
+@cli.command()
+def dev():
+    """Start local development environment (Ollama + backend + frontend)."""
+    console.print(Panel.fit("[bold cyan]Starting NexusForge Dev Environment[/bold cyan]", border_style="cyan"))
+
+    project_dir = os.path.join(os.path.expanduser("~"), "Desktop", "portafolio-completo", "proyectos", "07-nexusforge-ai")
+
+    if not os.path.exists(project_dir):
+        console.print("[red]Project not found. Run 'nexusforge setup' first.[/red]")
+        return
+
+    console.print("  [1] Starting Ollama...")
+    subprocess.Popen("ollama serve", shell=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+
+    console.print("  [2] Starting backend (port 8000)...")
+    subprocess.Popen(
+        f"cd {project_dir}/backend && python -m uvicorn app.main:app --reload --port 8000",
+        shell=True,
+    )
+
+    console.print("  [3] Starting frontend (port 5173)...")
+    subprocess.Popen(
+        f"cd {project_dir}/frontend && npm run dev",
+        shell=True,
+    )
+
+    console.print("\n  [green]NexusForge running![/green]")
+    console.print("  Frontend: http://localhost:5173")
+    console.print("  Backend:  http://localhost:8000/docs")
+    console.print("  Ollama:   http://localhost:11434")
+
+
+@cli.command()
+def tunnel():
+    """Start Cloudflare tunnel to expose local Ollama to Render."""
+    console.print(Panel.fit("[bold cyan]Ollama Tunnel[/bold cyan]", border_style="cyan"))
+
+    # Check Ollama
+    ok, _ = run("curl -s http://localhost:11434/api/tags")
+    if not ok:
+        console.print("[red]Ollama is not running. Start it first.[/red]")
+        return
+
+    # Find cloudflared
+    cf_path = os.path.join(os.path.expanduser("~"), "Desktop", "cloudflared.exe")
+    if not os.path.exists(cf_path):
+        console.print("[yellow]cloudflared not found. Downloading...[/yellow]")
+        run(f'curl -L -o "{cf_path}" https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-windows-amd64.exe')
+
+    console.print("  Starting tunnel to localhost:11434...")
+    console.print("  [dim]The tunnel URL will appear below. Copy it to Render as OLLAMA_TUNNEL_URL[/dim]")
+    os.system(f'"{cf_path}" tunnel --url http://localhost:11434')
+
+
+@cli.command()
+def kiro():
+    """Generate/refresh Kiro specs, steering, memory, and hooks."""
+    from .kiro_specs import generate_kiro_specs
+
+    project_dir = os.path.join(os.path.expanduser("~"), "Desktop", "portafolio-completo", "proyectos", "07-nexusforge-ai")
+
+    if not os.path.exists(project_dir):
+        console.print("[red]Project not found. Run 'nexusforge setup' first.[/red]")
+        return
+
+    kiro_dir = generate_kiro_specs(project_dir)
+    console.print(f"[green]Kiro specs generated at {kiro_dir}[/green]")
+    console.print("  steering/product.md — Product context")
+    console.print("  steering/tech.md — Tech stack")
+    console.print("  steering/structure.md — Project structure")
+    console.print("  steering/work-rules.md — Work rules & deployment")
+    console.print("  memory/ — Agent experience, risks, decisions")
+    console.print("  hooks/ — Pre-commit, test-on-change, build-check")
+
+
+@cli.command()
+def rules():
+    """Show work rules and critical guidelines."""
+    from .kiro_specs import WORK_RULES
+    console.print(Panel(WORK_RULES, title="[bold]Work Rules[/bold]", border_style="yellow"))
+
+
+if __name__ == "__main__":
+    cli()

nexusforge_cli-1.0.0.dist-info/METADATA

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: nexusforge-cli
+Version: 1.0.0
+Summary: NexusForge AI — Full stack setup CLI. Install local LLMs, agents, and orchestration in one command.
+Author-email: Christian Hernandez <christianescamilla15@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/christianescamilla15-cell/nexusforge-ai
+Project-URL: Demo, https://nexusforge-two.vercel.app
+Keywords: ai,agents,llm,orchestration,nexusforge,ollama,automation
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: click>=8.0.0
+
+# NexusForge CLI
+
+Enterprise AI Agent Orchestration Platform — setup and management CLI.
+
+## Install
+
+```bash
+pip install nexusforge-cli
+```
+
+## Commands
+
+```bash
+nexusforge setup          # Full environment setup (Python, Node, Ollama, LLMs, Kiro)
+nexusforge status         # Check all services status
+nexusforge dev            # Start local dev environment
+nexusforge tunnel         # Expose Ollama to Render via Cloudflare
+nexusforge agents         # View 24 agent profiles with experience
+nexusforge models         # Show LLM fallback chain
+nexusforge kiro           # Generate/refresh Kiro specs
+nexusforge rules          # Show work rules and guidelines
+```
+
+## What `nexusforge setup` installs
+
+| Component | Purpose |
+|-----------|---------|
+| deepseek-r1:8b | Chat with visible thinking |
+| qwen2.5-coder:7b | Code/JSON agents |
+| llama3.1:8b | Language agents |
+| gemma3:4b | Fast classification |
+| nomic-embed-text | RAG embeddings |
+| Kiro specs | Steering, memory, hooks |
+| Backend deps | FastAPI, asyncpg, etc. |
+| Frontend deps | React, Vite |
+
+## Architecture
+
+```
+Local: Ollama (5 LLMs) + FastAPI + React
+Cloud: Vercel + Render + PostgreSQL + Redis
+LLM:   deepseek-r1 → Groq (free) → Claude (paid)
+```
+
+## Links
+
+- Demo: https://nexusforge-two.vercel.app
+- API: https://nexusforge-api.onrender.com
+- Repo: https://github.com/christianescamilla15-cell/nexusforge-ai

nexusforge_cli-1.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+nexusforge_cli/__init__.py,sha256=XURh-7V4pCpqAT_wgDYxSTeyjWMAZ-CAwsSKb00vEC0,88
+nexusforge_cli/agents.py,sha256=rtKRm_BEc9g_LILeUhnKpL5fTNklbahck5rm7ymes_I,9371
+nexusforge_cli/kiro_specs.py,sha256=7XYSvJ2PDqRo4m-wZf8XtrdLJRbSyLUPUsFw1d0y2cY,9477
+nexusforge_cli/main.py,sha256=U5hY3Z3d0AJfh8bosS6ZGuq5AlpwqsIw5V5POsrMhw0,13438
+nexusforge_cli-1.0.0.dist-info/METADATA,sha256=rqaGpb35qCJPDVewjN7WOEcrFogWa5HEV8zHX3JAtzY,2320
+nexusforge_cli-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+nexusforge_cli-1.0.0.dist-info/entry_points.txt,sha256=2jLrJ5K2LdWeja-1Um6js8Qpadmf8ILxNNWR0NOLqW8,55
+nexusforge_cli-1.0.0.dist-info/top_level.txt,sha256=n1z0-BSxZKF2EpO3gyEda5YlMWgykIut4u92SFA9Dpo,15
+nexusforge_cli-1.0.0.dist-info/RECORD,,

nexusforge_cli-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

nexusforge_cli-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+nexusforge = nexusforge_cli.main:cli

nexusforge_cli-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+nexusforge_cli