pocketcoder-a1 0.1.0__py3-none-any.whl

a1/__init__.py

@@ -0,0 +1,6 @@
+"""
+PocketCoder-A1: Autonomous Coding Agent
+"""
+
+__version__ = "0.1.0"
+__codename__ = "Autonomous Gnome"

a1/checkpoint.py

@@ -0,0 +1,146 @@
+"""
+Checkpoint Manager — сохранение состояния между сессиями
+"""
+
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+class CheckpointManager:
+    """Управление checkpoint'ами для автономной работы"""
+
+    def __init__(self, project_dir: Path):
+        self.project_dir = Path(project_dir)
+        self.a1_dir = self.project_dir / ".a1"
+        self.checkpoint_file = self.a1_dir / "checkpoint.json"
+        self.checkpoints_dir = self.a1_dir / "checkpoints"
+
+        # Создаём структуру если не существует
+        self.a1_dir.mkdir(parents=True, exist_ok=True)
+        self.checkpoints_dir.mkdir(exist_ok=True)
+
+    def load(self) -> Dict[str, Any]:
+        """Загрузить текущий checkpoint"""
+        if not self.checkpoint_file.exists():
+            return self._create_initial()
+
+        try:
+            with open(self.checkpoint_file, "r") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError):
+            return self._create_initial()
+
+    def save(self, checkpoint: Dict[str, Any]) -> None:
+        """Сохранить checkpoint"""
+        checkpoint["updated_at"] = datetime.now().isoformat()
+
+        # Сохраняем текущий
+        with open(self.checkpoint_file, "w") as f:
+            json.dump(checkpoint, f, indent=2, ensure_ascii=False)
+
+        # Архивируем копию
+        session = checkpoint.get("session", 0)
+        archive_file = self.checkpoints_dir / f"session_{session:03d}.json"
+        with open(archive_file, "w") as f:
+            json.dump(checkpoint, f, indent=2, ensure_ascii=False)
+
+    def _create_initial(self) -> Dict[str, Any]:
+        """Создать начальный checkpoint"""
+        return {
+            "status": "STARTING",
+            "session": 0,
+            "current_task": None,
+            "context_percent": 0,
+            "files_modified": [],
+            "decisions": [],
+            "next_steps": [],
+            "last_action": None,
+            "created_at": datetime.now().isoformat(),
+            "updated_at": datetime.now().isoformat(),
+        }
+
+    def start_session(self) -> Dict[str, Any]:
+        """Начать новую сессию"""
+        checkpoint = self.load()
+        checkpoint["session"] += 1
+        checkpoint["status"] = "WORKING"
+        checkpoint["session_started_at"] = datetime.now().isoformat()
+        self.save(checkpoint)
+        return checkpoint
+
+    def end_session(
+        self,
+        current_task: Optional[str] = None,
+        files_modified: Optional[List[str]] = None,
+        decisions: Optional[List[str]] = None,
+        next_steps: Optional[List[str]] = None,
+        last_action: Optional[str] = None,
+        context_percent: int = 0,
+    ) -> None:
+        """Завершить сессию с сохранением состояния"""
+        checkpoint = self.load()
+
+        if current_task:
+            checkpoint["current_task"] = current_task
+        if files_modified:
+            # Добавляем к существующим, убираем дубли
+            existing = set(checkpoint.get("files_modified", []))
+            existing.update(files_modified)
+            checkpoint["files_modified"] = list(existing)
+        if decisions:
+            checkpoint["decisions"].extend(decisions)
+            checkpoint["decisions"] = checkpoint["decisions"][-20:]
+        if next_steps:
+            checkpoint["next_steps"] = next_steps
+        if last_action:
+            checkpoint["last_action"] = last_action
+
+        checkpoint["context_percent"] = context_percent
+        checkpoint["session_ended_at"] = datetime.now().isoformat()
+
+        self.save(checkpoint)
+
+    def mark_completed(self) -> None:
+        """Отметить всю работу как завершённую"""
+        checkpoint = self.load()
+        checkpoint["status"] = "COMPLETED"
+        checkpoint["completed_at"] = datetime.now().isoformat()
+        self.save(checkpoint)
+
+    def is_completed(self) -> bool:
+        """Проверить завершена ли работа"""
+        checkpoint = self.load()
+        return checkpoint.get("status") == "COMPLETED"
+
+    def get_session_number(self) -> int:
+        """Получить номер текущей сессии"""
+        checkpoint = self.load()
+        return checkpoint.get("session", 0)
+
+    def get_summary(self) -> str:
+        """Получить текстовое резюме для промпта"""
+        cp = self.load()
+
+        lines = [
+            f"## Checkpoint (Session #{cp['session']})",
+            f"Status: {cp['status']}",
+            f"Current task: {cp.get('current_task', 'None')}",
+            f"Last action: {cp.get('last_action', 'None')}",
+        ]
+
+        if cp.get("files_modified"):
+            lines.append(f"Files modified: {', '.join(cp['files_modified'][-10:])}")
+
+        if cp.get("decisions"):
+            lines.append("Recent decisions:")
+            for d in cp["decisions"][-5:]:
+                lines.append(f"  - {d}")
+
+        if cp.get("next_steps"):
+            lines.append("Next steps:")
+            for s in cp["next_steps"]:
+                lines.append(f"  - {s}")
+
+        return "\n".join(lines)

a1/cli.py

@@ -0,0 +1,368 @@
+#!/usr/bin/env python3
+"""
+PocketCoder-A1 CLI — Autonomous Coding Agent
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+from . import __codename__, __version__
+from .checkpoint import CheckpointManager
+from .config import Config
+from .dashboard import run_dashboard
+from .loop import SessionLoop
+from .tasks import TaskManager
+from .validator import Validator
+
+
+def cmd_init(args):
+    """Initialize A1 in project directory"""
+    project_dir = Path(args.dir if hasattr(args, 'dir') else args.project).resolve()
+
+    if not project_dir.exists():
+        print(f"[ERROR] Directory not found: {project_dir}")
+        return 1
+
+    # Создаём структуру
+    a1_dir = project_dir / ".a1"
+    a1_dir.mkdir(exist_ok=True)
+    (a1_dir / "sessions").mkdir(exist_ok=True)
+    (a1_dir / "checkpoints").mkdir(exist_ok=True)
+
+    # Инициализируем менеджеры
+    CheckpointManager(project_dir)
+    TaskManager(project_dir)
+
+    print(f"[OK] A1 initialized in {project_dir}")
+    print(f"   Created: {a1_dir}")
+    print()
+    print("Next steps:")
+    print("  pca think 'your task idea'   # Add tasks")
+    print("  pca tasks                     # View tasks")
+    print("  pca start                     # Start autonomous work")
+
+    return 0
+
+
+def cmd_think(args):
+    """Add a raw thought"""
+    project_dir = Path(args.project).resolve()
+    tasks = TaskManager(project_dir)
+
+    thought = " ".join(args.thought)
+    tasks.add_raw_thought(thought)
+
+    print(f"[THOUGHT] Added: {thought}")
+    print()
+    print("Use 'pca transform' to convert thoughts to tasks")
+    print("Or 'pca task add \"...\"' to add a specific task")
+
+    return 0
+
+
+def cmd_task_add(args):
+    """Add a specific task"""
+    project_dir = Path(args.project).resolve()
+    tasks = TaskManager(project_dir)
+
+    title = " ".join(args.title)
+    task = tasks.add_task(title, description=args.description or "")
+
+    print(f"[OK] Added task: [{task.id}] {task.title}")
+
+    return 0
+
+
+def cmd_tasks(args):
+    """Show all tasks"""
+    project_dir = Path(args.project).resolve()
+    tasks = TaskManager(project_dir)
+
+    print(tasks.get_summary())
+
+    return 0
+
+
+def cmd_start(args):
+    """Start autonomous work"""
+    project_dir = Path(args.project).resolve()
+
+    # Проверяем что A1 инициализирован
+    if not (project_dir / ".a1").exists():
+        print(f"[ERROR] A1 not initialized. Run: pca init {project_dir}")
+        return 1
+
+    # Проверяем есть ли задачи
+    tasks = TaskManager(project_dir)
+    pending = tasks.get_tasks(status="pending")
+    in_progress = tasks.get_tasks(status="in_progress")
+
+    if not pending and not in_progress:
+        print("[ERROR] No tasks to work on!")
+        print("   Add tasks with: pca think 'idea' or pca task add 'task'")
+        return 1
+
+    # Load config and merge with CLI args
+    config = Config(project_dir)
+    resolved = config.resolve(cli_args={
+        "provider": args.provider if args.provider != "claude-max" else None,
+        "model": getattr(args, "model", None),
+        "api_key": getattr(args, "api_key", None),
+        "ollama_host": getattr(args, "ollama_host", None),
+        "ollama_model": getattr(args, "ollama_model", None),
+        "max_sessions": args.max_sessions if args.max_sessions != 100 else None,
+        "max_turns": getattr(args, "max_turns", None),
+        "session_delay": getattr(args, "session_delay", None),
+    })
+
+    loop = SessionLoop(project_dir=project_dir, **resolved)
+    loop.start()
+
+    return 0
+
+
+def cmd_status(args):
+    """Show current status"""
+    project_dir = Path(args.project).resolve()
+
+    checkpoint = CheckpointManager(project_dir)
+    tasks = TaskManager(project_dir)
+    validator = Validator(project_dir)
+
+    print("=" * 50)
+    print("AUTONOMOUS GNOME STATUS")
+    print("=" * 50)
+    print()
+    print(checkpoint.get_summary())
+    print()
+    print(tasks.get_summary())
+
+    if args.validate:
+        print()
+        print(validator.get_summary())
+
+    return 0
+
+
+def cmd_validate(args):
+    """Run validation checks"""
+    project_dir = Path(args.project).resolve()
+    validator = Validator(project_dir)
+
+    print(validator.get_summary())
+
+    return 0
+
+
+def cmd_dashboard(args):
+    """Launch web dashboard"""
+    project_dir = Path(args.project).resolve()
+    run_dashboard(project_dir, port=args.port, open_browser=not args.no_browser)
+    return 0
+
+
+def cmd_test(args):
+    """Run E2E tests with real Playwright browser"""
+    project_dir = Path(args.project).resolve()
+
+    from .tester.runner import VisionTester
+
+    tester = VisionTester(
+        project_dir=project_dir,
+        base_url=f"http://localhost:{args.port}",
+    )
+
+    if args.scenario:
+        report = tester.run_one(args.scenario)
+    else:
+        report = tester.run_all()
+
+    return 0 if report.failed == 0 and report.errors == 0 else 1
+
+
+def cmd_log(args):
+    """Show session log"""
+    project_dir = Path(args.project).resolve()
+    checkpoints_dir = project_dir / ".a1" / "checkpoints"
+
+    if not checkpoints_dir.exists():
+        print("No sessions yet.")
+        return 0
+
+    sessions = sorted(checkpoints_dir.glob("session_*.json"))
+
+    if args.session:
+        # Показать конкретную сессию
+        session_file = checkpoints_dir / f"session_{args.session:03d}.json"
+        if session_file.exists():
+            print(session_file.read_text())
+        else:
+            print(f"Session {args.session} not found")
+    else:
+        # Показать список сессий
+        print(f"Sessions: {len(sessions)}")
+        for s in sessions[-10:]:  # Последние 10
+            print(f"  - {s.name}")
+
+    return 0
+
+
+def cmd_config(args):
+    """View or edit configuration"""
+    project_dir = Path(args.project).resolve()
+    config = Config(project_dir)
+
+    if args.reset:
+        config.reset()
+        print("[OK] Config reset to defaults")
+        return 0
+
+    if not args.key:
+        # Show all config
+        from .config import DEFAULTS
+        data = config.get_all()
+        print("=" * 50)
+        print("CONFIGURATION")
+        print("=" * 50)
+        print(f"  File: {config.path}")
+        print()
+        for key in DEFAULTS:
+            val = data.get(key)
+            # Mask API key
+            if key == "api_key" and val:
+                val = config.mask_api_key(val)
+            default = DEFAULTS[key]
+            marker = "" if val == default else " (custom)"
+            print(f"  {key}: {val}{marker}")
+        return 0
+
+    if args.value is None:
+        # Show single value
+        val = config.get(args.key)
+        if args.key == "api_key" and val:
+            val = config.mask_api_key(val)
+        print(f"{args.key}: {val}")
+        return 0
+
+    # Set value (auto-convert types)
+    value = args.value
+    if value.lower() in ("true", "false"):
+        value = value.lower() == "true"
+    elif value == "null" or value == "none":
+        value = None
+    else:
+        try:
+            value = int(value)
+        except ValueError:
+            try:
+                value = float(value)
+            except ValueError:
+                pass  # keep as string
+
+    config.set(args.key, value)
+    display = config.mask_api_key(value) if args.key == "api_key" and value else value
+    print(f"[OK] {args.key} = {display}")
+    return 0
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="pca",
+        description=f"PocketCoder-A1 v{__version__} ({__codename__})",
+    )
+    parser.add_argument(
+        "-V", "--version", action="version", version=f"%(prog)s {__version__}"
+    )
+    parser.add_argument(
+        "-p", "--project", default=".", help="Project directory (default: current)"
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Commands")
+
+    # init
+    p_init = subparsers.add_parser("init", help="Initialize A1 in project")
+    p_init.add_argument("dir", nargs="?", default=".", help="Project directory")
+    p_init.set_defaults(func=cmd_init)
+
+    # think
+    p_think = subparsers.add_parser("think", help="Add a raw thought")
+    p_think.add_argument("thought", nargs="+", help="Your thought")
+    p_think.set_defaults(func=cmd_think)
+
+    # task add
+    p_task = subparsers.add_parser("task", help="Task management")
+    task_sub = p_task.add_subparsers(dest="task_cmd")
+
+    p_task_add = task_sub.add_parser("add", help="Add a task")
+    p_task_add.add_argument("title", nargs="+", help="Task title")
+    p_task_add.add_argument("-d", "--description", help="Task description")
+    p_task_add.set_defaults(func=cmd_task_add)
+
+    # tasks
+    p_tasks = subparsers.add_parser("tasks", help="Show all tasks")
+    p_tasks.set_defaults(func=cmd_tasks)
+
+    # start
+    p_start = subparsers.add_parser("start", help="Start autonomous work")
+    p_start.add_argument(
+        "--provider",
+        default="claude-max",
+        choices=["claude-max", "claude-api", "ollama"],
+        help="AI provider",
+    )
+    p_start.add_argument(
+        "--max-sessions", type=int, default=100, help="Max sessions"
+    )
+    p_start.add_argument("--model", help="Model name (provider-specific)")
+    p_start.add_argument("--api-key", help="Anthropic API key (or env ANTHROPIC_API_KEY)")
+    p_start.add_argument("--ollama-host", help="Ollama host URL")
+    p_start.add_argument("--ollama-model", help="Ollama model name")
+    p_start.add_argument("--max-turns", type=int, help="Max turns per session (default: 25)")
+    p_start.add_argument("--session-delay", type=int, help="Delay between sessions in seconds")
+    p_start.set_defaults(func=cmd_start)
+
+    # status
+    p_status = subparsers.add_parser("status", help="Show status")
+    p_status.add_argument("-v", "--validate", action="store_true", help="Run validation")
+    p_status.set_defaults(func=cmd_status)
+
+    # validate
+    p_validate = subparsers.add_parser("validate", help="Run validation checks")
+    p_validate.set_defaults(func=cmd_validate)
+
+    # log
+    p_log = subparsers.add_parser("log", help="Show session log")
+    p_log.add_argument("-s", "--session", type=int, help="Session number")
+    p_log.set_defaults(func=cmd_log)
+
+    # test (vision tester)
+    p_test = subparsers.add_parser("test", help="Run E2E tests with real Playwright browser")
+    p_test.add_argument("-s", "--scenario", type=int, help="Run specific scenario (1-7)")
+    p_test.add_argument("--port", type=int, default=7331, help="Dashboard port (default: 7331)")
+    p_test.set_defaults(func=cmd_test)
+
+    # config
+    p_config = subparsers.add_parser("config", help="View/edit configuration")
+    p_config.add_argument("key", nargs="?", help="Config key to get/set")
+    p_config.add_argument("value", nargs="?", help="Value to set")
+    p_config.add_argument("--reset", action="store_true", help="Reset to defaults")
+    p_config.set_defaults(func=cmd_config)
+
+    # dashboard (web UI)
+    p_dash = subparsers.add_parser("ui", help="Launch web dashboard")
+    p_dash.add_argument("--port", type=int, default=None, help="Port (default: auto-find from 7331)")
+    p_dash.add_argument("--no-browser", action="store_true", help="Don't open browser")
+    p_dash.set_defaults(func=cmd_dashboard)
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        return 0
+
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

a1/config.py

@@ -0,0 +1,126 @@
+"""
+a1/config.py — Configuration management for PocketCoder-A1.
+
+Loads/saves .a1/config.json with priority resolution:
+  CLI args > env vars > config.json > defaults
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Optional
+
+DEFAULTS = {
+    "provider": "claude-max",
+    "model": None,
+    "api_key": None,
+    "ollama_host": "http://localhost:11434",
+    "ollama_model": "qwen3:30b-a3b",
+    "max_sessions": 100,
+    "max_turns": 25,
+    "session_delay": 5,
+    "context_threshold": 0.70,
+}
+
+# Env var → config key mapping
+ENV_MAP = {
+    "ANTHROPIC_API_KEY": "api_key",
+    "OLLAMA_HOST": "ollama_host",
+    "OLLAMA_MODEL": "ollama_model",
+}
+
+
+class Config:
+    """Configuration manager — load/save/resolve .a1/config.json."""
+
+    def __init__(self, project_dir: Path):
+        self.project_dir = Path(project_dir)
+        self.path = self.project_dir / ".a1" / "config.json"
+        self._data: dict = {}
+        self.load()
+
+    def load(self) -> dict:
+        """Load from disk. Returns stored values (not merged with defaults)."""
+        if self.path.exists():
+            try:
+                self._data = json.loads(self.path.read_text(encoding="utf-8"))
+            except (json.JSONDecodeError, OSError):
+                self._data = {}
+        else:
+            self._data = {}
+        return self._data
+
+    def save(self) -> None:
+        """Save current data to .a1/config.json."""
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self.path.write_text(
+            json.dumps(self._data, indent=2, ensure_ascii=False) + "\n",
+            encoding="utf-8",
+        )
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get value with fallback: config → DEFAULTS → default."""
+        if key in self._data and self._data[key] is not None:
+            return self._data[key]
+        if key in DEFAULTS and DEFAULTS[key] is not None:
+            return DEFAULTS[key]
+        return default
+
+    def set(self, key: str, value: Any) -> None:
+        """Set a value and save to disk."""
+        self._data[key] = value
+        self.save()
+
+    def get_all(self) -> dict:
+        """Get full config merged with defaults."""
+        result = dict(DEFAULTS)
+        result.update({k: v for k, v in self._data.items() if v is not None})
+        return result
+
+    def reset(self) -> None:
+        """Reset to defaults."""
+        self._data = {}
+        self.save()
+
+    def resolve(self, cli_args: Optional[dict] = None) -> dict:
+        """Merge all sources: CLI > env > config > defaults.
+
+        Returns dict with keys matching SessionLoop.__init__ params:
+          provider, model, api_key, ollama_host, ollama_model,
+          max_sessions, max_turns, session_delay
+        """
+        # 1. Start with defaults
+        result = dict(DEFAULTS)
+
+        # 2. Overlay config.json values
+        for k, v in self._data.items():
+            if v is not None:
+                result[k] = v
+
+        # 3. Overlay env vars
+        for env_var, config_key in ENV_MAP.items():
+            val = os.environ.get(env_var)
+            if val:
+                result[config_key] = val
+
+        # 4. Overlay CLI args (skip None values — means "not provided")
+        if cli_args:
+            for k, v in cli_args.items():
+                if v is not None:
+                    result[k] = v
+
+        # Remove context_threshold from result (it's not a SessionLoop param)
+        # Store it separately so loop.py can access if needed
+        result.pop("context_threshold", None)
+
+        return result
+
+    def mask_api_key(self, key: Optional[str] = None) -> Optional[str]:
+        """Mask API key for display: sk-ant-api03-...xxxx."""
+        k = key or self.get("api_key")
+        if not k or len(k) < 8:
+            return k
+        return k[:10] + "..." + k[-4:]
+
+    def __repr__(self) -> str:
+        return f"Config({self.path}, keys={list(self._data.keys())})"