@danmoisan/drm-copilot-mcp 0.0.1 → 0.0.6

package/resources/templates/push_down_claude_customizations.py

@@ -1,152 +1,118 @@
-"""Publish bundled `.claude` content into a destination workspace.
+"""Bundled template entry point for the `.claude` customization push-down.
 
 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.
+    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,
-        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_claude_customizations import (
+        CSHARP_VARIANT_CHOICES,
+        MEMORY_MODE_CHOICES,
+        PushDownSummary,
+        push_down_customizations,
+    )
     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",
-]
+__all__ = ["main", "parse_args"]
 
 
-class _ExcludingFileSystem:
-    """Wrap a PushDownFileSystem and filter specified paths from list_files.
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    """Parse CLI arguments for the bundled Claude customization push-down.
 
     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)
+        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"``).
 
-    def read_text(self, path: Path) -> str:
-        """Delegate to inner adapter."""
-        return self._inner.read_text(path)
+    Args:
+        argv (list[str] | None): Optional argument list for tests or embedding.
 
-    def write_text(self, path: Path, content: str) -> None:
-        """Delegate to inner adapter."""
-        self._inner.write_text(path, content)
+    Returns:
+        argparse.Namespace: Parsed arguments with attributes ``destination``,
+        ``packs``, ``csharp_variant``, and ``memory_mode``.
 
-    def ensure_dir(self, path: Path) -> None:
-        """Delegate to inner adapter."""
-        self._inner.ensure_dir(path)
+    Raises:
+        SystemExit: Raised by ``argparse`` when arguments are invalid.
 
-
-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.
+    Side Effects:
+        Emits usage/help text through ``argparse`` when parsing fails.
     """
-
-    # 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 "
@@ -158,27 +124,106 @@ def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
         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 Claude customization push-down publisher CLI."""
+    """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)
-    resolved_repo_root = resolve_cli_path(repo_root or Path.cwd())
+    # 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()
-    summary = push_down_customizations(
+    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

package/resources/claude-customizations/.claude/agent-memory/orchestrator/feedback_repo_root_is_source_of_truth.md

@@ -1,11 +0,0 @@
----
-name: repo-root-is-source-of-truth-for-codex-bundle
-description: When repo-root .codex/.agents/AGENTS.md/etc differ from the extension's bundled customizations, treat the repo root as authoritative and update the bundle to match — not the other way around.
-type: feedback
----
-
-When repo-root files such as `.codex/agents/*.toml`, `.codex/config.toml`, `.codex/hooks/*.ps1`, `.agents/skills/**`, and `AGENTS.md` differ from their bundled copies under `extensions/drm-copilot/resources/codex-and-agents-customizations/` and `extensions/drm-copilot/resources/claude-customizations/`, the repo-root version is the source of truth. Update the bundle to mirror the repo root.
-
-**Why:** The user actively overwrites repo-root files (e.g., by running the codex-native-converter in apply mode) and expects the bundle to reflect those changes. Reverting repo-root files to match the bundle is the wrong direction. Confirmed 2026-05-02 after a converter apply run regenerated `.codex/`, `.agents/`, and `AGENTS.md`.
-
-**How to apply:** When contract tests like `test_push_down_claude_resource_contracts`, `test_push_down_codex_and_agents_resource_contracts`, `test_codex_agent_wrapper_contracts`, `test_codex_full_migration_inventory`, `test_codex_handoff_contract_parity`, or `test_orchestration_guardrail_contracts` fail with diffs between repo and bundle, copy from repo → bundle. Never propose `git checkout HEAD --` on the repo-root file.

package/resources/claude-customizations/.claude/agent-memory/orchestrator/feedback_vsce_verify_package_location.md

@@ -1,19 +0,0 @@
----
-name: Verify which package.json is the VS Code extension before any vsce work
-description: In multi-package repos, never assume the repo root is the publishable extension. Verify location before vsce package/publish/.vscodeignore work.
-type: feedback
----
-
-Before doing any `vsce` packaging, publishing, or `.vscodeignore` work, verify which directory contains the actual VS Code extension. Do not assume the repo root.
-
-**Why:** On 2026-05-02, I spent multiple troubleshooting rounds (`.vscodeignore` rewrites, allow-list strategy, esbuild bundling) treating the repo root `package.json` as the publishable extension. The real extension lives at `extensions/drm-copilot/` with its own `package.json`, `src/`, `tsconfig.json`, `node_modules/`, and existing build pipeline. The user had been side-loading shipping `.vsix` builds for ~4 months from the correct location. The root `package.json` is a workspace orchestrator, not a publishable extension. My misdiagnosis caused the user to push back: "I have been side-loading this extension for a significant period of time and it functions properly." All the changes I made to the root (main, activationEvents, esbuild.config.cjs, bundle script, root .vscodeignore) were applied to the wrong package and produced no value for the actual extension.
-
-**How to apply:** When the user mentions `vsce`, packaging, publishing, `.vscodeignore`, extension manifests, or "the extension":
-
-1. First, locate every `package.json` in the workspace that declares `engines.vscode` or `contributes` or has `@types/vscode` as a dep. Use `Grep` for `"engines"` or `"contributes"` across all `package.json` files.
-2. If multiple candidates exist, identify the one with `main`, `activationEvents`, and `contributes` populated — that is the real extension.
-3. If shipping `.vsix` artifacts exist (e.g., under `artifacts/vsix/`), inspect the most recent one with `unzip -l` and read the included `extension/package.json` to see what is actually being shipped. The directory whose source matches the shipped `out/` files is the real extension.
-4. Run `vsce ls` only from that directory.
-5. State explicitly which directory you identified before making any edits.
-
-This rule applies even when the user opens a root `package.json` in the IDE. The `ide_opened_file` hint indicates focus, not authority over which package is the extension.

package/resources/claude-customizations/.claude/agent-memory/orchestrator/project_extension_location.md

@@ -1,11 +0,0 @@
----
-name: VS Code extension location in this repo
-description: The publishable VS Code extension lives at extensions/drm-copilot/, not at the repo root.
-type: project
----
-
-The publishable VS Code extension lives at `extensions/drm-copilot/`, not at the repo root.
-
-**Why:** This repo is a workspace orchestrator that contains multiple parallel toolchains (Python, PowerShell, TypeScript) plus a Claude/Copilot agent runtime. The VS Code extension is one component among several. Its source is at `extensions/drm-copilot/src/`, its build output is at `extensions/drm-copilot/out/`, its manifest is `extensions/drm-copilot/package.json`, and shipping `.vsix` artifacts go to `artifacts/vsix/` with timestamped filenames. Confirmed 2026-05-02 by inspecting the most recent shipping `.vsix` (`drm-copilot-20260501-114515.vsix`), whose `extension.vsixmanifest` description reads "Extension-side bundled workflow execution utilities and MCP bridge."
-
-**How to apply:** All `vsce` commands (`ls`, `package`, `publish`) must run from `extensions/drm-copilot/`. The repo root `package.json` is not a publishable extension and should not declare `main`, `activationEvents`, or be passed to `vsce`. When the user asks about extension packaging, install paths, the manifest, or the `.vsix`, default to inspecting `extensions/drm-copilot/` first. Verify the location is still current before acting (the layout could change).

package/resources/claude-customizations/.claude/agent-memory/prd-feature/MEMORY.md

@@ -1 +0,0 @@
-- [push-down command pattern](project_push_down_pattern.md) — 10-file change map for adding a new push-down command; reference impl is pushDownCodexAndAgentsCustomizations

package/resources/claude-customizations/.claude/agent-memory/prd-feature/project_push_down_pattern.md

@@ -1,13 +0,0 @@
----
-name: push-down command pattern
-description: The established 10-file pattern for adding a new push-down command to the drm-copilot extension, as used by pushDownCodexAndAgentsCustomizations and pushDownClaudeDir.
-type: project
----
-
-All push-down commands follow a zero-argument pattern across five layers: bundled resource directory, Python dev-tools publisher, Python entry-point template, TypeScript service, and MCP surface.
-
-The reference implementation is `pushDownCodexAndAgentsCustomizations`. New push-down commands clone it, changing only the resource path, tool name, and artifact directory string.
-
-**Why:** Consistency across the extension's automation surface and test coverage.
-
-**How to apply:** When speccing or implementing any new push-down command, the 10-file change map is: (1) resource bundle directory, (2) dev_tools publisher .py, (3) templates entry-point .py, (4) repo-automation-service.ts (REPO_AUTOMATION_TOOLS tuple, interface, implementation), (5) mcp-tool-inputs.ts (input resolver), (6) mcp-tools.ts (definition, dispatch, import), (7) extension.ts (register + subscriptions), (8) package.json (commands entry), (9) extension.workflow-commands.test.ts (registration test), (10) mcp-server.test.ts (mock + tool list assertion). The tool list assertion is an exact ordered array — insert new tool name at the correct position.

package/resources/claude-customizations/.claude/agent-memory/task-researcher/MEMORY.md

@@ -1,3 +0,0 @@
-# Task Researcher Memory Index
-
-- [push-down-claude-dir-149](project_push_down_claude_dir.md) — Issue #149: pushDownClaudeDir command research completed 2026-04-16

package/resources/claude-customizations/.claude/agent-memory/task-researcher/project_push_down_claude_dir.md

@@ -1,11 +0,0 @@
----
-name: push-down-claude-dir-149
-description: Research for Issue #149 — pushDownClaudeDir command. Pattern, file map, and risks documented.
-type: project
----
-
-Issue #149 adds `drmCopilotExtension.pushDownClaudeDir` / MCP tool `push_down_claude_dir`.
-
-**Why:** Developers opening new workspaces lack the `.claude/` runtime directory. The extension has push-down commands for `.github/` and `.codex/.agents/` but not `.claude/`.
-
-**How to apply:** When implementing, clone the `pushDownCodexAndAgentsCustomizations` pattern exactly. Full file change map is in `artifacts/research/push-down-claude-dir-149.md`. Key constraint: exclude `settings.local.json` and `agent-memory/` from the bundled resource directory at `resources/claude-dir-customizations/.claude/`.