@danmoisan/drm-copilot-mcp 0.0.6 → 1.0.1

package/resources/templates/push_down_claude_customizations.py

@@ -1,233 +0,0 @@
-"""Bundled template entry point for the `.claude` customization push-down.
-
-Purpose:
-    Provide the extension-invoked CLI that publishes the bundled `.claude`
-    payload into a destination workspace. This template bootstraps the bundled
-    ``resources/scripts`` directory onto ``sys.path`` and then delegates all
-    pack-selection, C# variant-routing, and memory-mode logic to the bundled
-    ``push_down_claude_customizations`` engine module so the template and the
-    repository source stay behaviorally identical.
-
-    Settings-local configuration is excluded from push-down because it holds
-    host-specific overrides. Agent-memory files under `.claude/agent-memory/`
-    are filtered by the engine's content-based scope check; only general-scoped
-    memories are distributed.
-
-Responsibilities:
-    - Ensure the bundled scripts directory is importable when invoked directly
-      from ``resources/templates/``.
-    - Parse the CLI arguments (``--destination``, ``--packs``,
-      ``--csharp-variant``, ``--memory-mode``).
-    - Resolve the source root and bundle root to the sibling bundled
-      ``claude-customizations`` directory so the template distributes the
-      bundled payload rather than a destination workspace's own `.claude`.
-
-Side Effects:
-    Mutates ``sys.path`` at import time; reads bundled source files and writes
-    destination files through the publisher engine.
-"""
-
-from __future__ import annotations
-
-import argparse
-import sys
-from pathlib import Path
-
-
-def _ensure_bundled_scripts_import_path() -> None:
-    """Prepend bundled ``resources/scripts`` directory to ``sys.path``.
-
-    Purpose:
-        Make extension-bundled Python packages importable when this template is
-        invoked directly from ``resources/templates/`` rather than from the
-        repository root. Without this bootstrap, neither
-        ``scripts.dev_tools.push_down_claude_customizations`` nor the fallback
-        ``dev_tools.push_down_claude_customizations`` import resolves because
-        ``resources/scripts`` is not on ``sys.path`` by default.
-
-    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)
-
-
-_ensure_bundled_scripts_import_path()
-
-try:
-    from scripts.dev_tools.push_down_claude_customizations import (
-        CSHARP_VARIANT_CHOICES,
-        MEMORY_MODE_CHOICES,
-        PushDownSummary,
-        push_down_customizations,
-    )
-    from scripts.dev_tools.push_down_copilot_customizations import (
-        PushDownFileSystem,
-        RealPushDownFileSystem,
-        resolve_cli_path,
-    )
-except ModuleNotFoundError as error:
-    if error.name is None or not error.name.startswith("scripts"):
-        raise
-    from dev_tools.push_down_claude_customizations import (
-        CSHARP_VARIANT_CHOICES,
-        MEMORY_MODE_CHOICES,
-        PushDownSummary,
-        push_down_customizations,
-    )
-    from dev_tools.push_down_copilot_customizations import (
-        PushDownFileSystem,
-        RealPushDownFileSystem,
-        resolve_cli_path,
-    )
-
-MODULE_ENTRY_POINT = "scripts.dev_tools.push_down_claude_customizations"
-
-__all__ = ["main", "parse_args"]
-
-
-def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
-    """Parse CLI arguments for the bundled Claude customization push-down.
-
-    Purpose:
-        Mirror the repository entry point's CLI contract, including the optional
-        ``--packs``, ``--csharp-variant``, and ``--memory-mode`` flags. With no
-        optional flags the parsed namespace yields the backward-compatible
-        defaults (``packs=None``, ``csharp_variant="modern"``,
-        ``memory_mode="overwrite"``).
-
-    Args:
-        argv (list[str] | None): Optional argument list for tests or embedding.
-
-    Returns:
-        argparse.Namespace: Parsed arguments with attributes ``destination``,
-        ``packs``, ``csharp_variant``, and ``memory_mode``.
-
-    Raises:
-        SystemExit: Raised by ``argparse`` when arguments are invalid.
-
-    Side Effects:
-        Emits usage/help text through ``argparse`` when parsing fails.
-    """
-    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."),
-    )
-    parser.add_argument(
-        "--packs",
-        default=None,
-        help=(
-            "Comma-separated language pack names to publish (for example "
-            "'core,typescript'). When omitted, the full tree is published. "
-            "'core' is always included."
-        ),
-    )
-    parser.add_argument(
-        "--csharp-variant",
-        dest="csharp_variant",
-        choices=CSHARP_VARIANT_CHOICES,
-        default="modern",
-        help="C# toolchain variant to source ('modern' default or 'legacy').",
-    )
-    parser.add_argument(
-        "--memory-mode",
-        dest="memory_mode",
-        choices=MEMORY_MODE_CHOICES,
-        default="overwrite",
-        help=("Agent-memory handling mode: 'overwrite' (default), 'merge', or 'skip'."),
-    )
-    return parser.parse_args(argv)
-
-
-def _parse_packs_argument(packs_value: str | None) -> frozenset[str] | None:
-    """Parse the raw ``--packs`` CLI value into a normalized pack-name set.
-
-    Args:
-        packs_value (str | None): The raw comma-separated value, or ``None`` when
-            the flag was omitted.
-
-    Returns:
-        frozenset[str] | None: The set of non-empty, stripped pack names, or
-        ``None`` when the flag was omitted or contained only empty entries (the
-        publish-everything default).
-    """
-    if packs_value is None:
-        return None
-    # Strip whitespace and drop empty entries so trailing commas or stray spaces
-    # do not produce empty pack names.
-    names = {entry.strip() for entry in packs_value.split(",") if entry.strip()}
-    if not names:
-        return None
-    return frozenset(names)
-
-
-def main(
-    argv: list[str] | None = None,
-    *,
-    repo_root: Path | None = None,
-    fs: PushDownFileSystem | None = None,
-) -> int:
-    """Run the bundled Claude customization push-down publisher CLI.
-
-    Purpose:
-        Parse arguments, resolve the source and bundle roots to the sibling
-        bundled ``claude-customizations`` directory, thread the pack selection,
-        C# variant, and memory mode into the engine, and print the summary
-        artifact path. With no optional flags this is byte-for-byte equivalent
-        to the prior bundled publish-everything/overwrite behavior.
-
-    Args:
-        argv (list[str] | None): Optional CLI argument list.
-        repo_root (Path | None): Optional explicit source root for tests; when
-            absent, the bundled ``claude-customizations`` directory is used.
-        fs (PushDownFileSystem | None): Optional filesystem adapter for tests.
-
-    Returns:
-        int: Process exit code (``0`` on success).
-
-    Side Effects:
-        Reads bundled source files and writes destination files and the summary
-        artifact through the adapter.
-    """
-    args = parse_args(argv)
-    # Resolve the source root to the bundled customizations directory so the
-    # template distributes the bundled `.claude` payload rather than copying a
-    # destination workspace's existing `.claude` back onto itself. The bundle
-    # root that holds the pack manifests and legacy variant subtree is the same
-    # customizations directory. The optional `repo_root` argument still allows
-    # tests to inject an explicit root.
-    customizations_root = (
-        Path(__file__).resolve().parent.parent / "claude-customizations"
-    )
-    resolved_repo_root = resolve_cli_path(repo_root or customizations_root)
-    resolved_destination = resolve_cli_path(args.destination)
-    resolved_fs = fs or RealPushDownFileSystem()
-    packs = _parse_packs_argument(args.packs)
-    summary: PushDownSummary = 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,
-        packs=packs,
-        csharp_variant=args.csharp_variant,
-        memory_mode=args.memory_mode,
-        bundle_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

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

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

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

@@ -1,65 +0,0 @@
-"""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/validate_orchestration_artifacts.py

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