code-agnostic 0.1.0__py3-none-any.whl

code_agnostic/repositories/opencode.py

@@ -0,0 +1,83 @@
+from copy import deepcopy
+from pathlib import Path
+from typing import Any, Optional, Tuple
+
+from code_agnostic.errors import InvalidConfigSchemaError, InvalidJsonFormatError
+from code_agnostic.repositories.base import ITargetRepository
+from code_agnostic.utils import read_json_safe
+
+
+class OpenCodeRepository(ITargetRepository):
+    def __init__(self, root: Optional[Path] = None) -> None:
+        self._root = root or (Path.home() / ".config" / "opencode")
+
+    @property
+    def root(self) -> Path:
+        return self._root
+
+    @property
+    def config_path(self) -> Path:
+        return self.root / "opencode.json"
+
+    @property
+    def skills_dir(self) -> Path:
+        return self.root / "skills"
+
+    @property
+    def agents_dir(self) -> Path:
+        plural = self.root / "agents"
+        singular = self.root / "agent"
+        if plural.exists():
+            return plural
+        if singular.exists():
+            return singular
+        return plural
+
+    def load_config_object(self) -> Tuple[dict[str, Any], Optional[Exception]]:
+        payload, error = read_json_safe(self.config_path)
+        if error is not None:
+            return {}, InvalidJsonFormatError(self.config_path, error)
+        if payload is None:
+            return {}, None
+        if not isinstance(payload, dict):
+            return {}, InvalidConfigSchemaError(self.config_path, "must be a JSON object")
+        return payload, None
+
+    @staticmethod
+    def _migrate_legacy_permission(base: dict[str, Any], merged: dict[str, Any]) -> None:
+        permission = base.get("permission")
+        if not isinstance(permission, list):
+            return
+
+        tools = merged.get("tools")
+        if not isinstance(tools, dict):
+            tools = {}
+
+        for rule in permission:
+            if not isinstance(rule, dict):
+                continue
+            permission_name = rule.get("permission")
+            action = rule.get("action")
+            if not isinstance(permission_name, str) or not isinstance(action, str):
+                continue
+            if permission_name == "*":
+                continue
+            if action == "deny":
+                tools[permission_name] = False
+            elif action == "allow":
+                tools[permission_name] = True
+
+        if tools:
+            merged["tools"] = tools
+
+        merged.pop("permission", None)
+
+    def merge_config(self, existing: dict[str, Any], base: dict[str, Any], mapped_mcp: dict[str, Any]) -> dict[str, Any]:
+        merged = deepcopy(existing)
+        self._migrate_legacy_permission(base, merged)
+        for key, value in base.items():
+            if key == "permission" and isinstance(value, list):
+                continue
+            merged[key] = deepcopy(value)
+        merged["mcp"] = deepcopy(mapped_mcp)
+        return merged

code_agnostic/status.py

@@ -0,0 +1,136 @@
+from pathlib import Path
+from typing import Any, Optional
+
+from code_agnostic.constants import AGENTS_FILENAME
+from code_agnostic.models import (
+    ActionStatus,
+    EditorStatusRow,
+    EditorSyncStatus,
+    RepoSyncStatus,
+    SyncPlan,
+    WorkspaceRepoStatusRow,
+    WorkspaceStatusRow,
+    WorkspaceSyncStatus,
+)
+from code_agnostic.repositories.base import ISourceRepository, ITargetRepository
+from code_agnostic.utils import is_under
+from code_agnostic.workspaces import WorkspaceService
+
+
+class StatusService:
+    def __init__(self, workspace_service: Optional[WorkspaceService] = None) -> None:
+        self.workspace_service = workspace_service or WorkspaceService()
+
+    def build_editor_status(self, plan: SyncPlan, target_repo: ITargetRepository) -> list[EditorStatusRow]:
+        opencode_actions = self._opencode_actions(plan, target_repo)
+        opencode_synced = self._synced_from_actions(opencode_actions)
+
+        return [
+            EditorStatusRow(
+                name="opencode",
+                status=EditorSyncStatus.SYNCED if opencode_synced else EditorSyncStatus.DRIFT,
+                detail="in sync" if opencode_synced else "out of sync",
+            ),
+            EditorStatusRow(
+                name="cursor",
+                status=EditorSyncStatus.DISABLED,
+                detail="not managed",
+            ),
+        ]
+
+    def build_workspace_status(self, source_repo: ISourceRepository) -> list[WorkspaceStatusRow]:
+        status_rows: list[WorkspaceStatusRow] = []
+
+        for workspace in source_repo.load_workspaces():
+            workspace_name = workspace["name"]
+            workspace_path = Path(workspace["path"])
+
+            if not workspace_path.exists() or not workspace_path.is_dir():
+                status_rows.append(
+                    WorkspaceStatusRow(
+                        name=workspace_name,
+                        path=str(workspace_path),
+                        status=WorkspaceSyncStatus.ERROR,
+                        detail="workspace path missing",
+                        repos=[],
+                    )
+                )
+                continue
+
+            rules_file = self.workspace_service.resolve_rules_file(workspace_path)
+            if rules_file is None:
+                status_rows.append(
+                    WorkspaceStatusRow(
+                        name=workspace_name,
+                        path=str(workspace_path),
+                        status=WorkspaceSyncStatus.ERROR,
+                        detail="no workspace rules file",
+                        repos=[],
+                    )
+                )
+                continue
+
+            repos = self.workspace_service.discover_git_repos(workspace_path)
+            repo_rows = [self._repo_sync_status(repo, rules_file) for repo in repos]
+
+            detail = "all git repos synced"
+            status = WorkspaceSyncStatus.SYNCED
+            if not repos:
+                detail = "no git repos found"
+            elif any(item.status != RepoSyncStatus.SYNCED for item in repo_rows):
+                status = WorkspaceSyncStatus.DRIFT
+                detail = "one or more repos need sync"
+
+            status_rows.append(
+                WorkspaceStatusRow(
+                    name=workspace_name,
+                    path=str(workspace_path),
+                    status=status,
+                    detail=detail,
+                    repos=repo_rows,
+                )
+            )
+
+        return status_rows
+
+    @staticmethod
+    def _opencode_actions(plan: SyncPlan, target_repo: ITargetRepository) -> list[Any]:
+        skills_root = target_repo.skills_dir.resolve()
+        agents_root = target_repo.agents_dir.resolve()
+
+        relevant = []
+        for action in plan.actions:
+            if action.path == target_repo.config_path:
+                relevant.append(action)
+                continue
+            if is_under(action.path, skills_root) or is_under(action.path, agents_root):
+                relevant.append(action)
+        return relevant
+
+    @staticmethod
+    def _synced_from_actions(actions: list[Any]) -> bool:
+        if not actions:
+            return True
+        return all(action.status == ActionStatus.NOOP for action in actions)
+
+    @staticmethod
+    def _repo_sync_status(repo_path: Path, rules_file: Path) -> WorkspaceRepoStatusRow:
+        target = repo_path / AGENTS_FILENAME
+        desired = str(rules_file.resolve())
+        if target.is_symlink() and str(target.resolve()) == desired:
+            return WorkspaceRepoStatusRow(repo=repo_path.name, status=RepoSyncStatus.SYNCED, detail="linked")
+        return WorkspaceRepoStatusRow(
+            repo=repo_path.name,
+            status=RepoSyncStatus.NEEDS_SYNC,
+            detail=f"missing or mismatched {AGENTS_FILENAME}",
+        )
+
+
+def build_editor_status(plan: SyncPlan, opencode: ITargetRepository) -> list[dict[str, str]]:
+    rows = StatusService().build_editor_status(plan=plan, target_repo=opencode)
+    return [row.as_dict() for row in rows]
+
+
+def build_workspace_status(common: ISourceRepository) -> list[dict[str, Any]]:
+    rows = StatusService().build_workspace_status(source_repo=common)
+    return [row.as_dict() for row in rows]

code_agnostic/tui/__init__.py

@@ -0,0 +1,3 @@
+from code_agnostic.tui.renderers import SyncConsoleUI
+
+__all__ = ["SyncConsoleUI"]

code_agnostic/tui/enums.py

@@ -0,0 +1,24 @@
+from enum import Enum
+
+from code_agnostic.models import ActionStatus
+
+
+class UIStyle(str, Enum):
+    BLUE = "blue"
+    GREEN = "green"
+    YELLOW = "yellow"
+    RED = "red"
+    CYAN = "cyan"
+    MAGENTA = "magenta"
+    DIM = "dim"
+    WHITE = "white"
+
+
+ACTION_STATUS_STYLE = {
+    ActionStatus.CREATE: UIStyle.GREEN.value,
+    ActionStatus.UPDATE: UIStyle.CYAN.value,
+    ActionStatus.FIX: UIStyle.YELLOW.value,
+    ActionStatus.REMOVE: UIStyle.MAGENTA.value,
+    ActionStatus.NOOP: UIStyle.DIM.value,
+    ActionStatus.CONFLICT: UIStyle.RED.value,
+}

code_agnostic/tui/renderers.py

@@ -0,0 +1,79 @@
+from typing import List, Optional
+
+from rich.console import Console
+
+from code_agnostic.models import PlanResult, WorkspaceSyncStatus
+from code_agnostic.tui.enums import UIStyle
+from code_agnostic.tui.sections import UISection
+from code_agnostic.tui.tables import AppsTable, ApplyTable, PlanTable, StatusTable, WorkspaceTable
+
+
+class SyncConsoleUI:
+    def __init__(self, console: Optional[Console] = None) -> None:
+        self.console = console or Console()
+
+    def render_plan(self, plan: PlanResult, mode: str) -> None:
+        app_actions, workspace_actions = PlanTable.split_actions(plan)
+
+        self.console.print(UISection.wrap("plan overview", PlanTable.summary_block(plan, mode=mode), style=UIStyle.BLUE.value))
+
+        if app_actions:
+            self.console.print(
+                UISection.wrap("app config sync", PlanTable.actions_table(app_actions), style=UIStyle.CYAN.value)
+            )
+        if workspace_actions:
+            self.console.print(
+                UISection.wrap("workspace links", PlanTable.actions_table(workspace_actions), style=UIStyle.MAGENTA.value)
+            )
+        if not app_actions and not workspace_actions:
+            self.console.print(UISection.note("actions", "No actions required.", style=UIStyle.DIM.value))
+
+        if plan.errors:
+            errors_text = "\n".join([f"- {item}" for item in plan.errors])
+            self.console.print(UISection.note("errors", errors_text, style=UIStyle.RED.value))
+
+        if plan.skipped:
+            skipped_text = "\n".join([f"- {item}" for item in plan.skipped])
+            self.console.print(UISection.note("skipped", skipped_text, style=UIStyle.YELLOW.value))
+
+    def render_apply_result(self, applied: int, failed: int, failures: List[str]) -> None:
+        self.console.print(ApplyTable.stats_panel(applied=applied, failed=failed))
+        if failures:
+            failure_text = "\n".join([f"- {item}" for item in failures])
+            self.console.print(UISection.note("failures", failure_text, style=UIStyle.RED.value))
+
+    def render_workspace_saved(self, name: str, path: str, removed: bool = False) -> None:
+        verb = "removed" if removed else "added"
+        border_style = UIStyle.YELLOW.value if removed else UIStyle.GREEN.value
+        self.console.print(UISection.note("workspace", f"Workspace {verb}: [bold]{name}[/bold]\n{path}", style=border_style))
+
+    def render_workspaces_overview(self, items: List[dict]) -> None:
+        if not items:
+            self.console.print(UISection.note("workspaces", "No workspaces configured.", style=UIStyle.YELLOW.value))
+            return
+
+        self.console.print(UISection.wrap("workspaces", WorkspaceTable.overview_table(items), style=UIStyle.BLUE.value))
+        self.console.print(UISection.wrap("workspace repositories", WorkspaceTable.repos_table(items), style=UIStyle.CYAN.value))
+
+    def render_status(self, editors: List[dict], workspaces: List[dict]) -> None:
+        self.console.print(UISection.wrap("app config sync", StatusTable.editor_table(editors), style=UIStyle.BLUE.value))
+
+        if not workspaces:
+            self.console.print(UISection.note("workspace sync", "No workspaces configured.", style=UIStyle.YELLOW.value))
+            return
+
+        workspace_style = UIStyle.GREEN.value
+        if any(item.get("status") == WorkspaceSyncStatus.DRIFT.value for item in workspaces):
+            workspace_style = UIStyle.YELLOW.value
+        if any(item.get("status") == WorkspaceSyncStatus.ERROR.value for item in workspaces):
+            workspace_style = UIStyle.RED.value
+
+        self.console.print(
+            UISection.wrap("workspace sync", StatusTable.workspace_overview(workspaces), style=workspace_style)
+        )
+        self.console.print(
+            UISection.wrap("workspace repositories", StatusTable.workspace_repos_group(workspaces), style=UIStyle.CYAN.value)
+        )
+
+    def render_apps(self, items: List[dict]) -> None:
+        self.console.print(UISection.wrap("apps", AppsTable.apps_table(items), style=UIStyle.BLUE.value))

code_agnostic/tui/sections.py

@@ -0,0 +1,15 @@
+from typing import Optional
+
+from rich.panel import Panel
+
+from code_agnostic.tui.enums import UIStyle
+
+
+class UISection:
+    @staticmethod
+    def wrap(title: str, body, style: str = UIStyle.BLUE.value, subtitle: Optional[str] = None) -> Panel:
+        return Panel(body, title=title, subtitle=subtitle, border_style=style, padding=(0, 1))
+
+    @staticmethod
+    def note(title: str, body: str, style: str) -> Panel:
+        return Panel(body, title=title, border_style=style, padding=(0, 1))

code_agnostic/tui/tables.py

@@ -0,0 +1,201 @@
+from collections import Counter
+from typing import Dict, List
+
+from rich.console import Group
+from rich.padding import Padding
+from rich.panel import Panel
+from rich.table import Column, Table
+from rich.text import Text
+
+from code_agnostic.constants import AGENTS_FILENAME
+from code_agnostic.models import Action, AppSyncStatus, EditorSyncStatus, PlanResult, RepoSyncStatus, WorkspaceSyncStatus
+from code_agnostic.tui.enums import ACTION_STATUS_STYLE, UIStyle
+
+
+class PlanTable:
+    @staticmethod
+    def summary_block(plan: PlanResult, mode: str):
+        counts = Counter(action.status.value for action in plan.actions)
+        chips = [f"{key}={value}" for key, value in sorted(counts.items()) if value > 0]
+        if not chips:
+            chips = ["none"]
+
+        table = Table.grid(padding=(0, 2))
+        table.add_column(style="bold")
+        table.add_column()
+        table.add_row("Mode", mode)
+        table.add_row("Actions", str(len(plan.actions)))
+        table.add_row("Statuses", "  ".join(chips))
+        return table
+
+    @staticmethod
+    def split_actions(plan: PlanResult) -> tuple[list[Action], list[Action]]:
+        app_actions: list[Action] = []
+        workspace_actions: list[Action] = []
+        for action in plan.actions:
+            is_workspace_link = action.path.name == AGENTS_FILENAME
+            if is_workspace_link:
+                workspace_actions.append(action)
+            else:
+                app_actions.append(action)
+        return app_actions, workspace_actions
+
+    @staticmethod
+    def actions_table(actions: list[Action]) -> Table:
+        table = Table(
+            Column(header="Type", width=12),
+            Column(header="Status", width=10),
+            Column(header="Target", overflow="ellipsis", max_width=58),
+            Column(header="Source", overflow="ellipsis", max_width=42),
+            Column(header="Reason", overflow="ellipsis"),
+            expand=True,
+            header_style="bold",
+        )
+
+        for action in actions:
+            source = str(action.source) if action.source is not None else ""
+            status_value = action.status.value
+            status_style = ACTION_STATUS_STYLE.get(action.status, UIStyle.WHITE.value)
+            status_text = f"[{status_style}]{status_value}[/{status_style}]"
+            table.add_row(action.kind.value, status_text, str(action.path), source, action.detail)
+        return table
+
+
+class ApplyTable:
+    @staticmethod
+    def stats_panel(applied: int, failed: int) -> Panel:
+        stats: Dict[str, str] = {
+            "applied": str(applied),
+            "failed": str(failed),
+        }
+        table = Table(show_header=False, box=None)
+        for key, value in stats.items():
+            table.add_row(f"[bold]{key}[/bold]", value)
+        return Panel(table, title="apply", border_style=UIStyle.GREEN.value if failed == 0 else UIStyle.RED.value)
+
+
+class WorkspaceTable:
+    @staticmethod
+    def overview_table(items: List[dict]) -> Table:
+        table = Table(
+            Column(header="Workspace", width=24),
+            Column(header="Path", overflow="ellipsis"),
+            Column(header="Repos", width=8, justify="right"),
+            expand=True,
+            header_style="bold",
+        )
+        for item in items:
+            table.add_row(item["name"], item["path"], str(len(item["repos"])))
+        return table
+
+    @staticmethod
+    def repos_table(items: List[dict]) -> Table:
+        table = Table(
+            Column(header="Workspace", width=24),
+            Column(header="Repositories", overflow="fold"),
+            expand=True,
+            header_style="bold",
+        )
+        for item in items:
+            repos = item.get("repos", [])
+            if not repos:
+                repo_line = "(no git repos found)"
+            else:
+                repo_line = ", ".join(repos)
+            table.add_row(item["name"], repo_line)
+        return table
+
+
+class StatusTable:
+    @staticmethod
+    def editor_table(items: List[dict]) -> Table:
+        table = Table(
+            "Editor",
+            "Status",
+            "Detail",
+            expand=True,
+            header_style="bold",
+        )
+        for item in items:
+            status = item["status"]
+            style = (
+                UIStyle.GREEN.value
+                if status == EditorSyncStatus.SYNCED.value
+                else UIStyle.YELLOW.value
+                if status == EditorSyncStatus.DISABLED.value
+                else UIStyle.RED.value
+            )
+            table.add_row(item["name"], f"[{style}]{status}[/{style}]", item["detail"])
+        return table
+
+    @staticmethod
+    def workspace_overview(items: List[dict]) -> Table:
+        table = Table(
+            Column(header="Workspace", width=24),
+            Column(header="Status", width=12),
+            Column(header="Repos", width=8, justify="right"),
+            Column(header="Detail", overflow="ellipsis"),
+            expand=True,
+            header_style="bold",
+        )
+        for item in items:
+            status = item["status"]
+            style = (
+                UIStyle.GREEN.value
+                if status == WorkspaceSyncStatus.SYNCED.value
+                else UIStyle.RED.value
+                if status == WorkspaceSyncStatus.ERROR.value
+                else UIStyle.YELLOW.value
+            )
+            table.add_row(
+                item["name"],
+                f"[{style}]{status}[/{style}]",
+                str(len(item.get("repos", []))),
+                item["detail"],
+            )
+        return table
+
+    @staticmethod
+    def workspace_repos_group(items: List[dict]):
+        blocks = []
+        for item in items:
+            repos = item.get("repos", [])
+            heading = Text(f"{item['name']}", style="bold")
+            if not repos:
+                blocks.append(Group(heading, Text("  (no git repos found)", style=UIStyle.DIM.value)))
+                continue
+
+            repo_table = Table(
+                Column(header="Repo", width=28),
+                Column(header="Status", width=12),
+                Column(header="Detail", overflow="ellipsis"),
+                expand=True,
+                header_style="bold",
+            )
+            for repo in repos:
+                status = repo["status"]
+                style = UIStyle.GREEN.value if status == RepoSyncStatus.SYNCED.value else UIStyle.YELLOW.value
+                label = RepoSyncStatus.SYNCED.value if status == RepoSyncStatus.SYNCED.value else "needs sync"
+                repo_table.add_row(repo["repo"], f"[{style}]{label}[/{style}]", repo["detail"])
+            blocks.append(Group(heading, Padding(repo_table, (0, 0, 0, 2))))
+
+        if not blocks:
+            return Text("No workspace details.", style=UIStyle.DIM.value)
+        return Group(*blocks)
+
+
+class AppsTable:
+    @staticmethod
+    def apps_table(items: List[dict]) -> Table:
+        table = Table(
+            Column(header="App", width=14),
+            Column(header="Status", width=12),
+            Column(header="Detail", overflow="ellipsis"),
+            expand=True,
+            header_style="bold",
+        )
+        for item in items:
+            status = item["status"]
+            style = UIStyle.GREEN.value if status == AppSyncStatus.ENABLED.value else UIStyle.YELLOW.value
+            table.add_row(item["name"], f"[{style}]{status}[/{style}]", item["detail"])
+        return table

code_agnostic/utils.py

@@ -0,0 +1,53 @@
+import json
+import shutil
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Optional, Tuple
+
+
+def now_stamp() -> str:
+    return datetime.now().strftime("%Y%m%d-%H%M%S")
+
+
+def read_json(path: Path) -> Any:
+    with path.open("r", encoding="utf-8") as handle:
+        return json.load(handle)
+
+
+def read_json_safe(path: Path) -> Tuple[Optional[Any], Optional[str]]:
+    if not path.exists():
+        return None, None
+    if path.stat().st_size == 0:
+        return None, None
+    try:
+        return read_json(path), None
+    except Exception as exc:
+        return None, str(exc)
+
+
+def write_json(path: Path, payload: Any) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as handle:
+        json.dump(payload, handle, indent=2, sort_keys=False)
+        handle.write("\n")
+
+
+def backup_file(path: Path) -> Path:
+    backup_path = Path(f"{path}.bak-{now_stamp()}")
+    shutil.copy2(path, backup_path)
+    return backup_path
+
+
+def same_json(path: Path, payload: Any) -> bool:
+    existing, error = read_json_safe(path)
+    if error is not None:
+        return False
+    return existing == payload
+
+
+def is_under(path: Path, root: Path) -> bool:
+    try:
+        path.resolve().relative_to(root.resolve())
+        return True
+    except Exception:
+        return False

code_agnostic/workspaces.py

@@ -0,0 +1,45 @@
+import os
+from pathlib import Path
+from typing import Optional
+
+from code_agnostic.constants import AGENTS_FILENAME, GIT_DIRNAME, WORKSPACE_IGNORED_DIRS, WORKSPACE_RULE_FILES
+
+
+class WorkspaceService:
+    def resolve_rules_file(self, workspace_path: Path) -> Optional[Path]:
+        for candidate in WORKSPACE_RULE_FILES:
+            rule_path = workspace_path / candidate
+            if rule_path.exists() and rule_path.is_file():
+                return rule_path
+        return None
+
+
+    def discover_git_repos(self, workspace_path: Path) -> list[Path]:
+        repos: list[Path] = []
+        workspace_real = workspace_path.resolve()
+
+        for root, dir_names, _ in os.walk(str(workspace_real), topdown=True):
+            current = Path(root)
+            if current == workspace_real:
+                pass
+            elif (current / GIT_DIRNAME).exists():
+                repos.append(current)
+                dir_names[:] = []
+                continue
+
+            dir_names[:] = [name for name in dir_names if not name.startswith(".") and name not in WORKSPACE_IGNORED_DIRS]
+
+        return sorted(set(repos))
+
+    def workspace_sync_targets(self, workspace_path: Path, rules_file: Optional[Path]) -> list[Path]:
+        if rules_file is None:
+            return []
+        return [repo / AGENTS_FILENAME for repo in self.discover_git_repos(workspace_path)]
+
+
+def resolve_workspace_rules_file(workspace_path: Path) -> Optional[Path]:
+    return WorkspaceService().resolve_rules_file(workspace_path)
+
+
+def list_workspace_repos(workspace_path: Path) -> list[Path]:
+    return WorkspaceService().discover_git_repos(workspace_path)