pactkit-copilot 2.9.4__tar.gz

pactkit_copilot-2.9.4/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: pactkit-copilot
+Version: 2.9.4
+Summary: PactKit adapter for GitHub Copilot
+Author: Slim
+License: MIT
+Project-URL: Homepage, https://github.com/pactkit/pactkit-copilot
+Project-URL: Repository, https://github.com/pactkit/pactkit-copilot
+Project-URL: Documentation, https://github.com/pactkit/pactkit-copilot#readme
+Project-URL: Issues, https://github.com/pactkit/pactkit-copilot/issues
+Keywords: ai,agent,copilot,github,github-copilot,code-assistant,code-quality,developer-tools,spec-driven,devops,scaffold,tdd,pdca
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pactkit>=2.9.4
+
+# pactkit-copilot
+
+PactKit adapter for GitHub Copilot — project-level deployment to `.github/`.
+
+## Install
+
+```bash
+pip install pactkit pactkit-copilot
+```
+
+## Usage
+
+```bash
+# Deploy PactKit to a project for GitHub Copilot
+cd your-project
+pactkit init --format copilot
+
+# Then open the project in your IDE and use /project-init
+```
+
+## What it deploys
+
+| Asset | Location |
+|-------|----------|
+| Skills | `.github/skills/{name}/SKILL.md` |
+| Agents | `.github/agents/{name}.md` |
+| Commands | `.github/prompts/{name}.prompt.md` |
+| Instructions | `.github/copilot-instructions.md` |
+
+## Key differences from other adapters
+
+- **Project-level only**: Everything goes into `.github/` (no user-level `~/` directory)
+- **Per-project init**: Each new project requires `pactkit init --format copilot`
+- **Rules inlined**: Copilot doesn't support `@include`, so rules are inlined into command prompts
+- **Two-step bootstrap**: `pactkit init` (terminal) → `/project-init` (IDE)
+
+## License
+
+MIT

pactkit_copilot-2.9.4/README.md

@@ -0,0 +1,39 @@
+# pactkit-copilot
+
+PactKit adapter for GitHub Copilot — project-level deployment to `.github/`.
+
+## Install
+
+```bash
+pip install pactkit pactkit-copilot
+```
+
+## Usage
+
+```bash
+# Deploy PactKit to a project for GitHub Copilot
+cd your-project
+pactkit init --format copilot
+
+# Then open the project in your IDE and use /project-init
+```
+
+## What it deploys
+
+| Asset | Location |
+|-------|----------|
+| Skills | `.github/skills/{name}/SKILL.md` |
+| Agents | `.github/agents/{name}.md` |
+| Commands | `.github/prompts/{name}.prompt.md` |
+| Instructions | `.github/copilot-instructions.md` |
+
+## Key differences from other adapters
+
+- **Project-level only**: Everything goes into `.github/` (no user-level `~/` directory)
+- **Per-project init**: Each new project requires `pactkit init --format copilot`
+- **Rules inlined**: Copilot doesn't support `@include`, so rules are inlined into command prompts
+- **Two-step bootstrap**: `pactkit init` (terminal) → `/project-init` (IDE)
+
+## License
+
+MIT

pactkit_copilot-2.9.4/pyproject.toml

@@ -0,0 +1,75 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pactkit-copilot"
+version = "2.9.4"
+description = "PactKit adapter for GitHub Copilot"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+dependencies = [
+    "pactkit>=2.9.4",
+]
+
+authors = [
+    { name = "Slim" },
+]
+keywords = [
+    "ai",
+    "agent",
+    "copilot",
+    "github",
+    "github-copilot",
+    "code-assistant",
+    "code-quality",
+    "developer-tools",
+    "spec-driven",
+    "devops",
+    "scaffold",
+    "tdd",
+    "pdca",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Build Tools",
+    "Topic :: Software Development :: Quality Assurance",
+]
+
+[project.urls]
+Homepage = "https://github.com/pactkit/pactkit-copilot"
+Repository = "https://github.com/pactkit/pactkit-copilot"
+Documentation = "https://github.com/pactkit/pactkit-copilot#readme"
+Issues = "https://github.com/pactkit/pactkit-copilot/issues"
+
+[project.entry-points."pactkit.deployers"]
+copilot = "pactkit_copilot:CopilotDeployer"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src", "../pactkit/src"]
+markers = [
+    "e2e: End-to-end CLI tests (subprocess-based)",
+    "integration: Integration tests that call deploy() with filesystem I/O",
+]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 120
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "W"]
+
+[tool.ruff.lint.per-file-ignores]
+"src/pactkit_copilot/deployer.py" = ["E501"]
+"tests/**/*.py" = ["E402", "E501", "E741", "F841", "I001"]

pactkit_copilot-2.9.4/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pactkit_copilot-2.9.4/src/pactkit_copilot/__init__.py

@@ -0,0 +1,5 @@
+"""PactKit Copilot — adapter for GitHub Copilot."""
+
+from pactkit import __version__  # noqa: F401
+
+from pactkit_copilot.deployer import CopilotDeployer  # noqa: F401

pactkit_copilot-2.9.4/src/pactkit_copilot/deployer.py

@@ -0,0 +1,590 @@
+"""Copilot deployer — project-level adapter for GitHub Copilot.
+
+STORY-013: Converts PactKit assets for GitHub Copilot deployment.
+
+Copilot-specific features:
+- **Project-level only**: Everything deploys to `.github/` inside the project
+- Skills → `.github/skills/{name}/SKILL.md`
+- Agents → `.github/agents/{name}.md` (individual files, not single AGENTS.md)
+- Commands → `.github/prompts/{name}.prompt.md` (Copilot slash commands)
+- Instructions → `.github/copilot-instructions.md` (project-level, no @include)
+- Rules → inlined into agents/skills (Copilot has no rules/ directory)
+- No user-level deployment (unlike Claude Code, OpenCode, Codex)
+- Each project requires `pactkit init --format copilot` before IDE use
+"""
+
+import re
+from pathlib import Path
+
+from pactkit import __version__, prompts
+from pactkit.config import (
+    VALID_SKILLS,
+    auto_merge_config_file,
+    load_config,
+)
+from pactkit.generators.deploy_base import DeployerBase, register_deployer
+from pactkit.generators.deployer import (
+    _cleanup_legacy,
+    _render_prompt,
+)
+from pactkit.profiles import get_profile
+from pactkit.prompts.rules import (
+    COMMAND_RULES_MAP,
+)
+from pactkit.skills import load_script
+from pactkit.utils import atomic_write
+
+# Commands excluded from Copilot deployment (require multi-agent orchestration)
+COPILOT_EXCLUDED_COMMANDS = frozenset({"project-sprint.md"})
+
+# Version marker filename
+VERSION_MARKER_FILE = ".pactkit-version"
+
+# --- Templates ---
+
+_COPILOT_INSTRUCTIONS_MD = """\
+# {project_name} — Copilot Instructions
+
+> Auto-generated by PactKit v{version}. Do not edit the [pactkit:managed] sections.
+> Read `docs/product/context.md` at session start for project state.
+> Read `.github/copilot-instructions.local.md` for project-specific overrides.
+
+## Dev Commands
+
+```bash
+{dev_commands}
+```
+
+## PDCA Routing Table
+
+| Phase | Command | Role |
+|-------|---------|------|
+| Plan | `/project-plan` | system-architect |
+| Plan | `/project-design` | product-designer |
+| Plan | `/project-clarify` | system-architect |
+| Act | `/project-act` | senior-developer |
+| Act | `/project-hotfix` | senior-developer |
+| Check | `/project-check` | qa-engineer |
+| Done | `/project-done` | repo-maintainer |
+| Done | `/project-release` | repo-maintainer |
+| Done | `/project-pr` | repo-maintainer |
+| Bootstrap | `/project-init` | system-architect |
+
+> **TIP**: Use `/project-init` to set up project governance.
+
+{rules_section}
+"""
+
+_COPILOT_LOCAL_INSTRUCTIONS = """\
+# Project Local Instructions
+# Add your custom Copilot instructions below.
+# PactKit will never overwrite this file.
+"""
+
+_STACK_DEV_COMMANDS = {
+    "python": "# Run tests\npython3 -m pytest tests/ -v\n\n# Lint\nruff check src/ tests/",
+    "node": "# Run tests\nnpm test\n\n# Lint\nnpm run lint",
+    "go": "# Run tests\ngo test ./...\n\n# Lint\ngolangci-lint run",
+    "java": "# Run tests\nmvn test\n\n# Lint\nmvn checkstyle:check",
+    "unknown": "# TODO: Add your test and lint commands here",
+}
+
+# Core rules to inline in copilot-instructions.md (minimal-core strategy)
+_MINIMAL_CORE_RULES = ["core", "hierarchy", "atlas", "workflow", "shared"]
+
+
+class CopilotDeployer(DeployerBase):
+    """GitHub Copilot deployment — project-level `.github/` structure.
+
+    Unlike other deployers, Copilot deploys everything into the project
+    directory (`.github/`) rather than a user-level config directory.
+    Each new project requires `pactkit init --format copilot`.
+    """
+
+    profile = get_profile("copilot")
+
+    def deploy(self, config=None, target=None):
+        """Deploy PactKit configuration for GitHub Copilot.
+
+        Target is the project root (not .github/). Everything goes into
+        {project_root}/.github/ subdirectories.
+        """
+        project_root = Path(target) if target else Path.cwd()
+        github_dir = project_root / ".github"
+
+        print("🚀 PactKit GitHub Copilot Deployment")
+
+        # Load pactkit.yaml from project if available
+        from pactkit.config import find_pactkit_yaml
+
+        project_yaml = find_pactkit_yaml()
+        if project_yaml is not None:
+            auto_added = auto_merge_config_file(project_yaml)
+            for item in auto_added:
+                print(f"  -> Auto-added: {item}")
+            cfg = load_config(project_yaml)
+        else:
+            cfg = {}
+
+        enabled_skills = cfg.get("skills", sorted(VALID_SKILLS))
+        rules_strategy = cfg.get("copilot_rules_strategy", "minimal-core")
+
+        # Deploy skills
+        skills_dir = github_dir / "skills"
+        skills_dir.mkdir(parents=True, exist_ok=True)
+        n_skills = self.deploy_copilot_skills(skills_dir, enabled_skills, self.profile)
+
+        # Deploy command prompts
+        prompts_dir = github_dir / "prompts"
+        prompts_dir.mkdir(parents=True, exist_ok=True)
+        n_commands = self.deploy_copilot_command_prompts(prompts_dir, self.profile)
+
+        # Deploy agent definitions
+        agents_dir = github_dir / "agents"
+        agents_dir.mkdir(parents=True, exist_ok=True)
+        self.deploy_copilot_agents(agents_dir, self.profile)
+
+        # Generate copilot-instructions.md
+        stack = _detect_stack(project_root)
+        self.generate_copilot_instructions(github_dir, project_root.name, stack, rules_strategy)
+
+        # Generate pactkit.yaml if missing
+        yaml_path = github_dir / "pactkit.yaml"
+        if yaml_path.exists():
+            print("  ⚠️ .github/pactkit.yaml already exists — skipping")
+        else:
+            yaml_content = (
+                f"stack: {stack}\n"
+                f"version: 0.0.1\n"
+                f"root: .\n"
+                f'developer: ""\n'
+            )
+            atomic_write(yaml_path, yaml_content)
+
+        # Write local instructions if missing
+        local_path = github_dir / "copilot-instructions.local.md"
+        if not local_path.exists():
+            atomic_write(local_path, _COPILOT_LOCAL_INSTRUCTIONS)
+
+        # Legacy cleanup
+        _cleanup_legacy(skills_dir)
+
+        self.write_version_marker(github_dir)
+
+        print(
+            f"\n✅ Copilot: {n_skills} Skills, {n_commands} Commands → {github_dir}"
+        )
+        print(
+            "\n📌 Next step: Open the project in your IDE and use /project-init to complete PDCA setup."
+        )
+
+    # --- Version tracking ---
+
+    @staticmethod
+    def write_version_marker(github_dir, version=None):
+        """Write version marker to .github/.pactkit-version."""
+        v = version if version is not None else __version__
+        atomic_write(github_dir / VERSION_MARKER_FILE, v + "\n")
+
+    @staticmethod
+    def read_deployed_version(github_dir):
+        """Read deployed version from marker file. Returns None if not found."""
+        marker = github_dir / VERSION_MARKER_FILE
+        if marker.exists():
+            return marker.read_text().strip()
+        return None
+
+    # --- Copilot-specific deployment methods ---
+
+    @staticmethod
+    def deploy_copilot_skills(skills_dir, enabled_skills, profile):
+        """Deploy skills to .github/skills/{name}/SKILL.md with embedded scripts."""
+        _prefix = profile.skills_path_var
+
+        scripted_skill_defs = [
+            {
+                "name": "pactkit-visualize",
+                "skill_md": prompts.SKILL_VISUALIZE_MD,
+                "script_name": "visualize.py",
+                "script_source": load_script("visualize.py"),
+            },
+            {
+                "name": "pactkit-board",
+                "skill_md": prompts.SKILL_BOARD_MD,
+                "script_name": "board.py",
+                "script_source": load_script("board.py"),
+            },
+            {
+                "name": "pactkit-scaffold",
+                "skill_md": prompts.SKILL_SCAFFOLD_MD,
+                "script_name": "scaffold.py",
+                "script_source": load_script("scaffold.py"),
+            },
+        ]
+
+        prompt_only_skill_defs = [
+            {"name": "pactkit-trace", "skill_md": prompts.SKILL_TRACE_MD},
+            {"name": "pactkit-draw", "skill_md": prompts.SKILL_DRAW_MD},
+            {"name": "pactkit-status", "skill_md": prompts.SKILL_STATUS_MD},
+            {"name": "pactkit-doctor", "skill_md": prompts.SKILL_DOCTOR_MD},
+            {"name": "pactkit-review", "skill_md": prompts.SKILL_REVIEW_MD},
+            {"name": "pactkit-release", "skill_md": prompts.SKILL_RELEASE_MD},
+            {"name": "pactkit-analyze", "skill_md": prompts.SKILL_ANALYZE_MD},
+        ]
+
+        enabled_set = set(enabled_skills)
+        deployed = 0
+
+        for sd in scripted_skill_defs:
+            if sd["name"] not in enabled_set:
+                continue
+            skill_dir = skills_dir / sd["name"]
+            scripts_dir = skill_dir / "scripts"
+            scripts_dir.mkdir(parents=True, exist_ok=True)
+
+            from pactkit.generators.deployer import _render_skill_md
+            skill_md = _render_skill_md(sd, profile, _prefix)
+            skill_md = _replace_paths_for_copilot(skill_md)
+            skill_md = CopilotDeployer.strip_model_references(skill_md)
+            atomic_write(skill_dir / "SKILL.md", skill_md)
+
+            script_content = sd["script_source"]
+            script_content = script_content.replace("~/.claude/", f"{profile.global_config_dir}/")
+            script_content = script_content.replace("~/.config/opencode/", f"{profile.global_config_dir}/")
+            script_content = script_content.replace("~/.codex/", f"{profile.global_config_dir}/")
+            atomic_write(scripts_dir / sd["script_name"], script_content)
+            deployed += 1
+
+        for sd in prompt_only_skill_defs:
+            if sd["name"] not in enabled_set:
+                continue
+            skill_dir = skills_dir / sd["name"]
+            skill_dir.mkdir(parents=True, exist_ok=True)
+
+            from pactkit.generators.deployer import _render_skill_md
+            skill_md = _render_skill_md(sd, profile, _prefix)
+            skill_md = _replace_paths_for_copilot(skill_md)
+            skill_md = CopilotDeployer.strip_model_references(skill_md)
+            atomic_write(skill_dir / "SKILL.md", skill_md)
+            deployed += 1
+
+        return deployed
+
+    @staticmethod
+    def deploy_copilot_command_prompts(prompts_dir, profile):
+        """Deploy PDCA commands as .github/prompts/{name}.prompt.md.
+
+        Copilot uses .prompt.md files in .github/prompts/ for slash commands.
+        Each file becomes a /command-name in the Copilot chat.
+        """
+        deployed = 0
+        for filename, raw_content in prompts.COMMANDS_CONTENT.items():
+            if filename in COPILOT_EXCLUDED_COMMANDS:
+                continue
+            cmd_name = filename.removesuffix(".md")
+
+            # Extract description from original frontmatter, then strip it
+            description = cmd_name
+            content = raw_content
+            if content.startswith("---"):
+                parts = content.split("---", 2)
+                if len(parts) >= 3:
+                    for line in parts[1].strip().split("\n"):
+                        if line.startswith("description:"):
+                            description = line.split(":", 1)[1].strip().strip('"')
+                    content = parts[2].lstrip("\n")
+
+            content = _render_prompt(content, profile)
+            content = _replace_paths_for_copilot(content)
+            content = CopilotDeployer.strip_model_references(content)
+            content = _replace_slash_commands(content)
+
+            # Inline rules for this command (Copilot doesn't support @include)
+            rules_block = CopilotDeployer.inline_rules_for_command(cmd_name, profile)
+
+            # Build .prompt.md with Copilot frontmatter
+            frontmatter = (
+                f"---\n"
+                f"mode: agent\n"
+                f"description: \"{description}\"\n"
+                f"---\n\n"
+            )
+
+            prompt_content = frontmatter + content
+            if rules_block:
+                prompt_content += "\n\n---\n\n## Rules Reference\n\n" + rules_block
+
+            atomic_write(prompts_dir / f"{cmd_name}.prompt.md", prompt_content)
+            deployed += 1
+
+        return deployed
+
+    @staticmethod
+    def deploy_copilot_agents(agents_dir, profile):
+        """Deploy agent definitions as individual .github/agents/{name}.md files.
+
+        Copilot supports multi-agent via individual .md files in .github/agents/.
+        Each file defines one agent with frontmatter (name, description, tools).
+        """
+        excluded_fields = profile.excluded_agent_fields
+
+        for name, cfg in sorted(prompts.AGENTS_EXPERT.items()):
+            # Build Copilot agent frontmatter
+            fm_lines = ["---"]
+            fm_lines.append(f"name: {name}")
+            fm_lines.append(f'description: "{cfg["desc"]}"')
+
+            # Map allowed-tools → tools
+            if "tools" not in excluded_fields and cfg.get("tools"):
+                tools_list = ", ".join(cfg["tools"])
+                fm_lines.append(f"tools: [{tools_list}]")
+
+            fm_lines.append("---")
+            frontmatter = "\n".join(fm_lines) + "\n\n"
+
+            # Agent prompt body
+            prompt = cfg.get("prompt", "")
+            prompt = _render_prompt(prompt, profile)
+            prompt = _replace_paths_for_copilot(prompt)
+            prompt = CopilotDeployer.strip_model_references(prompt)
+
+            # Remove excluded fields from prompt body
+            for field in excluded_fields:
+                prompt = re.sub(
+                    rf'^[-*]\s*\**{field}\**:.*$\n?',
+                    '',
+                    prompt,
+                    flags=re.MULTILINE,
+                )
+
+            content = frontmatter + prompt.strip() + "\n"
+            atomic_write(agents_dir / f"{name}.md", content)
+
+        print(f"  📋 {len(prompts.AGENTS_EXPERT)} agent definitions deployed")
+
+    @staticmethod
+    def generate_copilot_instructions(github_dir, project_name, stack, rules_strategy="minimal-core"):
+        """Generate .github/copilot-instructions.md with optional rules inlining.
+
+        Strategies:
+        - minimal-core: Only core rules in instructions, detailed rules inlined per-command
+        - full-inline: All rules merged into copilot-instructions.md
+        """
+        dev_commands = _STACK_DEV_COMMANDS.get(stack, _STACK_DEV_COMMANDS["unknown"])
+
+        # Build rules section based on strategy
+        if rules_strategy == "full-inline":
+            rules_lines = ["## Rules\n"]
+            for key in _MINIMAL_CORE_RULES:
+                content = prompts.RULES_MODULES.get(key, "")
+                if not content:
+                    continue
+                content = content.strip()
+                content = CopilotDeployer.strip_model_selection_table(content)
+                content = CopilotDeployer.strip_model_references(content)
+                content = _replace_paths_for_copilot(content)
+                rules_lines.append(content)
+                rules_lines.append("")
+            rules_section = "\n".join(rules_lines)
+        else:
+            # minimal-core: just a pointer
+            rules_section = (
+                "## Rules\n\n"
+                "Rules are embedded in each command prompt (`.github/prompts/`).\n"
+                "See individual command files for applicable governance rules.\n"
+            )
+
+        content = _COPILOT_INSTRUCTIONS_MD.format(
+            project_name=project_name,
+            version=__version__,
+            dev_commands=dev_commands,
+            rules_section=rules_section,
+        )
+
+        atomic_write(github_dir / "copilot-instructions.md", content)
+        print(f"  📄 copilot-instructions.md ({rules_strategy})")
+
+    # --- Brand replacement helpers ---
+
+    @staticmethod
+    def strip_model_references(content):
+        """Strip Claude/Anthropic model references from Copilot content."""
+        content = re.sub(r'claude-sonnet[\w-]*', 'capable-model', content)
+        content = re.sub(r'claude-haiku[\w-]*', 'fast-model', content)
+        content = re.sub(r'claude-opus[\w-]*', 'reasoning-model', content)
+        content = content.replace("[Claude Code](https://claude.com/claude-code)", "[GitHub Copilot](https://github.com/features/copilot)")
+        content = content.replace("Claude Code", "GitHub Copilot")
+        content = content.replace("Codex CLI", "GitHub Copilot")
+        content = content.replace("claude.com", "github.com/features/copilot")
+        content = re.sub(r'\bAnthropic\b', 'GitHub', content)
+        content = re.sub(r'\bOpenAI\b', 'GitHub', content)
+        return content
+
+    @staticmethod
+    def strip_model_selection_table(content):
+        """Remove the Subagent Model Selection section from inlined rules."""
+        lines = content.split("\n")
+        result = []
+        skip = False
+        for line in lines:
+            if "Subagent Model Selection" in line and line.strip().startswith("#"):
+                skip = True
+                continue
+            if skip:
+                if line.startswith("## ") or line.startswith("# "):
+                    skip = False
+                    result.append(line)
+            else:
+                result.append(line)
+        return "\n".join(result)
+
+    @staticmethod
+    def inline_rules_for_command(cmd_name, profile):
+        """Build inlined rules block for a command prompt (no @include support).
+
+        Returns the rules text to append, or empty string if no rules.
+        """
+        rule_keys = COMMAND_RULES_MAP.get(cmd_name, ["core", "credential"])
+        blocks = []
+
+        for key in rule_keys:
+            if key == "credential":
+                blocks.append(
+                    "### Credential Safety\n\n"
+                    "NEVER print passwords, keys, or tokens to stdout.\n"
+                    "NEVER commit secrets to version control.\n"
+                )
+                continue
+
+            content = prompts.RULES_MODULES.get(key, "")
+            if not content:
+                continue
+            content = content.strip()
+            content = CopilotDeployer.strip_model_selection_table(content)
+            content = CopilotDeployer.strip_model_references(content)
+            content = _replace_paths_for_copilot(content)
+            blocks.append(content)
+
+        return "\n\n".join(blocks)
+
+
+# --- Module-level functions ---
+
+
+def update(target=None, force=False, if_needed=False, dry_run=False):
+    """Update deployed PactKit files incrementally.
+
+    Args:
+        target: Project root directory (default: cwd)
+        force: Bypass version check, always redeploy
+        if_needed: Silent no-op if already current
+        dry_run: Show plan without making changes
+
+    Returns:
+        dict with 'action' key: 'skip', 'updated', or 'dry_run'
+    """
+    project_root = Path(target) if target else Path.cwd()
+    github_dir = project_root / ".github"
+
+    deployed_version = CopilotDeployer.read_deployed_version(github_dir)
+    needs_update = deployed_version != __version__
+
+    if not needs_update and not force:
+        if not if_needed:
+            print(f"✅ Already up to date (v{__version__})")
+        return {"action": "skip"}
+
+    if dry_run:
+        print(f"Would update ({deployed_version or 'none'} → {__version__}):")
+        print(f"  {github_dir}/copilot-instructions.md")
+        print(f"  {github_dir}/skills/*/")
+        print(f"  {github_dir}/prompts/*/")
+        print(f"  {github_dir}/agents/*/")
+        print("Preserved (user-owned):")
+        print(f"  {github_dir}/copilot-instructions.local.md")
+        print(f"  {github_dir}/pactkit.yaml")
+        return {"action": "dry_run"}
+
+    print(f"🔄 Updating PactKit ({deployed_version or 'none'} → {__version__})")
+    CopilotDeployer().deploy(target=str(project_root))
+
+    return {"action": "updated"}
+
+
+# --- Helper functions ---
+
+
+def _detect_stack(project_root):
+    """Detect project stack from filesystem markers."""
+    project_root = Path(project_root)
+    if (project_root / "pyproject.toml").exists() or (project_root / "requirements.txt").exists():
+        return "python"
+    if (project_root / "package.json").exists():
+        return "node"
+    if (project_root / "go.mod").exists():
+        return "go"
+    if (project_root / "pom.xml").exists() or (project_root / "build.gradle").exists():
+        return "java"
+    return "unknown"
+
+
+def _replace_paths_for_copilot(content):
+    """Replace Claude/OpenCode/Codex paths with Copilot .github/ paths."""
+    # Order matters: longer patterns first
+    content = content.replace("~/.claude/skills/", ".github/skills/")
+    content = content.replace("~/.claude/rules/", ".github/rules/")
+    content = content.replace("~/.claude/commands/", ".github/prompts/")
+    content = content.replace("~/.claude/agents/", ".github/agents/")
+    content = content.replace("~/.claude/", ".github/")
+    content = content.replace("~/.config/opencode/skills/", ".github/skills/")
+    content = content.replace("~/.config/opencode/", ".github/")
+    content = content.replace("~/.codex/skills/", ".github/skills/")
+    content = content.replace("~/.codex/rules/", ".github/rules/")
+    content = content.replace("~/.codex/", ".github/")
+    content = content.replace(".claude/settings.json", ".github/copilot-instructions.md")
+    content = content.replace(".claude/", ".github/")
+    content = content.replace(".codex/", ".github/")
+    content = content.replace(".opencode/", ".github/")
+    # Replace AGENTS.md → copilot-instructions.md
+    content = content.replace("AGENTS.md", "copilot-instructions.md")
+    content = content.replace("CLAUDE.md", "copilot-instructions.md")
+    return content
+
+
+def _replace_slash_commands(content):
+    """Adapt slash command references for Copilot format.
+
+    Copilot uses / prefix natively for slash commands (same as Claude Code).
+    Replace $ prefix (Codex style) back to / if present.
+    Also replace CLI-style pactkit commands with script paths.
+    """
+    # Codex uses $ prefix; Copilot uses / prefix (same as Claude Code)
+    content = re.sub(r'`\$project-', '`/project-', content)
+    content = re.sub(r'"\$project-', '"/project-', content)
+    content = re.sub(r"'\$project-", "'/project-", content)
+
+    # Replace pactkit CLI references with script paths for project-level deployment
+    _skills_base = ".github/skills"
+    viz_script = f"python3 {_skills_base}/pactkit-visualize/scripts/visualize.py"
+
+    content = content.replace("Run `pactkit visualize --lazy`",
+                              f"Run `{viz_script}` (file, `--mode class`, `--mode call` if source changed)")
+    content = content.replace("Run `pactkit visualize", f"Run `{viz_script}")
+    content = content.replace("Run `visualize --focus", f"Run `{viz_script} --focus")
+    content = content.replace("Run `visualize --mode", f"Run `{viz_script} --mode")
+    content = content.replace("Run `visualize`", f"Run `{viz_script}`")
+    content = content.replace("Run `pactkit clean`",
+                              "Run language-specific cleanup (e.g., `find . -name '__pycache__' -exec rm -rf {} +` for Python)")
+
+    # Handle backtick-wrapped bare visualize references
+    content = re.sub(
+        r'`visualize (--(?:focus|mode|entry))',
+        rf'`{viz_script} \1',
+        content,
+    )
+
+    return content
+
+
+# Auto-register when this module is imported
+register_deployer("copilot", CopilotDeployer, force=True)

pactkit_copilot-2.9.4/src/pactkit_copilot.egg-info/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: pactkit-copilot
+Version: 2.9.4
+Summary: PactKit adapter for GitHub Copilot
+Author: Slim
+License: MIT
+Project-URL: Homepage, https://github.com/pactkit/pactkit-copilot
+Project-URL: Repository, https://github.com/pactkit/pactkit-copilot
+Project-URL: Documentation, https://github.com/pactkit/pactkit-copilot#readme
+Project-URL: Issues, https://github.com/pactkit/pactkit-copilot/issues
+Keywords: ai,agent,copilot,github,github-copilot,code-assistant,code-quality,developer-tools,spec-driven,devops,scaffold,tdd,pdca
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pactkit>=2.9.4
+
+# pactkit-copilot
+
+PactKit adapter for GitHub Copilot — project-level deployment to `.github/`.
+
+## Install
+
+```bash
+pip install pactkit pactkit-copilot
+```
+
+## Usage
+
+```bash
+# Deploy PactKit to a project for GitHub Copilot
+cd your-project
+pactkit init --format copilot
+
+# Then open the project in your IDE and use /project-init
+```
+
+## What it deploys
+
+| Asset | Location |
+|-------|----------|
+| Skills | `.github/skills/{name}/SKILL.md` |
+| Agents | `.github/agents/{name}.md` |
+| Commands | `.github/prompts/{name}.prompt.md` |
+| Instructions | `.github/copilot-instructions.md` |
+
+## Key differences from other adapters
+
+- **Project-level only**: Everything goes into `.github/` (no user-level `~/` directory)
+- **Per-project init**: Each new project requires `pactkit init --format copilot`
+- **Rules inlined**: Copilot doesn't support `@include`, so rules are inlined into command prompts
+- **Two-step bootstrap**: `pactkit init` (terminal) → `/project-init` (IDE)
+
+## License
+
+MIT

pactkit_copilot-2.9.4/src/pactkit_copilot.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+src/pactkit_copilot/__init__.py
+src/pactkit_copilot/deployer.py
+src/pactkit_copilot.egg-info/PKG-INFO
+src/pactkit_copilot.egg-info/SOURCES.txt
+src/pactkit_copilot.egg-info/dependency_links.txt
+src/pactkit_copilot.egg-info/entry_points.txt
+src/pactkit_copilot.egg-info/requires.txt
+src/pactkit_copilot.egg-info/top_level.txt

pactkit_copilot-2.9.4/src/pactkit_copilot.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pactkit_copilot-2.9.4/src/pactkit_copilot.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pactkit.deployers]
+copilot = pactkit_copilot:CopilotDeployer

pactkit_copilot-2.9.4/src/pactkit_copilot.egg-info/requires.txt

@@ -0,0 +1 @@
+pactkit>=2.9.4

pactkit_copilot-2.9.4/src/pactkit_copilot.egg-info/top_level.txt

@@ -0,0 +1 @@
+pactkit_copilot