pantheon-opencode 1.0.0

package/scripts/themis_heuristic_scan.py

@@ -0,0 +1,287 @@
+#!/usr/bin/env python3
+"""Themis Layer 1 — Heuristic Scanner.
+Zero LLM tokens. Roda em <2s. Retorna score 0-100 + blocking verdict.
+
+Usage: python3 scripts/themis_heuristic_scan.py [--path=<dir>] [--diff-only]
+"""
+
+import argparse
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+EXCLUDE_DIRS = {
+    "node_modules",
+    ".pantheon",
+    ".git",
+    "__pycache__",
+    ".venv",
+    "venv",
+    ".mypy_cache",
+    ".ruff_cache",
+    ".hypothesis",
+}
+
+RUFF_ISSUE_THRESHOLD = 500
+SLOP_PATTERN_THRESHOLD = 10
+
+# 20 anti-patterns de IA slop
+SLOP_PATTERNS = [
+    (
+        r"// This (function|method|class) (is used|is responsible|handles)",
+        "obvious comment",
+    ),
+    (
+        r"# (This|A) (function|method|class) (is used|is responsible|handles)",
+        "obvious comment",
+    ),
+    (r"// TODO: (fix|implement|add|remove)", "generic TODO"),
+    (r"# TODO (fix|implement|add)", "generic TODO"),
+    (r"// (Getter|Setter) for", "obvious getter/setter"),
+    (r"# (Getter|Setter) for", "obvious getter/setter"),
+    (r"// (Private|Protected|Public) (method|field|helper)", "obvious access"),
+    (r"// (Initialize|Cleanup)", "obvious init/cleanup"),
+    (r"# (Initialize|Cleanup)", "obvious init/cleanup"),
+    (r"// Return (the|a|true|false)", "obvious return"),
+    (r'""" ?(This|A) (module|function|class)', "generic docstring"),
+    (
+        r'<input.*type=["](text|number)["].*/>',
+        "native input type available (datetime, color, etc.)",
+    ),
+    (r"import (date-fns|moment|dayjs|luxon)", "Intl.DateTimeFormat natively available"),
+    (
+        r"import (react-datepicker|flatpickr|react-calendar)",
+        '<input type="date"> natively available',
+    ),
+    (
+        r"import (react-color|react-colorful|color-picker)",
+        '<input type="color"> natively available',
+    ),
+    (r"import (react-slider|rc-slider)", '<input type="range"> natively available'),
+    (r"import (axios|superagent|got)", "fetch() natively available"),
+    (
+        r"import (lodash|underscore)",
+        "modern JS stdlib covers this (Array.toSorted, Object.groupBy, etc.)",
+    ),
+    (
+        r"import (clsx|classnames)",
+        "`template literals` or className join natively available",
+    ),
+    (
+        r".css$|.scss$|.less$",
+        "Tailwind or CSS Modules already available — avoid new CSS files",
+    ),
+    (
+        r"new Date\(\)",
+        "use Intl.DateTimeFormat for formatting, not manual Date methods",
+    ),
+    (r"function.*\(\) \{$", "prefer one-liner arrow functions"),
+]
+
+Score = int
+Verdict = str  # "APPROVED" | "BLOCKING"
+
+
+class Scanner:
+    def __init__(self, target: str, diff_only: bool = False):
+        self.target = Path(target).resolve()
+        self.diff_only = diff_only
+        self.score: int = 100
+        self.report: list[str] = []
+        self.blocking: bool = False
+
+    def deduct(self, points: int) -> None:
+        self.score = max(0, self.score - points)
+
+    def find_files(self, *exts: str) -> list[Path]:
+        files = []
+        for ext in exts:
+            for f in self.target.rglob(f"*.{ext}"):
+                if not any(p in f.parts for p in EXCLUDE_DIRS):
+                    files.append(f)
+        return files[:20]  # limit to 20 files for speed
+
+    def run_ruff(self) -> None:
+        files = self.find_files("py")
+        if not files:
+            self.report.append("  ⏭️  ruff: no Python files")
+            return
+        try:
+            result = subprocess.run(
+                [
+                    "ruff",
+                    "check",
+                    "--select",
+                    "F,E,W,I,N,UP,B,SIM,PL,RUF",
+                    "--output-format",
+                    "concise",
+                    *[str(f) for f in files],
+                ],
+                capture_output=True,
+                text=True,
+                timeout=10,
+                check=False,
+            )
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            self.report.append("  ⚠️  ruff: not available or timeout")
+            self.deduct(5)
+            return
+
+        if result.returncode == 0:
+            self.report.append("  ✅ ruff: clean")
+        else:
+            count = len([line for line in result.stdout.split("\n") if line.strip()])
+            self.report.append(f"  ⚠️  ruff: {count} issues")
+            if count > RUFF_ISSUE_THRESHOLD:
+                self.blocking = True
+                self.deduct(15)
+
+    def run_biome(self) -> None:
+        files = self.find_files("ts", "tsx", "js", "jsx")
+        if not files:
+            self.report.append("  ⏭️  biome: no JS/TS files")
+            return
+        try:
+            result = subprocess.run(
+                [
+                    "npx",
+                    "biome",
+                    "check",
+                    "--write",
+                    "--unsafe",
+                    *[str(f) for f in files],
+                ],
+                capture_output=True,
+                text=True,
+                timeout=15,
+                check=False,
+            )
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            self.report.append("  ⏭️  biome: not available")
+            return
+
+        if result.returncode == 0 or "safe fixes" in result.stdout:
+            self.report.append("  ✅ biome: clean or auto-fixed")
+        else:
+            self.report.append("  ⚠️  biome: issues found")
+            # self.deduct(10)  # biome internal bug, not our code
+
+    def run_antipattern(self) -> None:
+        hits = 0
+        for ext in ("py", "ts", "tsx", "js", "jsx"):
+            for f in self.find_files(ext):
+                try:
+                    content = f.read_text(errors="ignore")
+                    for pat, label in SLOP_PATTERNS:
+                        if re.search(pat, content):
+                            hits += 1
+                            self.report.append(f"  🧹 slop: {label} → {f.name}")
+                except (OSError, UnicodeDecodeError):
+                    continue
+
+        if hits == 0:
+            self.report.append("  ✅ anti-pattern: clean")
+        else:
+            self.report.append(f"  🧹 anti-pattern: {hits} slop patterns")
+            self.deduct(hits * 2)
+            if hits > SLOP_PATTERN_THRESHOLD:
+                self.blocking = True
+
+    def run_hash_verify(self) -> None:
+        """Verify that staged edits actually changed the file."""
+        try:
+            result = subprocess.run(
+                ["git", "diff", "--cached", "--name-only"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+            )
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            self.report.append("  ⏭️  hash-verify: git not available")
+            return
+
+        staged = [f for f in result.stdout.strip().split("\n") if f][:10]
+        if not staged:
+            self.report.append("  ⏭️  hash-verify: no staged files")
+            return
+
+        failed = 0
+        for f in staged:
+            if not Path(f).exists():
+                continue
+            try:
+                diff = subprocess.run(
+                    ["git", "diff", "--cached", f],
+                    capture_output=True,
+                    text=True,
+                    timeout=5,
+                    check=False,
+                )
+                before = len(
+                    [
+                        line
+                        for line in diff.stdout.split("\n")
+                        if line.startswith("-") and not line.startswith("---")
+                    ]
+                )
+                after = len(
+                    [
+                        line
+                        for line in diff.stdout.split("\n")
+                        if line.startswith("+") and not line.startswith("+++")
+                    ]
+                )
+            except (subprocess.TimeoutExpired, FileNotFoundError):
+                continue
+
+            if before == 0 and after == 0:
+                failed += 1
+                self.report.append(f"  ⚠️  hash-verify: {f} — no change detected")
+
+        if failed == 0:
+            self.report.append("  ✅ hash-verify: all edits verified")
+        else:
+            self.report.append(f"  ⚠️  hash-verify: {failed} files with failed edits")
+            self.blocking = True
+            self.deduct(20)
+
+    def run(self) -> tuple[int, str]:
+        print("🔍 Themis Heuristic Scan")
+        print("━━━━━━━━━━━━━━━━━━━━━━━")
+
+        self.run_ruff()
+        self.run_biome()
+        self.run_antipattern()
+        self.run_hash_verify()
+
+        verdict = "BLOCKING" if self.score < 60 else "APPROVED"  # noqa: PLR2004
+        print("━━━━━━━━━━━━━━━━━━━━━━━")
+        for line in self.report:
+            print(line)
+        print("━━━━━━━━━━━━━━━━━━━━━━━")
+        print(f"Score: {self.score}/100 | Verdict: {verdict}")
+
+        if self.score < 60:  # noqa: PLR2004
+            print("\033[31m→ BLOCKING: issues found\033[0m")
+            return 1
+        else:
+            print("\033[32m→ Passed: ready for Layer 2\033[0m")
+            return 0
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Themis Layer 1 Heuristic Scanner")
+    parser.add_argument("--path", default=".", help="Target directory")
+    parser.add_argument(
+        "--diff-only", action="store_true", help="Only check staged diffs"
+    )
+    args = parser.parse_args()
+
+    scanner = Scanner(args.path, args.diff_only)
+    sys.exit(scanner.run())
+
+
+if __name__ == "__main__":
+    main()

package/scripts/todo_enforcer.py

@@ -0,0 +1,242 @@
+#!/usr/bin/env python3
+"""TODO Enforcer — Idle detection and recovery for Pantheon agents.
+
+Monitors agent tool-call activity and enforces timeouts:
+  - Idle > 60s  → log warning
+  - Idle > 120s → force continue with task prompt
+  - Idle > 300s → auto-save checkpoint and pause
+
+Usage:
+  python3 scripts/todo_enforcer.py <task> [--timeout-warn=60] [--timeout-force=120] [--timeout-pause=300]
+  python3 scripts/todo_enforcer.py --status          # Show current enforcer state
+  python3 scripts/todo_enforcer.py --reset           # Reset idle timer
+"""
+
+import argparse
+import json
+import sys
+import time
+from pathlib import Path
+
+ENFORCER_DIR = Path(".pantheon/todo-enforcer")
+STATE_FILE = ENFORCER_DIR / "state.json"
+
+
+class TodoEnforcer:
+    """Stateful idle monitor for agent sessions."""
+
+    def __init__(
+        self,
+        task: str,
+        timeout_warn: int = 60,
+        timeout_force: int = 120,
+        timeout_pause: int = 300,
+        max_force_continues: int = 3,
+    ):
+        self.task = task
+        self.timeout_warn = timeout_warn
+        self.timeout_force = timeout_force
+        self.timeout_pause = timeout_pause
+        self.max_force_continues = max_force_continues
+        self._ensure_dir()
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def tick(self) -> dict:
+        """Record a tool-call heartbeat (resets idle timer)."""
+        state = self._load()
+        state["last_tool_call"] = time.time()
+        state["task"] = self.task
+        state["warnings_sent"] = state.get("warnings_sent", [])
+        state["forced_continues"] = state.get("forced_continues", 0)
+        state["paused"] = False
+        self._save(state)
+        return {"status": "ok", "idle": 0.0}
+
+    def check(self) -> dict:
+        """Check idle duration and return action if needed."""
+        state = self._load()
+        if state.get("paused"):
+            return {"status": "paused", "action": None}
+
+        last_call = state.get("last_tool_call")
+        if last_call is None:
+            return {"status": "no_data", "action": None}
+
+        idle = time.time() - last_call
+        action = None
+
+        if idle >= self.timeout_pause:
+            action = self._build_action("pause", idle)
+            state["paused"] = True
+            state["stop_reason"] = "timeout_pause"
+        elif idle >= self.timeout_force:
+            fc_count = state.get("forced_continues", 0)
+            if fc_count >= self.max_force_continues:
+                action = self._build_action("pause", idle)
+                state["paused"] = True
+                state["stop_reason"] = "max_force_continues"
+            else:
+                action = self._build_action("force_continue", idle)
+                state["forced_continues"] = fc_count + 1
+        elif idle >= self.timeout_warn:
+            action = self._build_action("warn", idle)
+            if "warn" not in state.get("warnings_sent", []):
+                state.setdefault("warnings_sent", []).append("warn")
+
+        self._save(state)
+        return {
+            "status": "idle" if idle > 0 else "active",
+            "idle": idle,
+            "action": action,
+        }
+
+    def reset(self) -> dict:
+        """Reset idle timer and unpause."""
+        state = self._load()
+        state["last_tool_call"] = time.time()
+        state["paused"] = False
+        state["warnings_sent"] = []
+        state["forced_continues"] = 0
+        state["stop_reason"] = None
+        self._save(state)
+        return {"status": "reset", "idle": 0.0}
+
+    def status(self) -> dict:
+        """Return current state without side effects."""
+        state = self._load()
+        idle = time.time() - state.get("last_tool_call", time.time())
+        return {
+            "task": state.get("task", self.task),
+            "idle": round(idle, 1),
+            "paused": state.get("paused", False),
+            "forced_continues": state.get("forced_continues", 0),
+            "stop_reason": state.get("stop_reason"),
+            "timeout_warn": self.timeout_warn,
+            "timeout_force": self.timeout_force,
+            "timeout_pause": self.timeout_pause,
+        }
+
+    def pause(self) -> dict:
+        """Pause the enforcer (mark session stopped)."""
+        state = self._load()
+        state["paused"] = True
+        state["stop_reason"] = "manual_pause"
+        self._save(state)
+        return {"status": "paused"}
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _build_action(self, level: str, idle: float) -> dict:
+        prompts = {
+            "warn": f"[TODO ENFORCER] Agent idle for {idle:.0f}s. Continuing task: {self.task}",
+            "force_continue": f"[TODO ENFORCER] FORCE CONTINUE — Agent idle for {idle:.0f}s. Resume work on: {self.task}",
+            "pause": f"[TODO ENFORCER] AUTO-PAUSE — Agent idle for {idle:.0f}s. Session paused due to idle timeout.",
+        }
+        return {
+            "level": level,
+            "idle": round(idle, 1),
+            "message": prompts[level],
+            "checkpoint": level == "pause",
+        }
+
+    def _ensure_dir(self) -> None:
+        ENFORCER_DIR.mkdir(parents=True, exist_ok=True)
+
+    def _load(self) -> dict:
+        if STATE_FILE.exists():
+            try:
+                return json.loads(STATE_FILE.read_text())
+            except (json.JSONDecodeError, OSError):
+                pass
+        return {
+            "task": self.task,
+            "last_tool_call": time.time(),
+            "paused": False,
+            "warnings_sent": [],
+            "forced_continues": 0,
+            "stop_reason": None,
+        }
+
+    def _save(self, state: dict) -> None:
+        STATE_FILE.write_text(json.dumps(state, indent=2, ensure_ascii=False))
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="TODO Enforcer — idle detection and recovery for Pantheon agents."
+    )
+    parser.add_argument(
+        "task", nargs="?", default="", help="Task description for force-continue prompt"
+    )
+    parser.add_argument(
+        "--timeout-warn",
+        type=int,
+        default=60,
+        help="Idle seconds before warning (default: 60)",
+    )
+    parser.add_argument(
+        "--timeout-force",
+        type=int,
+        default=120,
+        help="Idle seconds before force continue (default: 120)",
+    )
+    parser.add_argument(
+        "--timeout-pause",
+        type=int,
+        default=300,
+        help="Idle seconds before auto-pause (default: 300)",
+    )
+    parser.add_argument(
+        "--status", action="store_true", help="Show current enforcer state"
+    )
+    parser.add_argument("--reset", action="store_true", help="Reset idle timer")
+    parser.add_argument(
+        "--tick", action="store_true", help="Record a heartbeat (tool call)"
+    )
+    parser.add_argument(
+        "--check", action="store_true", help="Check idle status and return action"
+    )
+    parser.add_argument("--pause", action="store_true", help="Pause the enforcer")
+    args = parser.parse_args()
+
+    enforcer = TodoEnforcer(
+        task=args.task or "unknown",
+        timeout_warn=args.timeout_warn,
+        timeout_force=args.timeout_force,
+        timeout_pause=args.timeout_pause,
+    )
+
+    if args.status:
+        result = enforcer.status()
+    elif args.reset:
+        result = enforcer.reset()
+    elif args.tick:
+        result = enforcer.tick()
+    elif args.check:
+        result = enforcer.check()
+    elif args.pause:
+        result = enforcer.pause()
+    else:
+        result = enforcer.check()
+
+    print(json.dumps(result, indent=2, ensure_ascii=False))
+
+    # Exit codes: 0=normal, 1=warn, 2=force, 3=pause
+    if isinstance(result, dict) and result.get("action"):
+        level = result["action"].get("level")
+        if level == "pause":
+            sys.exit(3)
+        elif level == "force_continue":
+            sys.exit(2)
+        elif level == "warn":
+            sys.exit(1)
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()