flyee 0.1.0

package/bridge/local_tracker.py

@@ -0,0 +1,722 @@
+#!/usr/bin/env python3
+"""
+Local Tracker — Offline-first task and state management for @flyee.
+
+Manages tasks, decisions, and events locally in .flyee/ directory.
+No network required. Works 100% offline.
+
+When Flyee SaaS is configured (flyee.json exists), operations are synced.
+"""
+
+import json
+import os
+import tempfile
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Optional
+
+
+FLYEE_DIR = ".flyee"
+TASKS_FILE = "tasks.json"
+DECISIONS_FILE = "DECISIONS.md"
+EVENTS_FILE = "events.jsonl"
+CONFIG_FILE = "config.json"
+
+
+class LocalTracker:
+    """Offline-first task and state tracker using .flyee/ directory."""
+
+    def __init__(self, project_root: Optional[str] = None):
+        if project_root:
+            self.root = Path(project_root)
+        else:
+            self.root = self._find_project_root()
+        self.flyee_dir = self.root / FLYEE_DIR
+        self._ensure_dir()
+
+    def _find_project_root(self) -> Path:
+        """Walk up from CWD to find project root (has .git or flyee.json)."""
+        current = Path.cwd()
+        while current != current.parent:
+            if (current / ".git").exists() or (current / "flyee.json").exists():
+                return current
+            current = current.parent
+        return Path.cwd()
+
+    def _ensure_dir(self):
+        """Create .flyee/ if it doesn't exist."""
+        self.flyee_dir.mkdir(parents=True, exist_ok=True)
+        gitignore = self.flyee_dir / ".gitignore"
+        if not gitignore.exists():
+            gitignore.write_text(
+                "# Ephemeral state (not versioned)\n"
+                "STATE.md\n"
+                "session-lock.json\n"
+                "cost-log.jsonl\n"
+                "events.jsonl\n"
+                "tasks.json\n"
+                "**/continue.md\n"
+            )
+
+    def _atomic_write(self, filepath: Path, content: str):
+        """Write file atomically to prevent corruption."""
+        dir_path = filepath.parent
+        dir_path.mkdir(parents=True, exist_ok=True)
+        fd, tmp = tempfile.mkstemp(dir=str(dir_path), prefix="flyee-tmp-")
+        try:
+            os.write(fd, content.encode("utf-8"))
+            os.close(fd)
+            os.rename(tmp, str(filepath))
+        except Exception:
+            os.close(fd)
+            if os.path.exists(tmp):
+                os.unlink(tmp)
+            raise
+
+    # ─── Tasks ────────────────────────────────────────────────────────────
+
+    def _load_tasks(self) -> list:
+        """Load tasks from local storage."""
+        tasks_path = self.flyee_dir / TASKS_FILE
+        if not tasks_path.exists():
+            return []
+        try:
+            return json.loads(tasks_path.read_text())
+        except (json.JSONDecodeError, OSError):
+            return []
+
+    def _save_tasks(self, tasks: list):
+        """Save tasks to local storage."""
+        self._atomic_write(
+            self.flyee_dir / TASKS_FILE,
+            json.dumps(tasks, indent=2, ensure_ascii=False)
+        )
+
+    def create_task(
+        self,
+        name: str,
+        task_type: str = "implement_feature",
+        description: str = "",
+        priority: str = "normal",
+        parent_task_id: Optional[str] = None,
+        meta: Optional[dict] = None,
+    ) -> dict:
+        """Create a task locally. Returns the task dict."""
+        tasks = self._load_tasks()
+        
+        task = {
+            "id": str(uuid.uuid4()),
+            "name": name,
+            "type": task_type,
+            "description": description,
+            "priority": priority,
+            "status": "pending",
+            "result_status": None,
+            "parent_task_id": parent_task_id,
+            "meta": meta or {},
+            "created_at": datetime.now(timezone.utc).isoformat(),
+            "updated_at": datetime.now(timezone.utc).isoformat(),
+            "synced": False,  # Not yet synced with SaaS
+        }
+        
+        tasks.append(task)
+        self._save_tasks(tasks)
+        
+        print(f"✅ Task created locally: {name} (ID: {task['id'][:8]}...)")
+        return task
+
+    def update_task(
+        self,
+        task_id: str,
+        status: Optional[str] = None,
+        result_status: Optional[str] = None,
+        output: Optional[dict] = None,
+        meta: Optional[dict] = None,
+    ) -> Optional[dict]:
+        """Update a task locally."""
+        tasks = self._load_tasks()
+        
+        # Find task by full ID or prefix
+        task = None
+        for t in tasks:
+            if t["id"] == task_id or t["id"].startswith(task_id):
+                task = t
+                break
+        
+        if not task:
+            print(f"❌ Task not found: {task_id}")
+            return None
+        
+        if status:
+            task["status"] = status
+        if result_status:
+            task["result_status"] = result_status
+        if output:
+            task["output"] = output
+        if meta:
+            task["meta"].update(meta)
+        
+        task["updated_at"] = datetime.now(timezone.utc).isoformat()
+        task["synced"] = False  # Mark as needing sync
+        
+        self._save_tasks(tasks)
+        print(f"✅ Task updated: {task['name']} → {status or 'updated'}")
+        return task
+
+    def list_tasks(self, status: Optional[str] = None) -> list:
+        """List tasks, optionally filtered by status."""
+        tasks = self._load_tasks()
+        if status:
+            tasks = [t for t in tasks if t["status"] == status]
+        return tasks
+
+    def get_task(self, task_id: str) -> Optional[dict]:
+        """Get a single task by ID or prefix."""
+        tasks = self._load_tasks()
+        for t in tasks:
+            if t["id"] == task_id or t["id"].startswith(task_id):
+                return t
+        return None
+
+    def search_tasks(self, keywords: str) -> list:
+        """Search tasks by keywords in name and description."""
+        tasks = self._load_tasks()
+        kw = keywords.lower().split()
+        results = []
+        for t in tasks:
+            text = f"{t['name']} {t.get('description', '')}".lower()
+            if any(k in text for k in kw):
+                results.append(t)
+        return results
+
+    # ─── Decisions ────────────────────────────────────────────────────────
+
+    def create_decision(
+        self,
+        decision: str,
+        reason: Optional[str] = None,
+        impact: Optional[str] = None,
+        sprint: Optional[str] = None,
+        phase: Optional[str] = None,
+        task: Optional[str] = None,
+    ) -> dict:
+        """Append a decision to DECISIONS.md."""
+        decisions_path = self.flyee_dir / DECISIONS_FILE
+        
+        # Count existing decisions to generate ID
+        count = 0
+        if decisions_path.exists():
+            content = decisions_path.read_text()
+            count = content.count("## D")
+        
+        entry_id = f"D{count + 1:03d}"
+        now = datetime.now().strftime("%Y-%m-%d")
+        
+        entry = f"\n## {entry_id} — {decision} ({now})\n\n"
+        if reason:
+            entry += f"**Context:** {reason}\n"
+        entry += f"**Decision:** {decision}\n"
+        if impact:
+            entry += f"**Impact:** {impact}\n"
+        
+        location_parts = []
+        if sprint:
+            location_parts.append(f"**Sprint:** {sprint}")
+        if phase:
+            location_parts.append(f"**Phase:** {phase}")
+        if task:
+            location_parts.append(f"**Task:** {task}")
+        if location_parts:
+            entry += " | ".join(location_parts) + "\n"
+        
+        entry += "\n---\n"
+        
+        # Create or append
+        if not decisions_path.exists():
+            header = "# Decisions Register\n\n> Append-only log of technical decisions.\n\n---\n"
+            decisions_path.write_text(header + entry)
+        else:
+            with open(decisions_path, "a") as f:
+                f.write(entry)
+        
+        result = {
+            "id": entry_id,
+            "decision": decision,
+            "created_at": now,
+        }
+        print(f"✅ Decision recorded: {entry_id} — {decision}")
+        return result
+
+    # ─── Events ───────────────────────────────────────────────────────────
+
+    def emit_event(self, event_type: str, payload: Optional[dict] = None) -> bool:
+        """Log an event locally to events.jsonl."""
+        events_path = self.flyee_dir / EVENTS_FILE
+        
+        event = {
+            "event_type": event_type,
+            "payload": payload or {},
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "synced": False,
+        }
+        
+        with open(events_path, "a") as f:
+            f.write(json.dumps(event, ensure_ascii=False) + "\n")
+        
+        return True
+
+    # ─── Cost Tracking ────────────────────────────────────────────────────
+
+    def log_cost(
+        self,
+        sprint: str,
+        phase: str,
+        task: str,
+        operation: str,
+        model: str = "unknown",
+        tokens_in: int = 0,
+        tokens_out: int = 0,
+        cost_usd: float = 0.0,
+        duration_ms: int = 0,
+    ):
+        """Append a cost entry to cost-log.jsonl."""
+        cost_path = self.flyee_dir / "cost-log.jsonl"
+        
+        entry = {
+            "ts": datetime.now(timezone.utc).isoformat(),
+            "sprint": sprint,
+            "phase": phase,
+            "task": task,
+            "op": operation,
+            "model": model,
+            "tokens_in": tokens_in,
+            "tokens_out": tokens_out,
+            "cost_usd": cost_usd,
+            "duration_ms": duration_ms,
+        }
+        
+        with open(cost_path, "a") as f:
+            f.write(json.dumps(entry) + "\n")
+
+    # ─── Session Lock ─────────────────────────────────────────────────────
+
+    def acquire_session_lock(self, runtime: str = "antigravity") -> bool:
+        """Acquire session lock. Returns False if another session is active."""
+        lock_path = self.flyee_dir / "session-lock.json"
+        
+        if lock_path.exists():
+            try:
+                lock = json.loads(lock_path.read_text())
+                pid = lock.get("pid")
+                if pid and self._is_pid_alive(pid):
+                    print(f"⚠️ Another session is active (PID {pid})")
+                    return False
+                else:
+                    # Orphan lock = crash detected
+                    print(f"⚠️ Previous session crashed. Recovering...")
+                    self._handle_crash(lock)
+            except (json.JSONDecodeError, OSError):
+                pass
+        
+        lock_data = {
+            "pid": os.getpid(),
+            "startedAt": datetime.now(timezone.utc).isoformat(),
+            "runtime": runtime,
+            "lastUpdate": datetime.now(timezone.utc).isoformat(),
+        }
+        
+        self._atomic_write(lock_path, json.dumps(lock_data, indent=2))
+        return True
+
+    def release_session_lock(self):
+        """Release session lock on clean exit."""
+        lock_path = self.flyee_dir / "session-lock.json"
+        if lock_path.exists():
+            lock_path.unlink()
+
+    def update_session_lock(self, **kwargs):
+        """Update session lock with current activity."""
+        lock_path = self.flyee_dir / "session-lock.json"
+        if not lock_path.exists():
+            return
+        
+        try:
+            lock = json.loads(lock_path.read_text())
+            lock.update(kwargs)
+            lock["lastUpdate"] = datetime.now(timezone.utc).isoformat()
+            self._atomic_write(lock_path, json.dumps(lock, indent=2))
+        except (json.JSONDecodeError, OSError):
+            pass
+
+    def _is_pid_alive(self, pid: int) -> bool:
+        """Check if a PID is still running."""
+        try:
+            os.kill(pid, 0)
+            return True
+        except (OSError, ProcessLookupError):
+            return False
+
+    def _handle_crash(self, lock: dict):
+        """Handle a detected crash — show info and prepare for resume."""
+        sprint = lock.get("activeSprint", "?")
+        phase = lock.get("activePhase", "?")
+        task = lock.get("activeTask", "?")
+        action = lock.get("lastAction", "unknown")
+        crashed_at = lock.get("lastUpdate", "?")
+        
+        print(f"\n⚠️ CRASH RECOVERY")
+        print(f"  Sprint: {sprint} | Phase: {phase} | Task: {task}")
+        print(f"  Last action: {action}")
+        print(f"  Crashed at: {crashed_at}")
+        print()
+
+    # ─── Sync Status ──────────────────────────────────────────────────────
+
+    def get_unsynced_tasks(self) -> list:
+        """Get tasks that haven't been synced to SaaS."""
+        tasks = self._load_tasks()
+        return [t for t in tasks if not t.get("synced", False)]
+
+    def mark_synced(self, task_id: str, remote_id: Optional[str] = None):
+        """Mark a task as synced with SaaS."""
+        tasks = self._load_tasks()
+        for t in tasks:
+            if t["id"] == task_id or t["id"].startswith(task_id):
+                t["synced"] = True
+                if remote_id:
+                    t["remote_id"] = remote_id
+                t["synced_at"] = datetime.now(timezone.utc).isoformat()
+                break
+        self._save_tasks(tasks)
+
+    # ─── Context Search ───────────────────────────────────────────────────
+
+    def search_context(self, keywords: str) -> dict:
+        """Search local state for context relevant to keywords."""
+        results = {
+            "tasks": self.search_tasks(keywords),
+            "decisions": self._search_decisions(keywords),
+        }
+        return results
+
+    def _search_decisions(self, keywords: str) -> list:
+        """Search DECISIONS.md for keywords."""
+        decisions_path = self.flyee_dir / DECISIONS_FILE
+        if not decisions_path.exists():
+            return []
+        
+        content = decisions_path.read_text()
+        kw = keywords.lower().split()
+        
+        results = []
+        for section in content.split("## D")[1:]:
+            if any(k in section.lower() for k in kw):
+                first_line = section.split("\n")[0]
+                results.append({"decision": f"D{first_line}"})
+        
+        return results
+
+
+class FlyeeSync:
+    """Optional sync layer for Flyee SaaS platform."""
+
+    def __init__(self, config: dict):
+        self.config = config
+        self.api_url = config.get("api_url", "")
+        self.api_key = config.get("api_key", "")
+        self.project_id = config.get("project_id", "")
+
+    @property
+    def is_available(self) -> bool:
+        return bool(self.api_url and self.api_key and self.project_id)
+
+    def sync_task(self, local_task: dict) -> Optional[str]:
+        """Sync a local task to Flyee SaaS. Returns remote ID."""
+        if not self.is_available:
+            return None
+        
+        # Import bridge functions dynamically
+        try:
+            bridge_dir = Path(__file__).parent
+            import importlib.util
+            spec = importlib.util.spec_from_file_location(
+                "bridge", bridge_dir / "bridge.py"
+            )
+            bridge = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(bridge)
+            
+            result = bridge.create_task(
+                api_url=self.api_url,
+                api_key=self.api_key,
+                project_id=self.project_id,
+                task_type=local_task.get("type", "implement_feature"),
+                name=local_task.get("name", ""),
+                description=local_task.get("description", ""),
+                priority=local_task.get("priority", "normal"),
+                meta=local_task.get("meta", {}),
+            )
+            
+            if result and result.get("id"):
+                return str(result["id"])
+        except Exception as e:
+            print(f"⚠️ Flyee sync failed: {e}")
+        
+        return None
+
+    def sync_event(self, event: dict) -> bool:
+        """Sync a local event to Flyee SaaS."""
+        if not self.is_available:
+            return False
+        
+        try:
+            bridge_dir = Path(__file__).parent
+            import importlib.util
+            spec = importlib.util.spec_from_file_location(
+                "bridge", bridge_dir / "bridge.py"
+            )
+            bridge = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(bridge)
+            
+            return bridge.emit_event(
+                event["event_type"],
+                event.get("payload"),
+                self.config,
+            )
+        except Exception as e:
+            print(f"⚠️ Event sync failed: {e}")
+            return False
+
+
+class Bridge:
+    """Unified bridge — offline-first with optional SaaS sync.
+    
+    Usage:
+        bridge = Bridge()
+        bridge.create_task(name="Build feature", type="implement_feature")
+        bridge.create_decision(decision="Use RSC", reason="Performance")
+    """
+
+    def __init__(self, project_root: Optional[str] = None):
+        self.local = LocalTracker(project_root)
+        self.remote = self._init_remote()
+
+    def _init_remote(self) -> Optional[FlyeeSync]:
+        """Initialize remote sync if flyee.json exists and is configured."""
+        config_path = self.local.root / "flyee.json"
+        if not config_path.exists():
+            return None
+        
+        try:
+            config = json.loads(config_path.read_text())
+            if config.get("enabled") and config.get("api_key"):
+                sync = FlyeeSync(config)
+                if sync.is_available:
+                    return sync
+        except (json.JSONDecodeError, OSError):
+            pass
+        
+        return None
+
+    @property
+    def is_online(self) -> bool:
+        """Whether SaaS sync is available."""
+        return self.remote is not None and self.remote.is_available
+
+    def create_task(self, **kwargs) -> dict:
+        """Create task locally, sync to SaaS if available."""
+        task = self.local.create_task(**kwargs)
+        
+        if self.remote:
+            remote_id = self.remote.sync_task(task)
+            if remote_id:
+                self.local.mark_synced(task["id"], remote_id)
+                print(f"   ↳ Synced to Flyee SaaS (remote: {remote_id[:8]}...)")
+        
+        return task
+
+    def update_task(self, task_id: str, **kwargs) -> Optional[dict]:
+        """Update task locally, sync to SaaS if available."""
+        task = self.local.update_task(task_id, **kwargs)
+        # Remote sync for updates would go here
+        return task
+
+    def list_tasks(self, **kwargs) -> list:
+        """List tasks from local storage."""
+        return self.local.list_tasks(**kwargs)
+
+    def create_decision(self, **kwargs) -> dict:
+        """Record decision locally, sync to SaaS if available."""
+        result = self.local.create_decision(**kwargs)
+        
+        if self.remote:
+            try:
+                self.remote.sync_event({
+                    "event_type": "dev.decision_detected",
+                    "payload": {
+                        "decision": kwargs.get("decision", ""),
+                        "reason": kwargs.get("reason"),
+                    }
+                })
+            except Exception:
+                pass
+        
+        return result
+
+    def emit_event(self, event_type: str, payload: Optional[dict] = None) -> bool:
+        """Emit event locally, sync to SaaS if available."""
+        self.local.emit_event(event_type, payload)
+        
+        if self.remote:
+            self.remote.sync_event({
+                "event_type": event_type,
+                "payload": payload or {},
+            })
+        
+        return True
+
+    def search_context(self, keywords: str) -> dict:
+        """Search local context + SaaS if available."""
+        local_results = self.local.search_context(keywords)
+        
+        # If SaaS available, could enhance with remote search
+        # For now, local-only
+        return local_results
+
+    def status(self) -> dict:
+        """Get bridge status."""
+        tasks = self.local.list_tasks()
+        unsynced = self.local.get_unsynced_tasks()
+        
+        return {
+            "mode": "online" if self.is_online else "offline",
+            "project_root": str(self.local.root),
+            "flyee_dir": str(self.local.flyee_dir),
+            "total_tasks": len(tasks),
+            "unsynced_tasks": len(unsynced),
+            "saas_configured": self.is_online,
+        }
+
+
+# ─── CLI Interface ───────────────────────────────────────────────────────
+
+def main():
+    """CLI interface for the local tracker."""
+    args = sys.argv[1:]
+    bridge = Bridge()
+
+    if not args or "--help" in args:
+        print("""
+@flyee Local Tracker — Offline-first task management
+
+Usage:
+    python local_tracker.py --create-task --name "Task name" --type implement_feature
+    python local_tracker.py --update-task <id> --status completed
+    python local_tracker.py --list-tasks [--status pending]
+    python local_tracker.py --search-context "keywords"
+    python local_tracker.py --create-decision --decision "Use X" --reason "Because Y"
+    python local_tracker.py --status
+    python local_tracker.py --sync  (sync unsynced tasks to SaaS)
+        """)
+        return
+
+    if "--status" in args:
+        s = bridge.status()
+        print(f"\n📊 @flyee Bridge Status")
+        print(f"  Mode: {'🌐 Online' if s['saas_configured'] else '📴 Offline'}")
+        print(f"  Root: {s['project_root']}")
+        print(f"  Tasks: {s['total_tasks']} total, {s['unsynced_tasks']} unsynced")
+        return
+
+    if "--create-task" in args:
+        name = _get_arg(args, "--name", "Unnamed task")
+        task_type = _get_arg(args, "--type", "implement_feature")
+        description = _get_arg(args, "--description", "")
+        priority = _get_arg(args, "--priority", "normal")
+        
+        task = bridge.create_task(
+            name=name,
+            task_type=task_type,
+            description=description,
+            priority=priority,
+        )
+        print(json.dumps(task, indent=2))
+        return
+
+    if "--update-task" in args:
+        idx = args.index("--update-task")
+        task_id = args[idx + 1] if idx + 1 < len(args) else ""
+        status = _get_arg(args, "--status")
+        result = _get_arg(args, "--result")
+        
+        bridge.update_task(task_id, status=status, result_status=result)
+        return
+
+    if "--list-tasks" in args:
+        status = _get_arg(args, "--status")
+        tasks = bridge.list_tasks(status=status)
+        
+        if not tasks:
+            print("No tasks found.")
+            return
+        
+        print(f"\n{'ID':<10} {'Name':<35} {'Status':<12} {'Priority':<10}")
+        print("-" * 70)
+        for t in tasks:
+            tid = t["id"][:8]
+            print(f"{tid:<10} {t['name'][:33]:<35} {t['status']:<12} {t['priority']:<10}")
+        return
+
+    if "--search-context" in args:
+        idx = args.index("--search-context")
+        keywords = args[idx + 1] if idx + 1 < len(args) else ""
+        results = bridge.search_context(keywords)
+        print(json.dumps(results, indent=2, ensure_ascii=False))
+        return
+
+    if "--create-decision" in args:
+        decision = _get_arg(args, "--decision", "")
+        reason = _get_arg(args, "--reason")
+        impact = _get_arg(args, "--impact")
+        
+        bridge.create_decision(decision=decision, reason=reason, impact=impact)
+        return
+
+    if "--sync" in args:
+        if not bridge.is_online:
+            print("❌ Flyee SaaS not configured. Run bridge.py --setup first.")
+            return
+        
+        unsynced = bridge.local.get_unsynced_tasks()
+        if not unsynced:
+            print("✅ All tasks are synced.")
+            return
+        
+        print(f"Syncing {len(unsynced)} tasks...")
+        for task in unsynced:
+            remote_id = bridge.remote.sync_task(task)
+            if remote_id:
+                bridge.local.mark_synced(task["id"], remote_id)
+                print(f"  ✅ {task['name']} → {remote_id[:8]}")
+            else:
+                print(f"  ❌ {task['name']} — sync failed")
+        return
+
+    print(f"Unknown command. Use --help for usage.")
+
+
+def _get_arg(args: list, flag: str, default: str = None) -> Optional[str]:
+    """Extract a flag value from args list."""
+    try:
+        idx = args.index(flag)
+        if idx + 1 < len(args) and not args[idx + 1].startswith("--"):
+            return args[idx + 1]
+    except ValueError:
+        pass
+    return default
+
+
+import sys
+
+if __name__ == "__main__":
+    main()