pantheon-opencode 1.1.1-beta.9 → 1.1.1

package/scripts/memory_cache.py

@@ -1,78 +0,0 @@
-#!/usr/bin/env python3
-"""memory_cache.py — Migrate memory-bank flat files to MCP memory_store.
-Usage: python3 scripts/memory_cache.py [--dry-run] [--path=<dir>]
-"""
-
-import argparse
-import hashlib
-import sys
-from pathlib import Path
-
-EXCLUDE = {"_index.md", "_notes", ".tmp", "archive"}
-
-
-def chunk_by_headings(content: str, source: str) -> list[dict]:
-    chunks = []
-    lines = content.split("\n")
-    current_h2 = "intro"
-    current_lines = []
-    for line in lines:
-        if line.startswith("## "):
-            if current_lines:
-                chunks.append(
-                    {
-                        "source": source,
-                        "heading": current_h2,
-                        "content": "\n".join(current_lines).strip(),
-                    }
-                )
-            current_h2 = line.strip("# ")
-            current_lines = [line]
-        else:
-            current_lines.append(line)
-    if current_lines:
-        chunks.append(
-            {
-                "source": source,
-                "heading": current_h2,
-                "content": "\n".join(current_lines).strip(),
-            }
-        )
-    return chunks
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--dry-run", action="store_true", help="Preview only")
-    parser.add_argument("--path", default=".pantheon/memory-bank", help="Target dir")
-    args = parser.parse_args()
-    target = Path(args.path).resolve()
-
-    if not target.exists():
-        print(f"❌ Path not found: {target}")
-        sys.exit(1)
-
-    files = list(target.rglob("*.md"))
-    files = [f for f in files if not any(p in f.parts for p in EXCLUDE)]
-
-    total_chunks = 0
-    for f in files:
-        rel = f.relative_to(target)
-        content = f.read_text(encoding="utf-8", errors="ignore")
-        chunks = chunk_by_headings(content, str(rel))
-        total_chunks += len(chunks)
-        if args.dry_run:
-            print(f"  📄 {rel}: {len(chunks)} chunks")
-        else:
-            print(f"  📄 {rel}: {len(chunks)} chunks → memory_store()")
-            for c in chunks:
-                key = f"memory-cache:{rel}:{hashlib.md5(c['content'].encode()).hexdigest()[:8]}"
-                print(f"    stored {key}")
-
-    print(
-        f"\n{'🔍 DRY RUN' if args.dry_run else '✅ DONE'}: {len(files)} files, {total_chunks} chunks"
-    )
-
-
-if __name__ == "__main__":
-    main()

package/scripts/paths.py

@@ -1,64 +0,0 @@
-"""
-Pantheon XDG Path Utilities — XDG Base Directory compliant path resolution.
-
-Usage:
-    from paths import xdg_config_home, opencode_plans_dir
-
-Per the XDG Base Directory spec (XDG_CONFIG_HOME, XDG_DATA_HOME, XDG_STATE_HOME, XDG_CACHE_HOME).
-All fallback to their spec defaults when the env var is unset.
-"""
-
-import os
-from pathlib import Path
-
-
-def _from_env(var: str, default: str) -> Path:
-    value = os.environ.get(var)
-    if value is None or not value.strip():
-        value = default
-    return Path(os.path.expanduser(value.strip()))
-
-
-def xdg_config_home() -> Path:
-    """~/.config/ or $XDG_CONFIG_HOME"""
-    return _from_env("XDG_CONFIG_HOME", "~/.config")
-
-
-def xdg_data_home() -> Path:
-    """~/.local/share/ or $XDG_DATA_HOME"""
-    return _from_env("XDG_DATA_HOME", "~/.local/share")
-
-
-def xdg_state_home() -> Path:
-    """~/.local/state/ or $XDG_STATE_HOME"""
-    return _from_env("XDG_STATE_HOME", "~/.local/state")
-
-
-def xdg_cache_home() -> Path:
-    """~/.cache/ or $XDG_CACHE_HOME"""
-    return _from_env("XDG_CACHE_HOME", "~/.cache")
-
-
-def opencode_config_dir() -> Path:
-    """$XDG_CONFIG_HOME/opencode"""
-    return xdg_config_home() / "opencode"
-
-
-def opencode_plans_dir() -> Path:
-    """$XDG_CONFIG_HOME/opencode/platform/plans"""
-    return opencode_config_dir() / "platform" / "plans"
-
-
-def opencode_data_dir() -> Path:
-    """$XDG_DATA_HOME/opencode"""
-    return xdg_data_home() / "opencode"
-
-
-def opencode_sync_repo_dir() -> Path:
-    """$XDG_DATA_HOME/opencode/opencode-synced/repo"""
-    return opencode_data_dir() / "opencode-synced" / "repo"
-
-
-def pantheon_log_dir() -> Path:
-    """$XDG_STATE_HOME/pantheon/logs"""
-    return xdg_state_home() / "pantheon" / "logs"

package/scripts/prune_context.py

@@ -1,72 +0,0 @@
-#!/usr/bin/env python3
-"""prune_context.py — Tool Output Pruning (Level 2 Compression v2).
-Flags obsolete tool outputs in conversation history for pruning.
-Usage: python3 scripts/prune_context.py [--dry-run] [--turns=5]
-"""
-
-import argparse
-
-HIGH_AGE_TURNS = 10
-MID_AGE_TURNS = 5
-HIGH_LINES = 100
-MID_LINES = 50
-PRUNE_THRESHOLD = 0.5
-LOW_RELEVANCE_TYPES = ("read", "grep", "glob")
-HIGH_RELEVANCE_TYPES = ("test", "build")
-
-
-def score_output(lines: int, age_turns: int, output_type: str) -> float:
-    """Return relevance score 0.0-1.0. Lower = better to prune."""
-    score = 1.0
-    if age_turns > HIGH_AGE_TURNS:
-        score -= 0.3
-    elif age_turns > MID_AGE_TURNS:
-        score -= 0.15
-    if lines > HIGH_LINES:
-        score -= 0.2
-    elif lines > MID_LINES:
-        score -= 0.1
-    if output_type in LOW_RELEVANCE_TYPES:
-        score -= 0.1
-    if output_type in HIGH_RELEVANCE_TYPES:
-        score += 0.1
-    return max(0.0, min(1.0, score))
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--dry-run", action="store_true")
-    parser.add_argument("--turns", type=int, default=5, help="Min age in turns")
-    args = parser.parse_args()
-
-    candidates = [
-        {"file": "src/main.py", "lines": 120, "age": 7, "type": "read"},
-        {"file": "tests/test_auth.py", "lines": 45, "age": 3, "type": "test"},
-        {"file": "package.json", "lines": 60, "age": 12, "type": "read"},
-    ]
-
-    print(f"🔍 Context Pruning Scan (age threshold: {args.turns}+ turns)")
-    print("━" * 50)
-    prunable = []
-    for c in candidates:
-        s = score_output(c["lines"], c["age"], c["type"])
-        status = "🗑️ PRUNE" if s < PRUNE_THRESHOLD else "✅ KEEP"
-        if s < PRUNE_THRESHOLD:
-            prunable.append(c)
-        print(
-            f"  {status} | score: {s:.2f} | {c['file']} ({c['lines']}L, {c['age']}turns, {c['type']})"
-        )
-
-    print("━" * 50)
-    if args.dry_run:
-        print(
-            f"🔍 DRY RUN: {len(prunable)} candidates to prune (estimated ~{sum(c['lines'] for c in prunable)} lines)"
-        )
-    else:
-        print(
-            f"✅ {len(prunable)} outputs pruned (freed ~{sum(c['lines'] for c in prunable)} lines)"
-        )
-
-
-if __name__ == "__main__":
-    main()

package/scripts/release-bundle.mjs

@@ -1,109 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * release-bundle.mjs — Creates the distribution tar.gz for a Pantheon release.
- *
- * Packages all user-relevant files into pantheon-vX.Y.Z.tar.gz.
- * Excludes build tooling (scripts/, .github/, node_modules/).
- *
- * Usage:
- *   node scripts/release-bundle.mjs                      # reads version from package.json
- *   node scripts/release-bundle.mjs --output ./dist      # custom output dir
- *   node scripts/release-bundle.mjs --version 3.5.0     # explicit version
- */
-
-import { execSync } from 'node:child_process'
-import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-const ROOT = join(__dirname, '..')
-
-// ── Parse args ────────────────────────────────────────────────────────────────
-const args = process.argv.slice(2)
-function arg(flag) {
-  const i = args.indexOf(flag)
-  return i !== -1 ? args[i + 1] : null
-}
-
-const outputDir = arg('--output') ?? join(ROOT, 'dist')
-const version =
-  arg('--version') ?? JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf-8')).version
-
-const bundleName = `pantheon-v${version}`
-const stagingDir = join(ROOT, 'dist', `.staging-${bundleName}`)
-const outputTar = join(outputDir, `${bundleName}.tar.gz`)
-
-// ── Helpers ───────────────────────────────────────────────────────────────────
-function copy(src, dest) {
-  const srcPath = join(ROOT, src)
-  if (!existsSync(srcPath)) {
-    console.log(`  ⏭  skipped  ${src}  (not found)`)
-    return
-  }
-  const destPath = join(stagingDir, bundleName, dest ?? src)
-  mkdirSync(dirname(destPath), { recursive: true })
-  cpSync(srcPath, destPath, { recursive: true })
-  console.log(`  ✓  ${src}`)
-}
-
-// ── Stage files ───────────────────────────────────────────────────────────────
-console.log(`\nBuilding bundle: ${bundleName}`)
-
-if (existsSync(stagingDir)) rmSync(stagingDir, { recursive: true, force: true })
-mkdirSync(join(stagingDir, bundleName), { recursive: true })
-
-// Root documents
-copy('README.md')
-copy('AGENTS.md')
-copy('CHANGELOG.md')
-copy('CONTRIBUTING.md')
-copy('LICENSE')
-
-// Config
-copy('opencode.json')
-copy('plugin.json')
-
-// Shell helper
-copy('sync-opencode.sh')
-
-// Entry point exposed at root
-copy('bin/pantheon-init.mjs', 'pantheon-init.mjs')
-
-// Agent definitions
-copy('agents')
-copy('skills')
-copy('prompts')
-copy('platform')
-copy('instructions')
-copy('docs')
-copy('images')
-
-// Platform MCP configs
-copy('.vscode')
-copy('.cursor')
-copy('.claude')
-copy('platform/mcp/mcp-template.json')
-
-// ── Write a minimal package.json so install.mjs can resolve it ────────────────
-const minPkg = {
-  name: 'pantheon',
-  version,
-  description: 'Multi-agent orchestration platform for AI coding assistants',
-  type: 'module',
-}
-writeFileSync(join(stagingDir, bundleName, 'package.json'), `${JSON.stringify(minPkg, null, 2)}\n`)
-
-// ── Create tar.gz ─────────────────────────────────────────────────────────────
-if (!existsSync(outputDir)) mkdirSync(outputDir, { recursive: true })
-
-execSync(`tar czf "${outputTar}" -C "${stagingDir}" "${bundleName}"`, { stdio: 'inherit' })
-
-// ── Cleanup staging ───────────────────────────────────────────────────────────
-rmSync(stagingDir, { recursive: true, force: true })
-
-// ── Report ────────────────────────────────────────────────────────────────────
-const { size } = { size: execSync(`wc -c < "${outputTar}"`).toString().trim() }
-const kb = Math.round(Number(size) / 1024)
-console.log(`\n✅  ${outputTar}  (${kb} KB)`)

package/scripts/todo_enforcer.py

@@ -1,242 +0,0 @@
-#!/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()