canopy-cli 3.1.0__py3-none-any.whl

canopy/workspace/config.py

@@ -0,0 +1,378 @@
+"""
+Parse and validate canopy.toml workspace configuration.
+"""
+from __future__ import annotations
+
+import sys
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+class ConfigNotFoundError(Exception):
+    """No canopy.toml found in the directory tree."""
+
+
+class ConfigError(Exception):
+    """Invalid canopy.toml content."""
+
+
+@dataclass
+class RepoConfig:
+    """Configuration for a single repository in the workspace."""
+    name: str
+    path: str               # relative path from workspace root
+    role: str = ""           # optional: backend, frontend, shared, infra
+    lang: str = ""           # optional: primary language
+    default_branch: str = "main"
+    is_worktree: bool = False       # True if this is a linked worktree
+    worktree_main: str | None = None  # path to main working tree (if worktree)
+    augments: dict[str, Any] = field(default_factory=dict)  # per-repo augment overrides (M2)
+    # M6 worktree-bootstrap fields. All optional — missing means "skip
+    # this step." See docs/plans/worktree-bootstrap.md.
+    env_files: list[str] = field(default_factory=list)
+    install_cmd: str = ""
+    ide_settings: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class IssueProviderConfig:
+    """Per-workspace issue provider selection (M5).
+
+    Parsed from the ``[issue_provider]`` block in canopy.toml. The
+    ``options`` dict carries provider-specific settings from the
+    ``[issue_provider.<name>]`` sub-table.
+
+    When the block is missing entirely, defaults to Linear with a
+    deprecation warning logged once per session — explicit config will
+    be required in a future release.
+    """
+    name: str = "linear"
+    options: dict[str, Any] = field(default_factory=dict)
+    # Set to True when the parser fell back to the Linear default because
+    # no [issue_provider] block was present. The action layer logs a
+    # one-time deprecation notice.
+    is_default_fallback: bool = False
+
+
+@dataclass
+class WorkspaceConfig:
+    """Parsed workspace configuration."""
+    name: str
+    repos: list[RepoConfig]
+    root: Path              # absolute path to workspace root
+    slots: int = 2          # warm slot count (canonical is separate); default 2
+    issue_provider: IssueProviderConfig = field(default_factory=IssueProviderConfig)
+    augments: dict[str, Any] = field(default_factory=dict)  # workspace-level augment defaults (M2)
+    # M6 — IDE workspace template + per-workspace bootstrap default.
+    ide: str = "none"                   # "vscode" | "none" (default)
+    bootstrap_default: bool = False     # if true, --bootstrap is implicit on create/warm
+
+
+def load_config(path: Path | None = None) -> WorkspaceConfig:
+    """Find and parse canopy.toml.
+
+    If no path is given, walks up from cwd looking for canopy.toml.
+    Raises ConfigNotFoundError if none is found.
+    Raises ConfigError if the file is malformed.
+    """
+    if path is not None:
+        toml_path = path if path.name == "canopy.toml" else path / "canopy.toml"
+    else:
+        toml_path = _find_config()
+
+    if not toml_path.exists():
+        raise ConfigNotFoundError(f"No canopy.toml found at {toml_path}")
+
+    try:
+        with open(toml_path, "rb") as f:
+            data = tomllib.load(f)
+    except tomllib.TOMLDecodeError as e:
+        raise ConfigError(f"Invalid TOML in {toml_path}: {e}") from e
+
+    return _parse_config(data, toml_path.parent.resolve())
+
+
+def _find_config() -> Path:
+    """Walk up from cwd looking for canopy.toml."""
+    current = Path.cwd().resolve()
+    while True:
+        candidate = current / "canopy.toml"
+        if candidate.exists():
+            return candidate
+        parent = current.parent
+        if parent == current:
+            raise ConfigNotFoundError(
+                "No canopy.toml found in current directory or any parent."
+            )
+        current = parent
+
+
+def _parse_config(data: dict[str, Any], root: Path) -> WorkspaceConfig:
+    """Parse raw TOML dict into WorkspaceConfig."""
+    workspace = data.get("workspace", {})
+    name = workspace.get("name")
+    if not name:
+        raise ConfigError("Missing [workspace] name in canopy.toml")
+
+    repos_data = data.get("repos", [])
+    if not repos_data:
+        raise ConfigError("No [[repos]] entries in canopy.toml")
+
+    repos = []
+    seen_names: set[str] = set()
+    for i, entry in enumerate(repos_data):
+        repo_name = entry.get("name")
+        if not repo_name:
+            raise ConfigError(f"[[repos]] entry {i} missing 'name'")
+        if not entry.get("path"):
+            raise ConfigError(f"[[repos]] entry '{repo_name}' missing 'path'")
+        if repo_name in seen_names:
+            raise ConfigError(f"Duplicate repo name: '{repo_name}'")
+        seen_names.add(repo_name)
+
+        repo_augments = entry.get("augments")
+        if repo_augments is not None and not isinstance(repo_augments, dict):
+            raise ConfigError(
+                f"[[repos]] entry '{repo_name}' augments must be a table, got: {type(repo_augments).__name__}",
+            )
+        env_files = entry.get("env_files") or []
+        if env_files and not (
+            isinstance(env_files, list) and all(isinstance(p, str) for p in env_files)
+        ):
+            raise ConfigError(
+                f"[[repos]] entry '{repo_name}' env_files must be a list of strings",
+            )
+        ide_settings = entry.get("ide_settings")
+        if ide_settings is not None and not isinstance(ide_settings, dict):
+            raise ConfigError(
+                f"[[repos]] entry '{repo_name}' ide_settings must be a table",
+            )
+        repos.append(RepoConfig(
+            name=repo_name,
+            path=entry["path"],
+            role=entry.get("role", ""),
+            lang=entry.get("lang", ""),
+            default_branch=entry.get("default_branch", "main"),
+            augments=dict(repo_augments) if repo_augments else {},
+            env_files=list(env_files),
+            install_cmd=entry.get("install_cmd", "") or "",
+            ide_settings=dict(ide_settings) if ide_settings else {},
+        ))
+
+    if "max_worktrees" in workspace:
+        raise ConfigError(
+            "max_worktrees was renamed to `slots` in canopy 3.0 — "
+            "run `canopy migrate-slots` to update canopy.toml"
+        )
+    slots_count = workspace.get("slots", 2)
+    if not isinstance(slots_count, int) or slots_count < 1:
+        raise ConfigError(f"slots must be a positive integer, got: {slots_count!r}")
+    ide_choice = workspace.get("ide", "none")
+    if not isinstance(ide_choice, str):
+        raise ConfigError(f"[workspace] ide must be a string, got {type(ide_choice).__name__}")
+    bootstrap_default = bool(workspace.get("bootstrap_default", False))
+    issue_provider = _parse_issue_provider(data)
+    augments = _parse_augments(data)
+
+    return WorkspaceConfig(
+        name=name,
+        repos=repos,
+        root=root,
+        slots=slots_count,
+        issue_provider=issue_provider,
+        augments=augments,
+        ide=ide_choice,
+        bootstrap_default=bootstrap_default,
+    )
+
+
+def _parse_augments(data: dict[str, Any]) -> dict[str, Any]:
+    """Parse the ``[augments]`` block from canopy.toml (M2).
+
+    Schema::
+
+        [augments]
+        preflight_cmd = "make check"
+        test_cmd = "pytest"
+        review_bots = ["coderabbit", "korbit"]
+
+    Lenient: missing block returns empty dict; unknown keys preserved
+    so future augments don't require parser changes. Validation that
+    catches typos is deferred to ``canopy doctor`` (see plan §non-goals).
+    """
+    block = data.get("augments")
+    if block is None:
+        return {}
+    if not isinstance(block, dict):
+        raise ConfigError(
+            f"[augments] must be a table, got: {type(block).__name__}",
+        )
+    return dict(block)
+
+
+def _parse_issue_provider(data: dict[str, Any]) -> IssueProviderConfig:
+    """Parse the ``[issue_provider]`` block from canopy.toml.
+
+    Schema::
+
+        [issue_provider]
+        name = "linear"   # or "github_issues"
+
+        [issue_provider.linear]      # optional sub-table
+        api_key_env = "LINEAR_API_KEY"
+
+        [issue_provider.github_issues]
+        repo = "owner/repo"
+
+    Returns ``IssueProviderConfig(name="linear", is_default_fallback=True)``
+    when the block is missing — preserves backward compatibility with
+    pre-M5 canopy.toml files.
+    """
+    block = data.get("issue_provider")
+    if not isinstance(block, dict):
+        return IssueProviderConfig(name="linear", is_default_fallback=True)
+    name = block.get("name", "linear")
+    if not isinstance(name, str) or not name:
+        raise ConfigError(
+            f"[issue_provider] name must be a non-empty string, got: {name!r}",
+        )
+    sub_table = block.get(name)
+    options: dict[str, Any] = sub_table if isinstance(sub_table, dict) else {}
+    return IssueProviderConfig(name=name, options=options)
+
+
+# ── Workspace settings (keys under [workspace]) ────────────────────────
+
+# Settings that can be read/written via `canopy config`
+WORKSPACE_SETTINGS = {
+    "name": str,
+    "slots": int,
+}
+
+
+def get_config_value(root: Path, key: str) -> Any:
+    """Read a single workspace setting from canopy.toml."""
+    if key not in WORKSPACE_SETTINGS:
+        raise ConfigError(
+            f"Unknown setting: '{key}'. "
+            f"Available: {', '.join(sorted(WORKSPACE_SETTINGS))}"
+        )
+    toml_path = root / "canopy.toml"
+    if not toml_path.exists():
+        raise ConfigNotFoundError(f"No canopy.toml at {root}")
+    with open(toml_path, "rb") as f:
+        data = tomllib.load(f)
+    return data.get("workspace", {}).get(key)
+
+
+def set_config_value(root: Path, key: str, value: str) -> Any:
+    """Write a single workspace setting to canopy.toml.
+
+    Handles type coercion based on WORKSPACE_SETTINGS.
+    Returns the coerced value.
+    """
+    if key not in WORKSPACE_SETTINGS:
+        raise ConfigError(
+            f"Unknown setting: '{key}'. "
+            f"Available: {', '.join(sorted(WORKSPACE_SETTINGS))}"
+        )
+
+    expected_type = WORKSPACE_SETTINGS[key]
+    try:
+        if expected_type == int:
+            coerced = int(value)
+        else:
+            coerced = value
+    except (ValueError, TypeError):
+        raise ConfigError(f"Invalid value for '{key}': expected {expected_type.__name__}")
+
+    toml_path = root / "canopy.toml"
+    if not toml_path.exists():
+        raise ConfigNotFoundError(f"No canopy.toml at {root}")
+
+    content = toml_path.read_text()
+
+    # Try to update existing key under [workspace]
+    import re
+    # Match: key = value (with optional quotes for strings)
+    pattern = rf'^({re.escape(key)}\s*=\s*).*$'
+
+    # Find lines within the [workspace] section
+    lines = content.split("\n")
+    in_workspace = False
+    updated = False
+    for i, line in enumerate(lines):
+        stripped = line.strip()
+        if stripped == "[workspace]":
+            in_workspace = True
+            continue
+        if stripped.startswith("[") and stripped.endswith("]"):
+            # Hit a new section — if we haven't updated yet, insert before this
+            if in_workspace and not updated:
+                # Insert the key before this section
+                formatted = _format_toml_value(key, coerced)
+                lines.insert(i, formatted)
+                updated = True
+            in_workspace = False
+            continue
+        if in_workspace and re.match(pattern, stripped):
+            lines[i] = _format_toml_value(key, coerced)
+            updated = True
+            break
+
+    # If still not updated, append to [workspace] section
+    if not updated:
+        # Find the [workspace] line and append after it
+        for i, line in enumerate(lines):
+            if line.strip() == "[workspace]":
+                lines.insert(i + 1, _format_toml_value(key, coerced))
+                updated = True
+                break
+
+    if not updated:
+        raise ConfigError("Could not find [workspace] section in canopy.toml")
+
+    toml_path.write_text("\n".join(lines))
+    return coerced
+
+
+def get_all_config(root: Path) -> dict[str, Any]:
+    """Read all workspace settings from canopy.toml."""
+    toml_path = root / "canopy.toml"
+    if not toml_path.exists():
+        raise ConfigNotFoundError(f"No canopy.toml at {root}")
+    with open(toml_path, "rb") as f:
+        data = tomllib.load(f)
+    ws = data.get("workspace", {})
+    return {k: ws.get(k) for k in WORKSPACE_SETTINGS}
+
+
+def _format_toml_value(key: str, value: Any) -> str:
+    """Format a key = value line for TOML."""
+    if isinstance(value, int):
+        return f"{key} = {value}"
+    elif isinstance(value, str):
+        return f'{key} = "{value}"'
+    return f"{key} = {value}"
+
+
+def validate_config(config: WorkspaceConfig) -> list[str]:
+    """Validate a WorkspaceConfig and return a list of warnings.
+
+    Returns an empty list if everything is valid.
+    """
+    warnings = []
+
+    for repo in config.repos:
+        abs_path = (config.root / repo.path).resolve()
+        if not abs_path.exists():
+            warnings.append(f"Repo '{repo.name}': path does not exist: {abs_path}")
+        elif not (abs_path / ".git").exists():
+            warnings.append(f"Repo '{repo.name}': not a git repository: {abs_path}")
+
+    return warnings

canopy/workspace/context.py

@@ -0,0 +1,224 @@
+"""
+Context detection — figure out where canopy is running from.
+
+When you run canopy from inside a worktree directory, this module
+detects which feature lane, which repo(s), and which branch you're
+working in. This powers context-aware commands like `canopy stage`.
+
+Context hierarchy (from most to least specific):
+    1. Inside a specific repo worktree:
+       .canopy/worktrees/auth-flow/api/  →  feature=auth-flow, repo=api
+    2. Inside a feature directory (parent of repo worktrees):
+       .canopy/worktrees/auth-flow/      →  feature=auth-flow, repos=all
+    3. Inside a normal repo in the workspace:
+       workspace/api/                     →  repo=api, feature=current branch
+    4. At the workspace root:
+       workspace/                         →  whole workspace
+"""
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+from ..git import repo as git
+
+
+@dataclass
+class CanopyContext:
+    """Where canopy is running and what it can see."""
+
+    # Where we detected context from
+    cwd: Path
+
+    # Workspace root (where canopy.toml lives), if found
+    workspace_root: Optional[Path] = None
+
+    # Feature lane name, if detected
+    feature: Optional[str] = None
+
+    # Repo directories to operate on (worktree or regular repo paths)
+    repo_paths: list[Path] = field(default_factory=list)
+
+    # Repo names (matching repo_paths)
+    repo_names: list[str] = field(default_factory=list)
+
+    # The current branch (if in a single repo/worktree)
+    branch: Optional[str] = None
+
+    # How we detected context
+    context_type: str = "unknown"
+    # "feature_dir"    — inside .canopy/worktrees/<feature>/
+    # "repo_worktree"  — inside .canopy/worktrees/<feature>/<repo>/
+    # "repo"           — inside a normal workspace repo
+    # "workspace_root" — at the workspace root
+    # "unknown"        — couldn't detect
+
+    def to_dict(self) -> dict:
+        return {
+            "cwd": str(self.cwd),
+            "workspace_root": str(self.workspace_root) if self.workspace_root else None,
+            "feature": self.feature,
+            "repo_paths": [str(p) for p in self.repo_paths],
+            "repo_names": self.repo_names,
+            "branch": self.branch,
+            "context_type": self.context_type,
+        }
+
+
+def detect_context(cwd: Path | None = None) -> CanopyContext:
+    """Detect canopy context from the current working directory.
+
+    Walks up from cwd looking for clues:
+    - .canopy/worktrees/<feature>/<repo>/ structure
+    - canopy.toml (workspace root)
+    - .git directory (regular repo)
+    """
+    if cwd is None:
+        cwd = Path.cwd().resolve()
+    else:
+        cwd = cwd.resolve()
+
+    ctx = CanopyContext(cwd=cwd)
+
+    # Strategy 1: Are we inside a .canopy/worktrees/<feature>/ structure?
+    _detect_worktree_context(ctx)
+    if ctx.context_type != "unknown":
+        return ctx
+
+    # Strategy 2: Are we inside a normal repo in a workspace?
+    _detect_repo_context(ctx)
+    if ctx.context_type != "unknown":
+        return ctx
+
+    # Strategy 3: Are we at a workspace root?
+    _detect_workspace_root(ctx)
+
+    return ctx
+
+
+def _detect_worktree_context(ctx: CanopyContext) -> None:
+    """Check if cwd is inside .canopy/worktrees/worktree-N/[<repo>/]."""
+    path = ctx.cwd
+
+    # Walk up looking for a path segment that matches .canopy/worktrees/<slot-id>
+    parts = path.parts
+    for i, part in enumerate(parts):
+        if part == ".canopy" and i + 2 < len(parts) and parts[i + 1] == "worktrees":
+            # Found .canopy/worktrees/ — next part is the slot id (e.g. worktree-1)
+            slot_id = parts[i + 2]
+            canopy_dir = Path(*parts[:i])  # workspace root
+            slot_dir = Path(*parts[:i + 3])  # .canopy/worktrees/<slot-id>
+
+            ctx.workspace_root = canopy_dir
+            # Resolve feature via slots.json. If we can't load it (e.g. no
+            # canopy.toml on this branch), fall back to the slot id so
+            # downstream commands have *something*.
+            feature = _slot_to_feature(canopy_dir, slot_id) or slot_id
+            ctx.feature = feature
+
+            if i + 3 < len(parts):
+                # We're inside a specific repo worktree
+                repo_name = parts[i + 3]
+                repo_path = Path(*parts[:i + 4])
+
+                ctx.context_type = "repo_worktree"
+                ctx.repo_paths = [repo_path]
+                ctx.repo_names = [repo_name]
+                ctx.branch = _safe_branch(repo_path)
+            else:
+                # We're at the slot directory level — find all repo worktrees
+                ctx.context_type = "feature_dir"
+                if slot_dir.exists():
+                    for child in sorted(slot_dir.iterdir()):
+                        if child.is_dir() and (child / ".git").exists():
+                            ctx.repo_paths.append(child)
+                            ctx.repo_names.append(child.name)
+                if ctx.repo_paths:
+                    ctx.branch = _safe_branch(ctx.repo_paths[0])
+            return
+
+
+def _slot_to_feature(workspace_root: Path, slot_id: str) -> str | None:
+    """Read slots.json to map a slot id back to its current feature."""
+    p = workspace_root / ".canopy/state/slots.json"
+    if not p.exists():
+        return None
+    try:
+        data = json.loads(p.read_text())
+    except (OSError, json.JSONDecodeError):
+        return None
+    entry = (data.get("slots") or {}).get(slot_id)
+    if isinstance(entry, dict):
+        return entry.get("feature")
+    return None
+
+
+def _detect_repo_context(ctx: CanopyContext) -> None:
+    """Check if cwd is inside a normal repo in a canopy workspace."""
+    path = ctx.cwd
+
+    # Walk up looking for .git
+    current = path
+    while True:
+        if (current / ".git").exists():
+            # Found a repo — is it inside a canopy workspace?
+            parent = current.parent
+            ws_root = _find_workspace_root(parent)
+            if ws_root:
+                ctx.workspace_root = ws_root
+                ctx.context_type = "repo"
+                ctx.repo_paths = [current]
+                ctx.repo_names = [current.name]
+                ctx.branch = _safe_branch(current)
+
+                # Try to detect feature from branch name
+                if ctx.branch and ctx.branch not in ("main", "master", "(detached)"):
+                    ctx.feature = ctx.branch
+            return
+
+        parent = current.parent
+        if parent == current:
+            break
+        current = parent
+
+
+def _detect_workspace_root(ctx: CanopyContext) -> None:
+    """Check if cwd is a workspace root (has canopy.toml)."""
+    ws_root = _find_workspace_root(ctx.cwd)
+    if ws_root and ws_root == ctx.cwd:
+        ctx.workspace_root = ws_root
+        ctx.context_type = "workspace_root"
+
+        # Find all repos at the workspace level
+        try:
+            from .config import load_config
+            config = load_config(ws_root)
+            for rc in config.repos:
+                abs_path = (ws_root / rc.path).resolve()
+                if abs_path.exists():
+                    ctx.repo_paths.append(abs_path)
+                    ctx.repo_names.append(rc.name)
+        except Exception:
+            pass
+
+
+def _find_workspace_root(start: Path) -> Path | None:
+    """Walk up from start looking for canopy.toml."""
+    current = start.resolve()
+    while True:
+        if (current / "canopy.toml").exists():
+            return current
+        parent = current.parent
+        if parent == current:
+            return None
+        current = parent
+
+
+def _safe_branch(repo_path: Path) -> str | None:
+    """Get current branch, returning None on error."""
+    try:
+        return git.current_branch(repo_path)
+    except Exception:
+        return None