code-muse 0.0.1__py3-none-any.whl

code_muse/plugins/gac/git_ops.py

@@ -0,0 +1,136 @@
+"""Git operations for the GAC plugin.
+
+Lightweight subprocess wrappers for the commands needed to inspect and stage
+changes before an AI-generated commit.
+"""
+
+import logging
+import subprocess
+
+logger = logging.getLogger(__name__)
+
+
+def _run_git(args: list[str]) -> subprocess.CompletedProcess[str]:
+    """Run a git command, returning the CompletedProcess on failure as well."""
+    return subprocess.run(
+        ["git", *args],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+
+def get_staged_diff(context_lines: int = 5) -> str:
+    """Return the staged diff with *context_lines* of context.
+
+    Returns an empty string when there are no staged changes or the command
+    fails (e.g. not inside a git repository).
+    """
+    result = _run_git(["diff", f"-U{context_lines}", "--cached"])
+    if result.returncode != 0:
+        logger.debug("git diff --cached failed: %s", result.stderr.strip())
+        return ""
+    return result.stdout
+
+
+def get_git_status() -> str:
+    """Return a formatted status of staged files only.
+
+    Returns an empty string on failure.
+    """
+    result = _run_git(["diff", "--name-status", "--staged"])
+    if result.returncode != 0:
+        logger.debug(
+            "git diff --name-status --staged failed: %s", result.stderr.strip()
+        )
+        return ""
+
+    output = result.stdout.strip()
+    if not output:
+        return "No changes staged for commit."
+
+    status_map = {
+        "M": "modified",
+        "A": "new file",
+        "D": "deleted",
+        "R": "renamed",
+        "C": "copied",
+        "T": "typechange",
+    }
+
+    lines = ["Changes to be committed:"]
+    for line in output.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        parts = line.split("\t")
+        if len(parts) < 2:
+            continue
+        change_type = parts[0][0]
+        file_path = parts[-1]
+        label = status_map.get(change_type, "modified")
+        lines.append(f"\t{label}:   {file_path}")
+
+    return "\n".join(lines)
+
+
+def get_diff_stat() -> str:
+    """Return ``git diff --cached --stat`` output.
+
+    Returns an empty string on failure.
+    """
+    result = _run_git(["diff", "--cached", "--stat"])
+    if result.returncode != 0:
+        logger.debug("git diff --cached --stat failed: %s", result.stderr.strip())
+        return ""
+    return result.stdout
+
+
+def get_current_branch() -> str:
+    """Return the current branch name.
+
+    Returns an empty string on failure.
+    """
+    result = _run_git(["rev-parse", "--abbrev-ref", "HEAD"])
+    if result.returncode != 0:
+        logger.debug(
+            "git rev-parse --abbrev-ref HEAD failed: %s", result.stderr.strip()
+        )
+        return ""
+    return result.stdout.strip()
+
+
+def get_repo_root() -> str:
+    """Return the repository root absolute path.
+
+    Returns an empty string on failure.
+    """
+    result = _run_git(["rev-parse", "--show-toplevel"])
+    if result.returncode != 0:
+        logger.debug("git rev-parse --show-toplevel failed: %s", result.stderr.strip())
+        return ""
+    return result.stdout.strip()
+
+
+def has_staged_changes() -> bool:
+    """Return ``True`` if there are staged files."""
+    result = _run_git(["diff", "--cached", "--quiet"])
+    return result.returncode != 0
+
+
+def has_any_changes() -> bool:
+    """Return ``True`` if there are any changes (staged or unstaged)."""
+    result = _run_git(["status", "--porcelain"])
+    if result.returncode != 0:
+        return False
+    return bool(result.stdout.strip())
+
+
+def stage_all() -> None:
+    """Stage all changes with ``git add -A``.
+
+    Logs a warning on failure but does not raise.
+    """
+    result = _run_git(["add", "-A"])
+    if result.returncode != 0:
+        logger.warning("git add -A failed: %s", result.stderr.strip())

code_muse/plugins/gac/prompt.py

@@ -0,0 +1,191 @@
+"""Prompt building for the GAC plugin.
+
+Constructs the full prompt (system instructions + git context + execution
+instructions) that is sent to the agent when a ``/gac`` command is issued.
+"""
+
+from code_muse.plugins.gac.git_ops import (
+    get_current_branch,
+    get_diff_stat,
+    get_git_status,
+    get_repo_root,
+    get_staged_diff,
+)
+
+GAC_SYSTEM_INSTRUCTIONS = """
+<role>
+You are an expert git commit message generator acting as GAC (Git Auto Commit).
+Your task: analyze code changes, generate a conventional commit message,
+then execute the commit using git shell commands.
+</role>
+
+<conventions>
+You MUST start your commit message with a conventional commit prefix:
+- feat: A new feature or functionality
+- fix: A bug fix
+- docs: Documentation only
+- style: Code style/formatting (no logic change)
+- refactor: Code restructuring (no behavior change)
+- perf: Performance improvement
+- test: Adding/modifying tests
+- build: Build system/dependencies
+- ci: CI configuration
+- chore: Miscellaneous
+
+Check file types FIRST:
+- If ALL changes are docs (*.md, *.rst, *.txt in docs/, README*, CHANGELOG*), "
+  "use 'docs:'
+- If mixed, use the prefix for the PRIMARY purpose
+
+FORMAT:
+- First line: type: concise summary (present tense, max 50 chars ideal)
+- Line 2: BLANK
+- Lines 3+: bullet points explaining WHAT and WHY
+- DO NOT use markdown headers, code blocks, or formatting
+</conventions>
+
+<examples>
+Good:
+feat: add OAuth2 integration with Google and GitHub
+fix: resolve race condition in user session management
+docs: add troubleshooting section for installation
+refactor: extract validation logic into reusable utilities
+
+Bad:
+fix stuff
+update code
+WIP: still working on this
+Fixed bug
+</examples>
+"""
+
+EXECUTION_INSTRUCTIONS = """
+<execution>
+After generating the commit message, you MUST execute these shell commands:
+
+STEP 1 — Stage all changes (if nothing is staged):
+  git add -A
+
+STEP 2 — Commit with the generated message:
+  git commit -m "YOUR GENERATED MESSAGE"
+
+{extra_steps}
+
+CRITICAL:
+- Use the EXACT commit message you generated. No modifications.
+- Do NOT include reasoning, preamble, or explanations in your response — "
+  "just the commit message and confirmation.
+- If nothing to commit, report that.
+</execution>
+"""
+
+EXECUTION_INSTRUCTIONS_PUSH = """
+STEP 3 — Push to remote:
+  git push
+"""
+
+EXECUTION_INSTRUCTIONS_BUMP = """
+STEP 0 — Bump version FIRST (before staging):
+  Find the version file (__version__.py, pyproject.toml, package.json, Cargo.toml, etc.)
+  Determine the current version
+  Increment the PATCH version (e.g., 1.2.3 → 1.2.4)
+  Update the version file in place
+
+STEP 1 — Stage the version change:
+  git add <version_file>
+
+STEP 2 — Commit the bump:
+  git commit -m "chore: bump version to X.Y.Z"
+"""
+
+
+def build_gac_prompt(push: bool = False, bump: bool = False) -> str | None:
+    """Build the full GAC prompt for the agent.
+
+    Args:
+        push: Include ``git push`` instructions.
+        bump: Include version-bump instructions.
+
+    Returns:
+        The complete prompt string, or ``None`` when there is nothing to commit.
+    """
+    status = get_git_status()
+    diff_stat = get_diff_stat()
+    diff = get_staged_diff(context_lines=5)
+    branch = get_current_branch()
+    repo_root = get_repo_root()
+
+    if not bump and not push and not diff and not diff_stat:
+        return None
+
+    extra_steps = ""
+    if bump:
+        extra_steps = EXECUTION_INSTRUCTIONS_BUMP
+    if push:
+        extra_steps = extra_steps + "\n" + EXECUTION_INSTRUCTIONS_PUSH
+
+    execution = EXECUTION_INSTRUCTIONS.format(extra_steps=extra_steps)
+
+    parts = [
+        GAC_SYSTEM_INSTRUCTIONS.strip(),
+        "",
+        "--- Git context ---",
+        f"Repository: {repo_root or 'unknown'}",
+        f"Branch:     {branch or 'unknown'}",
+        "",
+        "<git_status>",
+        status,
+        "</git_status>",
+        "",
+        "<git_diff_stat>",
+        diff_stat,
+        "</git_diff_stat>",
+        "",
+        "<git_diff>",
+        diff,
+        "</git_diff>",
+        "",
+        execution.strip(),
+    ]
+
+    return "\n".join(parts)
+
+
+def build_gac_prompt_for_message_only() -> str | None:
+    """Build a prompt that only generates the commit message (no execution).
+
+    Returns:
+        The prompt string, or ``None`` when there is nothing to commit.
+    """
+    status = get_git_status()
+    diff_stat = get_diff_stat()
+    diff = get_staged_diff(context_lines=5)
+    branch = get_current_branch()
+    repo_root = get_repo_root()
+
+    if not diff and not diff_stat:
+        return None
+
+    parts = [
+        GAC_SYSTEM_INSTRUCTIONS.strip(),
+        "",
+        "--- Git context ---",
+        f"Repository: {repo_root or 'unknown'}",
+        f"Branch:     {branch or 'unknown'}",
+        "",
+        "<git_status>",
+        status,
+        "</git_status>",
+        "",
+        "<git_diff_stat>",
+        diff_stat,
+        "</git_diff_stat>",
+        "",
+        "<git_diff>",
+        diff,
+        "</git_diff>",
+        "",
+        "Generate ONLY the commit message. No shell commands. No preamble.",
+    ]
+
+    return "\n".join(parts)

code_muse/plugins/gac/register_callbacks.py

@@ -0,0 +1,82 @@
+"""Register GAC slash commands: /gac, /gac push, /gac bump."""
+
+import logging
+
+from code_muse.callbacks import register_callback
+from code_muse.plugins.gac.git_ops import (
+    has_any_changes,
+    has_staged_changes,
+    stage_all,
+)
+from code_muse.plugins.gac.prompt import build_gac_prompt
+
+logger = logging.getLogger(__name__)
+
+# Import CustomCommandResult from the custom_commands plugin
+try:
+    from code_muse.plugins.custom_commands.register_callbacks import (
+        CustomCommandResult,
+    )
+except ImportError:
+    CustomCommandResult = None
+
+
+def _on_custom_command(command: str, name: str):
+    """Handle /gac, /gac push, /gac bump commands.
+
+    Args:
+        command: Full command string (e.g. ``"/gac push"``).
+        name: Command name extracted by the handler (``"gac"``).
+
+    Returns:
+        - ``CustomCommandResult(prompt)`` when the command is resolved and
+          should be sent to the agent as input.
+        - ``True`` when there is nothing to commit (already handled).
+        - ``None`` if the command is not recognised (passthrough).
+    """
+    if name != "gac":
+        return None
+
+    parts = command.split()
+    rest = " ".join(parts[1:]).lower() if len(parts) > 1 else ""
+
+    push = "push" in rest
+    bump = "bump" in rest
+
+    # Check for changes (skip for bump — the agent creates the change)
+    if not bump and not has_any_changes():
+        from code_muse.messaging import emit_warning
+
+        emit_warning("No changes to commit.")
+        return True
+
+    # Stage all changes if nothing is staged
+    if not has_staged_changes():
+        stage_all()
+
+    # Build the prompt
+    prompt = build_gac_prompt(push=push, bump=bump)
+    if prompt is None:
+        from code_muse.messaging import emit_warning
+
+        emit_warning("No changes to commit.")
+        return True
+
+    if CustomCommandResult is not None:
+        return CustomCommandResult(prompt)
+
+    # Fallback: return prompt as string (will be displayed, not sent to agent)
+    return prompt
+
+
+def _on_custom_command_help():
+    """Return help entries for GAC commands."""
+    return [
+        ("gac", "Generate commit message and commit staged changes"),
+        ("gac push", "Generate commit message, commit, and push to remote"),
+        ("gac bump", "Bump patch version, commit, and push to remote"),
+    ]
+
+
+register_callback("custom_command", _on_custom_command)
+register_callback("custom_command_help", _on_custom_command_help)

code_muse/plugins/hook_creator/__init__.py

@@ -0,0 +1 @@
+# Hook Creator Plugin

code_muse/plugins/hook_creator/register_callbacks.py

@@ -0,0 +1,34 @@
+"""
+Hook Creator Plugin - Simple command that injects tool prompt
+"""
+
+from code_muse.callbacks import register_callback
+from code_muse.messaging import emit_info
+
+HOOK_CREATION_PROMPT = "Hook creation prompt placeholder - see Muse documentation for hook creation guidance."
+
+
+def _custom_help():
+    """Help entries for create-hook commands."""
+    return [
+        ("create-hook", "Get help creating Muse hooks"),
+    ]
+
+
+def _handle_custom_command(command: str, name: str):
+    """Handle /create-hook command.
+
+    Displays hook creation documentation and sends to model with context.
+    """
+    if name != "create-hook":
+        return None
+
+    emit_info(HOOK_CREATION_PROMPT)
+
+    # Send the prompt to the model with the hook docs as context
+    return "I need help creating a hook for Muse. Here's the documentation above. Can you help me?"
+
+
+# Register the custom command
+register_callback("custom_command_help", _custom_help)
+register_callback("custom_command", _handle_custom_command)

code_muse/plugins/hook_manager/__init__.py

@@ -0,0 +1 @@
+"""Hook Manager plugin – interactive TUI for managing Claude Code hooks."""