code-agnostic 0.1.0__py3-none-any.whl

code_agnostic/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

code_agnostic/__main__.py

@@ -0,0 +1,275 @@
+from pathlib import Path
+from typing import Dict
+
+import click
+from rich.console import Console
+
+from code_agnostic.apps import AppsService
+from code_agnostic.executor import SyncExecutor
+from code_agnostic.models import AppId, EditorStatusRow, EditorSyncStatus, SyncPlan, SyncTarget
+from code_agnostic.planner import SyncPlanner
+from code_agnostic.repositories.common import CommonRepository
+from code_agnostic.repositories.opencode import OpenCodeRepository
+from code_agnostic.status import StatusService
+from code_agnostic.tui import SyncConsoleUI
+from code_agnostic.workspaces import WorkspaceService
+
+
+def _repos_from_obj(_obj: Dict[str, str]) -> tuple[CommonRepository, OpenCodeRepository]:
+    common = CommonRepository()
+    opencode = OpenCodeRepository()
+    return common, opencode
+
+
+def _empty_plan(skipped_reason: str) -> SyncPlan:
+    return SyncPlan(actions=[], errors=[], skipped=[skipped_reason])
+
+
+def _cursor_status_row(apps: AppsService) -> EditorStatusRow:
+    if apps.is_enabled(AppId.CURSOR):
+        return EditorStatusRow(
+            name="cursor",
+            status=EditorSyncStatus.ERROR,
+            detail="enabled but sync is not implemented yet",
+        )
+    return EditorStatusRow(
+        name="cursor",
+        status=EditorSyncStatus.DISABLED,
+        detail="disabled by apps config",
+    )
+
+
+@click.group(context_settings={"help_option_names": ["-h", "--help"]})
+@click.pass_context
+def cli(ctx: click.Context) -> None:
+    """OpenCode-first config sync."""
+    ctx.obj = {}
+
+
+@cli.command(help="Build and print a dry-run plan.")
+@click.pass_obj
+def plan(obj: Dict[str, str]) -> None:
+    ui = SyncConsoleUI(Console())
+    common, opencode = _repos_from_obj(obj)
+    apps = AppsService(common)
+
+    if not apps.is_enabled(AppId.OPENCODE):
+        enabled = apps.enabled_apps()
+        if enabled:
+            names = ", ".join([app.value for app in enabled])
+            plan_result = _empty_plan(f"Enabled apps not implemented for planning yet: {names}")
+        else:
+            plan_result = _empty_plan("No apps enabled for plan (enable 'opencode' first).")
+    else:
+        try:
+            plan_result = SyncPlanner(common=common, opencode=opencode).build()
+        except Exception as exc:
+            raise click.ClickException(f"Fatal: {exc}")
+
+    ui.render_plan(plan_result, mode="plan")
+
+    if plan_result.errors:
+        raise click.exceptions.Exit(1)
+
+
+@cli.command(help="Apply planned sync changes.")
+@click.argument(
+    "target",
+    required=False,
+    type=click.Choice([SyncTarget.ALL.value, SyncTarget.OPENCODE.value], case_sensitive=False),
+    default=SyncTarget.ALL.value,
+)
+@click.pass_obj
+def apply(obj: Dict[str, str], target: str) -> None:
+    ui = SyncConsoleUI(Console())
+    common, opencode = _repos_from_obj(obj)
+    apps = AppsService(common)
+
+    if not apps.is_enabled(AppId.OPENCODE):
+        enabled = apps.enabled_apps()
+        if enabled:
+            names = ", ".join([app.value for app in enabled])
+            plan_result = _empty_plan(f"Enabled apps not implemented for apply yet: {names}")
+        else:
+            plan_result = _empty_plan("No apps enabled for apply (enable 'opencode' first).")
+        ui.render_plan(plan_result, mode=f"apply:{target.lower()}")
+        ui.render_apply_result(applied=0, failed=0, failures=[])
+        return
+
+    try:
+        plan_result = SyncPlanner(common=common, opencode=opencode).build()
+    except Exception as exc:
+        raise click.ClickException(f"Fatal: {exc}")
+
+    normalized_target = SyncTarget(target.lower())
+    scoped_plan = plan_result.filter_for_target(
+        target=normalized_target,
+        config_path=opencode.config_path,
+        skills_root=opencode.skills_dir,
+        agents_root=opencode.agents_dir,
+    )
+
+    ui.render_plan(scoped_plan, mode=f"apply:{normalized_target.value}")
+
+    if scoped_plan.errors:
+        raise click.ClickException("Apply aborted due to planning/parsing errors above.")
+
+    applied, failed, failures = SyncExecutor(common=common, opencode=opencode).execute(scoped_plan)
+    ui.render_apply_result(applied, failed, failures)
+
+    if failed:
+        raise click.exceptions.Exit(1)
+
+
+@cli.command(help="Show sync status for editors and workspaces.")
+@click.pass_obj
+def status(obj: Dict[str, str]) -> None:
+    ui = SyncConsoleUI(Console())
+    common, opencode = _repos_from_obj(obj)
+    apps = AppsService(common)
+    status_service = StatusService()
+
+    if apps.is_enabled(AppId.OPENCODE):
+        try:
+            plan_result = SyncPlanner(common=common, opencode=opencode).build()
+            editor_rows = status_service.build_editor_status(plan_result, opencode)
+            editor_rows = [row for row in editor_rows if row.name != "cursor"]
+            editor_rows.append(_cursor_status_row(apps))
+        except Exception as exc:
+            editor_rows = [
+                EditorStatusRow(
+                    name="opencode",
+                    status=EditorSyncStatus.ERROR,
+                    detail=f"cannot evaluate ({exc})",
+                ),
+                _cursor_status_row(apps),
+            ]
+        workspace_rows = status_service.build_workspace_status(common)
+    else:
+        editor_rows = [
+            EditorStatusRow(
+                name="opencode",
+                status=EditorSyncStatus.DISABLED,
+                detail="disabled by apps config",
+            ),
+            _cursor_status_row(apps),
+        ]
+        workspace_rows = []
+
+    ui.render_status(
+        [item.as_dict() for item in editor_rows],
+        [item.as_dict() for item in workspace_rows],
+    )
+
+
+@cli.group(help="Enable or disable app sync targets.")
+def apps() -> None:
+    pass
+
+
+@apps.command("list", help="List app sync target status.")
+@click.pass_obj
+def apps_list(obj: Dict[str, str]) -> None:
+    ui = SyncConsoleUI(Console())
+    common, _ = _repos_from_obj(obj)
+    service = AppsService(common)
+    ui.render_apps([row.as_dict() for row in service.list_status_rows()])
+
+
+@apps.command("enable", help="Enable app sync target.")
+@click.argument("name", type=click.Choice([app.value for app in AppId], case_sensitive=False))
+@click.pass_obj
+def apps_enable(obj: Dict[str, str], name: str) -> None:
+    ui = SyncConsoleUI(Console())
+    common, _ = _repos_from_obj(obj)
+    service = AppsService(common)
+    app_id = AppId(name.lower())
+    service.enable(app_id)
+    ui.render_apps([row.as_dict() for row in service.list_status_rows()])
+
+
+@apps.command("disable", help="Disable app sync target.")
+@click.argument("name", type=click.Choice([app.value for app in AppId], case_sensitive=False))
+@click.pass_obj
+def apps_disable(obj: Dict[str, str], name: str) -> None:
+    ui = SyncConsoleUI(Console())
+    common, _ = _repos_from_obj(obj)
+    service = AppsService(common)
+    app_id = AppId(name.lower())
+    service.disable(app_id)
+    ui.render_apps([row.as_dict() for row in service.list_status_rows()])
+
+
+@cli.group(help="Manage workspace roots for repo rule propagation.")
+def workspaces() -> None:
+    pass
+
+
+@workspaces.command("add", help="Add a workspace by name and path.")
+@click.argument("name")
+@click.argument("path", type=click.Path(path_type=Path))
+@click.pass_obj
+def workspaces_add(obj: Dict[str, str], name: str, path: Path) -> None:
+    ui = SyncConsoleUI(Console())
+    common, _ = _repos_from_obj(obj)
+    try:
+        common.add_workspace(name, path)
+    except ValueError as exc:
+        raise click.ClickException(str(exc))
+    ui.render_workspace_saved(name, str(path.expanduser().resolve()))
+
+
+@workspaces.command("remove", help="Remove a workspace from config by name.")
+@click.argument("name")
+@click.pass_obj
+def workspaces_remove(obj: Dict[str, str], name: str) -> None:
+    ui = SyncConsoleUI(Console())
+    common, _ = _repos_from_obj(obj)
+    existing = {item["name"]: item["path"] for item in common.load_workspaces()}
+    removed = common.remove_workspace(name)
+    if not removed:
+        raise click.ClickException(f"Workspace not found: {name}")
+    ui.render_workspace_saved(name, existing.get(name, ""), removed=True)
+
+
+@workspaces.command("list", help="List configured workspaces and detected repos.")
+@click.pass_obj
+def workspaces_list(obj: Dict[str, str]) -> None:
+    ui = SyncConsoleUI(Console())
+    common, _ = _repos_from_obj(obj)
+    workspace_service = WorkspaceService()
+
+    overview: list[dict] = []
+    for item in common.load_workspaces():
+        workspace_path = Path(item["path"])
+        repos: list[str] = []
+        if workspace_path.exists() and workspace_path.is_dir():
+            repos = [
+                str(path.relative_to(workspace_path))
+                for path in workspace_service.discover_git_repos(workspace_path)
+            ]
+        overview.append(
+            {
+                "name": item["name"],
+                "path": item["path"],
+                "repos": repos,
+            }
+        )
+
+    ui.render_workspaces_overview(overview)
+
+
+def main() -> int:
+    try:
+        cli(standalone_mode=False)
+    except click.exceptions.Exit as exc:
+        code = exc.exit_code
+        return code if isinstance(code, int) else 1
+    except click.ClickException as exc:
+        exc.show()
+        return 2
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

code_agnostic/apps.py

@@ -0,0 +1,71 @@
+from pathlib import Path
+
+from code_agnostic.models import AppId, AppStatusRow, AppSyncStatus
+from code_agnostic.repositories.common import CommonRepository
+from code_agnostic.utils import read_json_safe, write_json
+
+
+class AppsService:
+    def __init__(self, common: CommonRepository) -> None:
+        self.common = common
+
+    @property
+    def apps_path(self) -> Path:
+        return self.common.config_dir / "apps.json"
+
+    def load_apps(self) -> dict[str, bool]:
+        payload, error = read_json_safe(self.apps_path)
+        if error is not None or not isinstance(payload, dict):
+            return self._default_apps()
+
+        result = self._default_apps()
+        for app in AppId:
+            value = payload.get(app.value)
+            if isinstance(value, bool):
+                result[app.value] = value
+        return result
+
+    def save_apps(self, apps: dict[str, bool]) -> None:
+        normalized = self._default_apps()
+        for app in AppId:
+            value = apps.get(app.value)
+            if isinstance(value, bool):
+                normalized[app.value] = value
+        write_json(self.apps_path, normalized)
+
+    def is_enabled(self, app: AppId) -> bool:
+        return self.load_apps().get(app.value, False)
+
+    def set_enabled(self, app: AppId, enabled: bool) -> None:
+        apps = self.load_apps()
+        apps[app.value] = enabled
+        self.save_apps(apps)
+
+    def enable(self, app: AppId) -> None:
+        self.set_enabled(app=app, enabled=True)
+
+    def disable(self, app: AppId) -> None:
+        self.set_enabled(app=app, enabled=False)
+
+    def list_status_rows(self) -> list[AppStatusRow]:
+        apps = self.load_apps()
+        rows: list[AppStatusRow] = []
+        for app in AppId:
+            enabled = apps.get(app.value, False)
+            detail = "enabled by user" if enabled else "disabled by default"
+            rows.append(
+                AppStatusRow(
+                    name=app,
+                    status=AppSyncStatus.ENABLED if enabled else AppSyncStatus.DISABLED,
+                    detail=detail,
+                )
+            )
+        return rows
+
+    def enabled_apps(self) -> list[AppId]:
+        apps = self.load_apps()
+        return [app for app in AppId if apps.get(app.value, False)]
+
+    @staticmethod
+    def _default_apps() -> dict[str, bool]:
+        return {app.value: False for app in AppId}

code_agnostic/constants.py

@@ -0,0 +1,19 @@
+from typing import Final, Tuple
+
+
+AGENTS_FILENAME: Final[str] = "AGENTS.md"
+CLAUDE_FILENAME: Final[str] = "CLAUDE.md"
+GIT_DIRNAME: Final[str] = ".git"
+
+WORKSPACE_RULE_FILES: Final[Tuple[str, ...]] = (
+    AGENTS_FILENAME,
+    AGENTS_FILENAME.lower(),
+    CLAUDE_FILENAME,
+    CLAUDE_FILENAME.lower(),
+)
+WORKSPACE_RULE_FILES_DISPLAY: Final[str] = "AGENTS.md/CLAUDE.md"
+
+WORKSPACE_IGNORED_DIRS: Final[Tuple[str, ...]] = (
+    "node_modules",
+    ".venv",
+)

code_agnostic/errors.py

@@ -0,0 +1,29 @@
+from pathlib import Path
+
+
+class SyncAppError(Exception):
+    """Base user-facing application error."""
+
+
+class SyncFileError(SyncAppError):
+    def __init__(self, path: Path, message: str) -> None:
+        self.path = path
+        self.message = message
+        super().__init__(f"{message}: {path}")
+
+
+class MissingConfigFileError(SyncFileError):
+    def __init__(self, path: Path) -> None:
+        super().__init__(path=path, message="Missing required config file")
+
+
+class InvalidJsonFormatError(SyncFileError):
+    def __init__(self, path: Path, detail: str) -> None:
+        self.detail = detail
+        super().__init__(path=path, message=f"Invalid JSON format ({detail})")
+
+
+class InvalidConfigSchemaError(SyncFileError):
+    def __init__(self, path: Path, detail: str) -> None:
+        self.detail = detail
+        super().__init__(path=path, message=f"Invalid config schema ({detail})")

code_agnostic/executor.py

@@ -0,0 +1,158 @@
+import os
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Protocol
+
+from code_agnostic.constants import AGENTS_FILENAME
+from code_agnostic.models import Action, ActionKind, ActionStatus, SyncPlan
+from code_agnostic.repositories.base import ISourceRepository, ITargetRepository
+from code_agnostic.utils import backup_file, write_json
+from code_agnostic.workspaces import WorkspaceService
+
+
+@dataclass
+class ExecutionContext:
+    common: ISourceRepository
+    opencode: ITargetRepository
+
+
+class ActionHandler(Protocol):
+    def handle(self, action: Action, context: ExecutionContext) -> tuple[bool, Optional[str]]:
+        ...
+
+
+class WriteJsonHandler:
+    def handle(self, action: Action, context: ExecutionContext) -> tuple[bool, Optional[str]]:
+        if action.status == ActionStatus.NOOP:
+            return False, None
+        if action.path.exists():
+            backup_file(action.path)
+        write_json(action.path, action.payload)
+        return True, None
+
+
+class SymlinkHandler:
+    def handle(self, action: Action, context: ExecutionContext) -> tuple[bool, Optional[str]]:
+        if action.status == ActionStatus.NOOP:
+            return False, None
+        if action.status == ActionStatus.CONFLICT:
+            return False, f"Conflict (not overwritten): {action.path}"
+        if action.source is None:
+            return False, f"Missing source for symlink action: {action.path}"
+
+        action.path.parent.mkdir(parents=True, exist_ok=True)
+        if action.path.exists() or action.path.is_symlink():
+            action.path.unlink()
+        action.path.symlink_to(action.source.resolve())
+        return True, None
+
+
+class RemoveSymlinkHandler:
+    def handle(self, action: Action, context: ExecutionContext) -> tuple[bool, Optional[str]]:
+        if action.status == ActionStatus.NOOP:
+            return False, None
+        if action.status == ActionStatus.CONFLICT:
+            return False, f"Stale cleanup conflict (not symlink): {action.path}"
+        if action.path.is_symlink():
+            action.path.unlink()
+            return True, None
+        return False, None
+
+
+class SyncExecutor:
+    def __init__(
+        self,
+        common: ISourceRepository,
+        opencode: ITargetRepository,
+        workspace_service: Optional[WorkspaceService] = None,
+    ) -> None:
+        self.context = ExecutionContext(common=common, opencode=opencode)
+        self.workspace_service = workspace_service or WorkspaceService()
+        self.handlers: dict[ActionKind, ActionHandler] = {
+            ActionKind.WRITE_JSON: WriteJsonHandler(),
+            ActionKind.SYMLINK: SymlinkHandler(),
+            ActionKind.REMOVE_SYMLINK: RemoveSymlinkHandler(),
+        }
+
+    def execute(self, plan: SyncPlan) -> tuple[int, int, list[str]]:
+        applied = 0
+        failed = 0
+        failures: list[str] = []
+
+        for action in plan.actions:
+            try:
+                handler = self.handlers.get(action.kind)
+                if handler is None:
+                    failed += 1
+                    failures.append(f"Unknown action kind: {action.kind.value}")
+                    continue
+
+                changed, failure = handler.handle(action, self.context)
+                if failure is not None:
+                    failed += 1
+                    failures.append(failure)
+                    continue
+                if changed:
+                    applied += 1
+            except Exception as exc:
+                failed += 1
+                failures.append(f"{action.kind.value} failed for {action.path}: {exc}")
+
+        self._persist_state(plan=plan)
+        return applied, failed, failures
+
+    def _persist_state(self, plan: SyncPlan) -> None:
+        common = self.context.common
+        opencode = self.context.opencode
+
+        managed_skill_links = self._collect_managed_links(opencode.skills_dir, common.skills_dir)
+        managed_agent_links = self._collect_managed_links(opencode.agents_dir, common.agents_dir)
+        managed_workspace_links = self._collect_workspace_links(common)
+
+        updated_at = datetime.now().isoformat(timespec="seconds")
+        state = {
+            "updated_at": updated_at,
+            "managed_skill_links": sorted(set(managed_skill_links)),
+            "managed_agent_links": sorted(set(managed_agent_links)),
+            "managed_workspace_links": sorted(set(managed_workspace_links)),
+            "skipped": plan.skipped,
+        }
+        common.save_state(state)
+
+    def _collect_workspace_links(self, common: ISourceRepository) -> list[str]:
+        managed: list[str] = []
+        for workspace in common.load_workspaces():
+            workspace_path = Path(workspace["path"])
+            if not workspace_path.exists() or not workspace_path.is_dir():
+                continue
+            rules_file = self.workspace_service.resolve_rules_file(workspace_path)
+            if rules_file is None:
+                continue
+            rules_target = str(rules_file.resolve())
+            for repo in self.workspace_service.discover_git_repos(workspace_path):
+                target = repo / AGENTS_FILENAME
+                if not target.is_symlink():
+                    continue
+                if os.path.realpath(target) == rules_target:
+                    managed.append(str(target))
+        return managed
+
+    @staticmethod
+    def _collect_managed_links(target_root: Path, source_root: Path) -> list[str]:
+        if not target_root.exists():
+            return []
+
+        managed: list[str] = []
+        source_prefix = str(source_root.resolve())
+        for child in target_root.iterdir():
+            if not child.is_symlink():
+                continue
+            target = os.path.realpath(child)
+            if target.startswith(source_prefix):
+                managed.append(str(child))
+        return managed
+
+
+def execute_apply(plan: SyncPlan, common: ISourceRepository, opencode: ITargetRepository) -> tuple[int, int, list[str]]:
+    return SyncExecutor(common=common, opencode=opencode).execute(plan)

code_agnostic/mappers/__init__.py

@@ -0,0 +1,4 @@
+from code_agnostic.mappers.base import IConfigMapper
+from code_agnostic.mappers.opencode import OpenCodeMapper, map_mcp_servers_to_opencode
+
+__all__ = ["IConfigMapper", "OpenCodeMapper", "map_mcp_servers_to_opencode"]

code_agnostic/mappers/base.py

@@ -0,0 +1,17 @@
+from abc import ABC
+from pathlib import Path
+from typing import Any
+
+
+class IConfigMapper(ABC):
+    def map_mcp_servers(self, mcp_servers: dict[str, Any]) -> dict[str, Any]:
+        return dict(mcp_servers)
+
+    def map_skill_source(self, source: Path) -> Path:
+        return source
+
+    def map_agent_source(self, source: Path) -> Path:
+        return source
+
+    def map_workspace_rules_source(self, source: Path) -> Path:
+        return source

code_agnostic/mappers/opencode.py

@@ -0,0 +1,50 @@
+from copy import deepcopy
+from typing import Any
+
+from code_agnostic.mappers.base import IConfigMapper
+
+
+def _as_command_array(command: Any, args: Any) -> list[str]:
+    if isinstance(command, list):
+        base = [str(item) for item in command]
+    elif isinstance(command, str):
+        base = [command]
+    else:
+        base = []
+
+    if isinstance(args, list):
+        base.extend(str(item) for item in args)
+    return base
+
+
+class OpenCodeMapper(IConfigMapper):
+    def map_mcp_servers(self, mcp_servers: dict[str, Any]) -> dict[str, Any]:
+        mapped: dict[str, Any] = {}
+        for name, server in mcp_servers.items():
+            if not isinstance(server, dict):
+                continue
+
+            out: dict[str, Any] = {}
+
+            if "url" in server:
+                out["type"] = "remote"
+                out["url"] = server["url"]
+            elif "command" in server:
+                command_list = _as_command_array(server.get("command"), server.get("args"))
+                if not command_list:
+                    continue
+                out["type"] = "local"
+                out["command"] = command_list
+            else:
+                continue
+
+            for passthrough_key in ["headers", "environment", "enabled", "oauth", "timeout"]:
+                if passthrough_key in server:
+                    out[passthrough_key] = deepcopy(server[passthrough_key])
+
+            mapped[name] = out
+        return mapped
+
+
+def map_mcp_servers_to_opencode(mcp_servers: dict[str, Any]) -> dict[str, Any]:
+    return OpenCodeMapper().map_mcp_servers(mcp_servers)