@danmoisan/drm-copilot-mcp 0.0.6 → 1.0.0

package/resources/templates/collect_commit_context.py

@@ -1,212 +0,0 @@
-"""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

@@ -1,74 +0,0 @@
-"""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_python.py

@@ -1,11 +0,0 @@
-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()

package/resources/templates/new_active_feature_folder.py

@@ -1,67 +0,0 @@
-"""Compatibility wrapper for extension-side active feature folder creation.
-
-Purpose:
-    Preserve the bundled-script entry point while delegating folder-creation
-    behavior to the bundled package implementation.
-
-Usage:
-    python new_active_feature_folder.py --feature-name <name> --type <type> \
-    [--issue-number <number>] --work-mode <mode>
-
-Flow:
-    1. Ensure `resources/scripts/` is importable at runtime.
-    2. Import `dev_tools.new_active_feature_folder` from bundled sources.
-    3. Invoke the bundled CLI entrypoint in-process with unmodified CLI args.
-
-Invariants / Constraints:
-    - No feature-folder business logic is implemented in this wrapper.
-    - Argument contract is owned by the bundled folder-creation module and
-      forwarded unchanged.
-
-Side Effects:
-    Imports bundled folder-creation 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``."""
-    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 active-feature-folder entrypoint in-process.
-
-    Injects ``--template-root`` pointing to the extension's bundled
-    ``feature-templates`` directory so the downstream module resolves
-    templates from the extension rather than the workspace.
-    """
-    _ensure_bundled_scripts_import_path()
-
-    # Compute the bundled template root relative to this wrapper script.
-    template_root = str(Path(__file__).resolve().parent.parent / "feature-templates")
-    if "--template-root" not in sys.argv:
-        sys.argv.extend(["--template-root", template_root])
-
-    module = importlib.import_module("dev_tools.new_active_feature_folder")
-    module_main = cast("Callable[[], None]", module.main)
-    module_main()
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/resources/templates/new_potential_bug_entry.py

@@ -1,54 +0,0 @@
-"""Compatibility wrapper for extension-side potential bug entry creation.
-
-Purpose:
-    Preserve the bundled-script entry point while delegating bug-entry creation
-    behavior to the bundled package implementation.
-
-Usage:
-    python new_potential_bug_entry.py --short-name <name> [--template-root <path>]
-
-Flow:
-    1. Ensure `resources/scripts/` is importable at runtime.
-    2. Import `dev_tools.new_potential_bug_entry` from bundled sources.
-    3. Invoke the bundled CLI entrypoint in-process with unmodified CLI args.
-
-Invariants / Constraints:
-    - No bug-entry business logic is implemented in this wrapper.
-    - Argument contract is owned by the bundled bug-entry module and forwarded
-      unchanged.
-
-Side Effects:
-    Imports bundled bug-entry 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``."""
-    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 potential-bug-entry entrypoint in-process."""
-    _ensure_bundled_scripts_import_path()
-    module = importlib.import_module("dev_tools.new_potential_bug_entry")
-    module_main = cast("Callable[[], None]", module.main)
-    module_main()
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/resources/templates/potential_to_issue.py

@@ -1,55 +0,0 @@
-"""Compatibility wrapper for extension-side potential-to-issue promotion.
-
-Purpose:
-    Preserve the bundled-script entry point while delegating promotion behavior
-    to the bundled package implementation.
-
-Usage:
-    python potential_to_issue.py --potential-path <path> --promotion-type <type> \
-    --work-mode <mode>
-
-Flow:
-    1. Ensure `resources/scripts/` is importable at runtime.
-    2. Import `dev_tools.potential_to_issue` from bundled sources.
-    3. Invoke the bundled CLI entrypoint in-process with unmodified CLI args.
-
-Invariants / Constraints:
-    - No promotion business logic is implemented in this wrapper.
-        - Argument contract is owned by the bundled promotion module and forwarded
-            unchanged.
-
-Side Effects:
-    Imports bundled promotion 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``."""
-    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 potential-to-issue entrypoint in-process."""
-    _ensure_bundled_scripts_import_path()
-    module = importlib.import_module("dev_tools.potential_to_issue")
-    module_main = cast("Callable[[], None]", module.main)
-    module_main()
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())