Justfile

# OmoiOS Justfile
# Task runner for development, testing, and deployment
# Install just: https://github.com/casey/just

# Use bash for all recipes
set shell := ["bash", "-uc"]

# Load .env file automatically
set dotenv-load := true

# Set default environment
export OMOIOS_ENV := env_var_or_default("OMOIOS_ENV", "local")

# ============================================================================
# Variables
# ============================================================================

# Backend directory
backend_dir := "backend"

# Frontend directory
frontend_dir := "frontend"

# Frontend port
frontend_port := env_var_or_default("FRONTEND_PORT", "3000")

# Python command (runs in backend directory)
python := "uv run python"

# Pytest command (runs in backend directory)
pytest := "uv run pytest"

# Coverage threshold
coverage_threshold := "80"

# API port
api_port := env_var_or_default("API_PORT", "18000")

# ============================================================================
# Default Recipe (show help)
# ============================================================================

default:
    @just --list

# ============================================================================
# Development Setup
# ============================================================================

# Install all dependencies (including test)
install:
    cd {{backend_dir}} && uv sync --active --group test

# Install with dev and test dependencies
[group('setup')]
install-all:
    cd {{backend_dir}} && uv sync --active --group dev --group test

# Sync all monorepo dependencies (backend + frontend + migrations)
[group('setup')]
sync:
    #!/usr/bin/env bash
    set -e
    echo "🔄 Syncing OmoiOS monorepo..."
    echo ""

    # --- Backend dependencies ---
    echo "🐍 Installing backend dependencies..."
    cd {{backend_dir}} && uv sync --active --group dev --group test
    cd ..
    echo "   ✅ Backend synced"
    echo ""

    # --- Frontend dependencies ---
    echo "⚡ Installing frontend dependencies..."
    cd {{frontend_dir}} && pnpm install
    cd ..
    echo "   ✅ Frontend synced"
    echo ""

    # --- Database migrations ---
    echo "🗄️  Running database migrations..."
    cd {{backend_dir}} && uv run python -m alembic upgrade head
    cd ..
    echo "   ✅ Migrations applied"
    echo ""

    echo "═══════════════════════════════════════════════════════════"
    echo "✅ Monorepo sync complete!"
    echo ""
    echo "Start developing:"
    echo "  just dev-all         # Start API + frontend"
    echo "  just watch           # Backend with hot-reload"
    echo "  just test            # Run tests"

# Setup test environment (create .env.test, config/test.yaml)
[group('setup')]
setup-test:
    cd {{backend_dir}} && ./scripts/setup_test_environment.sh

# Complete first-time setup
[group('setup')]
setup: install-all setup-test
    @echo "✅ Setup complete!"
    @echo ""
    @echo "Next steps:"
    @echo "  just docker-up      # Start services"
    @echo "  just db-migrate     # Run migrations"
    @echo "  just test           # Run tests"

# One-command quickstart: env files, Docker services, deps, migrations, everything
[group('setup')]
quickstart:
    #!/usr/bin/env bash
    set -e
    echo ""
    echo "🚀 OmoiOS Quickstart"
    echo "═══════════════════════════════════════════════════════════"
    echo ""

    # --- Step 1: Environment files ---
    echo "📋 Step 1/5: Environment files"
    if [ ! -f .env.local ]; then
        cp .env.example .env.local
        echo "   Created .env.local from .env.example"
        echo "   ⚠️  Edit .env.local later to add your API keys (LLM_API_KEY, etc.)"
    else
        echo "   ✅ .env.local already exists"
    fi

    if [ ! -f frontend/.env.local ]; then
        cp frontend/.env.example frontend/.env.local
        echo "   Created frontend/.env.local from frontend/.env.example"
    else
        echo "   ✅ frontend/.env.local already exists"
    fi
    echo ""

    # --- Step 2: Start Docker services (Postgres + Redis) ---
    echo "🐳 Step 2/5: Starting database services (PostgreSQL + Redis)"
    echo "   Waiting for services to be healthy..."
    cd {{backend_dir}} && docker compose up -d --wait postgres redis
    echo "   ✅ PostgreSQL (port 15432) and Redis (port 16379) are healthy"
    cd ..
    echo ""

    # --- Step 3: Install backend dependencies ---
    echo "🐍 Step 3/5: Installing backend dependencies"
    cd {{backend_dir}} && uv sync --group test
    cd ..
    echo "   ✅ Backend dependencies installed"
    echo ""

    # --- Step 4: Run database migrations ---
    echo "🗄️  Step 4/5: Running database migrations"
    cd {{backend_dir}} && uv run python -m alembic upgrade head
    cd ..
    echo "   ✅ Database migrations applied"
    echo ""

    # --- Step 5: Install frontend dependencies ---
    echo "⚡ Step 5/5: Installing frontend dependencies"
    cd {{frontend_dir}} && pnpm install
    cd ..
    echo "   ✅ Frontend dependencies installed"
    echo ""

    # --- Done ---
    echo "═══════════════════════════════════════════════════════════"
    echo "✅ OmoiOS is ready!"
    echo ""
    echo "Start developing:"
    echo "  just dev-all         # Start everything (API + frontend)"
    echo "  just watch           # Backend with hot-reload (Docker)"
    echo "  just frontend-dev    # Frontend only"
    echo "  just backend-api     # Backend API only"
    echo ""
    echo "Other useful commands:"
    echo "  just test            # Run tests"
    echo "  just bootstrap       # Check environment health"
    echo "  just --list          # See all commands"
    echo ""
    echo "💡 Don't forget to edit .env.local with your API keys!"
    echo ""

# ============================================================================
# Git Worktree Management
# ============================================================================
#
# Worktrees let you work on multiple branches simultaneously in separate
# directories, each with its own working tree but sharing the same .git.
#
# Typical workflow:
#   just worktree-create feature-xyz ../feature-xyz
#   cd ../feature-xyz
#   just dev-all
#
# For isolated worktrees (env changes won't affect the original repo):
#   just worktree-create feature-xyz ../feature-xyz --copy
#

# Symlink .env files into a git worktree (default) or copy them (--copy).
# Automatically finds the main working tree to source .env files from.
# Usage: just worktree-env [path]          # path defaults to "."
#        just worktree-env ../my-feature-branch
#        just worktree-env --copy
[group('setup')]
worktree-env worktree_path='.' *flags:
    #!/usr/bin/env bash
    set -euo pipefail
    WORKTREE="{{worktree_path}}"

    # Parse flags
    COPY_MODE=false
    for flag in {{flags}}; do
        case "$flag" in
            --copy) COPY_MODE=true ;;
            *) echo "Unknown flag: $flag" >&2; exit 1 ;;
        esac
    done

    # Resolve worktree path to absolute
    if [[ ! "$WORKTREE" = /* ]]; then
        WORKTREE="$(cd "$WORKTREE" && pwd)"
    fi

    if [ ! -d "$WORKTREE" ]; then
        echo "❌ Worktree directory not found: $WORKTREE" >&2
        echo "   Create it first: git worktree add $WORKTREE <branch>" >&2
        exit 1
    fi

    # Find the main working tree (source of .env files).
    # In a worktree, .git is a file pointing to the main repo's .git/worktrees/<name>/.
    # In the main repo, .git is a directory.
    # We need the main repo's root — that's where the authoritative .env files live.
    MAIN_REPO=""
    if [ -f "$WORKTREE/.git" ]; then
        # We're in a worktree — extract main repo path from .git file
        # .git contains: gitdir: /path/to/main-repo/.git/worktrees/<name>
        GITDIR_LINE="$(cat "$WORKTREE/.git")"
        GITDIR_PATH="${GITDIR_LINE#gitdir: }"
        # Derive main repo root: go up from .git/worktrees/<name> to the repo root
        # e.g., /path/to/main-repo/.git/worktrees/feature-xyz → /path/to/main-repo
        MAIN_REPO="$(cd "$(dirname "$(dirname "$(dirname "$GITDIR_PATH")")")" && pwd)"
    else
        # We're in the main repo (or a bare repo) — find the root normally
        MAIN_REPO="$(git -C "$WORKTREE" rev-parse --show-toplevel)"
    fi

    if [ "$MAIN_REPO" = "$WORKTREE" ]; then
        echo "ℹ️  Worktree is the main repo — no .env linking needed."
        echo "   .env files are already in place."
        exit 0
    fi

    echo "📁 Main repo: $MAIN_REPO"
    echo "🌳 Worktree:  $WORKTREE"

    if [ "$COPY_MODE" = true ]; then
        echo "📋 Copying .env files from main repo to worktree"
    else
        echo "🔗 Symlinking .env files from main repo to worktree"
    fi
    echo ""

    # Find all .env files in the MAIN repo (excluding examples, backups, node_modules, .venv)
    cd "$MAIN_REPO"

    FOUND=0
    fd --hidden --type f '^\.env' \
       --exclude '*.example' \
       --exclude '*.backup*' \
       --exclude 'node_modules' \
       --exclude '.venv' \
       --exclude '.git' \
       --exclude '__pycache__' \
       --exclude '.next' \
       | while read -r envfile; do

         target="$WORKTREE/$envfile"

         # Create parent directory in worktree if needed
         mkdir -p "$(dirname "$target")"

         # Use absolute paths for symlinks to survive directory changes
         abs_source="$(cd "$(dirname "$envfile")" && pwd)/$(basename "$envfile")"

         if [ -L "$target" ] || [ -f "$target" ]; then
             echo "  ⚠️  $envfile already exists in worktree, skipping"
         elif [ "$COPY_MODE" = true ]; then
             cp "$abs_source" "$target"
             echo "  ✅ $envfile (copied) → $target"
         else
             ln -s "$abs_source" "$target"
             echo "  ✅ $envfile (symlinked) → $target"
         fi
    done \
    | { output=$(cat); count=$(echo "$output" | grep -c '✅\|⚠️' 2>/dev/null || echo 0); echo "$output"; echo "FILES_SYNCED=$count"; }

    echo ""
    if [ "$COPY_MODE" = true ]; then
        echo "Done. .env files are copied to worktree (edits are isolated)."
    else
        echo "Done. .env files are symlinked from main repo (edits sync back)."
        echo "💡 Use --copy for isolated env (worktree edits won't affect original)."
    fi

# Install all dependencies inside a worktree (Python + Node.js).
# Runs env sync, uv sync on all workspace members, and pnpm install in frontend.
# Defaults to current directory if no path given.
# Automatically finds .env files from the main repo.
# Usage: just worktree-setup                  # in the worktree dir
#        just worktree-setup ../my-feature-branch
#        just worktree-setup --copy
[group('setup')]
worktree-setup worktree_path='.' *flags:
    #!/usr/bin/env bash
    set -euo pipefail
    WORKTREE="{{worktree_path}}"

    # Resolve relative to absolute path
    if [[ ! "$WORKTREE" = /* ]]; then
        WORKTREE="$(cd "$WORKTREE" && pwd)"
    fi

    if [ ! -d "$WORKTREE" ]; then
        echo "❌ Worktree directory not found: $WORKTREE" >&2
        exit 1
    fi

    echo "🔧 Setting up worktree dependencies: $WORKTREE"
    echo ""
    echo "═══════════════════════════════════════════════════════════"

    # --- Step 1: Environment files ---
    echo ""
    echo "📋 Step 1/4: Environment files"
    FLAGS=""
    for flag in {{flags}}; do FLAGS="$FLAGS $flag"; done
    just worktree-env "$WORKTREE" $FLAGS

    # --- Step 2: Backend Python dependencies (uv workspace) ---
    echo ""
    echo "🐍 Step 2/4: Installing backend dependencies (uv sync)"
    if [ -f "$WORKTREE/backend/pyproject.toml" ]; then
        cd "$WORKTREE/backend" && uv sync --group test
        echo "   ✅ Backend dependencies installed"
    else
        echo "   ⚠️  No backend/pyproject.toml found, skipping"
    fi

    # --- Step 3: SDK Python dependencies ---
    echo ""
    echo "📦 Step 3/4: Installing SDK dependencies"
    if [ -f "$WORKTREE/sdk/python/pyproject.toml" ]; then
        cd "$WORKTREE/sdk/python" && uv sync
        echo "   ✅ SDK dependencies installed"
    else
        echo "   ⚠️  No sdk/python/pyproject.toml found, skipping"
    fi

    # --- Step 4: Frontend Node.js dependencies ---
    echo ""
    echo "⚡ Step 4/4: Installing frontend dependencies (pnpm install)"
    if [ -f "$WORKTREE/frontend/package.json" ]; then
        cd "$WORKTREE/frontend" && pnpm install
        echo "   ✅ Frontend dependencies installed"
    else
        echo "   ⚠️  No frontend/package.json found, skipping"
    fi

    echo ""
    echo "═══════════════════════════════════════════════════════════"
    echo "✅ Worktree setup complete: $WORKTREE"
    echo ""
    echo "Start developing:"
    echo "  cd $WORKTREE"
    echo "  just docker-up        # Start Postgres + Redis"
    echo "  just dev-all           # Start API + frontend"
    echo "  just test              # Run tests"

# Create a git worktree and set it up in one step.
# Creates the worktree, symlinks .env files, and installs all dependencies.
# Usage: just worktree-create feature-xyz ../feature-xyz
#        just worktree-create feature-xyz ../feature-xyz --copy
[group('setup')]
worktree-create branch path *flags:
    #!/usr/bin/env bash
    set -euo pipefail

    # Parse flags
    COPY_FLAG=""
    for flag in {{flags}}; do
        case "$flag" in
            --copy) COPY_FLAG="--copy" ;;
            *) echo "Unknown flag: $flag" >&2; exit 1 ;;
        esac
    done

    echo "🌳 Creating git worktree: {{path}} (branch: {{branch}})"
    echo ""

    # Create the worktree
    git worktree add "{{path}}" "{{branch}}"
    echo "✅ Worktree created at {{path}}"
    echo ""

    # Run full setup (env + dependencies)
    just worktree-env "{{path}}" $COPY_FLAG
    just worktree-setup "{{path}}"

# Check all development dependencies
[group('setup')]
bootstrap:
    cd {{backend_dir}} && {{python}} -m omoi_os.cli.bootstrap check

# Show live health dashboard
[group('setup')]
health:
    cd {{backend_dir}} && {{python}} -m omoi_os.cli.bootstrap health

# Start all services in local-only mode (no external APIs needed)
[group('dev')]
dev-local:
    OMOIOS_ENV=local just dev-all

# Inspect task context (what an agent would receive)
[group('dev')]
inspect-context task_id format="markdown":
    cd {{backend_dir}} && {{python}} -m omoi_os.cli.inspect_context {{task_id}} --format {{format}}

# Stream live orchestration events from Redis
[group('dev')]
event-stream *args='':
    cd {{backend_dir}} && {{python}} -m omoi_os.cli.event_stream {{args}}

# Replay monitoring sessions through Guardian/Conductor
[group('dev')]
monitoring-replay *ARGS:
    cd {{backend_dir}} && {{python}} -m omoi_os.cli.monitoring_replay {{ARGS}}


# Run spec pipeline in fixture mode
[group('dev')]
spec-fixture *args='':
    cd {{backend_dir}} && {{python}} -m omoi_os.cli.spec_fixture {{args}}
#NJ|
# Preview branch strategy for a spec
[group('dev')]
branch-preview *ARGS:
    cd {{backend_dir}} && {{python}} -m omoi_os.cli.branch_preview {{ARGS}}

# ============================================================================
# Testing (with pytest-testmon)
# ============================================================================

# Default: run unit tests (fast, no external deps)
[group('test')]
test pattern="":
    cd {{backend_dir}} && {{pytest}} tests/unit/ {{pattern}} -x -q

# Run all affected tests (uses testmon, may hit DB/Redis)
[group('test')]
test-affected pattern="":
    cd {{backend_dir}} && {{pytest}} {{pattern}} --testmon -x

# Run unit tests only (verbose)
[group('test')]
test-unit:
    cd {{backend_dir}} && {{pytest}} tests/unit/ -v

# Run integration tests
[group('test')]
test-integration:
    cd {{backend_dir}} && {{pytest}} tests/integration/ --testmon -v

# Run end-to-end tests
[group('test')]
test-e2e:
    cd {{backend_dir}} && {{pytest}} tests/e2e/ --testmon -v

# Run performance tests
[group('test')]
test-performance:
    cd {{backend_dir}} && {{pytest}} tests/performance/ --testmon -v

# Run ALL tests (no testmon, full suite)
[group('test')]
test-all:
    cd {{backend_dir}} && {{pytest}} --no-testmon --cov

# Run fast tests in parallel (unit tests, not slow)
[group('test')]
test-fast:
    cd {{backend_dir}} && {{pytest}} -m "unit and not slow" --testmon -x -n auto

# Run tests in parallel
[group('test')]
test-parallel workers="auto":
    cd {{backend_dir}} && {{pytest}} --testmon -n {{workers}}

# Generate HTML coverage report
[group('test')]
test-coverage:
    cd {{backend_dir}} && {{pytest}} --no-testmon --cov --cov-report=html --cov-report=term
    @echo ""
    @echo "📊 Coverage report: {{backend_dir}}/htmlcov/index.html"
    @command -v open >/dev/null && open {{backend_dir}}/htmlcov/index.html || \
     command -v xdg-open >/dev/null && xdg-open {{backend_dir}}/htmlcov/index.html || true

# Re-run only failed tests
[group('test')]
test-failed:
    cd {{backend_dir}} && {{pytest}} --lf --testmon -x

# Run tests matching a keyword
[group('test')]
test-match keyword:
    cd {{backend_dir}} && {{pytest}} -k {{keyword}} --testmon -v

# Run tests with specific marker
[group('test')]
test-mark marker:
    cd {{backend_dir}} && {{pytest}} -m {{marker}} --testmon -v

# Rebuild testmon dependency cache
[group('test')]
test-rebuild:
    @echo "🔄 Rebuilding testmon cache..."
    cd {{backend_dir}} && rm -rf .testmondata
    cd {{backend_dir}} && {{pytest}} --testmon

# Clean all test artifacts
[group('test')]
test-clean:
    @echo "🧹 Cleaning test artifacts..."
    cd {{backend_dir}} && rm -rf .testmondata .pytest_cache htmlcov .coverage coverage.xml
    cd {{backend_dir}} && find . -type d -name __pycache__ -exec rm -rf {} + 2>/dev/null || true

# Run smoke test (critical path only)
[group('test')]
test-smoke:
    cd {{backend_dir}} && {{pytest}} -m critical --testmon -x

# Show what tests would run (dry-run)
[group('test')]
test-dry:
    cd {{backend_dir}} && {{pytest}} --testmon --collect-only

# Watch mode (requires pytest-watch)
[group('test')]
test-watch:
    cd {{backend_dir}} && uv run ptw -- --testmon -x

# ============================================================================
# Code Quality
# ============================================================================

# Format code with ruff
[group('quality')]
format:
    cd {{backend_dir}} && uv run ruff check --fix .
    cd {{backend_dir}} && uv run ruff format .

# Lint code with ruff (check only, no fixes)
[group('quality')]
lint:
    cd {{backend_dir}} && uv run ruff check .

# Type check with mypy
[group('quality')]
type-check:
    cd {{backend_dir}} && uv run mypy omoi_os

# Run quality checks (fix + format with ruff)
[group('quality')]
check:
    cd {{backend_dir}} && uv run ruff check --fix .
    cd {{backend_dir}} && uv run ruff format .

# Fix all auto-fixable issues (alias for check)
[group('quality')]
fix:
    cd {{backend_dir}} && uv run ruff check --fix .
    cd {{backend_dir}} && uv run ruff format .
    @echo "✅ Auto-fixes applied"

# ============================================================================
# Database Operations
# ============================================================================

# Run all migrations
[group('database')]
db-migrate:
    cd {{backend_dir}} && uv run alembic upgrade head

# Create new migration
[group('database')]
db-revision message:
    cd {{backend_dir}} && uv run alembic revision -m "{{message}}"

# Rollback one migration
[group('database')]
db-downgrade count="1":
    cd {{backend_dir}} && uv run alembic downgrade -{{count}}

# Show migration history
[group('database')]
db-history:
    cd {{backend_dir}} && uv run alembic history

# Show current migration
[group('database')]
db-current:
    cd {{backend_dir}} && uv run alembic current

# Start a local Postgres (pg0, no Docker) on the test port; creates app_db
[group('database')]
pg0-up:
    bash scripts/pg0_up.sh

# Apply migrations to the local pg0 instance (app_db)
[group('database')]
pg0-migrate: pg0-up
    cd {{backend_dir}} && DATABASE_URL="postgresql+psycopg://postgres:postgres@127.0.0.1:15432/app_db" uv run alembic upgrade head

# Stop the local pg0 instance (data persists at ~/.pg0/instances/omoi-os/)
[group('database')]
pg0-down:
    ${HOME}/.local/bin/pg0 stop --name omoi-os || true

# Drop the local pg0 instance entirely (deletes data; irreversible)
[group('database')]
pg0-nuke:
    ${HOME}/.local/bin/pg0 drop --name omoi-os

# Status of the local pg0 instance
[group('database')]
pg0-info:
    ${HOME}/.local/bin/pg0 info --name omoi-os

# ============================================================================
# Docker Operations
# ============================================================================

# Start all services
[group('docker')]
docker-up:
    cd {{backend_dir}} && docker-compose up -d

# Stop all services
[group('docker')]
docker-down:
    cd {{backend_dir}} && docker-compose down

# View logs (optionally specify service)
[group('docker')]
docker-logs service="":
    #!/usr/bin/env bash
    cd {{backend_dir}}
    if [ -z "{{service}}" ]; then
        docker-compose logs -f
    else
        docker-compose logs -f {{service}}
    fi

# Rebuild and restart services
[group('docker')]
docker-rebuild:
    cd {{backend_dir}} && docker-compose up -d --build

# Clean Docker volumes and rebuild
[group('docker')]
docker-clean:
    cd {{backend_dir}} && docker-compose down -v
    cd {{backend_dir}} && docker-compose up -d --build

# ============================================================================
# Docker Compose Watch (Hot-Reload Development)
# ============================================================================

# Start all backend services with hot-reload (recommended for development)
[group('docker')]
watch:
    @echo "🚀 Starting all backend services with hot-reload..."
    @echo "   API: http://localhost:{{api_port}}"
    @echo "   Press Ctrl+C to stop"
    cd {{backend_dir}} && docker compose watch

# Start only API + infrastructure (no background workers)
[group('docker')]
watch-api:
    @echo "🚀 Starting API with hot-reload (no workers)..."
    cd {{backend_dir}} && docker compose watch api postgres redis

# Start orchestrator worker only
[group('docker')]
watch-orchestrator:
    @echo "🚀 Starting orchestrator worker with hot-reload..."
    cd {{backend_dir}} && docker compose watch orchestrator postgres redis

# Start monitoring worker only
[group('docker')]
watch-monitoring:
    @echo "🚀 Starting monitoring worker with hot-reload..."
    cd {{backend_dir}} && docker compose watch monitoring postgres redis

# ============================================================================
# Service Utilities
# ============================================================================

# Check if a port is in use
[group('services')]
check-port port:
    #!/usr/bin/env bash
    if lsof -Pi :{{port}} -sTCP:LISTEN -t >/dev/null 2>&1 ; then
        echo "⚠️  Port {{port}} is already in use"
        echo "Process using port {{port}}:"
        lsof -Pi :{{port}} -sTCP:LISTEN
        exit 1
    else
        echo "✅ Port {{port}} is available"
        exit 0
    fi

# Kill process on a specific port
[group('services')]
kill-port port:
    #!/usr/bin/env bash
    PID=$(lsof -ti:{{port}})
    if [ -z "$PID" ]; then
        echo "ℹ️  No process found on port {{port}}"
    else
        echo "🛑 Killing process $PID on port {{port}}..."
        kill -9 $PID
        echo "✅ Process killed"
    fi

# Check status of all services (ports and health endpoints)
[group('services')]
status:
    #!/usr/bin/env bash
    echo "📊 Service Status"
    echo "=================="
    echo ""
    echo "Port {{api_port}} (Backend API):"
    if lsof -Pi :{{api_port}} -sTCP:LISTEN -t >/dev/null 2>&1 ; then
        echo "  ✅ Running"
        PID=$(lsof -ti:{{api_port}})
        echo "  PID: $PID"
        if curl -s http://localhost:{{api_port}}/health >/dev/null 2>&1 ; then
            echo "  ✅ Health check: OK"
            HEALTH=$(curl -s http://localhost:{{api_port}}/health | head -c 100)
            echo "  Response: $HEALTH..."
        else
            echo "  ⚠️  Health check: FAILED"
        fi
    else
        echo "  ❌ Not running"
    fi
    echo ""
    echo "Port {{frontend_port}} (Frontend):"
    if lsof -Pi :{{frontend_port}} -sTCP:LISTEN -t >/dev/null 2>&1 ; then
        echo "  ✅ Running"
        PID=$(lsof -ti:{{frontend_port}})
        echo "  PID: $PID"
        if curl -s http://localhost:{{frontend_port}} >/dev/null 2>&1 ; then
            echo "  ✅ Health check: OK"
        else
            echo "  ⚠️  Health check: FAILED"
        fi
    else
        echo "  ❌ Not running"
    fi
    echo ""
    echo "Worker processes:"
    WORKER_COUNT=$(ps aux | grep -c "[p]ython -m omoi_os.worker" || echo "0")
    if [ "$WORKER_COUNT" -gt 0 ]; then
        echo "  ✅ $WORKER_COUNT worker(s) running"
        ps aux | grep "[p]ython -m omoi_os.worker" | awk '{print "    PID: " $2}'
    else
        echo "  ❌ No workers running"
    fi

# Health check for backend API
[group('services')]
health-api:
    #!/usr/bin/env bash
    echo "🏥 Checking backend API health..."
    if curl -s http://localhost:{{api_port}}/health ; then
        echo ""
        echo "✅ Backend API is healthy"
    else
        echo "❌ Backend API health check failed"
        exit 1
    fi

# Health check for frontend
[group('services')]
health-frontend:
    #!/usr/bin/env bash
    echo "🏥 Checking frontend health..."
    if curl -s http://localhost:{{frontend_port}} >/dev/null 2>&1 ; then
        echo "✅ Frontend is healthy"
    else
        echo "❌ Frontend health check failed"
        exit 1
    fi

# Health check for all services
[group('services')]
health-all: health-api health-frontend
    @echo "✅ All services are healthy"

# Stop all running services
[group('services')]
stop-all:
    #!/usr/bin/env bash
    echo "🛑 Stopping all services..."
    echo ""
    # Kill API server
    API_PID=$(lsof -ti:{{api_port}} 2>/dev/null || true)
    if [ -n "$API_PID" ]; then
        echo "  Stopping API server (PID: $API_PID)..."
        kill -9 $API_PID 2>/dev/null || true
        echo "  ✅ API server stopped"
    else
        echo "  ℹ️  API server not running"
    fi
    # Kill frontend
    FRONTEND_PID=$(lsof -ti:{{frontend_port}} 2>/dev/null || true)
    if [ -n "$FRONTEND_PID" ]; then
        echo "  Stopping frontend (PID: $FRONTEND_PID)..."
        kill -9 $FRONTEND_PID 2>/dev/null || true
        echo "  ✅ Frontend stopped"
    else
        echo "  ℹ️  Frontend not running"
    fi
    # Kill workers
    WORKER_COUNT=$(pgrep -f "python -m omoi_os.worker" 2>/dev/null | wc -l | tr -d ' ' || echo "0")
    if [ "$WORKER_COUNT" -gt 0 ]; then
        echo "  Stopping $WORKER_COUNT worker(s)..."
        pkill -9 -f "python -m omoi_os.worker" 2>/dev/null || true
        echo "  ✅ Workers stopped"
    else
        echo "  ℹ️  No workers running"
    fi
    echo ""
    echo "✅ All services stopped"

# Restart all services (stop then start)
[group('services')]
restart-all:
    just stop-all
    sleep 2
    just dev-all

# ============================================================================
# Running Services
# ============================================================================

# Start API server (development mode with reload)
[group('services')]
api port=api_port:
    cd {{backend_dir}} && uv run uvicorn omoi_os.api.main:app --host 0.0.0.0 --port {{port}} --reload

# Start worker process
[group('services')]
worker:
    cd {{backend_dir}} && uv run python -m omoi_os.worker

# Run smoke test
[group('services')]
smoke:
    cd {{backend_dir}} && uv run python scripts/smoke_test.py

# Start API and worker in parallel (requires tmux or separate terminals)
[group('services')]
dev:
    @echo "Starting services..."
    @echo "API will be at http://localhost:{{api_port}}"
    @just api &
    @sleep 2
    @just worker

# Start both backend services (API and worker) in separate terminals
# Note: This runs them in background - use 'backend-api' and 'backend-worker'
# in separate terminal windows for better control
[group('services')]
backend-dev:
    @echo "🚀 Starting backend services..."
    @echo ""
    @echo "Starting API server..."
    @cd {{backend_dir}} && uv run uvicorn omoi_os.api.main:app --host 0.0.0.0 --port {{api_port}} --reload &
    @sleep 2
    @echo "Starting worker..."
    @cd {{backend_dir}} && uv run python -m omoi_os.worker

# Start only the API server (runs in backend directory)
[group('services')]
backend-api:
    @echo "🚀 Starting API server on port {{api_port}}..."
    @echo "API will be at http://localhost:{{api_port}}"
    cd {{backend_dir}} && uv run uvicorn omoi_os.api.main:app --host 0.0.0.0 --port {{api_port}} --reload

# Start only the worker (runs in backend directory)
[group('services')]
backend-worker:
    @echo "🚀 Starting worker..."
    cd {{backend_dir}} && uv run python -m omoi_os.worker

# ============================================================================
# Separate Process Development (No Docker)
# ============================================================================

# Quick local API - all background loops disabled
[group('services')]
api-light port=api_port:
    @echo "🚀 Starting lightweight API (no background loops)..."
    cd {{backend_dir}} && MONITORING_ENABLED=false ORCHESTRATOR_ENABLED=false MCP_ENABLED=false \
    DAYTONA_SANDBOX_EXECUTION=true \
    uv run uvicorn omoi_os.api.main:app --host 0.0.0.0 --port {{port}} --reload

# Start orchestrator as separate process (local, no Docker)
[group('services')]
orchestrator:
    @echo "🚀 Starting orchestrator worker..."
    cd {{backend_dir}} && uv run python -m omoi_os.workers.orchestrator_worker

# Start monitoring as separate process (local, no Docker)
[group('services')]
monitoring:
    @echo "🚀 Starting monitoring worker..."
    cd {{backend_dir}} && uv run python -m omoi_os.workers.monitoring_worker

# ============================================================================
# Full Stack Development
# ============================================================================

# Start everything: backend (docker watch) + frontend
[group('services')]
dev-watch:
    #!/usr/bin/env bash
    set -e
    echo "🚀 Starting full stack with hot-reload..."
    echo ""
    echo "Backend API: http://localhost:{{api_port}}"
    echo "Frontend: http://localhost:{{frontend_port}}"
    echo ""

    # Start backend in background
    cd {{backend_dir}} && docker compose watch &
    BACKEND_PID=$!

    # Wait for API to be ready
    echo "Waiting for backend..."
    sleep 5

    # Start frontend in foreground
    echo "Starting frontend..."
    cd {{frontend_dir}} && NODE_OPTIONS="--max-old-space-size=4096" pnpm exec next dev --port {{frontend_port}}

    # Cleanup on exit
    kill $BACKEND_PID 2>/dev/null || true

# ============================================================================
# Frontend Services
# ============================================================================

# Install frontend dependencies
[group('frontend')]
frontend-install:
    @echo "📦 Installing frontend dependencies..."
    cd {{frontend_dir}} && pnpm install

# Start frontend development server
[group('frontend')]
frontend-dev port=frontend_port:
    @echo "🚀 Starting frontend development server..."
    @echo "Frontend will be at http://localhost:{{port}}"
    cd {{frontend_dir}} && NODE_OPTIONS="--max-old-space-size=4096" pnpm exec next dev --port {{port}}

# Build frontend for production
[group('frontend')]
frontend-build:
    @echo "🏗️  Building frontend for production..."
    cd {{frontend_dir}} && pnpm build

# Start frontend production server
[group('frontend')]
frontend-start port=frontend_port:
    @echo "🚀 Starting frontend production server..."
    @echo "Frontend will be at http://localhost:{{port}}"
    cd {{frontend_dir}} && pnpm start -- -p {{port}}

# Format frontend code with Prettier
[group('frontend')]
frontend-format:
    @echo "🔧 Formatting frontend code..."
    cd {{frontend_dir}} && pnpm exec prettier --write "app/**/*.{ts,tsx}" "components/**/*.{ts,tsx}" "hooks/**/*.{ts,tsx}" "lib/**/*.{ts,tsx}" "providers/**/*.{ts,tsx}" "__tests__/**/*.{ts,tsx}" --log-level warn
    @echo "✅ Frontend formatted"

# Type check frontend code
[group('frontend')]
frontend-type-check:
    @echo "🔍 Type checking frontend code..."
    cd {{frontend_dir}} && pnpm exec tsc --noEmit

# Clean frontend build artifacts and cache
[group('frontend')]
frontend-clean:
    @echo "🧹 Cleaning frontend artifacts..."
    cd {{frontend_dir}} && rm -rf .next node_modules/.cache
    @echo "✅ Frontend artifacts cleaned"

# Clean and reinstall frontend dependencies
[group('frontend')]
frontend-clean-install:
    @echo "🧹 Cleaning and reinstalling frontend dependencies..."
    cd {{frontend_dir}} && rm -rf node_modules pnpm-lock.yaml
    cd {{frontend_dir}} && pnpm install
    @echo "✅ Frontend dependencies reinstalled"

# Check for outdated frontend packages
[group('frontend')]
frontend-deps-check:
    @echo "🔍 Checking for outdated frontend packages..."
    cd {{frontend_dir}} && pnpm outdated

# Update frontend dependencies
[group('frontend')]
frontend-deps-update:
    @echo "🔄 Updating frontend dependencies..."
    cd {{frontend_dir}} && pnpm update

# Run all frontend checks (format + type check)
[group('frontend')]
frontend-check: frontend-format frontend-type-check
    @echo "✅ All frontend checks passed"

# Start all development services (backend API, worker, and frontend)
# Note: For better control, use separate terminals with 'backend-api', 'backend-worker', and 'frontend-dev'
[group('services')]
dev-all:
    #!/usr/bin/env bash
    set -e
    echo "🚀 Starting all development services..."
    echo ""
    echo "Backend API: http://localhost:{{api_port}}"
    echo "Frontend: http://localhost:{{frontend_port}}"
    echo ""

    # Check if ports are already in use
    if lsof -Pi :{{api_port}} -sTCP:LISTEN -t >/dev/null 2>&1 ; then
        echo "⚠️  Port {{api_port}} is already in use"
        echo "   Use 'just kill-port {{api_port}}' to free the port, or"
        echo "   Use 'just stop-all' to stop all services"
        exit 1
    fi

    if lsof -Pi :{{frontend_port}} -sTCP:LISTEN -t >/dev/null 2>&1 ; then
        echo "⚠️  Port {{frontend_port}} is already in use"
        echo "   Use 'just kill-port {{frontend_port}}' to free the port, or"
        echo "   Use 'just stop-all' to stop all services"
        exit 1
    fi

    echo "Starting backend API..."
    cd {{backend_dir}} && uv run uvicorn omoi_os.api.main:app --host 0.0.0.0 --port {{api_port}} --reload &
    API_PID=$!
    sleep 3

    # Wait for API to be ready
    echo "Waiting for API to be ready..."
    for i in {1..30}; do
        if curl -s http://localhost:{{api_port}}/health >/dev/null 2>&1 ; then
            echo "✅ API is ready!"
            break
        fi
        sleep 1
    done

    echo "Starting backend worker..."
    cd {{backend_dir}} && uv run python -m omoi_os.worker &
    WORKER_PID=$!
    sleep 2

    echo ""
    echo "✅ Backend services started"
    echo "   API PID: $API_PID"
    echo "   Worker PID: $WORKER_PID"
    echo ""
    echo "Starting frontend (this will block - press Ctrl+C to stop all services)..."
    echo ""

    # Cleanup function
    cleanup() {
        echo ""
        echo "🛑 Stopping all services..."
        kill $API_PID $WORKER_PID 2>/dev/null || true
        pkill -f "npm run dev" 2>/dev/null || true
        echo "✅ All services stopped"
        exit 0
    }

    trap cleanup SIGINT SIGTERM

    # Start frontend in foreground (this blocks)
    cd {{frontend_dir}} && NODE_OPTIONS="--max-old-space-size=4096" pnpm exec next dev --port {{frontend_port}}

    # If frontend exits, cleanup
    cleanup

# ============================================================================
# Documentation
# ============================================================================

# Generate documentation index
[group('docs')]
docs-index:
    cd {{backend_dir}} && {{python}} scripts/generate_doc_index.py

# Validate documentation structure
[group('docs')]
docs-validate:
    cd {{backend_dir}} && {{python}} scripts/validate_docs.py

# Check for orphaned docs
[group('docs')]
docs-check:
    @echo "🔍 Checking for orphaned documents..."
    @find docs/ -maxdepth 1 -type f -name "*.md" ! -name "README.md" ! -name "*_SUMMARY.md" ! -name "DOCUMENTATION_STANDARDS.md"

# Open documentation in browser
[group('docs')]
docs-open:
    @command -v open >/dev/null && open docs/README.md || \
     command -v xdg-open >/dev/null && xdg-open docs/README.md || \
     echo "Open docs/README.md in your editor"

# Organize documentation with AI (batch processing, dry-run)
[group('docs')]
docs-organize concurrent="50":
    cd {{backend_dir}} && {{python}} scripts/organize_docs_batch.py --concurrent {{concurrent}} --detailed --export reorganization_plan.md
    @echo ""
    @echo "📋 Review the plan: reorganization_plan.md"
    @echo "Then run: just docs-organize-apply"

# Apply AI-suggested organization
[group('docs')]
docs-organize-apply concurrent="50":
    cd {{backend_dir}} && {{python}} scripts/organize_docs_batch.py --apply --detailed --concurrent {{concurrent}}

# Organize specific pattern (batch)
[group('docs')]
docs-organize-pattern pattern concurrent="25":
    cd {{backend_dir}} && {{python}} scripts/organize_docs_batch.py --pattern "{{pattern}}" --concurrent {{concurrent}} --detailed

# Organize single file (non-batch for quick test)
[group('docs')]
docs-organize-single file:
    cd {{backend_dir}} && {{python}} scripts/organize_docs.py --pattern "{{file}}"

# ============================================================================
# Configuration
# ============================================================================

# Validate all configuration files
[group('config')]
config-validate:
    cd {{backend_dir}} && {{python}} scripts/validate_config.py

# Show current configuration (for current environment)
[group('config')]
config-show section="":
    #!/usr/bin/env bash
    cd {{backend_dir}}
    if [ -z "{{section}}" ]; then
        uv run python -c "from omoi_os.config import _load_yaml_config; import json; print(json.dumps(_load_yaml_config(), indent=2))"
    else
        uv run python -c "from omoi_os.config import load_yaml_section; import json; print(json.dumps(load_yaml_section('{{section}}'), indent=2))"
    fi

# List all configuration sections
[group('config')]
config-list:
    cd {{backend_dir}} && uv run python -c "from omoi_os.config import _load_yaml_config; print('\n'.join(_load_yaml_config().keys()))"

# Check for configuration drift (settings without YAML or vice versa)
[group('config')]
config-check:
    cd {{backend_dir}} && {{python}} scripts/check_config_drift.py

# ============================================================================
# Git Operations
# ============================================================================

# Stage and commit with validation
[group('git')]
commit message:
    just docs-validate
    just config-validate
    just test
    git add -A
    git commit -m "{{message}}"

# Push to GitHub after running tests
[group('git')]
push:
    just test-all
    git push origin main

# Create a checkpoint commit (before major changes)
[group('git')]
checkpoint message="Checkpoint":
    git add -A
    git commit -m "🔖 {{message}} - $(date +%Y-%m-%d-%H%M)"

# ============================================================================
# Cleaning
# ============================================================================

# Clean Python cache files
[group('clean')]
clean-py:
    cd {{backend_dir}} && find . -type d -name __pycache__ -exec rm -rf {} + 2>/dev/null || true
    cd {{backend_dir}} && find . -type f -name "*.pyc" -delete
    cd {{backend_dir}} && find . -type f -name "*.pyo" -delete
    cd {{backend_dir}} && find . -type d -name "*.egg-info" -exec rm -rf {} + 2>/dev/null || true

# Clean test artifacts
[group('clean')]
clean-test:
    cd {{backend_dir}} && rm -rf .pytest_cache htmlcov .coverage coverage.xml
    cd {{backend_dir}} && rm -rf .testmondata

# Clean all artifacts
[group('clean')]
clean-all: clean-py clean-test
    cd {{backend_dir}} && rm -rf dist build
    @echo "✅ Cleaned all artifacts"

# ============================================================================
# Utilities
# ============================================================================

# Show project statistics
[group('util')]
stats:
    @echo "📊 Project Statistics"
    @echo "===================="
    @echo "Python files:  $(cd {{backend_dir}} && find omoi_os -name '*.py' | wc -l | tr -d ' ')"
    @echo "Test files:    $(cd {{backend_dir}} && find tests -name 'test_*.py' | wc -l | tr -d ' ')"
    @echo "Documentation: $(find docs -name '*.md' | wc -l | tr -d ' ')"
    @echo "Lines of code: $(cd {{backend_dir}} && find omoi_os -name '*.py' -exec wc -l {} + | tail -1 | awk '{print $1}')"
    @echo "Test coverage: $(cd {{backend_dir}} && grep -A 1 'TOTAL' htmlcov/index.html 2>/dev/null | tail -1 | grep -oP '\d+%' || echo 'Run tests first')"

# Check dependency updates
[group('util')]
deps-check:
    cd {{backend_dir}} && uv pip list --outdated

# Update dependencies
[group('util')]
deps-update:
    cd {{backend_dir}} && uv sync --upgrade

# Generate dependency tree
[group('util')]
deps-tree package="omoi_os":
    cd {{backend_dir}} && uv pip tree | grep -A 20 {{package}}

# ============================================================================
# Validation
# ============================================================================

# Validate everything (docs, config, tests, code)
[group('validate')]
validate-all: docs-validate config-validate lint type-check test
    @echo "✅ All validations passed"

# Validate documentation structure
[group('validate')]
validate-docs:
    {{python}} scripts/validate_docs.py

# Validate configuration
[group('validate')]
validate-config:
    {{python}} scripts/validate_config.py

# Pre-commit checks (fast)
[group('validate')]
pre-commit: validate-all

# Pre-push checks (comprehensive)
[group('validate')]
pre-push: validate-all test-all
    @echo "✅ Ready to push"

# ============================================================================
# Help & Information
# ============================================================================

# Show available recipes
help:
    @just --list

# Show recipe details
info recipe:
    @just --show {{recipe}}

# Show environment variables
env:
    @echo "OMOIOS_ENV: $OMOIOS_ENV"
    @echo "API_PORT: {{api_port}}"
    @echo "Python: $(which python)"
    @echo "UV: $(which uv)"

# Show configuration summary
config-summary:
    @echo "📋 Configuration Summary"
    @echo "======================="
    @echo "Environment: $OMOIOS_ENV"
    @echo "Config files:"
    @ls -1 {{backend_dir}}/config/*.yaml 2>/dev/null | sed 's/^/  - /'
    @echo "Active config: {{backend_dir}}/config/$OMOIOS_ENV.yaml (+ {{backend_dir}}/config/base.yaml)"

# ============================================================================
# Advanced Recipes
# ============================================================================

# Run a specific test file with testmon
[group('advanced')]
test-file file:
    cd {{backend_dir}} && {{pytest}} tests/{{file}} --testmon -v

# Run tests with specific marker and coverage
[group('advanced')]
test-marker-cov marker:
    cd {{backend_dir}} && {{pytest}} -m {{marker}} --testmon --cov

# Create new test file from template
[group('advanced')]
create-test category feature:
    #!/usr/bin/env bash
    set -euo pipefail
    cd {{backend_dir}}

    mkdir -p tests/{{category}}

    # Capitalize feature name for class (bash string manipulation)
    feature_class=$(echo "{{feature}}" | awk '{for(i=1;i<=NF;i++) $i=toupper(substr($i,1,1)) tolower(substr($i,2))}1' | tr -d '_')

    cat > tests/{{category}}/test_{{feature}}.py << EOF
    """Test {{feature}}.

    Tests cover:
    - Functionality 1
    - Functionality 2
    """

    import pytest


    class Test${feature_class}:
        """Test suite for {{feature}}."""

        @pytest.mark.{{category}}
        def test_{{feature}}_basic(self):
            """Test basic {{feature}} functionality."""
            # Arrange
            # Act
            # Assert
            pass
    EOF

    echo "✅ Created {{backend_dir}}/tests/{{category}}/test_{{feature}}.py"

# Create new documentation from template
[group('advanced')]
create-doc doc_type category feature:
    #!/usr/bin/env bash
    set -euo pipefail

    mkdir -p docs/{{doc_type}}/{{category}}
    filepath="docs/{{doc_type}}/{{category}}/{{feature}}.md"

    # Capitalize feature name for title (bash string manipulation)
    feature_title=$(echo "{{feature}}" | sed 's/_/ /g' | awk '{for(i=1;i<=NF;i++) $i=toupper(substr($i,1,1)) substr($i,2)}1')

    cat > "$filepath" << EOF
    # ${feature_title}

    **Created**: $(date +%Y-%m-%d)
    **Status**: Draft
    **Purpose**: {One-sentence description}

    ---

    ## Overview

    {Description here}

    ## Details

    {Content here}
    EOF

    echo "✅ Created $filepath"

# Interactive Python shell with OmoiOS context
[group('advanced')]
shell:
    cd {{backend_dir}} && uv run python -i -c "from omoi_os.services.database import DatabaseService; from omoi_os.config import load_database_settings; print('OmoiOS shell ready')"

# ============================================================================
# CI/CD Simulation
# ============================================================================

# Simulate CI pipeline locally
[group('ci')]
ci: validate-all test-all
    @echo "✅ CI pipeline passed"

# Simulate PR checks
[group('ci')]
ci-pr: validate-all test-parallel
    @echo "✅ PR checks passed"

# Generate coverage badge
[group('ci')]
coverage-badge:
    cd {{backend_dir}} && {{pytest}} --no-testmon --cov --cov-report=json
    @echo "Coverage: $(cd {{backend_dir}} && uv run python -c 'import json; print(json.load(open(\"coverage.json\"))[\"totals\"][\"percent_covered\"])')%"

# ============================================================================
# Special Recipes
# ============================================================================

# Run everything (full validation)
all: clean-all install-all validate-all test-all
    @echo "✅ Complete validation successful"

# Development workflow (format, test, commit)
dev-commit message: format test
    git add -A
    git commit -m "{{message}}"

# Release checklist
release version: validate-all test-all
    @echo "🚀 Release Checklist for v{{version}}"
    @echo "  ✅ All tests passed"
    @echo "  ✅ All validations passed"
    @echo ""
    @echo "Next steps:"
    @echo "  1. Update version in pyproject.toml"
    @echo "  2. Create git tag: git tag -a v{{version}} -m 'Release v{{version}}'"
    @echo "  3. Push: git push && git push --tags"

# ============================================================================
# Recipe Groups Help
# ============================================================================

# Show test commands
test-help:
    @just --list --list-heading $'Test Commands:\n' --list-prefix '  ' | grep -A 100 "Test Commands"

# Show setup commands
setup-help:
    @just --list | grep -A 20 "setup"

# Show all groups
groups:
    @echo "Recipe Groups:"
    @echo "  setup      - Installation and setup"
    @echo "  test       - Testing commands"
    @echo "  quality    - Code quality (lint, format, type)"
    @echo "  database   - Database operations"
    @echo "  docker     - Docker operations"
    @echo "    • watch            - Hot-reload all backend services"
    @echo "    • watch-api        - Hot-reload API only (no workers)"
    @echo "    • watch-orchestrator - Hot-reload orchestrator"
    @echo "    • watch-monitoring - Hot-reload monitoring"
    @echo "  services   - Running services (backend & frontend)"
    @echo "    • api-light    - Lightweight API (no background loops)"
    @echo "    • orchestrator - Standalone orchestrator worker"
    @echo "    • monitoring   - Standalone monitoring worker"
    @echo "    • dev-watch    - Full stack (backend docker + frontend)"
    @echo "    • status       - Check all service statuses"
    @echo "    • stop-all     - Stop all running services"
    @echo "    • health-*     - Health check commands"
    @echo "  frontend   - Frontend development commands"
    @echo "  docs       - Documentation (includes AI organization)"
    @echo "  config     - Configuration"
    @echo "  git        - Git operations"
    @echo "  clean      - Cleaning artifacts"
    @echo "  validate   - Validation commands"
    @echo "  ci         - CI/CD simulation"
    @echo "  advanced   - Advanced operations"
    @echo ""
    @echo "Quick Start (Hot-Reload Development):"
    @echo "  just watch                      - Start all backend services"
    @echo "  just watch-api                  - Start API only (for quick testing)"
    @echo "  just api-light                  - Local API without Docker"
    @echo "  just dev-watch                  - Full stack (backend + frontend)"
    @echo ""
    @echo "Use 'just --list' to see all commands"

# ── Version Management ─────────────────────────────────────────────────────────

# Set project version and sync to all manifests
set-version version:
    echo "{{version}}" > VERSION
    python3 scripts/sync-version.py

# Check all version files are in sync (for CI)
check-version:
    python3 scripts/sync-version.py --check

# Sync VERSION file to all package manifests
sync-version:
    python3 scripts/sync-version.py

# ============================================================================
# Poof / proof-of-life — local API + prod DB, Fireworks-only
# Cheatsheet: docs/poof-cheatsheet.md
# ============================================================================

# Alias — `just poof` opens the viewer in a new Terminal window.
alias poof := poof-watch

# Open the poof tmux session in a NEW Terminal window with a banner +
# safe attach. Auto-starts the session if it's not already running.
poof-watch:
    @./scripts/poof_watch.sh

# Boot the poof tmux session (idempotent — safe to call repeatedly).
poof-start:
    @./scripts/poof_tmux.sh start

# Attach in the CURRENT terminal (use `Ctrl-B d` to detach).
poof-attach:
    @./scripts/poof_watch.sh --inline

# Show session windows + API health without attaching.
poof-status:
    @./scripts/poof_tmux.sh status

# Tear down the session AND uvicorn.
poof-kill:
    @./scripts/poof_tmux.sh kill

# Quick health probe.
poof-health:
    @curl -s -o /dev/null -w "api=%{http_code} time=%{time_total}\n" --max-time 5 http://localhost:18000/health

# Tail the uvicorn log (Ctrl-C to exit).
poof-logs:
    @tail -F /tmp/uvicorn-prod.log

# Snapshot the last N lines of any window. Defaults to the poof window.
# Usage:
#   just poof-snap            # poof:1, last 200 lines
#   just poof-snap api 100    # poof:0 (api), last 100 lines
poof-snap window="poof" lines="200":
    @echo "=== snapshot of poof:{{window}} ({{lines}} lines) ==="
    @tmux capture-pane -p -t "poof:{{window}}" -S "-{{lines}}" 2>/dev/null \
      || (echo "  ✗ window '{{window}}' not found. Use: api | poof | logs | probes" && exit 1)

# Snapshot ALL four windows at once (handy after a run).
poof-snap-all lines="100":
    @for w in api poof logs probes; do \
      echo "=== poof:$w (last {{lines}} lines) ==="; \
      tmux capture-pane -p -t "poof:$w" -S "-{{lines}}" 2>/dev/null || echo "  (window not found)"; \
      echo ""; \
    done

# Kick off the proof-of-life (sends keys to the poof window — the script
# runs IN tmux so it's visible to anyone attached).
poof-run:
    @tmux send-keys -t poof:1 '.venv/bin/python scripts/agent_proof_of_life.py' Enter
    @echo "  ▸ kicked off in poof:1 — `just poof-snap` to view"

# Same but clears the cached state file first.
poof-run-fresh:
    @tmux send-keys -t poof:1 'rm -f .sisyphus/poof.state.json && .venv/bin/python scripts/agent_proof_of_life.py' Enter
    @echo "  ▸ kicked off fresh in poof:1 — `just poof-snap` to view"

# Run a single step (1-7).
poof-step n:
    @tmux send-keys -t poof:1 ".venv/bin/python scripts/agent_proof_of_life.py --step {{n}}" Enter
    @echo "  ▸ step {{n}} kicked off in poof:1"

# Show the cached resource ids from the most recent run.
poof-state:
    @if [ -f .sisyphus/poof.state.json ]; then jq . .sisyphus/poof.state.json; else echo "  · no state file yet — run `just poof-run-fresh`"; fi

# Show events for the cached session (queries prod DB directly).
poof-events:
    @SID=$(jq -r .session_id .sisyphus/poof.state.json 2>/dev/null) && [ -n "$SID" ] || (echo "  ✗ no cached session_id — run `just poof-run-fresh` first" && exit 1); \
    DB=$(railway variables --kv | grep '^DATABASE_URL=' | cut -d= -f2- | sed 's/postgresql+psycopg/postgresql/'); \
    psql "$DB" -c "SELECT seq, event_type, actor, LEFT(payload::text, 100) AS payload FROM events WHERE entity_id = '$SID' ORDER BY seq;"

# Run layered probes against the cached session — pinpoints which layer
# is broken when something hangs.
poof-probes:
    @SID=$(jq -r .session_id .sisyphus/poof.state.json 2>/dev/null) && [ -n "$SID" ] || (echo "  ✗ no cached session_id — run `just poof-run-fresh` first" && exit 1); \
    DB=$(railway variables --kv | grep '^DATABASE_URL=' | cut -d= -f2-); \
    SESSION_ID=$SID DATABASE_URL=$DB OMOIOS_API_BASE_URL=http://localhost:18000 ./scripts/poof_probes.sh

# Open the cheatsheet in the default markdown viewer.
poof-cheat:
    @open docs/poof-cheatsheet.md 2>/dev/null || cat docs/poof-cheatsheet.md

# Restart the whole tmux session and uvicorn (kill + start).
poof-reload:
    @./scripts/poof_tmux.sh kill
    @sleep 1
    @./scripts/poof_tmux.sh start

# Show which Modal account/workspace the CLI is currently logged into.
modal-whoami:
    @modal profile current

# List Modal profiles in ~/.modal.toml; mark active.
modal-profile name="":
    @if [ -z "{{name}}" ]; then ./scripts/modal_profile.sh status; \
    else ./scripts/modal_profile.sh switch "{{name}}"; fi

# Switch to the personal Modal profile (with confirm).
modal-personal:
    @./scripts/modal_profile.sh switch personal-account

# Switch to the business / org Modal profile (with confirm).
modal-business:
    @./scripts/modal_profile.sh switch automation-workz

# End-to-end streaming demo: probe the API, mint a session, launch the TUI.
# Requires uvicorn already running on :18000 (see `tmux attach -t poof`).
# Sources backend env files so OMOIOS_PLATFORM_API_KEY + co are present;
# pulls in the SDK editable so the `omoios` binary + package are both
# available for the TUI handoff. Pass `--no-tui` to bootstrap a session
# without launching the TUI (useful for CI or print-only checks).
stream-demo *ARGS:
    @set -a; \
    source {{backend_dir}}/.env 2>/dev/null || true; \
    source {{backend_dir}}/.env.local 2>/dev/null || true; \
    source {{backend_dir}}/.env.smoke-test 2>/dev/null || true; \
    source {{backend_dir}}/.env.smoke-test.local 2>/dev/null || true; \
    set +a; \
    export OMOIOS_API_BASE_URL="http://localhost:{{api_port}}"; \
    : "${FIREWORKS_API_KEY:=${LLM_FIREWORKS_API_KEY:-}}"; export FIREWORKS_API_KEY; \
    cd {{backend_dir}} && uv run --with-editable ../sdk/python python ../scripts/stream_demo.py {{ARGS}}

# Same as stream-demo but clears cached poof state first so workspace,
# environment, and session are all freshly created.
stream-demo-fresh *ARGS:
    @rm -rf .sisyphus/poof-state .sisyphus/poof.state.json 2>/dev/null || true
    @just stream-demo {{ARGS}}

# Re-attach the TUI to the most recently bootstrapped session
# (whatever stream-demo cached in .sisyphus/poof-state/stream_demo.json).
stream-reconnect:
    @SID=$(jq -r .session_id .sisyphus/poof-state/stream_demo.json 2>/dev/null); \
    if [ -z "$SID" ] || [ "$SID" = "null" ]; then \
      echo "  ✗ no cached session — run 'just stream-demo' first"; exit 1; \
    fi; \
    set -a; \
    source {{backend_dir}}/.env 2>/dev/null || true; \
    source {{backend_dir}}/.env.local 2>/dev/null || true; \
    source {{backend_dir}}/.env.smoke-test 2>/dev/null || true; \
    source {{backend_dir}}/.env.smoke-test.local 2>/dev/null || true; \
    set +a; \
    export OMOIOS_API_BASE_URL="http://localhost:{{api_port}}"; \
    : "${FIREWORKS_API_KEY:=${LLM_FIREWORKS_API_KEY:-}}"; export FIREWORKS_API_KEY; \
    cd {{backend_dir}} && uv run --with-editable ../sdk/python omoios sessions connect $SID