@danmoisan/drm-copilot-mcp 0.0.1

package/resources/templates/collect_commit_context.py

@@ -0,0 +1,212 @@
+"""Collect Git commit context for commit message generation.
+
+This script gathers staged changes and repository state information
+to provide context for generating conventional commit messages.
+"""
+
+from __future__ import annotations
+
+import argparse
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+
+def run_git(args: list[str], allow_error: bool = False) -> str:
+    """Run a git command and return stdout.
+
+    Args:
+        args: Git subcommand and arguments (e.g., ["status", "-sb"])
+        allow_error: If True, return empty output on error instead of raising
+
+    Returns:
+        Git command stdout as string, stripped of whitespace
+
+    Raises:
+        FileNotFoundError: If git executable not found on PATH
+        subprocess.CalledProcessError: If git command fails and allow_error is False
+    """
+    # Validate git executable exists
+    git_exe = shutil.which("git")
+    if not git_exe:
+        raise FileNotFoundError("git executable not found on PATH")
+
+    try:
+        result = subprocess.run(  # noqa: S603 - static analysis can't verify runtime validation
+            [git_exe, *args],
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            check=not allow_error,
+        )
+        stdout = result.stdout or ""
+        return stdout.strip()
+    except subprocess.CalledProcessError as e:
+        if allow_error:
+            stdout = e.stdout or ""
+            return stdout.strip()
+        raise
+
+
+def collect_commit_context(output_path: Path) -> None:
+    """Collect commit context and write to output file."""
+    sections: list[str] = []
+
+    sections.append("Please generate a commit message based on the following content:")
+    sections.append("\n")
+
+    # Repository remotes
+    sections.append("===== Repository remotes =====")
+    sections.append("")
+    remotes = run_git(["remote", "-v"])
+    sections.append(remotes)
+    sections.append("")
+
+    # Current branch
+    sections.append("===== Current branch =====")
+    sections.append("")
+    branch = run_git(["rev-parse", "--abbrev-ref", "HEAD"])
+    sections.append(branch)
+    sections.append("")
+
+    # Upstream
+    sections.append("===== Upstream =====")
+    sections.append("")
+    upstream = run_git(
+        ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], allow_error=True
+    )
+    sections.append(upstream if upstream else "(no upstream)")
+    sections.append("")
+
+    # Status (short)
+    sections.append("===== Status (short) =====")
+    sections.append("")
+    status = run_git(["status", "-sb"])
+    sections.append(status)
+    sections.append("")
+
+    # Staged files (name-status)
+    sections.append("===== Staged files (name-status) =====")
+    sections.append("")
+    staged = run_git(["diff", "--cached", "--name-status"], allow_error=True)
+    sections.append(staged if staged else "(no staged changes)")
+    sections.append("")
+
+    # Staged diff
+    sections.append("===== Staged diff =====")
+    sections.append("")
+    staged_diff = run_git(["diff", "--cached"], allow_error=True)
+    sections.append(staged_diff if staged_diff else "(no staged changes)")
+    sections.append("")
+
+    # Unstaged files (name-status)
+    sections.append("===== Unstaged files (name-status) =====")
+    sections.append("")
+    unstaged = run_git(["diff", "--name-status"], allow_error=True)
+    sections.append(unstaged if unstaged else "(no unstaged changes)")
+    sections.append("")
+
+    # Unstaged diff
+    sections.append("===== Unstaged diff =====")
+    sections.append("")
+    unstaged_diff = run_git(["diff"], allow_error=True)
+    sections.append(unstaged_diff if unstaged_diff else "(no unstaged changes)")
+    sections.append("")
+
+    # Untracked files
+    sections.append("===== Untracked files =====")
+    sections.append("")
+    untracked = run_git(
+        ["ls-files", "--others", "--exclude-standard"], allow_error=True
+    )
+    sections.append(untracked if untracked else "(no untracked files)")
+    sections.append("")
+
+    # Diff stat (combined)
+    sections.append("===== Diff stat (staged + unstaged) =====")
+    sections.append("")
+    diff_stat = run_git(["diff", "HEAD", "--stat"], allow_error=True)
+    sections.append(diff_stat if diff_stat else "(no changes)")
+    sections.append("")
+
+    # Changed Python files
+    sections.append("===== Changed Python files =====")
+    sections.append("")
+    all_changed = run_git(["diff", "HEAD", "--name-only"], allow_error=True)
+    py_files = (
+        [f for f in all_changed.split("\n") if f.endswith(".py")] if all_changed else []
+    )
+    sections.append("\n".join(py_files) if py_files else "(no Python files changed)")
+    sections.append("")
+
+    # Last commit (header only)
+    sections.append("===== Last commit (header only) =====")
+    sections.append("")
+    last_commit = run_git(
+        ["log", "-1", "--format=%H%n%aN <%aE>%n%aD%n%cN <%cE>%n%cD%n%s%n%b"],
+        allow_error=True,
+    )
+    if last_commit:
+        lines = last_commit.split("\n")
+        sections.append(f"commit {lines[0]}")
+        if len(lines) > 1:
+            sections.append(f"Author:     {lines[1]}")
+        if len(lines) > 2:
+            sections.append(f"AuthorDate: {lines[2]}")
+        if len(lines) > 3:
+            sections.append(f"Commit:     {lines[3]}")
+        if len(lines) > 4:
+            sections.append(f"CommitDate: {lines[4]}")
+        if len(lines) > 5:
+            sections.append("")
+            sections.append(f"    {lines[5]}")
+            for line in lines[6:]:
+                if line.strip():
+                    sections.append(f"    {line}")
+    else:
+        sections.append("(no previous commits)")
+    sections.append("")
+
+    # Change intent (editable section)
+    sections.append("===== Change intent (edit below) =====")
+    sections.append("- What/why summary:")
+    sections.append("- Breaking changes:")
+    sections.append("- Affected modules:")
+    sections.append("- Issue/PR refs:")
+    sections.append("")
+
+    # Write to output file
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text("\n".join(sections), encoding="utf-8")
+    print(f"Commit context written to: {output_path}")
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Main entry point."""
+    parser = argparse.ArgumentParser(
+        description="Collect Git commit context for commit message generation"
+    )
+    parser.add_argument(
+        "--output",
+        "-o",
+        type=Path,
+        default=Path("artifacts/commit_context.txt"),
+        help="Output file path (default: artifacts/commit_context.txt)",
+    )
+    args = parser.parse_args(argv)
+
+    try:
+        collect_commit_context(args.output)
+        return 0
+    except subprocess.CalledProcessError as e:
+        print(f"Git command failed: {e}", file=sys.stderr)
+        return 1
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/resources/templates/collect_pr_context.py

@@ -0,0 +1,74 @@
+"""Compatibility wrapper for extension-side PR context collection.
+
+Purpose:
+    Preserve the historical bundled-script entry point while delegating all
+    collection/rendering behavior to the bundled package implementation.
+
+Usage:
+    python collect_pr_context.py --base <ref> --repo-root <path> \
+    --out <path> --appendix-out <path>
+
+Flow:
+    1. Ensure `resources/scripts/` is importable at runtime.
+    2. Import `dev_tools.pr_context.collector.main` from bundled sources.
+    3. Invoke collector entrypoint in-process with unmodified CLI args.
+
+Invariants / Constraints:
+    - No PR context rendering logic is implemented in this wrapper.
+    - Argument contract is owned by the collector module and forwarded unchanged.
+
+Side Effects:
+    Imports bundled collector code and executes it in the current Python process.
+"""
+
+from __future__ import annotations
+
+import importlib
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING, cast
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+def _ensure_bundled_scripts_import_path() -> None:
+    """Prepend bundled `resources/scripts` directory to ``sys.path``.
+
+    Purpose:
+        Make extension-bundled Python packages importable regardless of the
+        destination workspace layout.
+
+    Side Effects:
+        Mutates ``sys.path`` by inserting the bundled scripts directory at
+        index 0 when not already present.
+    """
+    scripts_dir = Path(__file__).resolve().parent.parent / "scripts"
+    scripts_dir_str = str(scripts_dir)
+
+    if scripts_dir_str not in sys.path:
+        sys.path.insert(0, scripts_dir_str)
+
+
+def main() -> int:
+    """Execute bundled PR-context collector entrypoint in-process.
+
+    Purpose:
+        Keep the bundled extension script as a thin adapter and avoid duplicated
+        PR-context business logic while preserving collector-owned CLI parsing.
+
+    Returns:
+        Exit code from bundled collector main function.
+
+    Side Effects:
+        Imports the bundled collector module and executes its CLI flow.
+    """
+    _ensure_bundled_scripts_import_path()
+    collector_module = importlib.import_module("dev_tools.pr_context.collector")
+    collector_main = cast("Callable[[], int]", collector_module.main)
+
+    return collector_main()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/resources/templates/hello_pwsh.ps1

@@ -0,0 +1,3 @@
+$outputPath = Join-Path -Path (Get-Location) -ChildPath 'artifacts/hello_pwsh.txt'
+$null = New-Item -ItemType Directory -Path (Split-Path -Path $outputPath -Parent) -Force
+Set-Content -Path $outputPath -Value 'hello_pwsh:ok' -Encoding UTF8

package/resources/templates/hello_python.py

@@ -0,0 +1,11 @@
+from pathlib import Path
+
+
+def main() -> None:
+    output_file = Path("artifacts/hello_python.txt")
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+    output_file.write_text("hello_python:ok\n", encoding="utf-8")
+
+
+if __name__ == "__main__":
+    main()