cc2.sh

#!/usr/bin/env bash
# code-context-v2 CLI wrapper
# Usage: cc2 [command] [options]
#
# Commands:
#   (none)          Interactive menu (requires gum)
#   list, -l        List all indexed projects
#   stats, -s       Show global statistics
#   index, -i       Index a project (requires path)
#   sync            Sync project (reindex only changed files)
#   check           Check if project needs syncing (dry-run)
#   delete, -d      Delete a project (requires id)
#   watch, -w       Start watcher for a project
#   watch-all       Start global watcher (all projects, single process)
#   watchers        List active watchers
#   sync-all        Sync all indexed projects
#   stop            Stop watcher for a project
#   stop-all        Stop all watchers
#   stop-global     Stop the global watcher
#   search          Semantic search across project codebase
#   search-file     Search within a specific file
#   search-lit      Search indexed literature (books)
#   memory          Memory root init/index/search
#   analyze         Analyze search quality logs (JSONL)
#   benchmark       Run retrieval benchmark for a project
#
# Examples:
#   cc2                                    # Interactive menu
#   cc2 list                               # List projects
#   cc2 index ~/projects/myapp             # Index with auto-id
#   cc2 index ~/projects/myapp -id myapp   # Index with custom id
#   cc2 search "auth middleware" -p myapp   # Semantic codebase search
#   cc2 search-file src/auth.ts "q" -p app # Search within a file
#   cc2 search-lit "dependency injection"   # Search literature
#   cc2 memory init                       # Create .pi/memory/MEMORY.md
#   cc2 memory index .pi/memory -p myapp  # Index project memory
#   cc2 memory search "auth flow" -p myapp # Search memory
#   cc2 check myapp                        # Check if needs syncing
#   cc2 sync myapp                         # Sync project (only changes)
#   cc2 delete myapp                       # Delete project
#   cc2 watch ~/projects/myapp             # Start watcher

set -euo pipefail

BASE_DIR="${HOME}/.claude/mcp-servers/code-context-v2"
VENV_PYTHON="${BASE_DIR}/.venv/bin/python"

# Colors
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
PURPLE='\033[0;35m'
NC='\033[0m' # No Color

print_success() { echo -e "${GREEN}✓${NC} $1"; }
print_error() { echo -e "${RED}✗${NC} $1"; }
print_info() { echo -e "${BLUE}→${NC} $1"; }
print_warn() { echo -e "${YELLOW}⚠${NC} $1"; }

check_deps() {
    if [[ ! -f "${VENV_PYTHON}" ]]; then
        print_error "Python venv not found at ${VENV_PYTHON}"
        print_info "Run: cd ${BASE_DIR} && uv venv && uv pip install -e ."
        exit 1
    fi
}

run_cli() {
    local caller_cwd="$PWD"
    cd "${BASE_DIR}"
    CC2_CALLER_CWD="${caller_cwd}" "${VENV_PYTHON}" -m cli.manage "$@"
}

run_memory_cli() {
    local caller_cwd="$PWD"
    cd "${BASE_DIR}"
    CC2_CALLER_CWD="${caller_cwd}" "${VENV_PYTHON}" -m cli.memory "$@"
}

show_help() {
    echo -e "${PURPLE}code-context-v2 CLI${NC}"
    echo ""
    echo "Usage: cc2 [command] [options]"
    echo ""
    echo "Commands:"
    echo "  (none)              Interactive menu (requires gum)"
    echo "  list, -l            List all indexed projects"
    echo "  stats, -s           Show global statistics"
    echo "  books               List indexed books"
    echo "  search QUERY -p ID  Semantic codebase search"
    echo "  search-file FILE QUERY -p ID  Search within a file"
    echo "  search-lit QUERY    Search indexed literature"
    echo "  memory ...          Memory init/index/search"
    echo "  index PATH [-id ID] Index a project"
    echo "  sync ID             Sync project (reindex only changed files)"
    echo "  sync-all            Sync all indexed projects"
    echo "  check ID            Check sync status (dry-run, no changes)"
    echo "  delete ID           Delete a project by ID"
    echo "  watch PATH          Start background watcher (single project)"
    echo "  watch-all           Start global watcher (all projects)"
    echo "  watchers            List active watchers"
    echo "  stop PATH           Stop watcher for project"
    echo "  stop-all            Stop all watchers"
    echo "  stop-global         Stop the global watcher"
    echo ""
    echo "Examples:"
    echo "  cc2                                  # Interactive menu"
    echo "  cc2 list                             # List projects"
    echo "  cc2 search 'auth middleware' -p app  # Semantic search"
    echo "  cc2 search 'auth' -p app --intent usage  # With intent"
    echo "  cc2 search-file src/auth.ts 'mid' -p app # File-scoped"
    echo "  cc2 search-lit 'dependency injection'     # Literature search"
    echo "  cc2 search-lit 'DI' --book clean-code     # Scoped to book"
    echo "  cc2 memory init                      # Create .pi/memory/MEMORY.md"
    echo "  cc2 memory index .pi/memory -p app   # Index memory root"
    echo "  cc2 memory search 'auth flow' -p app # Search memory"
    echo "  cc2 index ~/myproject                # Index (id = folder name)"
    echo "  cc2 index ~/myproject -id my-proj    # Index with custom id"
    echo "  cc2 check my-proj                    # Check if needs syncing"
    echo "  cc2 sync my-proj                     # Sync (only changed files)"
    echo "  cc2 sync-all                         # Sync all projects"
    echo "  cc2 delete my-proj                   # Delete project"
    echo "  cc2 watch ~/myproject                # Start watcher (single project)"
    echo "  cc2 watch-all                        # Start global watcher"
    echo "  cc2 analyze [--last N] [--since DATE] # Analyze search quality logs"
    echo "  cc2 benchmark PROJECT                # Run retrieval benchmark"
    echo "  cc2 benchmark PROJECT --save v1      # Save baseline"
    echo "  cc2 benchmark PROJECT --compare v1   # Compare vs baseline"
    echo ""
    echo "Pipeline: voyage-4-large (index) → voyage-4-lite (query) → rerank-2.5"
}

show_memory_help() {
    echo -e "${PURPLE}cc2 memory${NC}"
    echo ""
    echo "Usage: cc2 memory <init|index|search> [options]"
    echo ""
    echo "Commands:"
    echo "  init [PATH]         Create a memory root with MEMORY.md (default: .pi/memory)"
    echo "  index [PATH]        Index a memory root (default: .pi/memory)"
    echo "  search QUERY        Search indexed memory (auto-scopes to nearest .pi/memory)"
    echo ""
    echo "Examples:"
    echo "  cc2 memory init"
    echo "  cc2 memory init .pi/memory --title 'Courtex'"
    echo "  cc2 memory index .pi/memory --project courtex"
    echo "  cc2 memory search 'refresh token rotation' --project courtex"
    echo "  # If no --root is passed, search uses the nearest .pi/memory above cwd"
    echo "  cc2 memory search 'oauth cookies' --project courtex --tags auth,security"
}

cmd_list() {
    run_cli --list
}

cmd_stats() {
    run_cli --stats
}

cmd_index() {
    local path=""
    local project_id=""
    local force=""

    while [[ $# -gt 0 ]]; do
        case "$1" in
            -id|--id)
                project_id="$2"
                shift 2
                ;;
            -f|--force)
                force="--force"
                shift
                ;;
            *)
                if [[ -z "${path}" ]]; then
                    path="$1"
                fi
                shift
                ;;
        esac
    done

    if [[ -z "${path}" ]]; then
        print_error "Path required. Usage: cc2 index PATH [-id ID]"
        exit 1
    fi

    # Expand path
    path=$(realpath -m "${path/#\~/$HOME}")

    if [[ ! -d "${path}" ]]; then
        print_error "Not a directory: ${path}"
        exit 1
    fi

    local args=(--index "${path}")
    [[ -n "${project_id}" ]] && args+=(--id "${project_id}")
    [[ -n "${force}" ]] && args+=(--force)

    run_cli "${args[@]}"
}

cmd_sync() {
    local project_id="$1"

    if [[ -z "${project_id}" ]]; then
        print_error "Project ID required. Usage: cc2 sync ID"
        print_info "Use 'cc2 list' to see available projects"
        exit 1
    fi

    run_cli --sync "${project_id}"
}

cmd_sync_all() {
    run_cli --sync-all
}

cmd_check() {
    local project_id="$1"

    if [[ -z "${project_id}" ]]; then
        print_error "Project ID required. Usage: cc2 check ID"
        print_info "Use 'cc2 list' to see available projects"
        exit 1
    fi

    run_cli --check "${project_id}"
}

cmd_delete() {
    local project_id="$1"

    if [[ -z "${project_id}" ]]; then
        print_error "Project ID required. Usage: cc2 delete ID"
        exit 1
    fi

    run_cli --delete "${project_id}"
}

cmd_watch() {
    local path="$1"

    if [[ -z "${path}" ]]; then
        print_error "Path required. Usage: cc2 watch PATH"
        exit 1
    fi

    path=$(realpath -m "${path/#\~/$HOME}")
    run_cli --watch "${path}"
}

cmd_watchers() {
    run_cli --watchers
}

cmd_stop() {
    local path="$1"

    if [[ -z "${path}" ]]; then
        print_error "Path required. Usage: cc2 stop PATH"
        exit 1
    fi

    path=$(realpath -m "${path/#\~/$HOME}")
    run_cli --stop-watcher "${path}"
}

cmd_stop_all() {
    run_cli --stop-all-watchers
}

cmd_watch_all() {
    run_cli --watch-all
}

cmd_stop_global() {
    run_cli --stop-global
}

cmd_search() {
    local query=""
    local args=()

    # First positional arg is the query
    if [[ $# -gt 0 && ! "$1" =~ ^- ]]; then
        query="$1"
        shift
    fi

    if [[ -z "${query}" ]]; then
        print_error "Query required. Usage: cc2 search 'query' -p PROJECT [--intent TYPE] [--json]"
        exit 1
    fi

    args=(--search "${query}")

    while [[ $# -gt 0 ]]; do
        case "$1" in
            -p|--project) args+=(--project "$2"); shift 2 ;;
            --intent) args+=(--intent "$2"); shift 2 ;;
            --file-type) args+=(--file-type "$2"); shift 2 ;;
            --dir|--directory) args+=(--directory "$2"); shift 2 ;;
            --scope) args+=(--scope "$2"); shift 2 ;;
            --language) args+=(--language "$2"); shift 2 ;;
            --chunk-type) args+=(--chunk-type "$2"); shift 2 ;;
            --max-tokens) args+=(--max-tokens "$2"); shift 2 ;;
            --include-tests) args+=(--include-tests); shift ;;
            --json) args+=(--json); shift ;;
            *) shift ;;
        esac
    done

    run_cli "${args[@]}"
}

cmd_search_file() {
    local filepath=""
    local query=""
    local args=()

    # First two positional args: filepath, query
    if [[ $# -gt 0 && ! "$1" =~ ^- ]]; then
        filepath="$1"
        shift
    fi
    if [[ $# -gt 0 && ! "$1" =~ ^- ]]; then
        query="$1"
        shift
    fi

    if [[ -z "${filepath}" || -z "${query}" ]]; then
        print_error "Usage: cc2 search-file FILEPATH 'query' -p PROJECT [--intent TYPE] [--json]"
        exit 1
    fi

    args=(--search-file "${filepath}" --query "${query}")

    while [[ $# -gt 0 ]]; do
        case "$1" in
            -p|--project) args+=(--project "$2"); shift 2 ;;
            --intent) args+=(--intent "$2"); shift 2 ;;
            --max-tokens) args+=(--max-tokens "$2"); shift 2 ;;
            --include-tests) args+=(--include-tests); shift ;;
            --json) args+=(--json); shift ;;
            *) shift ;;
        esac
    done

    run_cli "${args[@]}"
}

cmd_search_lit() {
    local query=""
    local args=()

    if [[ $# -gt 0 && ! "$1" =~ ^- ]]; then
        query="$1"
        shift
    fi

    if [[ -z "${query}" ]]; then
        print_error "Query required. Usage: cc2 search-lit 'query' [--book ID] [--top-k N] [--json]"
        exit 1
    fi

    args=(--search-lit "${query}")

    while [[ $# -gt 0 ]]; do
        case "$1" in
            --book) args+=(--book "$2"); shift 2 ;;
            --top-k) args+=(--top-k "$2"); shift 2 ;;
            --json) args+=(--json); shift ;;
            *) shift ;;
        esac
    done

    run_cli "${args[@]}"
}

cmd_memory() {
    local subcmd="${1:-help}"
    shift || true

    case "${subcmd}" in
        help|--help|-h)
            show_memory_help
            ;;
        init)
            local path=".pi/memory"
            local title=""
            local force=""

            if [[ $# -gt 0 && ! "$1" =~ ^- ]]; then
                path="$1"
                shift
            fi

            while [[ $# -gt 0 ]]; do
                case "$1" in
                    --title)
                        title="$2"
                        shift 2
                        ;;
                    -f|--force)
                        force="--force"
                        shift
                        ;;
                    *)
                        shift
                        ;;
                esac
            done

            path=$(realpath -m "${path/#\~/$HOME}")
            local args=(init "${path}")
            [[ -n "${title}" ]] && args+=(--title "${title}")
            [[ -n "${force}" ]] && args+=(--force)
            run_memory_cli "${args[@]}"
            ;;
        index)
            local path=".pi/memory"
            local project=""
            local scope=""
            local force=""

            if [[ $# -gt 0 && ! "$1" =~ ^- ]]; then
                path="$1"
                shift
            fi

            while [[ $# -gt 0 ]]; do
                case "$1" in
                    -p|--project)
                        project="$2"
                        shift 2
                        ;;
                    --scope)
                        scope="$2"
                        shift 2
                        ;;
                    -f|--force)
                        force="--force"
                        shift
                        ;;
                    *)
                        shift
                        ;;
                esac
            done

            path=$(realpath -m "${path/#\~/$HOME}")
            local args=(index "${path}")
            [[ -n "${project}" ]] && args+=(--project "${project}")
            [[ -n "${scope}" ]] && args+=(--scope "${scope}")
            [[ -n "${force}" ]] && args+=(--force)
            run_memory_cli "${args[@]}"
            ;;
        search)
            local query=""
            local project=""
            local root=""
            local scope=""
            local tags=""
            local limit=""
            local json_output=""

            if [[ $# -gt 0 && ! "$1" =~ ^- ]]; then
                query="$1"
                shift
            fi

            if [[ -z "${query}" ]]; then
                print_error "Query required. Usage: cc2 memory search 'query' [--project ID]"
                exit 1
            fi

            while [[ $# -gt 0 ]]; do
                case "$1" in
                    -p|--project)
                        project="$2"
                        shift 2
                        ;;
                    --root)
                        root="$2"
                        shift 2
                        ;;
                    --scope)
                        scope="$2"
                        shift 2
                        ;;
                    --tags)
                        tags="$2"
                        shift 2
                        ;;
                    --limit)
                        limit="$2"
                        shift 2
                        ;;
                    --json)
                        json_output="--json"
                        shift
                        ;;
                    *)
                        shift
                        ;;
                esac
            done

            local args=(search "${query}")
            [[ -n "${project}" ]] && args+=(--project "${project}")
            if [[ -n "${root}" ]]; then
                root=$(realpath -m "${root/#\~/$HOME}")
                args+=(--root "${root}")
            fi
            [[ -n "${scope}" ]] && args+=(--scope "${scope}")
            [[ -n "${tags}" ]] && args+=(--tags "${tags}")
            [[ -n "${limit}" ]] && args+=(--limit "${limit}")
            [[ -n "${json_output}" ]] && args+=(--json)
            run_memory_cli "${args[@]}"
            ;;
        *)
            print_error "Unknown memory command: ${subcmd}"
            echo ""
            show_memory_help
            exit 1
            ;;
    esac
}

cmd_analyze() {
    run_cli --analyze "$@"
}

cmd_benchmark() {
    local project_id="${1:-}"
    shift 2>/dev/null || true
    local args=()

    if [[ -z "${project_id}" ]]; then
        print_error "Project ID required. Usage: cc2 benchmark PROJECT [--save NAME] [--compare NAME]"
        exit 1
    fi

    args+=(--benchmark "${project_id}")

    while [[ $# -gt 0 ]]; do
        case "$1" in
            --save)
                args+=(--save-baseline "$2")
                shift 2
                ;;
            --compare)
                args+=(--compare-baseline "$2")
                shift 2
                ;;
            *)
                shift
                ;;
        esac
    done

    run_cli "${args[@]}"
}

cmd_interactive() {
    if ! command -v gum >/dev/null 2>&1; then
        print_warn "gum not installed. Using text mode."
        print_info "Install gum for better experience: brew install gum"
    fi
    run_cli
}

main() {
    check_deps

    if [[ $# -eq 0 ]]; then
        cmd_interactive
        exit 0
    fi

    local cmd="$1"
    shift

    case "${cmd}" in
        help|--help|-h)
            show_help
            ;;
        list|--list|-l)
            cmd_list
            ;;
        stats|--stats|-s)
            cmd_stats
            ;;
        books)
            run_cli --list-books
            ;;
        search)
            cmd_search "$@"
            ;;
        search-file)
            cmd_search_file "$@"
            ;;
        search-lit)
            cmd_search_lit "$@"
            ;;
        memory)
            cmd_memory "$@"
            ;;
        index|--index|-i)
            cmd_index "$@"
            ;;
        sync-all|--sync-all)
            cmd_sync_all
            ;;
        sync|--sync)
            cmd_sync "${1:-}"
            ;;
        check|--check)
            cmd_check "${1:-}"
            ;;
        delete|--delete|-d)
            cmd_delete "${1:-}"
            ;;
        watch-all|--watch-all)
            cmd_watch_all
            ;;
        watch|--watch|-w)
            cmd_watch "${1:-}"
            ;;
        watchers|--watchers)
            cmd_watchers
            ;;
        stop|--stop)
            cmd_stop "${1:-}"
            ;;
        stop-all|--stop-all)
            cmd_stop_all
            ;;
        stop-global|--stop-global)
            cmd_stop_global
            ;;
        analyze|--analyze)
            cmd_analyze "$@"
            ;;
        benchmark|--benchmark)
            cmd_benchmark "$@"
            ;;
        *)
            print_error "Unknown command: ${cmd}"
            echo ""
            show_help
            exit 1
            ;;
    esac
}

main "$@"