"""

Cyclops v2 - orchestrator loop.

Ties the pillars into one queue-driven loop:

    feed (fresh targets) -> brain (dataflow hypotheses) -> oracle (execution

    proof) -> memory gate (finding only with proof) -> vault projection.

This is intentionally THIN. The intelligence lives in the brain queries, the

oracle harnesses, and the severity gate - not in a 164-tool buffet. The loop's

job is sequencing, caching, and refusing to skip the proof step.

Run modes:

    orchestrator.py feed

    orchestrator.py drain-targets

    orchestrator.py drain-oracle

    orchestrator.py status

"""

import os, sys, subprocess, json

sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "memory"))

sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "brain"))

from memory import Memory

CYCLOPS_HOME = os.environ.get("CYCLOPS_HOME", "/opt/cyclops-v2")

PY = os.environ.get("CYCLOPS_PY", "/opt/cyclops-venv/bin/python")

SRC_CACHE = os.path.join(CYCLOPS_HOME, "targets", "src")

def _checkout(repo, tag):

    """Shallow-clone a target at a tag into the src cache. Returns local path."""

    os.makedirs(SRC_CACHE, exist_ok=True)

    name = repo.replace("github.com/", "").replace("/", "__")

    dest = os.path.join(SRC_CACHE, name)

    url = "https://" + repo + ".git"

    if not os.path.isdir(dest):

        subprocess.run(["git", "clone", "--quiet", "--depth", "1",

                        "--branch", tag, url, dest],

                       capture_output=True, text=True)

    if not os.path.isdir(dest):

        subprocess.run(["git", "clone", "--quiet", url, dest], capture_output=True)

        subprocess.run(["git", "-C", dest, "checkout", "-q", tag], capture_output=True)

    return dest

def cmd_feed():

    subprocess.run([PY, os.path.join(CYCLOPS_HOME, "orchestrator", "feed.py")])

def cmd_drain_targets(limit=20):

    m = Memory()

    n = 0

    while n < limit:

        job = m.dequeue("targets", timeout=2)

        if not job:

            break

        repo, arch, tag = job["repo"], job["archetype"], job.get("tag", "HEAD")

        print(f"[orch] target {repo}@{tag} [{arch}]")

        src = _checkout(repo, tag)

        if not os.path.isdir(src):

            print(f"[orch] checkout failed: {repo}@{tag}")

            continue

        lang = _guess_lang(src)

        subprocess.run([PY, os.path.join(CYCLOPS_HOME, "brain", "brain.py"),

                        repo, arch, src, lang, tag])

        n += 1

    print(f"[orch] drained {n} targets")

def cmd_drain_oracle(limit=20):

    """Pull brain's oracle jobs. For memory-corruption hypotheses on C targets we

    can auto-fuzz; other sink classes are queued for a harness author (logged)."""

    m = Memory()

    n = 0

    while n < limit:

        job = m.dequeue("oracle", timeout=2)

        if not job:

            break

        hyps = job.get("hypotheses", [])

        mem = [h for h in hyps if h["sink_class"] == "memory-corruption"]

        print(f"[orch] oracle job {job['repo']}: {len(hyps)} hyps "

              f"({len(mem)} auto-fuzzable memory-corruption)")

        for h in mem:

            m.enqueue("harness_author", {"target": job["target"], "repo": job["repo"],

                                         "src": job["src"], "hyp": h})

        for h in hyps:

            if h["sink_class"] != "memory-corruption":

                m.enqueue("detonation", {"target": job["target"], "repo": job["repo"],

                                         "src": job["src"], "hyp": h})

        n += 1

    print(f"[orch] routed {n} oracle jobs (harness_author + detonation queues)")

def cmd_status():

    m = Memory()

    print("=== GRAPH ===")

    for k, v in m.stats().items():

        print(f"  {k}: {v}")

    print("=== QUEUES ===")

    for q in ("targets", "oracle", "harness_author", "detonation"):

        print(f"  {q}: {m.r.llen('cyclops:q:'+q)}")

    print("=== FINDINGS (gated) ===")

    res = m._exec("""MATCH (f:Finding) RETURN f.severity, f.impact_family, f.title

                     ORDER BY f.severity""")

    while res.has_next():

        r = res.get_next()

        print(f"  [{r[0]}] {r[1]} :: {r[2]}")

def _guess_lang(src):

    import collections

    ext = collections.Counter()

    for root, _, files in os.walk(src):

        if "/.git" in root:

            continue

        for f in files:

            e = f.rsplit(".", 1)[-1].lower() if "." in f else ""

            if e in ("c", "h", "cc", "cpp", "cxx"): ext["c"] += 1

            elif e in ("py",): ext["python"] += 1

            elif e in ("js", "ts", "jsx", "tsx"): ext["javascript"] += 1

            elif e in ("java",): ext["java"] += 1

            elif e in ("go",): ext["go"] += 1

    return ext.most_common(1)[0][0] if ext else ""

if __name__ == "__main__":

    cmd = sys.argv[1] if len(sys.argv) > 1 else "status"

    {"feed": cmd_feed, "drain-targets": cmd_drain_targets,

     "drain-oracle": cmd_drain_oracle, "status": cmd_status}.get(cmd, cmd_status)()