monoco-toolkit 0.2.7__py3-none-any.whl → 0.3.0__py3-none-any.whl

monoco/core/git.py

@@ -6,24 +6,23 @@ from pathlib import Path
 
 logger = logging.getLogger("monoco.core.git")
 
+
 def _run_git(args: List[str], cwd: Path) -> Tuple[int, str, str]:
     """Run a raw git command."""
     try:
         result = subprocess.run(
-            ["git"] + args,
-            cwd=cwd,
-            capture_output=True,
-            text=True,
-            check=False
+            ["git"] + args, cwd=cwd, capture_output=True, text=True, check=False
         )
         return result.returncode, result.stdout, result.stderr
     except FileNotFoundError:
         return 1, "", "Git executable not found"
 
+
 def is_git_repo(path: Path) -> bool:
     code, _, _ = _run_git(["rev-parse", "--is-inside-work-tree"], path)
     return code == 0
 
+
 def get_git_status(path: Path, subpath: Optional[str] = None) -> List[str]:
     """
     Get list of modified files.
@@ -32,11 +31,11 @@ def get_git_status(path: Path, subpath: Optional[str] = None) -> List[str]:
     cmd = ["status", "--porcelain"]
     if subpath:
         cmd.append(subpath)
-        
+
     code, stdout, _ = _run_git(cmd, path)
     if code != 0:
         raise RuntimeError("Failed to check git status")
-        
+
     lines = []
     for line in stdout.splitlines():
         line = line.strip()
@@ -50,6 +49,7 @@ def get_git_status(path: Path, subpath: Optional[str] = None) -> List[str]:
             lines.append(path_str)
     return lines
 
+
 def git_add(path: Path, files: List[str]) -> None:
     if not files:
         return
@@ -57,43 +57,46 @@ def git_add(path: Path, files: List[str]) -> None:
     if code != 0:
         raise RuntimeError(f"Git add failed: {stderr}")
 
+
 def git_commit(path: Path, message: str) -> str:
     code, stdout, stderr = _run_git(["commit", "-m", message], path)
     if code != 0:
         raise RuntimeError(f"Git commit failed: {stderr}")
-    
+
     code, hash_out, _ = _run_git(["rev-parse", "HEAD"], path)
     return hash_out.strip()
 
+
 def search_commits_by_message(path: Path, grep_pattern: str) -> List[Dict[str, str]]:
     cmd = ["log", f"--grep={grep_pattern}", "--name-only", "--format=COMMIT:%H|%s"]
     code, stdout, stderr = _run_git(cmd, path)
     if code != 0:
         raise RuntimeError(f"Git log failed: {stderr}")
-        
+
     commits = []
     current_commit = None
-    
+
     for line in stdout.splitlines():
         if line.startswith("COMMIT:"):
             if current_commit:
                 commits.append(current_commit)
-            
+
             parts = line[7:].split("|", 1)
             current_commit = {
                 "hash": parts[0],
                 "subject": parts[1] if len(parts) > 1 else "",
-                "files": []
+                "files": [],
             }
         elif line.strip():
             if current_commit:
                 current_commit["files"].append(line.strip())
-                
+
     if current_commit:
         commits.append(current_commit)
-        
+
     return commits
 
+
 def get_commit_stats(path: Path, commit_hash: str) -> Dict[str, int]:
     cmd = ["show", "--shortstat", "--format=", commit_hash]
     code, stdout, _ = _run_git(cmd, path)
@@ -110,87 +113,111 @@ def get_commit_stats(path: Path, commit_hash: str) -> Dict[str, int]:
                 stats["deletions"] = int(p.split()[0])
     return stats
 
+
 # --- Branch & Worktree Extensions ---
 
+
 def get_current_branch(path: Path) -> str:
     code, stdout, _ = _run_git(["rev-parse", "--abbrev-ref", "HEAD"], path)
     if code != 0:
         return ""
     return stdout.strip()
 
+
 def branch_exists(path: Path, branch_name: str) -> bool:
     code, _, _ = _run_git(["rev-parse", "--verify", branch_name], path)
     return code == 0
 
+
 def create_branch(path: Path, branch_name: str, checkout: bool = False):
     cmd = ["checkout", "-b", branch_name] if checkout else ["branch", branch_name]
     code, _, stderr = _run_git(cmd, path)
     if code != 0:
         raise RuntimeError(f"Failed to create branch {branch_name}: {stderr}")
 
+
 def checkout_branch(path: Path, branch_name: str):
     code, _, stderr = _run_git(["checkout", branch_name], path)
     if code != 0:
         raise RuntimeError(f"Failed to checkout {branch_name}: {stderr}")
 
+
 def delete_branch(path: Path, branch_name: str, force: bool = False):
     flag = "-D" if force else "-d"
     code, _, stderr = _run_git(["branch", flag, branch_name], path)
     if code != 0:
         raise RuntimeError(f"Failed to delete branch {branch_name}: {stderr}")
 
+
 def get_worktrees(path: Path) -> List[Tuple[str, str, str]]:
     """Returns list of (path, head, branch)"""
     code, stdout, stderr = _run_git(["worktree", "list", "--porcelain"], path)
     if code != 0:
         raise RuntimeError(f"Failed to list worktrees: {stderr}")
-    
+
     trees = []
     current = {}
     for line in stdout.splitlines():
         if line.startswith("worktree "):
             if current:
-                trees.append((current.get("worktree"), current.get("HEAD"), current.get("branch")))
+                trees.append(
+                    (
+                        current.get("worktree"),
+                        current.get("HEAD"),
+                        current.get("branch"),
+                    )
+                )
             current = {"worktree": line[9:].strip()}
         elif line.startswith("HEAD "):
             current["HEAD"] = line[5:].strip()
         elif line.startswith("branch "):
             current["branch"] = line[7:].strip()
-            
+
     if current:
-        trees.append((current.get("worktree"), current.get("HEAD"), current.get("branch")))
+        trees.append(
+            (current.get("worktree"), current.get("HEAD"), current.get("branch"))
+        )
     return trees
 
+
 def worktree_add(path: Path, branch_name: str, worktree_path: Path):
-    # If branch doesn't exist, -b will create it. 
+    # If branch doesn't exist, -b will create it.
     # Logic: git worktree add [-b <new_branch>] <path> <commit-ish>
-    
+
     # We assume if branch_exists, use it. If not, create it.
     cmd = ["worktree", "add"]
     if not branch_exists(path, branch_name):
         cmd.extend(["-b", branch_name])
-    
+
     cmd.extend([str(worktree_path), branch_name])
-    
+
     code, _, stderr = _run_git(cmd, path)
     if code != 0:
         raise RuntimeError(f"Failed to create worktree: {stderr}")
 
+
 def worktree_remove(path: Path, worktree_path: Path, force: bool = False):
     cmd = ["worktree", "remove"]
     if force:
         cmd.append("--force")
     cmd.append(str(worktree_path))
-    
+
     code, _, stderr = _run_git(cmd, path)
     if code != 0:
         raise RuntimeError(f"Failed to remove worktree: {stderr}")
 
+
 class GitMonitor:
     """
     Polls the Git repository for HEAD changes and triggers updates.
     """
-    def __init__(self, path: Path, on_head_change: Callable[[str], Awaitable[None]], poll_interval: float = 2.0):
+
+    def __init__(
+        self,
+        path: Path,
+        on_head_change: Callable[[str], Awaitable[None]],
+        poll_interval: float = 2.0,
+    ):
         self.path = path
         self.on_head_change = on_head_change
         self.poll_interval = poll_interval
@@ -200,10 +227,12 @@ class GitMonitor:
     async def get_head_hash(self) -> Optional[str]:
         try:
             process = await asyncio.create_subprocess_exec(
-                "git", "rev-parse", "HEAD",
+                "git",
+                "rev-parse",
+                "HEAD",
                 cwd=self.path,
                 stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE
+                stderr=asyncio.subprocess.PIPE,
             )
             stdout, _ = await process.communicate()
             if process.returncode == 0:
@@ -216,15 +245,17 @@ class GitMonitor:
     async def start(self):
         self.is_running = True
         logger.info(f"Git Monitor started for {self.path}.")
-        
+
         self.last_head_hash = await self.get_head_hash()
-        
+
         while self.is_running:
             await asyncio.sleep(self.poll_interval)
             current_hash = await self.get_head_hash()
-            
+
             if current_hash and current_hash != self.last_head_hash:
-                logger.info(f"Git HEAD changed: {self.last_head_hash} -> {current_hash}")
+                logger.info(
+                    f"Git HEAD changed: {self.last_head_hash} -> {current_hash}"
+                )
                 self.last_head_hash = current_hash
                 await self.on_head_change(current_hash)
 

monoco/core/hooks.py

@@ -0,0 +1,57 @@
+import os
+from pathlib import Path
+from typing import Dict
+from rich.console import Console
+
+console = Console()
+
+
+def install_hooks(project_root: Path, hooks: Dict[str, str]):
+    """
+    Install git hooks based on configuration.
+    """
+    git_dir = project_root / ".git"
+    if not git_dir.exists():
+        console.print("[dim]Skipping hooks installation: Not a git repository.[/dim]")
+        return
+
+    hooks_dir = git_dir / "hooks"
+    hooks_dir.mkdir(exist_ok=True)
+
+    for hook_name, command in hooks.items():
+        hook_path = hooks_dir / hook_name
+
+        # Check if exists
+        if hook_path.exists():
+            # Check if it was generated by us
+            try:
+                with open(hook_path, "r") as f:
+                    first_line = f.readline()
+                if "Monoco Hook" not in first_line:
+                    console.print(
+                        f"[yellow]Warning: Hook '{hook_name}' already exists and is not managed by Monoco. Skipping.[/yellow]"
+                    )
+                    continue
+                # If it IS managed by us, we overwrite it to update the command
+            except Exception:
+                console.print(
+                    f"[yellow]Warning: Hook '{hook_name}' exists and cannot be read. Skipping.[/yellow]"
+                )
+                continue
+
+        content = f"""#!/bin/sh
+# Monoco Hook: {hook_name}
+# Auto-generated by Monoco Toolkit. Do not edit manually.
+
+{command}
+exit $?
+"""
+        try:
+            with open(hook_path, "w") as f:
+                f.write(content)
+
+            # Make executable
+            os.chmod(hook_path, 0o755)
+            console.print(f"[green]✓ Installed hook '{hook_name}'[/green]")
+        except Exception as e:
+            console.print(f"[red]Failed to install hook '{hook_name}': {e}[/red]")

monoco/core/injection.py

@@ -1,6 +1,7 @@
 import re
 from pathlib import Path
-from typing import Dict, List, Optional
+from typing import Dict
+
 
 class PromptInjector:
     """
@@ -9,17 +10,17 @@ class PromptInjector:
     """
 
     MANAGED_HEADER = "## Monoco Toolkit"
-    
+
     def __init__(self, target_file: Path):
         self.target_file = target_file
 
     def inject(self, prompts: Dict[str, str]) -> bool:
         """
         Injects the provided prompts into the target file.
-        
+
         Args:
             prompts: A dictionary where key is the section title and value is the content.
-            
+
         Returns:
             True if changes were written, False otherwise.
         """
@@ -28,7 +29,7 @@ class PromptInjector:
             current_content = self.target_file.read_text(encoding="utf-8")
 
         new_content = self._merge_content(current_content, prompts)
-        
+
         if new_content != current_content:
             self.target_file.write_text(new_content, encoding="utf-8")
             return True
@@ -40,24 +41,26 @@ class PromptInjector:
         """
         # 1. Generate the new managed block content
         managed_block = [self.MANAGED_HEADER, ""]
-        managed_block.append("> **Auto-Generated**: This section is managed by Monoco. Do not edit manually.\n")
-        
+        managed_block.append(
+            "> **Auto-Generated**: This section is managed by Monoco. Do not edit manually.\n"
+        )
+
         for title, content in prompts.items():
             managed_block.append(f"### {title}")
-            managed_block.append("") # Blank line after header
-            
+            managed_block.append("")  # Blank line after header
+
             # Sanitize content: remove leading header if it matches the title
             clean_content = content.strip()
             # Regex to match optional leading hash header matching the title (case insensitive)
             # e.g. "### Issue Management" or "# Issue Management"
             pattern = r"^(#+\s*)" + re.escape(title) + r"\s*\n"
             match = re.match(pattern, clean_content, re.IGNORECASE)
-            
+
             if match:
-                clean_content = clean_content[match.end():].strip()
-            
+                clean_content = clean_content[match.end() :].strip()
+
             managed_block.append(clean_content)
-            managed_block.append("") # Blank line after section
+            managed_block.append("")  # Blank line after section
 
         managed_block_str = "\n".join(managed_block).strip() + "\n"
 
@@ -65,13 +68,13 @@ class PromptInjector:
         lines = original.splitlines()
         start_idx = -1
         end_idx = -1
-        
+
         # Find start
         for i, line in enumerate(lines):
             if line.strip() == self.MANAGED_HEADER:
                 start_idx = i
                 break
-        
+
         if start_idx == -1:
             # Block not found, append to end
             if original and not original.endswith("\n"):
@@ -85,44 +88,44 @@ class PromptInjector:
         # Or EOF
         # Note: If MANAGED_HEADER is "# ...", we look for next "# ..."
         # But allow "## ..." as children.
-        
+
         header_level_match = re.match(r"^(#+)\s", self.MANAGED_HEADER)
         header_level_prefix = header_level_match.group(1) if header_level_match else "#"
-        
+
         for i in range(start_idx + 1, len(lines)):
             line = lines[i]
             # Check if this line is a header of the same level or higher (fewer #s)
             # e.g. if Managed is "###", then "#" and "##" are higher/parents, "###" is sibling.
             # We treat siblings as end of block too.
             if line.startswith("#"):
-                 # Match regex to get level
-                 match = re.match(r"^(#+)\s", line)
-                 if match:
-                     level = match.group(1)
-                     if len(level) <= len(header_level_prefix):
-                         end_idx = i
-                         break
-        
+                # Match regex to get level
+                match = re.match(r"^(#+)\s", line)
+                if match:
+                    level = match.group(1)
+                    if len(level) <= len(header_level_prefix):
+                        end_idx = i
+                        break
+
         if end_idx == -1:
             end_idx = len(lines)
 
         # 3. Construct result
         pre_block = "\n".join(lines[:start_idx])
         post_block = "\n".join(lines[end_idx:])
-        
+
         result = pre_block
         if result:
-             result += "\n\n"
-        
+            result += "\n\n"
+
         result += managed_block_str
-        
+
         if post_block:
             # Ensure separation if post block exists and isn't just empty lines
             if post_block.strip():
                 result += "\n" + post_block
             else:
-                result += post_block # Keep trailing newlines if any, or normalize?
-                
+                result += post_block  # Keep trailing newlines if any, or normalize?
+
         return result.strip() + "\n"
 
     def remove(self) -> bool:
@@ -157,23 +160,23 @@ class PromptInjector:
         for i in range(start_idx + 1, len(lines)):
             line = lines[i]
             if line.startswith("#"):
-                 match = re.match(r"^(#+)\s", line)
-                 if match:
-                     level = match.group(1)
-                     if len(level) <= len(header_level_prefix):
-                         end_idx = i
-                         break
-        
+                match = re.match(r"^(#+)\s", line)
+                if match:
+                    level = match.group(1)
+                    if len(level) <= len(header_level_prefix):
+                        end_idx = i
+                        break
+
         if end_idx == -1:
             end_idx = len(lines)
 
         # Reconstruct content without the block
         # We also need to be careful about surrounding newlines to avoid leaving gaps
-        
+
         # Check lines before start_idx
-        while start_idx > 0 and not lines[start_idx-1].strip():
+        while start_idx > 0 and not lines[start_idx - 1].strip():
             start_idx -= 1
-        
+
         # Check lines after end_idx (optional, but good for cleanup)
         # Usually end_idx points to the next header or EOF.
         # If it points to next header, we keep it.
@@ -182,12 +185,12 @@ class PromptInjector:
         post_block = lines[end_idx:]
 
         # If we removed everything, the file might become empty or just newlines
-        
+
         new_lines = pre_block + post_block
         if not new_lines:
-             new_content = ""
+            new_content = ""
         else:
-             new_content = "\n".join(new_lines).strip() + "\n"
+            new_content = "\n".join(new_lines).strip() + "\n"
 
         if new_content != current_content:
             self.target_file.write_text(new_content, encoding="utf-8")