#!/usr/bin/env python3
"""
Farnsworth - Your Claude Companion AI
A self-evolving AI companion that integrates with Claude Code to provide:
- Persistent memory across sessions
- Specialist agent delegation
- Self-improvement through evolution
- Visual dashboard for transparency
- Health tracking and insights
- Workflow automation with n8n integration
This transforms Claude from a stateless assistant into a learning,
adapting companion that remembers you and improves over time.
Usage:
python main.py # Start all services
python main.py --mcp # MCP server only (for Claude Code)
python main.py --ui # Streamlit dashboard only
python main.py --cli # Interactive CLI mode
python main.py --user # User-friendly CLI mode
python main.py --rich-cli # Rich TUI with swarm chat (AGI v1.8.4)
python main.py --health # Start health dashboard
python main.py --setup # First-time setup wizard
python main.py --node # Spin up as P2P network node
python main.py --node --port 9999 # Custom port for P2P node
"""
import argparse
import asyncio
import sys
from pathlib import Path
from dotenv import load_dotenv
# Add project root to path
PROJECT_ROOT = Path(__file__).parent
sys.path.insert(0, str(PROJECT_ROOT))
# Load configuration from .env if exists
load_dotenv(PROJECT_ROOT / ".env")
def print_banner():
"""Print the Farnsworth banner."""
banner = """
╔═══════════════════════════════════════════════════════════════╗
║ ║
║ ███████╗ █████╗ ██████╗ ███╗ ██╗███████╗██╗ ██╗ ║
║ ██╔════╝██╔══██╗██╔══██╗████╗ ██║██╔════╝██║ ██║ ║
║ █████╗ ███████║██████╔╝██╔██╗ ██║███████╗██║ █╗ ██║ ║
║ ██╔══╝ ██╔══██║██╔══██╗██║╚██╗██║╚════██║██║███╗██║ ║
║ ██║ ██║ ██║██║ ██║██║ ╚████║███████║╚███╔███╔╝ ║
║ ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═══╝╚══════╝ ╚══╝╚══╝ ║
║ ║
║ Your Claude Companion AI ║
║ Memory • Agents • Evolution ║
║ ║
╚═══════════════════════════════════════════════════════════════╝
"""
# ASCII fallback for Windows console encoding issues
banner_ascii = """
+---------------------------------------------------------------+
| |
| FARNSWORTH |
| |
| Your Claude Companion AI |
| Memory - Agents - Evolution |
| |
+---------------------------------------------------------------+
"""
try:
print(banner)
except UnicodeEncodeError:
print(banner_ascii)
def print_status(component: str, status: str, details: str = ""):
"""Print component status with visual indicators."""
icons = {
"ok": "✅",
"loading": "🔄",
"error": "❌",
"info": "ℹ️",
"warning": "⚠️",
}
icons_ascii = {
"ok": "[OK]",
"loading": "[..]",
"error": "[X]",
"info": "[i]",
"warning": "[!]",
}
icon = icons.get(status, "•")
try:
print(f" {icon} {component}: {details}")
except UnicodeEncodeError:
icon = icons_ascii.get(status, "-")
print(f" {icon} {component}: {details}")
async def run_setup_wizard():
"""Run granular setup wizard."""
from farnsworth.core.setup_wizard import SetupWizard
wizard = SetupWizard(PROJECT_ROOT)
await wizard.run()
async def run_mcp_server():
"""Run the MCP server for Claude Code integration."""
print_status("MCP Server", "loading", "Starting...")
try:
from farnsworth.mcp_server.server import run_server
await run_server()
except ImportError as e:
print_status("MCP Server", "error", f"Import error: {e}")
print("\nMake sure you have the MCP library installed:")
print(" pip install mcp")
except Exception as e:
print_status("MCP Server", "error", str(e))
def run_streamlit_ui():
"""Run the Streamlit dashboard."""
print_status("Streamlit UI", "loading", "Starting...")
try:
import subprocess
ui_path = PROJECT_ROOT / "farnsworth" / "ui" / "streamlit_app.py"
subprocess.run(["streamlit", "run", str(ui_path)], check=True)
except FileNotFoundError:
print_status("Streamlit UI", "error", "Streamlit not installed")
print("Run: pip install streamlit")
except Exception as e:
print_status("Streamlit UI", "error", str(e))
async def run_cli_mode():
"""Run interactive CLI mode."""
print("\n🖥️ Farnsworth CLI Mode")
print("Type 'help' for commands, 'exit' to quit.\n")
# Initialize components
from farnsworth.memory.memory_system import MemorySystem
from farnsworth.evolution.fitness_tracker import FitnessTracker
from farnsworth.evolution.genetic_optimizer import GeneticOptimizer
memory = MemorySystem(data_dir=str(PROJECT_ROOT / "data"))
await memory.initialize()
fitness = FitnessTracker()
optimizer = GeneticOptimizer(data_dir=str(PROJECT_ROOT / "data" / "evolution"))
# Define evolvable parameters
optimizer.define_gene("response_temperature", min_val=0.0, max_val=1.0, default=0.7)
optimizer.define_gene("context_weight", min_val=0.0, max_val=1.0, default=0.5)
optimizer.define_gene("memory_recall_threshold", min_val=0.1, max_val=0.9, default=0.3)
optimizer.define_gene("creativity_factor", min_val=0.0, max_val=1.0, default=0.5)
# Set fitness function using the tracker
def fitness_function(genome):
"""Evaluate genome fitness based on tracked metrics."""
current = fitness.get_current_fitness()
return {
"user_satisfaction": current.get("user_satisfaction", 0.5),
"task_success": current.get("task_success_rate", 0.5),
"response_quality": current.get("response_quality", 0.5),
}
optimizer.set_fitness_function(fitness_function)
optimizer.initialize_population()
print_status("Memory System", "ok", "Initialized")
print_status("Fitness Tracker", "ok", "Ready")
print_status("Genetic Optimizer", "ok", f"Population: {len(optimizer.population)}")
while True:
try:
cmd = input("\nfarnsworth> ").strip()
if not cmd:
continue
if cmd == "exit" or cmd == "quit":
print("Goodbye!")
await memory.shutdown()
break
elif cmd == "help":
print("""
Available Commands:
status - Show system status
remember - Store a memory (usage: remember <content>)
recall - Search memories (usage: recall <query>)
fitness - Show fitness metrics
evolve - Trigger evolution cycle
dream - Trigger memory consolidation
backup - Create a backup
P2P Network:
node start - Start P2P node in background
node stop - Stop P2P node
node status - Show node and peer status
planetary - Show Planetary Memory stats
Token Management:
tokens - Show token budget and usage
cache - Show response cache stats
Productivity:
notes - List recent quick notes
note <text> - Add a quick note
snippets - List code snippets
focus start - Start focus timer
focus stop - Stop focus timer
summary - Generate daily summary
profile - Show current context profile
profiles - List all profiles
switch <id> - Switch context profile
clear - Clear screen
exit - Exit CLI
""")
elif cmd == "status":
stats = memory.get_stats()
print(f"\nMemory Status:")
print(f" Archival memories: {stats.get('archival_memory', {}).get('total_entries', 0)}")
print(f" Conversation turns: {stats.get('recall_memory', {}).get('total_turns', 0)}")
print(f" Knowledge entities: {stats.get('knowledge_graph', {}).get('total_entities', 0)}")
print(f"\nFitness: {fitness.get_weighted_fitness():.2f}")
elif cmd.startswith("remember "):
content = cmd[9:]
mem_id = await memory.remember(content)
print(f"✅ Stored memory: {mem_id}")
elif cmd.startswith("recall "):
query = cmd[7:]
results = await memory.recall(query, top_k=5)
if results:
print(f"\nFound {len(results)} memories:")
for i, r in enumerate(results, 1):
print(f" {i}. [{r.score:.2f}] {r.content[:100]}...")
else:
print("No memories found.")
elif cmd == "fitness":
current = fitness.get_current_fitness()
print("\nFitness Metrics:")
for metric, value in current.items():
bar = "█" * int(value * 20) + "░" * (20 - int(value * 20))
print(f" {metric:20} [{bar}] {value:.2f}")
elif cmd == "evolve":
print("Triggering evolution cycle...")
try:
# Run evolution cycle
await optimizer.evolve_generation()
best = optimizer.get_best_genome()
stats = optimizer.get_stats()
print(f"✅ Evolution cycle complete!")
print(f" Generation: {stats.get('current_generation', 'N/A')}")
print(f" Best fitness: {best.total_fitness():.3f}" if best else " Best fitness: N/A")
print(f" Population size: {stats.get('population_size', 'N/A')}")
print(f" Total evaluations: {stats.get('total_evaluations', 0)}")
if best:
print(f" Best genome parameters:")
for gene_name, gene in best.genes.items():
print(f" {gene_name}: {gene.value:.3f}")
except Exception as e:
print(f"⚠️ Evolution cycle completed with warnings: {e}")
# Still consider it a success if partial evolution occurred
print("✅ Partial evolution applied")
elif cmd == "dream":
print("Triggering memory consolidation (dreaming)...")
try:
dream_result = await memory.trigger_dream()
print(f"✅ Dream session complete!")
if dream_result:
print(f" Consolidated: {dream_result.get('consolidated', 0)} memories")
print(f" Pruned: {dream_result.get('pruned', 0)} low-value entries")
except Exception as e:
print(f"⚠️ Dream session: {e}")
elif cmd == "backup":
print("Creating backup...")
try:
from farnsworth.core.resilience import BackupManager
backup_mgr = BackupManager(
data_dir=str(PROJECT_ROOT / "data"),
backup_dir=str(PROJECT_ROOT / "backups")
)
backup_path = await backup_mgr.create_backup()
if backup_path:
print(f"✅ Backup created: {backup_path}")
else:
print("⚠️ Backup creation failed")
except Exception as e:
print(f"❌ Backup error: {e}")
elif cmd == "node start":
print("Starting P2P node in background...")
try:
import os
if os.getenv("FARNSWORTH_ISOLATED", "").lower() == "true":
print("❌ Cannot start: FARNSWORTH_ISOLATED=true")
print(" Set FARNSWORTH_ISOLATED=false in .env to enable P2P")
else:
from farnsworth.core.swarm.p2p import swarm_fabric
if not hasattr(run_cli_mode, '_node_task') or run_cli_mode._node_task is None:
run_cli_mode._node_task = asyncio.create_task(swarm_fabric.start())
print(f"✅ P2P Node started: {swarm_fabric.node_id}")
print(f" TCP Port: {swarm_fabric.port}")
print(" UDP Discovery: Port 8888")
else:
print("⚠️ Node already running")
except Exception as e:
print(f"❌ Failed to start node: {e}")
elif cmd == "node stop":
try:
if hasattr(run_cli_mode, '_node_task') and run_cli_mode._node_task:
run_cli_mode._node_task.cancel()
run_cli_mode._node_task = None
print("✅ P2P Node stopped")
else:
print("⚠️ No node running")
except Exception as e:
print(f"❌ Error stopping node: {e}")
elif cmd == "node status":
try:
from farnsworth.core.swarm.p2p import swarm_fabric
print(f"\n🌐 P2P Node Status")
print(f" Node ID: {swarm_fabric.node_id}")
print(f" Port: {swarm_fabric.port}")
print(f" Connected Peers: {len(swarm_fabric.peers)}")
if swarm_fabric.peers:
print("\n Peers:")
for pid, peer in swarm_fabric.peers.items():
caps = ", ".join(peer.capabilities) if peer.capabilities else "none"
print(f" • {pid} @ {peer.addr}:{peer.port} [{caps}]")
print(f"\n DKG Status:")
print(f" Nodes: {len(swarm_fabric.dkg.nodes)}")
print(f" Edges: {len(swarm_fabric.dkg.edges)}")
print(f" Messages seen: {len(swarm_fabric.seen_messages)}")
except Exception as e:
print(f"❌ Error getting status: {e}")
elif cmd == "planetary":
try:
from farnsworth.core.memory.planetary.akashic import PlanetaryMemory
pm = PlanetaryMemory(use_p2p=True)
print(f"\n🌍 Planetary Memory (Akashic Record)")
print(f" Local Skills: {len(pm.local_skills)}")
print(f" Global Cache: {len(pm.global_cache)}")
print(f" Privacy Mode: {'Enabled' if pm.privacy_mode else 'Disabled'}")
if pm.local_skills:
print("\n Local Skills:")
for sid, skill in list(pm.local_skills.items())[:5]:
print(f" • {sid[:8]}... : {skill.abstract_solution[:50]}...")
except Exception as e:
print(f"❌ Error: {e}")
elif cmd == "tokens":
try:
from farnsworth.core.token_saver import token_saver
status = token_saver.get_status()
budget = status["budget"]
print(f"\n💰 Token Budget Status")
print(f" Daily Limit: {budget['daily_limit']:,}")
print(f" Used Today: {budget['used_today']:,}")
print(f" Remaining: {budget['remaining']:,}")
if budget['warning']:
print(" ⚠️ WARNING: Approaching budget limit!")
cache = status["cache"]
print(f"\n📦 Response Cache")
print(f" Entries: {cache['entries']} / {cache['max_size']}")
comp = status["compression"]
if comp.get("compressions", 0) > 0:
print(f"\n🗜️ Compression Stats")
print(f" Compressions: {comp['compressions']}")
print(f" Tokens Saved: {comp['tokens_saved']:,}")
except Exception as e:
print(f"❌ Error: {e}")
elif cmd == "cache":
try:
from farnsworth.core.token_saver import token_saver
stats = token_saver.cache.stats()
print(f"\n📦 Response Cache")
print(f" Entries: {stats['entries']} / {stats['max_size']}")
print(f" TTL: {stats['ttl_hours']} hours")
except Exception as e:
print(f"❌ Error: {e}")
elif cmd == "notes":
try:
from farnsworth.tools.productivity.quick_notes import quick_notes
recent = quick_notes.list_recent(10)
stats = quick_notes.stats()
print(f"\n📝 Quick Notes ({stats['active']} active, {stats['pinned']} pinned)")
if recent:
for note in recent:
pin = "📌 " if note.pinned else ""
tags = f" [{', '.join(note.tags)}]" if note.tags else ""
print(f" {pin}{note.id[:8]}: {note.content[:60]}...{tags}")
else:
print(" No notes yet. Use 'note <text>' to add one.")
except Exception as e:
print(f"❌ Error: {e}")
elif cmd.startswith("note "):
try:
from farnsworth.tools.productivity.quick_notes import quick_notes
content = cmd[5:]
# Extract tags from #hashtags
import re
tags = re.findall(r'#(\w+)', content)
content = re.sub(r'#\w+', '', content).strip()
note = quick_notes.add(content, tags)
print(f"✅ Note added: {note.id[:8]}")
except Exception as e:
print(f"❌ Error: {e}")
elif cmd == "snippets":
try:
from farnsworth.tools.productivity.snippet_manager import snippet_manager
popular = snippet_manager.list_popular(10)
stats = snippet_manager.stats()
print(f"\n📋 Code Snippets ({stats['total']} total, {stats['favorites']} favorites)")
if popular:
for s in popular:
fav = "⭐ " if s.favorite else ""
print(f" {fav}{s.id[:8]}: {s.name} [{s.language}] (used {s.usage_count}x)")
else:
print(" No snippets yet.")
except Exception as e:
print(f"❌ Error: {e}")
elif cmd == "focus start":
try:
from farnsworth.tools.productivity.focus_timer import focus_timer
asyncio.create_task(focus_timer.start_work())
print(f"🍅 Focus session started ({focus_timer.config.work_minutes} min)")
except Exception as e:
print(f"❌ Error: {e}")
elif cmd == "focus stop":
try:
from farnsworth.tools.productivity.focus_timer import focus_timer
asyncio.create_task(focus_timer.stop())
print("⏹️ Focus session stopped")
except Exception as e:
print(f"❌ Error: {e}")
elif cmd == "focus" or cmd == "focus status":
try:
from farnsworth.tools.productivity.focus_timer import focus_timer
status = focus_timer.get_status()
today = focus_timer.get_today_stats()
print(f"\n🍅 Focus Timer")
print(f" State: {status['state']}")
if status['remaining_seconds'] > 0:
print(f" Remaining: {status['remaining_display']}")
print(f" Sessions Today: {today['sessions']}")
print(f" Focus Time: {today['total_minutes']} min")
except Exception as e:
print(f"❌ Error: {e}")
elif cmd == "summary":
try:
from farnsworth.tools.productivity.daily_summary import daily_summary
print("Generating daily summary...")
s = await daily_summary.generate_summary(memory_system=memory)
print(daily_summary.format_summary(s))
except Exception as e:
print(f"❌ Error: {e}")
elif cmd == "profile":
try:
from farnsworth.core.context_profiles import context_profiles
active = context_profiles.get_active_profile()
if active:
print(f"\n{active.icon} Active Profile: {active.name}")
print(f" Description: {active.description}")
print(f" Memory Pool: {active.memory_pool}")
print(f" Personality: {active.personality}")
print(f" Temperature: {active.temperature}")
else:
print("No active profile")
except Exception as e:
print(f"❌ Error: {e}")
elif cmd == "profiles":
try:
from farnsworth.core.context_profiles import context_profiles
profiles = context_profiles.list_profiles()
active_id = context_profiles.active_profile_id
print(f"\n📋 Context Profiles")
for p in profiles:
active = " (ACTIVE)" if p.id == active_id else ""
print(f" {p.icon} {p.id}: {p.name}{active}")
print(f" {p.description}")
except Exception as e:
print(f"❌ Error: {e}")
elif cmd.startswith("switch "):
try:
from farnsworth.core.context_profiles import context_profiles
profile_id = cmd[7:].strip()
profile = context_profiles.switch_profile(profile_id)
if profile:
print(f"✅ Switched to {profile.icon} {profile.name}")
else:
print(f"❌ Profile not found: {profile_id}")
except Exception as e:
print(f"❌ Error: {e}")
elif cmd == "clear":
print("\033[H\033[J", end="")
else:
print(f"Unknown command: {cmd}")
print("Type 'help' for available commands.")
except KeyboardInterrupt:
print("\nUse 'exit' to quit.")
except Exception as e:
print(f"Error: {e}")
async def run_p2p_node(port: int = 9999, enable_planetary: bool = True):
"""
Spin up as a P2P network node.
This allows your Farnsworth instance to:
- Discover other nodes on the local network
- Share knowledge via the Decentralized Knowledge Graph (DKG)
- Contribute to and benefit from Planetary Memory
- Participate in distributed task auctions
"""
print("\n🌐 Farnsworth P2P Node")
print("=" * 50)
import os
# Check if isolated mode is enabled
if os.getenv("FARNSWORTH_ISOLATED", "").lower() == "true":
print_status("P2P Node", "error", "Cannot start: FARNSWORTH_ISOLATED=true")
print("\n⚠️ To enable P2P networking, set FARNSWORTH_ISOLATED=false in your .env")
return
try:
from farnsworth.core.swarm.p2p import SwarmFabric
from farnsworth.core.swarm.dkg import DecentralizedKnowledgeGraph
from farnsworth.core.memory.planetary.akashic import PlanetaryMemory
from farnsworth.memory.memory_system import MemorySystem
# Initialize memory system for planetary integration
memory = MemorySystem(data_dir=str(PROJECT_ROOT / "data"))
await memory.initialize()
print_status("Memory System", "ok", "Initialized")
# Initialize Planetary Memory
planetary = None
if enable_planetary:
planetary = PlanetaryMemory(use_p2p=True)
print_status("Planetary Memory", "ok", "Enabled (Akashic Record)")
else:
print_status("Planetary Memory", "warning", "Disabled")
# Initialize P2P Swarm Fabric
fabric = SwarmFabric(port=port)
print_status("P2P Fabric", "ok", f"Node ID: {fabric.node_id}")
print_status("TCP Server", "loading", f"Port {port}")
print_status("UDP Discovery", "loading", "Port 8888 (broadcast)")
print("\n" + "=" * 50)
print(f"🚀 Node '{fabric.node_id}' is now LIVE on port {port}")
print("=" * 50)
print("\nCapabilities:")
print(" • CV - Computer Vision")
print(" • NLP - Natural Language Processing")
print(" • P2P - Peer-to-Peer Networking")
print("\nListening for peers...")
print("Press Ctrl+C to shutdown gracefully.\n")
# Start the fabric (this runs forever)
await fabric.start()
except KeyboardInterrupt:
print("\n\n🛑 Shutting down P2P node...")
print_status("P2P Node", "ok", "Gracefully terminated")
except ImportError as e:
print_status("P2P Node", "error", f"Missing dependency: {e}")
print("\nMake sure all P2P dependencies are installed.")
except Exception as e:
print_status("P2P Node", "error", str(e))
async def run_node_with_dashboard(port: int = 9999):
"""Run P2P node with live status dashboard."""
import os
if os.getenv("FARNSWORTH_ISOLATED", "").lower() == "true":
print_status("P2P Node", "error", "Cannot start: FARNSWORTH_ISOLATED=true")
return
try:
from farnsworth.core.swarm.p2p import SwarmFabric
fabric = SwarmFabric(port=port)
print("\n🌐 Farnsworth P2P Node Dashboard")
print("=" * 60)
print(f" Node ID: {fabric.node_id}")
print(f" TCP Port: {port}")
print(f" UDP Port: 8888 (discovery)")
print("=" * 60)
# Status update task
async def status_loop():
while True:
await asyncio.sleep(30)
peers = len(fabric.peers)
dkg_nodes = len(fabric.dkg.nodes)
dkg_edges = len(fabric.dkg.edges)
print(f"\r📊 Peers: {peers} | DKG: {dkg_nodes} nodes, {dkg_edges} edges | Messages seen: {len(fabric.seen_messages)}", end="", flush=True)
# Start status loop in background
asyncio.create_task(status_loop())
# Start the fabric
await fabric.start()
except KeyboardInterrupt:
print("\n\n🛑 Node shutdown complete.")
except Exception as e:
print_status("P2P Node", "error", str(e))
async def run_user_cli_mode():
"""Run user-friendly CLI mode."""
print("\n User-Friendly CLI Mode")
try:
from farnsworth.cli.user_cli import run_user_cli
await run_user_cli(data_dir=str(PROJECT_ROOT / "data"))
except ImportError as e:
print_status("User CLI", "error", f"Import error: {e}")
print("\nMake sure all dependencies are installed.")
except Exception as e:
print_status("User CLI", "error", str(e))
async def run_rich_cli_mode():
"""Run Rich CLI mode with TUI interface."""
print("\n🎨 Farnsworth Rich CLI Mode")
try:
from farnsworth.cli.rich_cli import run_rich_cli
await run_rich_cli(data_dir=str(PROJECT_ROOT / "data"))
except ImportError as e:
print_status("Rich CLI", "error", f"Import error: {e}")
print("\nMake sure Rich is installed: pip install rich")
except Exception as e:
print_status("Rich CLI", "error", str(e))
async def run_health_dashboard():
"""Run the health tracking dashboard."""
print_status("Health Dashboard", "loading", "Starting on port 8081...")
try:
from farnsworth.health.dashboard.server import app
import uvicorn
config = uvicorn.Config(
app,
host="0.0.0.0",
port=8081,
log_level="info",
)
server = uvicorn.Server(config)
await server.serve()
except ImportError as e:
print_status("Health Dashboard", "error", f"Import error: {e}")
print("\nMake sure health module dependencies are installed.")
except Exception as e:
print_status("Health Dashboard", "error", str(e))
async def run_all_services():
"""Run all Farnsworth services."""
print_status("Starting Services", "info", "")
# Start MCP server in background
print_status("MCP Server", "loading", "Starting in background...")
# For now, just run MCP server (UI would be separate process)
await run_mcp_server()
def main():
"""Main entry point."""
parser = argparse.ArgumentParser(
description="Farnsworth - Your Claude Companion AI",
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog="""
Examples:
python main.py Start all services
python main.py --mcp MCP server only (for Claude Code)
python main.py --ui Streamlit dashboard only
python main.py --cli Interactive CLI mode
python main.py --setup First-time setup wizard
python main.py --node Spin up as P2P network node
python main.py --node --port 9999 --dashboard Node with live stats
P2P Node Options:
--node Enable P2P networking mode
--port PORT Custom TCP port (default: 9999)
--no-planetary Disable Planetary Memory sharing
--dashboard Show live node status updates
For more info: https://github.com/timowhite88/Farnsworth
"""
)
parser.add_argument("--mcp", action="store_true", help="Run MCP server only")
parser.add_argument("--ui", action="store_true", help="Run Streamlit UI only")
parser.add_argument("--cli", action="store_true", help="Run interactive CLI")
parser.add_argument("--user", action="store_true", help="Run user-friendly CLI (recommended for beginners)")
parser.add_argument("--rich-cli", action="store_true", help="Run Rich TUI CLI with swarm chat (AGI v1.8.4)")
parser.add_argument("--health", action="store_true", help="Run health dashboard on port 8081")
parser.add_argument("--setup", action="store_true", help="Run setup wizard")
parser.add_argument("--node", action="store_true", help="Spin up as P2P network node")
parser.add_argument("--port", type=int, default=9999, help="Port for P2P node (default: 9999)")
parser.add_argument("--no-planetary", action="store_true", help="Disable Planetary Memory sharing")
parser.add_argument("--dashboard", action="store_true", help="Show live node dashboard")
parser.add_argument("--no-banner", action="store_true", help="Skip banner")
parser.add_argument("--data-dir", type=str, default="./data", help="Data directory")
args = parser.parse_args()
if not args.no_banner:
print_banner()
if args.setup:
asyncio.run(run_setup_wizard())
elif args.user:
asyncio.run(run_user_cli_mode())
elif getattr(args, 'rich_cli', False):
asyncio.run(run_rich_cli_mode())
elif args.health:
asyncio.run(run_health_dashboard())
elif args.node:
if args.dashboard:
asyncio.run(run_node_with_dashboard(port=args.port))
else:
asyncio.run(run_p2p_node(port=args.port, enable_planetary=not args.no_planetary))
elif args.mcp:
asyncio.run(run_mcp_server())
elif args.ui:
run_streamlit_ui()
elif args.cli:
asyncio.run(run_cli_mode())
else:
# Default: run all services
asyncio.run(run_all_services())
if __name__ == "__main__":
main()
