clsync 1.0.1__py3-none-any.whl

claude_sync/apply.py

@@ -0,0 +1,147 @@
+import difflib
+import shutil
+from datetime import datetime, timezone
+from pathlib import Path
+
+from rich.console import Console
+
+from claude_sync.claude_paths import claude_memory_dir
+from claude_sync.models import Config
+
+console = Console()
+
+
+def apply_consolidated(config: Config, skip_scopes: set[str] | None = None) -> list[str]:
+    """
+    Copy consolidated artifacts from sync repo to local machine.
+    Returns list of scopes that were applied.
+
+    Global:
+    1. {repo}/consolidated/global/CLAUDE.md     -> ~/.claude/CLAUDE.md
+    2. {repo}/consolidated/global/settings.json -> ~/.claude/settings.json
+
+    Per-project:
+    1. {repo}/consolidated/projects/{name}/CLAUDE.md -> {project}/.claude/CLAUDE.md
+    2. {repo}/consolidated/projects/{name}/memory/   -> ~/.claude/projects/{slug}/memory/
+    """
+    if skip_scopes is None:
+        skip_scopes = set()
+    repo = Path(config.repo.local_path)
+    applied: list[str] = []
+
+    # Global
+    if "global" not in skip_scopes:
+        consolidated_global = repo / "consolidated" / "global"
+        global_applied = False
+
+        global_md = consolidated_global / "CLAUDE.md"
+        if global_md.exists():
+            dest = Path.home() / ".claude" / "CLAUDE.md"
+            if config.safety.backup_before_apply and dest.exists():
+                _backup(dest)
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(global_md, dest)
+            global_applied = True
+
+        global_settings = consolidated_global / "settings.json"
+        if global_settings.exists():
+            dest = Path.home() / ".claude" / "settings.json"
+            if config.safety.backup_before_apply and dest.exists():
+                _backup(dest)
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(global_settings, dest)
+            global_applied = True
+
+        if global_applied:
+            applied.append("global")
+
+    # Per-project
+    consolidated_projects = repo / "consolidated" / "projects"
+    if consolidated_projects.exists():
+        for project_dir in consolidated_projects.iterdir():
+            if not project_dir.is_dir():
+                continue
+            name = project_dir.name
+            scope = f"projects/{name}"
+            if scope in skip_scopes:
+                continue
+
+            local_project = _find_local_project(name, config)
+            if local_project is None:
+                console.print(f"[yellow]Warning: no local project found matching '{name}', skipping scope {scope}[/yellow]")
+                continue
+
+            scope_applied = False
+
+            consolidated_md = project_dir / "CLAUDE.md"
+            if consolidated_md.exists():
+                dest = local_project / ".claude" / "CLAUDE.md"
+                if config.safety.backup_before_apply and dest.exists():
+                    _backup(dest)
+                dest.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(consolidated_md, dest)
+                scope_applied = True
+
+            consolidated_memory = project_dir / "memory"
+            if consolidated_memory.exists():
+                dest_memory = claude_memory_dir(local_project)
+                dest_memory.mkdir(parents=True, exist_ok=True)
+                consolidated_rels: set[Path] = set()
+                for mem_file in consolidated_memory.rglob("*"):
+                    if mem_file.is_file():
+                        rel = mem_file.relative_to(consolidated_memory)
+                        consolidated_rels.add(rel)
+                        dest_file = dest_memory / rel
+                        dest_file.parent.mkdir(parents=True, exist_ok=True)
+                        shutil.copy2(mem_file, dest_file)
+                # Remove local memory files that were previously pushed but
+                # are no longer in consolidated (deleted on another machine).
+                # Only remove files that exist in our own snapshot — files that
+                # were never pushed are left untouched.
+                machine_mem = (
+                    repo / "machines" / config.client.machine_id
+                    / "projects" / name / "memory"
+                )
+                if machine_mem.exists():
+                    for local_file in list(dest_memory.rglob("*")):
+                        if local_file.is_file():
+                            rel = local_file.relative_to(dest_memory)
+                            if rel not in consolidated_rels and (machine_mem / rel).exists():
+                                local_file.unlink()
+                scope_applied = True
+
+            if scope_applied:
+                applied.append(scope)
+
+    return applied
+
+
+def _backup(path: Path) -> None:
+    timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H%M%SZ")
+    backup_dir = path.parent / "backups" / timestamp
+    backup_dir.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(path, backup_dir / path.name)
+
+
+def _find_local_project(name: str, config: Config) -> Path | None:
+    for p in config.projects.paths:
+        if Path(p).name == name:
+            return Path(p)
+    return None
+
+
+def check_large_diff(local_file: Path, consolidated_file: Path) -> bool:
+    """
+    Return True if more than 50% of lines differ between the two files.
+    """
+    local_lines = local_file.read_text(encoding="utf-8", errors="replace").splitlines()
+    consolidated_lines = consolidated_file.read_text(encoding="utf-8", errors="replace").splitlines()
+
+    if not local_lines and not consolidated_lines:
+        return False
+
+    matcher = difflib.SequenceMatcher(None, local_lines, consolidated_lines)
+    matching = sum(block.size for block in matcher.get_matching_blocks())
+    total = max(len(local_lines), len(consolidated_lines))
+    differing = total - matching
+    return (differing / total) > 0.5

claude_sync/bootstrap.py

@@ -0,0 +1,250 @@
+"""
+Generate CLAUDE.md files from existing Claude Code artifacts (memory files, session summaries).
+
+This module calls the Anthropic API directly on the client machine. It requires the
+'bootstrap' optional dependency: pip install claude-sync[bootstrap]
+"""
+import json
+from pathlib import Path
+
+from claude_sync.claude_paths import claude_memory_dir, claude_sessions_index
+
+MODEL = "claude-sonnet-4-20250514"
+MAX_TOKENS = 8192
+
+_PROMPTS_DIR = Path(__file__).parent / "prompts"
+
+
+def _load_prompt_template() -> str:
+    return (_PROMPTS_DIR / "bootstrap.txt").read_text(encoding="utf-8")
+
+
+def gather_project_context(project_path: Path) -> dict:
+    """
+    Collect all available context for a project.
+
+    Returns dict with keys (all optional):
+    - "memory_files": dict[str, str]  — filename -> content
+    - "session_summaries": list[str]  — summaries from sessions-index.json
+    - "existing_claude_md": str | None
+    """
+    context: dict = {}
+
+    memory_dir = claude_memory_dir(project_path)
+    if memory_dir.exists():
+        memory_files: dict[str, str] = {}
+        for f in sorted(memory_dir.rglob("*")):
+            if f.is_file():
+                try:
+                    key = f.relative_to(memory_dir).as_posix()
+                    memory_files[key] = f.read_text(encoding="utf-8", errors="replace")
+                except OSError:
+                    pass
+        if memory_files:
+            context["memory_files"] = memory_files
+
+    sessions_path = claude_sessions_index(project_path)
+    if sessions_path.exists():
+        try:
+            data = json.loads(sessions_path.read_text(encoding="utf-8"))
+            summaries = [
+                entry["summary"]
+                for entry in (data if isinstance(data, list) else [])
+                if isinstance(entry, dict) and entry.get("summary")
+            ]
+            if summaries:
+                context["session_summaries"] = summaries
+        except (OSError, json.JSONDecodeError, KeyError):
+            pass
+
+    claude_md = project_path / ".claude" / "CLAUDE.md"
+    if claude_md.exists():
+        try:
+            context["existing_claude_md"] = claude_md.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            pass
+
+    return context
+
+
+def gather_global_context(project_paths: list[Path]) -> dict:
+    """
+    Collect cross-project context for generating a global CLAUDE.md.
+
+    Returns dict with keys:
+    - "all_memory_files": dict[str, dict[str, str]]  — project_name -> {filename -> content}
+    - "all_session_summaries": dict[str, list[str]]  — project_name -> [summaries]
+    - "settings": str | None
+    - "existing_claude_md": str | None
+    """
+    context: dict = {}
+    all_memory: dict[str, dict[str, str]] = {}
+    all_summaries: dict[str, list[str]] = {}
+
+    for project_path in project_paths:
+        project_path = Path(project_path)
+        proj_context = gather_project_context(project_path)
+        name = project_path.name
+        if "memory_files" in proj_context:
+            all_memory[name] = proj_context["memory_files"]
+        if "session_summaries" in proj_context:
+            all_summaries[name] = proj_context["session_summaries"]
+
+    if all_memory:
+        context["all_memory_files"] = all_memory
+    if all_summaries:
+        context["all_session_summaries"] = all_summaries
+
+    settings_path = Path.home() / ".claude" / "settings.json"
+    if settings_path.exists():
+        try:
+            context["settings"] = settings_path.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            pass
+
+    global_md = Path.home() / ".claude" / "CLAUDE.md"
+    if global_md.exists():
+        try:
+            context["existing_claude_md"] = global_md.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            pass
+
+    return context
+
+
+def build_bootstrap_prompt(context: dict, scope: str) -> str:
+    """Build the prompt for generating a CLAUDE.md from gathered context."""
+    template = _load_prompt_template()
+
+    sections: list[str] = []
+
+    # Per-project context
+    if "memory_files" in context:
+        sections.append("## MEMORY FILES\n")
+        for filename, content in context["memory_files"].items():
+            sections.append(f"### {filename}\n{content}\n")
+
+    if "session_summaries" in context:
+        sections.append("## SESSION SUMMARIES\n")
+        for summary in context["session_summaries"]:
+            sections.append(f"- {summary}")
+        sections.append("")
+
+    if "existing_claude_md" in context and context["existing_claude_md"]:
+        sections.append("## EXISTING CLAUDE.md (baseline — preserve if still accurate)\n")
+        sections.append(context["existing_claude_md"])
+
+    # Global context
+    if "all_memory_files" in context:
+        for project_name, files in context["all_memory_files"].items():
+            sections.append(f"## MEMORY FILES — {project_name}\n")
+            for filename, content in files.items():
+                sections.append(f"### {filename}\n{content}\n")
+
+    if "all_session_summaries" in context:
+        for project_name, summaries in context["all_session_summaries"].items():
+            sections.append(f"## SESSION SUMMARIES — {project_name}\n")
+            for summary in summaries:
+                sections.append(f"- {summary}")
+            sections.append("")
+
+    if "settings" in context and context["settings"]:
+        sections.append("## CLAUDE CODE SETTINGS (settings.json)\n")
+        sections.append(context["settings"])
+
+    context_text = "\n".join(sections).strip()
+
+    if scope == "global":
+        scope_instruction = (
+            "Focus on cross-project patterns: your user's general coding style, "
+            "preferred tools, workflow habits, and environment setup."
+        )
+    else:
+        scope_instruction = (
+            "Focus on knowledge specific to this project: its architecture, "
+            "conventions, tooling, and key decisions."
+        )
+
+    return (
+        template
+        .replace("{CONTEXT_SECTIONS}", context_text)
+        .replace("{SCOPE_INSTRUCTION}", scope_instruction)
+    )
+
+
+def generate_claude_md(context: dict, scope: str, api_key: str) -> str | None:
+    """
+    Call the Anthropic API to generate a CLAUDE.md from context.
+
+    Returns the generated content, or None if context is empty / generation fails.
+    """
+    if not context:
+        return None
+
+    try:
+        import anthropic
+    except ImportError:
+        raise ImportError(
+            "The 'anthropic' package is required for bootstrap. "
+            "Install it with: pip install claude-sync[bootstrap]"
+        )
+
+    prompt = build_bootstrap_prompt(context, scope)
+
+    client = anthropic.Anthropic(api_key=api_key)
+    response = client.messages.create(
+        model=MODEL,
+        max_tokens=MAX_TOKENS,
+        messages=[{"role": "user", "content": prompt}],
+    )
+    return response.content[0].text
+
+
+def bootstrap_project(project_path: Path, api_key: str) -> str | None:
+    """
+    Generate a CLAUDE.md for a single project.
+
+    1. Gather context from memory/ and sessions-index.json
+    2. If no sources found, return None
+    3. Generate CLAUDE.md via API
+    4. Write result to {project_path}/.claude/CLAUDE.md
+    5. Return the generated content
+    """
+    project_path = Path(project_path).resolve()
+    context = gather_project_context(project_path)
+    if not context:
+        return None
+
+    scope = f"projects/{project_path.name}"
+    result = generate_claude_md(context, scope, api_key)
+    if result is None:
+        return None
+
+    dest = project_path / ".claude" / "CLAUDE.md"
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    dest.write_text(result, encoding="utf-8")
+    return result
+
+
+def bootstrap_global(project_paths: list[Path], api_key: str) -> str | None:
+    """
+    Generate a global ~/.claude/CLAUDE.md.
+
+    1. Gather cross-project context
+    2. If no sources found, return None
+    3. Generate CLAUDE.md via API
+    4. Write result to ~/.claude/CLAUDE.md
+    5. Return the generated content
+    """
+    context = gather_global_context(project_paths)
+    if not context:
+        return None
+
+    result = generate_claude_md(context, "global", api_key)
+    if result is None:
+        return None
+
+    dest = Path.home() / ".claude" / "CLAUDE.md"
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    dest.write_text(result, encoding="utf-8")
+    return result

claude_sync/ci_provider.py

@@ -0,0 +1,296 @@
+"""
+CI provider abstraction for triggering and polling synthesis pipelines.
+
+Supported providers:
+  gitlab  — GitLab CI pipeline trigger + polling (default)
+  github  — GitHub Actions workflow dispatch
+  local   — Run pipeline/synthesize.py directly as a subprocess
+"""
+import subprocess
+import time
+from datetime import datetime, timezone
+from typing import Protocol, runtime_checkable
+
+import httpx
+from rich.console import Console
+
+from claude_sync.models import Config
+
+console = Console()
+
+GITLAB_TERMINAL_STATES = {"success", "failed", "canceled", "skipped"}
+GITHUB_SUCCESS_CONCLUSIONS = {"success"}
+GITHUB_TERMINAL_CONCLUSIONS = {"success", "failure", "cancelled", "timed_out", "action_required", "skipped"}
+
+
+@runtime_checkable
+class CIProvider(Protocol):
+    def trigger(self) -> int | None:
+        """Start the synthesis pipeline. Returns a run/pipeline ID, or None for local."""
+        ...
+
+    def wait_for_completion(self, run_id: int | None, timeout: int = 300, poll_interval: int = 10) -> bool:
+        """Wait until completion. Returns True on success."""
+        ...
+
+    def get_failure_diagnosis(self, run_id: int | None) -> str | None:
+        """Return a human-readable hint about a known failure, or None."""
+        ...
+
+
+# ---------------------------------------------------------------------------
+# GitLab provider
+# ---------------------------------------------------------------------------
+
+class GitLabProvider:
+    def __init__(self, config: Config) -> None:
+        self.config = config
+
+    def _gitlab(self):
+        if not self.config.gitlab:
+            raise RuntimeError(
+                "GitLab is not configured. Run 'claude-sync init --provider gitlab'."
+            )
+        return self.config.gitlab
+
+    def trigger(self) -> int:
+        gl = self._gitlab()
+        if not gl.trigger_token:
+            raise RuntimeError(
+                "GitLab trigger token is not configured. "
+                "Run 'claude-sync init' or set trigger_token in ~/.claude-sync/config.toml."
+            )
+        url = f"{gl.url}/api/v4/projects/{gl.project_id}/trigger/pipeline"
+        response = httpx.post(url, data={"token": gl.trigger_token, "ref": "main"})
+        if response.status_code not in (200, 201):
+            raise RuntimeError(
+                f"Failed to trigger pipeline: HTTP {response.status_code} — {response.text}"
+            )
+        return response.json()["id"]
+
+    def wait_for_completion(self, run_id: int | None, timeout: int = 300, poll_interval: int = 10) -> bool:
+        if run_id is None:
+            return False
+        gl = self._gitlab()
+        if not gl.access_token:
+            raise RuntimeError(
+                "GitLab access token is not configured. "
+                "Run 'claude-sync init' or set access_token in ~/.claude-sync/config.toml."
+            )
+        url = f"{gl.url}/api/v4/projects/{gl.project_id}/pipelines/{run_id}"
+        headers = {"PRIVATE-TOKEN": gl.access_token}
+        deadline = time.monotonic() + timeout
+        last_status = ""
+
+        while time.monotonic() < deadline:
+            response = httpx.get(url, headers=headers)
+            if response.status_code != 200:
+                raise RuntimeError(
+                    f"Failed to get pipeline status: HTTP {response.status_code} — {response.text}"
+                )
+            status = response.json()["status"]
+            if status != last_status:
+                console.print(f"Pipeline #{run_id}: [bold]{status}[/bold]")
+                last_status = status
+            if status in GITLAB_TERMINAL_STATES:
+                return status == "success"
+            time.sleep(poll_interval)
+
+        raise TimeoutError(
+            f"Pipeline #{run_id} did not reach a terminal state within {timeout}s. "
+            f"Last status: {last_status}"
+        )
+
+    def get_failure_diagnosis(self, run_id: int | None) -> str | None:
+        if run_id is None:
+            return None
+        gl = self._gitlab()
+        if not gl.access_token:
+            return None
+        base = f"{gl.url}/api/v4/projects/{gl.project_id}"
+        headers = {"PRIVATE-TOKEN": gl.access_token}
+        try:
+            jobs_resp = httpx.get(f"{base}/pipelines/{run_id}/jobs", headers=headers)
+            if jobs_resp.status_code != 200:
+                return None
+            failed = [j for j in jobs_resp.json() if j.get("status") == "failed"]
+            if not failed:
+                return None
+            job_id = failed[0]["id"]
+            trace_resp = httpx.get(f"{base}/jobs/{job_id}/trace", headers=headers)
+            if trace_resp.status_code != 200:
+                return None
+            log = trace_resp.text
+        except Exception:
+            return None
+
+        return _diagnose_gitlab_log(log)
+
+
+def _diagnose_gitlab_log(log: str) -> str | None:
+    """Return a human-readable hint if a known failure pattern is found."""
+    if "not allowed to push" in log or ("403" in log and "push" in log.lower()):
+        return (
+            "The CI job was denied push access.\n"
+            "Fix: in your sync repo go to Settings → CI/CD → Token Access\n"
+            "     and enable 'Allow Git push requests to the repository'."
+        )
+    if "ANTHROPIC_API_KEY" in log or "AuthenticationError" in log or "invalid x-api-key" in log.lower():
+        return (
+            "The Anthropic API key is missing or invalid.\n"
+            "Fix: add ANTHROPIC_API_KEY as a masked CI/CD variable in your sync repo\n"
+            "     under Settings → CI/CD → Variables."
+        )
+    return None
+
+
+# ---------------------------------------------------------------------------
+# GitHub Actions provider
+# ---------------------------------------------------------------------------
+
+class GitHubProvider:
+    def __init__(self, config: Config) -> None:
+        self.config = config
+        self._dispatch_time: float = 0.0
+
+    def _gh(self):
+        if not self.config.github:
+            raise RuntimeError(
+                "GitHub is not configured. Run 'claude-sync init --provider github'."
+            )
+        return self.config.github
+
+    def _headers(self) -> dict:
+        return {
+            "Authorization": f"Bearer {self._gh().token}",
+            "Accept": "application/vnd.github+json",
+            "X-GitHub-Api-Version": "2022-11-28",
+        }
+
+    def trigger(self) -> int:
+        gh = self._gh()
+        if not gh.token:
+            raise RuntimeError(
+                "GitHub token is not configured. "
+                "Run 'claude-sync init' or set token in ~/.claude-sync/config.toml."
+            )
+        url = f"https://api.github.com/repos/{gh.repo}/actions/workflows/{gh.workflow_id}/dispatches"
+        self._dispatch_time = time.time()
+        response = httpx.post(url, headers=self._headers(), json={"ref": "main"})
+        if response.status_code != 204:
+            raise RuntimeError(
+                f"Failed to dispatch workflow: HTTP {response.status_code} — {response.text}"
+            )
+        return self._find_run_id()
+
+    def _find_run_id(self, search_timeout: int = 15) -> int:
+        gh = self._gh()
+        url = f"https://api.github.com/repos/{gh.repo}/actions/runs"
+        deadline = time.monotonic() + search_timeout
+        while time.monotonic() < deadline:
+            time.sleep(2)
+            resp = httpx.get(
+                url, headers=self._headers(),
+                params={"event": "workflow_dispatch", "per_page": 10},
+            )
+            if resp.status_code != 200:
+                continue
+            for run in resp.json().get("workflow_runs", []):
+                created_str = run.get("created_at", "")
+                try:
+                    created = datetime.fromisoformat(created_str.replace("Z", "+00:00")).timestamp()
+                except ValueError:
+                    continue
+                if created >= self._dispatch_time - 5:
+                    return run["id"]
+        raise RuntimeError(
+            "Could not find the dispatched GitHub Actions run. "
+            "Check the Actions tab in your repository."
+        )
+
+    def wait_for_completion(self, run_id: int | None, timeout: int = 300, poll_interval: int = 10) -> bool:
+        if run_id is None:
+            return False
+        gh = self._gh()
+        url = f"https://api.github.com/repos/{gh.repo}/actions/runs/{run_id}"
+        deadline = time.monotonic() + timeout
+        last_display = ""
+
+        while time.monotonic() < deadline:
+            resp = httpx.get(url, headers=self._headers())
+            if resp.status_code != 200:
+                time.sleep(poll_interval)
+                continue
+            data = resp.json()
+            status = data["status"]       # queued | in_progress | completed
+            conclusion = data.get("conclusion")  # success | failure | cancelled | …
+            display = conclusion if status == "completed" and conclusion else status
+            if display != last_display:
+                console.print(f"Run #{run_id}: [bold]{display}[/bold]")
+                last_display = display
+            if status == "completed":
+                return conclusion in GITHUB_SUCCESS_CONCLUSIONS
+            time.sleep(poll_interval)
+
+        raise TimeoutError(
+            f"GitHub Actions run #{run_id} did not complete within {timeout}s. "
+            f"Last status: {last_display}"
+        )
+
+    def get_failure_diagnosis(self, run_id: int | None) -> str | None:
+        # GitHub Actions logs require following a signed S3 redirect; too complex for
+        # automatic diagnosis. Direct the user to the web UI instead.
+        if run_id is None:
+            return None
+        gh = self._gh()
+        return (
+            f"Check the Actions tab for details:\n"
+            f"  https://github.com/{gh.repo}/actions/runs/{run_id}"
+        )
+
+
+# ---------------------------------------------------------------------------
+# Local provider (runs pipeline/synthesize.py as a subprocess)
+# ---------------------------------------------------------------------------
+
+class LocalProvider:
+    def __init__(self, config: Config) -> None:
+        self.config = config
+        self._success: bool = False
+
+    def trigger(self) -> None:
+        import os
+        repo_path = self.config.repo.local_path
+        if not os.environ.get("ANTHROPIC_API_KEY"):
+            raise RuntimeError(
+                "ANTHROPIC_API_KEY is not set. "
+                "Export it before running 'claude-sync trigger' with the local provider."
+            )
+        result = subprocess.run(
+            ["python", "pipeline/synthesize.py"],
+            cwd=repo_path,
+        )
+        self._success = result.returncode == 0
+        return None
+
+    def wait_for_completion(self, run_id: int | None, timeout: int = 300, poll_interval: int = 10) -> bool:
+        # synthesis already ran synchronously in trigger()
+        return self._success
+
+    def get_failure_diagnosis(self, run_id: int | None) -> str | None:
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Factory
+# ---------------------------------------------------------------------------
+
+def get_provider(config: Config) -> CIProvider:
+    provider_type = config.provider.type
+    if provider_type == "gitlab":
+        return GitLabProvider(config)
+    if provider_type == "github":
+        return GitHubProvider(config)
+    if provider_type == "local":
+        return LocalProvider(config)
+    raise ValueError(f"Unknown provider type: {provider_type!r}")