@danmoisan/drm-copilot-mcp 0.0.1

package/resources/templates/potential_to_issue.py

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

package/resources/templates/push_down_claude_customizations.py

@@ -0,0 +1,188 @@
+"""Publish bundled `.claude` content into a destination workspace.
+
+Purpose:
+    Provide a dedicated public entry point for the Claude customization push-down
+    workflow while reusing the shared publisher engine behind the existing
+    `.github` customization flow. Settings-local configuration is excluded from
+    push-down because it holds host-specific overrides that must not propagate.
+"""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+try:
+    from scripts.dev_tools.push_down_copilot_customizations import (
+        PushDownFileSystem,
+        PushDownSummary,
+        RealPushDownFileSystem,
+        resolve_cli_path,
+    )
+    from scripts.dev_tools.push_down_copilot_customizations import (
+        push_down_customizations as push_down_scoped_customizations,
+    )
+except ModuleNotFoundError as error:
+    if error.name is None or not error.name.startswith("scripts"):
+        raise
+    from dev_tools.push_down_copilot_customizations import (
+        PushDownFileSystem,
+        PushDownSummary,
+        RealPushDownFileSystem,
+        resolve_cli_path,
+    )
+    from dev_tools.push_down_copilot_customizations import (
+        push_down_customizations as push_down_scoped_customizations,
+    )
+
+ARTIFACT_DIRECTORY = "artifacts/claude-customizations"
+MODULE_ENTRY_POINT = "scripts.dev_tools.push_down_claude_customizations"
+ROOT_FOLDERS: tuple[Path, ...] = (Path(".claude"),)
+EXCLUDED_RELATIVE_PATHS: tuple[Path, ...] = (Path(".claude/settings.local.json"),)
+
+__all__ = [
+    "ARTIFACT_DIRECTORY",
+    "EXCLUDED_RELATIVE_PATHS",
+    "PushDownSummary",
+    "ROOT_FOLDERS",
+    "main",
+    "parse_args",
+    "push_down_customizations",
+]
+
+
+class _ExcludingFileSystem:
+    """Wrap a PushDownFileSystem and filter specified paths from list_files.
+
+    Purpose:
+        Prevent host-specific files (e.g. `settings.local.json`) from being
+        included when the publisher enumerates source files. Chosen over a
+        post-enumeration filter so the exclusion travels with the filesystem
+        contract and is transparent to the shared engine.
+
+    Usage:
+        Instantiate with the inner adapter and exclusion paths relative to
+        the repo root; pass the result as the `fs` argument to the engine.
+
+    Invariants / Constraints:
+        Excluded paths are resolved once at construction time for O(1) checks.
+
+    Side Effects:
+        Delegates all I/O to the inner adapter.
+    """
+
+    def __init__(
+        self, inner: PushDownFileSystem, repo_root: Path, excluded: tuple[Path, ...]
+    ) -> None:
+        """Set up the adapter; resolve exclusion paths relative to repo_root."""
+        self._inner = inner
+        # Resolve once at init so list_files per-path checks are O(1).
+        self._excluded: frozenset[Path] = frozenset(
+            (repo_root / p).resolve() for p in excluded
+        )
+
+    def list_files(self, root: Path) -> list[Path]:
+        """Return inner list_files output with excluded paths removed."""
+        return [
+            p for p in self._inner.list_files(root) if p.resolve() not in self._excluded
+        ]
+
+    def is_dir(self, path: Path) -> bool:
+        """Delegate to inner adapter."""
+        return self._inner.is_dir(path)
+
+    def is_file(self, path: Path) -> bool:
+        """Delegate to inner adapter."""
+        return self._inner.is_file(path)
+
+    def read_text(self, path: Path) -> str:
+        """Delegate to inner adapter."""
+        return self._inner.read_text(path)
+
+    def write_text(self, path: Path, content: str) -> None:
+        """Delegate to inner adapter."""
+        self._inner.write_text(path, content)
+
+    def ensure_dir(self, path: Path) -> None:
+        """Delegate to inner adapter."""
+        self._inner.ensure_dir(path)
+
+
+def _passthrough_rewrite(
+    text: str,
+) -> tuple[str, int, int, list[str]]:
+    """Return unmodified text for payloads that do not need command rewrites."""
+
+    return text, 0, 0, []
+
+
+def push_down_customizations(
+    *,
+    repo_root: Path,
+    destination_root: Path,
+    fs: PushDownFileSystem,
+    source_root: Path | None = None,
+    artifact_root: Path | None = None,
+) -> PushDownSummary:
+    """Copy the `.claude` tree into the destination workspace.
+
+    Excludes paths in `EXCLUDED_RELATIVE_PATHS` by wrapping `fs` in
+    `_ExcludingFileSystem` before delegating to the shared engine.
+    """
+
+    # Wrap the caller-supplied adapter so enumeration omits excluded paths.
+    excluding_fs = _ExcludingFileSystem(fs, repo_root, EXCLUDED_RELATIVE_PATHS)
+    return push_down_scoped_customizations(
+        repo_root=repo_root,
+        destination_root=destination_root,
+        fs=excluding_fs,
+        source_root=source_root,
+        artifact_root=artifact_root,
+        root_folders=ROOT_FOLDERS,
+        artifact_directory=ARTIFACT_DIRECTORY,
+        rewrite_references=_passthrough_rewrite,
+    )
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    """Parse CLI arguments for the Claude customization push-down publisher."""
+
+    parser = argparse.ArgumentParser(
+        description=(
+            "Publish bundled Claude customizations with "
+            f"python -m {MODULE_ENTRY_POINT}."
+        )
+    )
+    parser.add_argument(
+        "--destination",
+        required=True,
+        help=("Destination workspace root that will receive the copied .claude tree."),
+    )
+    return parser.parse_args(argv)
+
+
+def main(
+    argv: list[str] | None = None,
+    *,
+    repo_root: Path | None = None,
+    fs: PushDownFileSystem | None = None,
+) -> int:
+    """Run the Claude customization push-down publisher CLI."""
+
+    args = parse_args(argv)
+    resolved_repo_root = resolve_cli_path(repo_root or Path.cwd())
+    resolved_destination = resolve_cli_path(args.destination)
+    resolved_fs = fs or RealPushDownFileSystem()
+    summary = push_down_customizations(
+        repo_root=resolved_repo_root,
+        destination_root=resolved_destination,
+        fs=resolved_fs,
+        source_root=resolved_repo_root,
+        artifact_root=resolved_repo_root,
+    )
+    print(f"Wrote push-down summary artifact to: {summary.artifact_path}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/resources/templates/push_down_codex_and_agents_customizations.py

@@ -0,0 +1,95 @@
+"""Compatibility wrapper for extension-side Codex/agents customization publishing.
+
+Purpose:
+    Preserve the bundled-script entry point while delegating all publishing
+    behavior to the bundled package implementation.
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib
+import sys
+from pathlib import Path
+from typing import Protocol
+
+
+class _PublisherResult(Protocol):
+    """Typed contract for the push-down summary surface accessed by this wrapper."""
+
+    artifact_path: str
+
+
+class _FileSystemFactory(Protocol):
+    """Construction contract for the publisher's filesystem implementation."""
+
+    def __call__(self) -> object: ...
+
+
+class _PublisherFunction(Protocol):
+    """Call contract matching the bundled push_down_customizations signature."""
+
+    def __call__(
+        self,
+        *,
+        repo_root: Path,
+        destination_root: Path,
+        fs: object,
+        source_root: Path,
+        artifact_root: Path,
+    ) -> _PublisherResult: ...
+
+
+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 the bundled Codex/agents publisher in-process."""
+
+    _ensure_bundled_scripts_import_path()
+
+    parser = argparse.ArgumentParser(
+        description="Bundled Codex/agents customization publisher wrapper."
+    )
+    parser.add_argument(
+        "--destination",
+        required=True,
+        help=(
+            "Destination workspace root that will receive the copied .codex "
+            "and .agents trees."
+        ),
+    )
+    args = parser.parse_args()
+
+    module = importlib.import_module(
+        "dev_tools.push_down_codex_and_agents_customizations"
+    )
+    publish_fn: _PublisherFunction = module.push_down_customizations
+    fs_factory: _FileSystemFactory = module.RealPushDownFileSystem
+
+    customizations_root = (
+        Path(__file__).resolve().parent.parent / "codex-and-agents-customizations"
+    )
+    resolved_destination = Path(args.destination).expanduser().resolve()
+    artifact_root = Path.cwd().resolve()
+
+    summary = publish_fn(
+        repo_root=customizations_root,
+        destination_root=resolved_destination,
+        fs=fs_factory(),
+        source_root=customizations_root,
+        artifact_root=artifact_root,
+    )
+    print(f"Wrote push-down summary artifact to: {summary.artifact_path}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/resources/templates/push_down_copilot_customizations.py

@@ -0,0 +1,124 @@
+"""Compatibility wrapper for extension-side push-down customization publishing.
+
+Purpose:
+    Preserve the bundled-script entry point while delegating all publishing
+    behavior to the bundled package implementation.
+
+Usage:
+    python push_down_copilot_customizations.py --destination <path>
+
+Flow:
+    1. Ensure `resources/scripts/` is importable at runtime.
+    2. Import `dev_tools.push_down_copilot_customizations` from bundled sources.
+    3. Resolve `source_root` to `resources/customizations` payload.
+    4. Resolve `artifact_root` to the current working directory.
+    5. Invoke publisher in-process with `--destination` from CLI args.
+
+Invariants / Constraints:
+    - No publishing logic is implemented in this wrapper.
+    - Argument contract is owned by the publisher module and forwarded unchanged.
+
+Side Effects:
+    Imports bundled publisher code and executes it in the current Python process.
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib
+import sys
+from pathlib import Path
+from typing import Protocol
+
+
+class _PublisherResult(Protocol):
+    """Typed contract for the PushDownSummary surface accessed by this wrapper."""
+
+    artifact_path: str
+
+
+class _FileSystemFactory(Protocol):
+    """Construction contract for the publisher's filesystem implementation."""
+
+    def __call__(self) -> object: ...
+
+
+class _PublisherFunction(Protocol):
+    """Call contract matching the bundled push_down_customizations signature."""
+
+    def __call__(
+        self,
+        *,
+        repo_root: Path,
+        destination_root: Path,
+        fs: object,
+        source_root: Path,
+        artifact_root: Path,
+    ) -> _PublisherResult: ...
+
+
+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 push-down customization publisher in-process.
+
+    Purpose:
+        Keep the bundled extension script as a thin adapter and avoid duplicated
+        publishing logic while resolving source and artifact roots automatically.
+
+    Returns:
+        Exit code from bundled publisher main function.
+
+    Side Effects:
+        Imports the bundled publisher module and executes its publishing flow.
+    """
+    _ensure_bundled_scripts_import_path()
+
+    parser = argparse.ArgumentParser(
+        description="Bundled push-down customization publisher wrapper."
+    )
+    parser.add_argument(
+        "--destination",
+        required=True,
+        help="Destination workspace root that will receive the copied .github trees.",
+    )
+    args = parser.parse_args()
+
+    # Extract typed callables from the dynamically loaded publisher module.
+    module = importlib.import_module("dev_tools.push_down_copilot_customizations")
+    publish_fn: _PublisherFunction = module.push_down_customizations
+    fs_factory: _FileSystemFactory = module.RealPushDownFileSystem
+
+    customizations_root = Path(__file__).resolve().parent.parent / "customizations"
+    resolved_destination = Path(args.destination).expanduser().resolve()
+    artifact_root = Path.cwd().resolve()
+
+    summary = publish_fn(
+        repo_root=customizations_root,
+        destination_root=resolved_destination,
+        fs=fs_factory(),
+        source_root=customizations_root,
+        artifact_root=artifact_root,
+    )
+    print(f"Wrote push-down summary artifact to: {summary.artifact_path}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/resources/templates/resolve_atomic_plan_prompt.py

@@ -0,0 +1,75 @@
+"""Compatibility wrapper for extension-side atomic-plan prompt resolution.
+
+Purpose:
+    Preserve a stable bundled-script entry point while delegating atomic-plan
+    prompt resolution to the bundled resolver module under `resources/scripts`.
+
+Usage:
+    python resolve_atomic_plan_prompt.py --target <plan> --workspace <root>
+
+Flow:
+    1. Ensure `resources/scripts/` is importable.
+    2. Inject the bundled atomic-plan prompt template when `--template` is absent.
+    3. Import `dev_tools.resolve_file_prompt` from bundled sources.
+    4. Execute the bundled resolver in-process and return its exit code.
+"""
+
+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 atomic-plan prompt resolution in-process.
+
+    Purpose:
+        Keep the wrapper free of prompt-resolution business logic while ensuring
+        the bundled atomic-plan prompt template is supplied when the caller does
+        not pass `--template` explicitly.
+
+    Args:
+        None.
+
+    Returns:
+        int: Exit code returned by the bundled resolver module.
+
+    Raises:
+        None explicitly. Import or resolver failures propagate to the caller.
+
+    Side Effects:
+        Mutates `sys.argv` additively when `--template` is absent and imports the
+        bundled resolver module in the current Python process.
+    """
+    _ensure_bundled_scripts_import_path()
+
+    template_path = (
+        Path(__file__).resolve().parent.parent
+        / "customizations"
+        / ".github"
+        / "prompts"
+        / "generate-atomic-plan.prompt.md"
+    )
+    if "--template" not in sys.argv:
+        sys.argv.extend(["--template", str(template_path)])
+
+    module = importlib.import_module("dev_tools.resolve_file_prompt")
+    module_main = cast("Callable[[], int]", module.main)
+    return int(module_main())
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/resources/templates/resolve_hard_lock_prompt.py

@@ -0,0 +1,65 @@
+"""Compatibility wrapper for extension-side hard-lock prompt resolution.
+
+Purpose:
+    Preserve the bundled-script entry point while delegating hard-lock prompt
+    resolution behavior to the bundled package implementation.
+
+Usage:
+    python resolve_hard_lock_prompt.py --target <plan> --workspace <workspace>
+
+Flow:
+    1. Ensure `resources/scripts/` is importable at runtime.
+    2. Inject the bundled `.github/codex` template root when the caller omitted it.
+    3. Import `dev_tools.resolve_hard_lock_prompt` from bundled sources.
+    4. Invoke the bundled CLI entrypoint in-process with the active CLI args.
+
+Invariants / Constraints:
+    - No prompt-resolution business logic is implemented in this wrapper.
+    - Argument contract is owned by the bundled resolver module and forwarded
+      unchanged except for additive `--template-root` injection.
+
+Side Effects:
+    Imports bundled resolver 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 hard-lock prompt resolution in-process.
+
+    Injects `--template-root` pointing to the extension's bundled hard-lock
+    prompt templates when the caller did not already provide one.
+    """
+    _ensure_bundled_scripts_import_path()
+
+    template_root = str(
+        Path(__file__).resolve().parent.parent / "customizations" / ".github" / "codex"
+    )
+    if "--template-root" not in sys.argv:
+        sys.argv.extend(["--template-root", template_root])
+
+    module = importlib.import_module("dev_tools.resolve_hard_lock_prompt")
+    module_main = cast("Callable[[], int]", module.main)
+    return int(module_main())
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/resources/templates/run-poshqc-analyze-autofix.ps1

@@ -0,0 +1,16 @@
+[CmdletBinding()]
+param(
+    [Parameter()]
+    [string] $WorkspaceRoot = ".",
+
+    [Parameter()]
+    [string[]] $ScanFolders
+)
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = "Stop"
+
+$poshQcModulePath = Join-Path -Path $PSScriptRoot -ChildPath "..\powershell\PoshQC\PoshQC.psd1"
+Import-Module $poshQcModulePath -Force
+
+Invoke-PoshQCAnalyzeAutofix -Root $WorkspaceRoot -ScanFolders $ScanFolders

package/resources/templates/run-poshqc-analyze.ps1

@@ -0,0 +1,26 @@
+[CmdletBinding()]
+param(
+    [Parameter()]
+    [string] $WorkspaceRoot = ".",
+
+    [Parameter()]
+    [string[]] $ScanFolders,
+
+    [Parameter()]
+    [string] $ScanFoldersJson
+)
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = "Stop"
+
+$poshQcModulePath = Join-Path -Path $PSScriptRoot -ChildPath "..\powershell\PoshQC\PoshQC.psd1"
+Import-Module $poshQcModulePath -Force
+
+$resolvedScanFolders = $ScanFolders
+if (-not [string]::IsNullOrWhiteSpace($ScanFoldersJson)) {
+    $resolvedScanFolders = @(
+        ConvertFrom-Json -InputObject $ScanFoldersJson
+    ) | ForEach-Object { [string] $_ }
+}
+
+Invoke-PoshQCAnalyze -Root $WorkspaceRoot -ScanFolders $resolvedScanFolders

package/resources/templates/run-poshqc-format.ps1

@@ -0,0 +1,26 @@
+[CmdletBinding()]
+param(
+    [Parameter()]
+    [string] $WorkspaceRoot = ".",
+
+    [Parameter()]
+    [string[]] $ScanFolders,
+
+    [Parameter()]
+    [string] $ScanFoldersJson
+)
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = "Stop"
+
+$poshQcModulePath = Join-Path -Path $PSScriptRoot -ChildPath "..\powershell\PoshQC\PoshQC.psd1"
+Import-Module $poshQcModulePath -Force
+
+$resolvedScanFolders = $ScanFolders
+if (-not [string]::IsNullOrWhiteSpace($ScanFoldersJson)) {
+    $resolvedScanFolders = @(
+        ConvertFrom-Json -InputObject $ScanFoldersJson
+    ) | ForEach-Object { [string] $_ }
+}
+
+Invoke-PoshQCFormat -Root $WorkspaceRoot -ScanFolders $resolvedScanFolders