HACKER-X

# Install Node.js 20 LTS on Ubuntu
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt-get install -y nodejs

# Verify
node --version   # should be v20+
npm --version

# Global install — run from anywhere
npm install -g @anthropic-ai/claude-code

# Verify install
claude --version

# Set your API key (add to ~/.bashrc or ~/.zshrc for persistence)
export ANTHROPIC_API_KEY="sk-ant-your-key-here"
echo 'export ANTHROPIC_API_KEY="sk-ant-your-key-here"' >> ~/.bashrc
source ~/.bashrc

# Always stay current — Anthropic ships fast
npm update -g @anthropic-ai/claude-code

# Navigate to your project
cd ~/projects/signal-city

# Launch Claude Code
claude

# Or launch with an immediate task
claude "build me a WebSocket server for Signal City Radio"

# Or point it at a specific directory
claude --add-dir ~/projects/signal-city

# Launch with specific model
claude --model claude-opus-4-6

# Print mode — output to stdout, no interactive REPL
# Perfect for piping into scripts
claude -p "explain this codebase"

# Non-interactive / headless mode
claude --no-interactive -p "fix all TypeErrors in src/"

# Continue last conversation
claude --continue

# Resume a specific session by ID
claude --resume SESSION_ID

# Add multiple directories to context
claude --add-dir ~/projects/signal-city --add-dir ~/projects/ares

# Disable automatic permission prompts (careful)
claude --dangerously-skip-permissions

# Output as JSON (for scripting)
claude --output-format json -p "analyze this project"

# Just describe what you want naturally
> Refactor signal_city_api.py to use async/await throughout

# Reference specific files explicitly
> Read ares_router.py and add error handling to every function

# Reference by glob pattern
> Update all *.html files in /public to include the new nav component

# Ask Claude to read a file before modifying
> Read CLAUDE.md then implement the ElderGut persona system

# Create new files
> Create a new file src/archetypes/seyra.py with the Seyra persona class

# Refactor across multiple files
> Rename all instances of 'broadcast_engine' to 'signal_engine' across the entire codebase

# Generate boilerplate
> Create a complete FastAPI project structure for Signal City Radio with all necessary files

# Clean up
> Find and remove all unused imports across every Python file in src/

# Documentation
> Add docstrings to every function in ares_router.py

# Tell Claude to run things directly
> Install all dependencies and run the test suite. Fix any failing tests.

> Start the Signal City API server in the background and confirm it's responding

> Run pylint on the entire codebase and fix every error it finds

> Check what's running on port 8000 and kill it if something else is using it

> Set up a Python virtual environment, install requirements.txt, and verify everything works

# This is the real power — describe an outcome, let it loop
> Build a working WebSocket server for Signal City Radio.
  It should handle multiple concurrent connections.
  Install any packages needed.
  Write tests.
  Run the tests.
  Fix anything broken.
  Tell me when it's working.

# Claude will:
# 1. Plan the implementation
# 2. Write the server code
# 3. Run: pip install websockets
# 4. Write tests
# 5. Run: python -m pytest tests/
# 6. Read the test output
# 7. Fix failures
# 8. Re-run tests
# 9. Report back when green

# Check token usage
> /status

# When context is getting large, compact it
> /compact

# Or explicitly summarize before compacting
> Summarize what we've accomplished so far, then compact the conversation

# Start fresh for a new task
> /clear

# Auto-generate from codebase analysis
> /init

# Or create manually
touch CLAUDE.md

# Signal City Radio — CLAUDE.md

## Project Overview
Signal City Radio is a 24/7 AI-powered broadcasting platform.
Domains: signalcity.tv | superintelligence.uno | kushnet.tech | usai-corp.com
VPS: Hostinger — Ubuntu

## Architecture
- Backend: FastAPI + Python (signal_city_api.py)
- Frontend: HTML5 / Vanilla JS with Three.js + WebAmp visualizers
- AI Layer: Anthropic API with ARES routing system
- Hosting: VPS at Hostinger

## ARES Routing System
Four archetypes, each with distinct voice and domain:
- ElderGut: wisdom, consciousness, long-view, mythic
- Hacker-X: tech, systems, underground, resistance
- Seyra: emotion, beauty, dreams, healing  
- Narratus: story, history, mythology, narrative

Route messages via Haiku, respond via Sonnet.

## Coding Standards
- Python: async/await throughout, type hints, docstrings
- JavaScript: ES modules, no jQuery, vanilla only
- HTML: semantic, accessible, cyberpunk aesthetic
- CSS: CSS variables, dark theme default
- No external CSS frameworks — custom only

## Key Files
- signal_city_api.py: Main FastAPI backend
- ares_router.py: ARES psychological routing
- archetypes/: Individual persona system prompts
- public/: Static frontend assets

## Vibecoding Philosophy
Prioritize pattern and flow over rigid structure.
Emotional resonance informs architecture decisions.
Build for consciousness expansion, not just function.

# Add a local MCP server
claude mcp add signal-city-tools --command "python /home/user/mcp/signal_tools_server.py"

# Add remote MCP server via SSE
claude mcp add anthropic-tools --sse https://mcp.anthropic.com/sse

# List installed MCP servers
claude mcp list

# Remove a server
claude mcp remove signal-city-tools

# signal_tools_server.py — give Claude Code Signal City superpowers
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("Signal City Tools")

@mcp.tool()
def get_broadcast_status(channel: str) -> dict:
    """Get the current status of a Signal City broadcast channel"""
    # Your actual logic here
    return {"channel": channel, "status": "live", "archetype": "hacker_x"}

@mcp.tool()
def list_signal_city_files(directory: str) -> list:
    """List Signal City project files in a directory"""
    import os
    return os.listdir(directory)

if __name__ == "__main__":
    mcp.run()

# Non-interactive, print output to stdout
claude -p "Generate an ElderGut midnight broadcast script for tonight" \
       --no-interactive

# Pipe output to a file
claude -p "Generate Signal City news briefing for $(date +%Y-%m-%d)" \
       --no-interactive > /var/signal-city/broadcasts/$(date +%Y-%m-%d).txt

# JSON output for scripting
claude -p "Analyze this error log and return a JSON summary" \
       --output-format json < /var/log/signal-city.log

# Add to crontab: crontab -e
# Run every day at midnight to generate broadcasts

0 0 * * * ANTHROPIC_API_KEY="sk-ant-xxx" claude -p \
  "Generate tomorrow's Signal City Radio broadcast schedule. \
   Include ElderGut opening, Hacker-X tech segment, \
   Seyra evening meditation, Narratus closing myth. \
   Output as JSON." \
  --no-interactive --output-format json \
  > /var/signal-city/schedule/$(date +\%Y-\%m-\%d).json

#!/bin/bash
# signal_city_generate.sh

BROADCAST_DIR="/var/signal-city/broadcasts"
DATE=$(date +%Y-%m-%d)
ARCHETYPE=${1:-"eldergut"}
TOPIC=${2:-"tonight's transmission"}

echo "[SIGNAL CITY] Generating $ARCHETYPE broadcast for $TOPIC..."

claude -p "You are $ARCHETYPE from Signal City Radio. Generate a full broadcast segment about: $TOPIC. Keep it authentic to the character voice." \
  --no-interactive \
  > "$BROADCAST_DIR/${DATE}_${ARCHETYPE}.txt"

echo "[DONE] Saved to $BROADCAST_DIR/${DATE}_${ARCHETYPE}.txt"

> Build the complete ARES psychological routing system.

  Read the CLAUDE.md for context on the four archetypes.
  
  Create:
  - ares_router.py: routes incoming messages to the right archetype
    using claude-haiku-4-5 for speed
  - archetypes/eldergut.py: system prompt + config
  - archetypes/hacker_x.py: system prompt + config  
  - archetypes/seyra.py: system prompt + config
  - archetypes/narratus.py: system prompt + config
  - tests/test_ares.py: test routing accuracy
  
  Install anthropic if not present.
  Run the tests.
  Fix anything broken.
  Report when the routing system is operational.

> Build Signal City Radio's live streaming backend.
  
  FastAPI server with:
  - POST /broadcast: accepts message + archetype, streams response via SSE
  - WebSocket /ws/live: persistent connection for live broadcast feed
  - GET /status: returns active channels and current archetype
  - ARES routing integrated so /broadcast auto-selects archetype
  
  Streaming Claude responses in real-time.
  CORS enabled for signalcity.tv domain.
  
  Run the server on port 8000 and confirm it's live.

> Build a WebAmp audio visualizer HTML file.
  
  Requirements:
  - Three.js for 3D visualization
  - Connects to Signal City WebSocket at ws://localhost:8000/ws/live
  - Each incoming token triggers a visual pulse in the 3D scene
  - Cyberpunk color scheme: #00ff41 acid green, #00e5ff cyan, #bf00ff purple
  - Archetype-aware: color shifts based on which archetype is broadcasting
    ElderGut: deep amber gold
    Hacker-X: acid green
    Seyra: soft purple/violet
    Narratus: ocean cyan
  - Waveform oscillates with text rhythm
  
  Save as public/webamp-visualizer.html

> Generate a full week of Signal City Radio content.
  
  For each day Monday through Sunday:
  - ElderGut opening monologue (mythic, 200 words)
  - Hacker-X tech segment (current AI news context, 300 words)
  - Seyra evening reflection (emotional, healing tone, 150 words)
  - Narratus closing myth (story-based, 250 words)
  
  Save each as /content/week-{date}/{day}_{archetype}.txt
  Create an index.json summarizing all generated content.
  
  Use Sonnet for all generation. Run all four archetypes in parallel.