darkplex-core/cortex/cli.py

#!/usr/bin/env python3
"""Cortex CLI — unified entry point for all intelligence modules.

Usage:
    cortex init [--enable-all] [--non-interactive]
    cortex schedule list|status|enable|disable|logs <job>
    cortex triage score "task description"
    cortex health [--json]
    cortex feedback --since 6h [--dry-run]
    cortex hygiene stats|stale|duplicates|orphans|archive
    cortex roadmap list|add|update|overdue|upcoming|report
    cortex validate --transcript <path> --task "description"
    cortex search "query" [--memory-dir ~/.cortex/memory]
    cortex handoff --from <session> --to <agent> --task "description"
    cortex learn --since 24h [--nats url] [--jsonl file]
    cortex context [--events 2000] [--output file]
    cortex track scan|list|done|check
    cortex sentinel scan|matches|report|stats
    cortex needs [--json] [--quiet]
    cortex alert [--json] [--quiet]
    cortex summarize [--date YYYY-MM-DD] [--dry-run]
    cortex anomaly [--hours N] [--json]
    cortex predict [--learn] [--patterns]
    cortex monitor [--json]
    cortex memory bootstrap [--dry-run] [--max-tokens N]
    cortex memory snapshot [--dry-run]
    cortex memory threads [--summary] [--hours N]
    cortex version
"""

import sys


def main():
    if len(sys.argv) < 2:
        print(__doc__.strip())
        sys.exit(1)

    cmd = sys.argv[1]
    # Strip the command from argv so sub-modules see clean args
    sys.argv = [f"cortex {cmd}"] + sys.argv[2:]

    if cmd == "init":
        from cortex.init import main as init_main
        init_main()

    elif cmd == "schedule":
        from cortex.scheduler import main as schedule_main
        schedule_main()

    elif cmd == "version":
        from cortex import __version__
        print(f"cortex {__version__}")

    elif cmd == "triage":
        from cortex.triage import main as triage_main
        triage_main()

    elif cmd == "health":
        from cortex.health_scanner import main as health_main
        health_main()

    elif cmd == "feedback":
        from cortex.feedback_loop import main as feedback_main
        feedback_main()

    elif cmd == "hygiene":
        from cortex.memory_hygiene import main as hygiene_main
        hygiene_main()

    elif cmd == "roadmap":
        from cortex.roadmap import main as roadmap_main
        roadmap_main()

    elif cmd == "validate":
        from cortex.validate_output import main as validate_main
        validate_main()

    elif cmd == "search":
        from cortex.enhanced_search import main as search_main
        search_main()

    elif cmd == "handoff":
        from cortex.auto_handoff import main as handoff_main
        handoff_main()

    elif cmd == "learn":
        from cortex.learn import main as learn_main
        learn_main()

    elif cmd == "context":
        from cortex.context import main as context_main
        context_main()

    elif cmd == "track":
        from cortex.tracker import main as tracker_main
        tracker_main()

    elif cmd == "sentinel":
        from cortex.sentinel import main as sentinel_main
        sentinel_main()

    elif cmd == "needs":
        from cortex.needs import main as needs_main
        needs_main()

    elif cmd == "alert":
        from cortex.alert import main as alert_main
        alert_main()

    elif cmd == "summarize":
        from cortex.summarize import main as summarize_main
        summarize_main()

    elif cmd == "anomaly":
        from cortex.anomaly import main as anomaly_main
        anomaly_main()

    elif cmd == "predict":
        from cortex.predict import main as predict_main
        predict_main()

    elif cmd == "monitor":
        from cortex.monitor import main as monitor_main
        monitor_main()

    elif cmd == "memory":
        if len(sys.argv) < 2:
            print("Usage: cortex memory bootstrap|snapshot|threads [options]")
            sys.exit(1)
        subcmd = sys.argv[1] if len(sys.argv) > 1 else ""
        sys.argv = [f"cortex memory {subcmd}"] + sys.argv[2:]
        if subcmd == "bootstrap":
            from cortex.memory.boot_assembler import main as boot_main
            boot_main()
        elif subcmd == "snapshot":
            from cortex.memory.pre_compaction import main as snap_main
            snap_main()
        elif subcmd == "threads":
            # Default to --show mode for display
            if "--hours" not in sys.argv and "--dry-run" not in sys.argv:
                sys.argv.append("--show")
            from cortex.memory.thread_tracker import main as thread_main
            thread_main()
        else:
            print(f"Unknown memory subcommand: {subcmd}")
            print("Available: bootstrap, snapshot, threads")
            sys.exit(1)

    elif cmd in ("-h", "--help", "help"):
        print(__doc__.strip())

    else:
        print(f"Unknown command: {cmd}")
        print(__doc__.strip())
        sys.exit(1)


if __name__ == "__main__":
    main()