moai-adk 0.34.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

moai_adk/cli/worktree/cli.py

@@ -153,7 +153,11 @@ def _find_main_repository(start_path: Path) -> Path:
 
 @click.group()
 def worktree() -> None:
-    """Manage Git worktrees for parallel SPEC development."""
+    """Manage Git worktrees for parallel SPEC development.
+
+    \b
+    Alias: moai-wt
+    """
     pass
 
 
@@ -164,6 +168,8 @@ def worktree() -> None:
 @click.option("--repo", type=click.Path(), default=None, help="Repository path")
 @click.option("--worktree-root", type=click.Path(), default=None, help="Worktree root directory")
 @click.option("--force", "-f", is_flag=True, help="Force creation even if worktree exists")
+@click.option("--glm", is_flag=True, help="Use GLM LLM config (copies .moai/llm-configs/glm.json)")
+@click.option("--llm-config", type=click.Path(), default=None, help="Path to custom LLM config file")
 def new_worktree(
     spec_id: str,
     branch: str | None,
@@ -171,6 +177,8 @@ def new_worktree(
     repo: str | None,
     worktree_root: str | None,
     force: bool,
+    glm: bool,
+    llm_config: str | None,
 ) -> None:
     """Create a new worktree for a SPEC.
 
@@ -180,17 +188,36 @@ def new_worktree(
         base: Base branch to create from (default: main)
         repo: Repository path (optional)
         worktree_root: Worktree root directory (optional)
+        glm: Use GLM LLM config
+        llm_config: Path to custom LLM config file
     """
     try:
         repo_path = Path(repo) if repo else Path.cwd()
         wt_root = Path(worktree_root) if worktree_root else None
 
+        # Determine LLM config path
+        llm_config_path: Path | None = None
+        if llm_config:
+            llm_config_path = Path(llm_config)
+            if not llm_config_path.exists():
+                console.print(f"[red]✗[/red] LLM config file not found: {llm_config}")
+                raise click.Abort()
+        elif glm:
+            # Use default GLM config from .moai/llm-configs/glm.json
+            glm_config_path = repo_path / ".moai" / "llm-configs" / "glm.json"
+            if glm_config_path.exists():
+                llm_config_path = glm_config_path
+            else:
+                console.print(f"[yellow]![/yellow] GLM config not found: {glm_config_path}")
+                console.print("[yellow]  Worktree will be created without LLM config[/yellow]")
+
         manager = get_manager(repo_path, wt_root)
         info = manager.create(
             spec_id=spec_id,
             branch_name=branch,
             base_branch=base,
             force=force,
+            llm_config_path=llm_config_path,
         )
 
         console.print("[green]✓[/green] Worktree created successfully")
@@ -198,6 +225,8 @@ def new_worktree(
         console.print(f"  Path:       {info.path}")
         console.print(f"  Branch:     {info.branch}")
         console.print(f"  Status:     {info.status}")
+        if llm_config_path:
+            console.print(f"  LLM Config: {llm_config_path.name}")
         console.print()
         console.print("[yellow]Next steps:[/yellow]")
         console.print(f"  moai-worktree go {spec_id}       # Go to this worktree")
@@ -624,6 +653,82 @@ def recover_worktrees(repo: str | None, worktree_root: str | None) -> None:
         raise click.Abort()
 
 
+@worktree.command(name="done")
+@click.argument("spec_id")
+@click.option("--base", default="main", help="Base branch to merge into")
+@click.option("--push", is_flag=True, help="Push to remote after merge")
+@click.option("--force", "-f", is_flag=True, help="Force remove with uncommitted changes")
+@click.option("--repo", type=click.Path(), default=None, help="Repository path")
+@click.option("--worktree-root", type=click.Path(), default=None, help="Worktree root directory")
+def done_worktree(
+    spec_id: str,
+    base: str,
+    push: bool,
+    force: bool,
+    repo: str | None,
+    worktree_root: str | None,
+) -> None:
+    """Complete worktree: merge to main and cleanup.
+
+    This command performs the full completion workflow:
+    1. Checkout base branch (main)
+    2. Merge worktree branch into base
+    3. Remove worktree
+    4. Delete feature branch
+
+    Args:
+        spec_id: SPEC ID to complete
+        base: Base branch to merge into (default: main)
+        push: Push to remote after merge
+        force: Force removal even with uncommitted changes
+        repo: Repository path (optional)
+        worktree_root: Worktree root directory (optional)
+    """
+    try:
+        repo_path = Path(repo) if repo else Path.cwd()
+        wt_root = Path(worktree_root) if worktree_root else None
+
+        manager = get_manager(repo_path, wt_root)
+
+        # Get worktree info for display
+        info = manager.registry.get(spec_id, project_name=manager.project_name)
+        if not info:
+            console.print(f"[red]✗[/red] Worktree not found: {spec_id}")
+            raise click.Abort()
+
+        console.print(f"[cyan]Completing worktree: {spec_id}[/cyan]")
+        console.print(f"  Branch: {info.branch}")
+        console.print(f"  Merging into: {base}")
+        console.print()
+
+        result = manager.done(
+            spec_id=spec_id,
+            base_branch=base,
+            push=push,
+            force=force,
+        )
+
+        console.print("[green]✓[/green] Worktree completed successfully")
+        console.print(f"  Merged: {result['merged_branch']} → {result['base_branch']}")
+        if result["pushed"]:
+            console.print(f"  Pushed: origin/{result['base_branch']}")
+        console.print()
+        console.print("[yellow]Branch cleanup:[/yellow]")
+        console.print(f"  - Worktree removed: {spec_id}")
+        console.print(f"  - Branch deleted: {result['merged_branch']}")
+
+    except WorktreeNotFoundError as e:
+        console.print(f"[red]✗[/red] {e}")
+        raise click.Abort()
+    except MergeConflictError as e:
+        console.print(f"[red]✗[/red] Merge conflict: {e}")
+        console.print("[yellow]Resolve conflicts manually and try again[/yellow]")
+        raise click.Abort()
+    except GitOperationError as e:
+        console.print(f"[red]✗[/red] {e}")
+        raise click.Abort()
+
+
 @worktree.command(name="config")
 @click.argument("key", required=False)
 @click.argument("value", required=False)

moai_adk/cli/worktree/manager.py

@@ -46,6 +46,7 @@ class WorktreeManager:
         branch_name: str | None = None,
         base_branch: str = "main",
         force: bool = False,
+        llm_config_path: Path | None = None,
     ) -> WorktreeInfo:
         """Create a new worktree for a SPEC.
 
@@ -56,6 +57,9 @@ class WorktreeManager:
             branch_name: Custom branch name (defaults to spec_id).
             base_branch: Base branch to create from (defaults to 'main').
             force: Force creation even if worktree exists.
+            llm_config_path: Path to LLM config file to copy to worktree.
+                            If provided, copies to {worktree}/.claude/settings.local.json
+                            and substitutes environment variables (e.g., ${GLM_API_TOKEN}).
 
         Returns:
             WorktreeInfo for the created worktree.
@@ -133,6 +137,10 @@ class WorktreeManager:
             # Register in registry
             self.registry.register(info, project_name=self.project_name)
 
+            # Copy LLM config to worktree if provided
+            if llm_config_path and llm_config_path.exists():
+                self._copy_llm_config(worktree_path, llm_config_path)
+
             return info
 
         except WorktreeExistsError:
@@ -491,3 +499,150 @@ class WorktreeManager:
         except Exception as e:
             # Auto-resolution failed, raise error for manual intervention
             raise GitOperationError(f"Auto-resolution failed for {spec_id}: {e}")
+
+    def done(
+        self,
+        spec_id: str,
+        base_branch: str = "main",
+        push: bool = False,
+        force: bool = False,
+    ) -> dict:
+        """Complete worktree workflow: merge to base branch and remove worktree.
+
+        This is a convenience method that performs the following steps:
+        1. Checkout base branch in main repository
+        2. Merge worktree branch into base branch
+        3. Remove worktree and its branch
+
+        Args:
+            spec_id: SPEC ID of worktree to complete.
+            base_branch: Branch to merge into (defaults to 'main').
+            push: Push merged changes to remote after merge.
+            force: Force removal even with uncommitted changes.
+
+        Returns:
+            dict with keys: 'merged_branch', 'base_branch', 'pushed'
+
+        Raises:
+            WorktreeNotFoundError: If worktree doesn't exist.
+            MergeConflictError: If merge conflict occurs.
+            GitOperationError: If Git operation fails.
+        """
+        info = self.registry.get(spec_id, project_name=self.project_name)
+        if not info:
+            raise WorktreeNotFoundError(spec_id)
+
+        merged_branch = info.branch
+        pushed = False
+
+        try:
+            # Step 1: Fetch latest from remote
+            try:
+                self.repo.remotes.origin.fetch()
+            except Exception:
+                pass
+
+            # Step 2: Checkout base branch in main repo
+            try:
+                self.repo.git.checkout(base_branch)
+            except Exception as e:
+                raise GitOperationError(f"Failed to checkout {base_branch}: {e}")
+
+            # Step 3: Merge worktree branch into base branch
+            try:
+                self.repo.git.merge(merged_branch, "--no-ff", "-m", f"Merge {merged_branch} into {base_branch}")
+            except Exception as e:
+                # Check for merge conflicts
+                try:
+                    status = self.repo.git.status("--porcelain")
+                    conflicted = [
+                        line.split()[-1]
+                        for line in status.split("\n")
+                        if line.startswith("UU")
+                        or line.startswith("DD")
+                        or line.startswith("AA")
+                        or line.startswith("DU")
+                    ]
+                    if conflicted:
+                        # Abort merge to leave clean state
+                        try:
+                            self.repo.git.merge("--abort")
+                        except Exception:
+                            pass
+                        raise MergeConflictError(spec_id, conflicted)
+                except MergeConflictError:
+                    raise
+                except Exception:
+                    pass
+                raise GitOperationError(f"Failed to merge {merged_branch}: {e}")
+
+            # Step 4: Push if requested
+            if push:
+                try:
+                    self.repo.git.push("origin", base_branch)
+                    pushed = True
+                except Exception as e:
+                    raise GitOperationError(f"Failed to push to origin/{base_branch}: {e}")
+
+            # Step 5: Remove worktree
+            self.remove(spec_id=spec_id, force=force)
+
+            # Step 6: Delete the branch (optional cleanup)
+            try:
+                self.repo.git.branch("-d", merged_branch)
+            except Exception:
+                # Branch might be protected or already deleted
+                pass
+
+            return {
+                "merged_branch": merged_branch,
+                "base_branch": base_branch,
+                "pushed": pushed,
+            }
+
+        except (WorktreeNotFoundError, MergeConflictError, GitOperationError):
+            raise
+        except Exception as e:
+            raise GitOperationError(f"Failed to complete worktree: {e}")
+
+    def _copy_llm_config(self, worktree_path: Path, llm_config_path: Path) -> None:
+        """Copy LLM config to worktree with environment variable substitution.
+
+        Args:
+            worktree_path: Path to the worktree directory.
+            llm_config_path: Path to the LLM config template file.
+
+        The config file is copied to {worktree}/.claude/settings.local.json.
+        Environment variables in the format ${VAR_NAME} are substituted
+        with their actual values from the environment.
+        """
+        import os
+        import re
+
+        try:
+            # Create .claude directory in worktree
+            claude_dir = worktree_path / ".claude"
+            claude_dir.mkdir(parents=True, exist_ok=True)
+
+            # Read template config
+            with open(llm_config_path, "r", encoding="utf-8") as f:
+                config_content = f.read()
+
+            # Substitute environment variables (${VAR_NAME} pattern)
+            def substitute_env_var(match: re.Match) -> str:
+                var_name = match.group(1)
+                env_value = os.environ.get(var_name)
+                return env_value if env_value is not None else match.group(0)
+
+            config_content = re.sub(r"\$\{([^}]+)\}", substitute_env_var, config_content)
+
+            # Write to worktree
+            target_path = claude_dir / "settings.local.json"
+            with open(target_path, "w", encoding="utf-8") as f:
+                f.write(config_content)
+
+        except Exception as e:
+            # Log warning but don't fail worktree creation
+            import sys
+
+            print(f"Warning: Failed to copy LLM config: {e}", file=sys.stderr)