Skip to content

CowboyLogic/ai-dev / skills/copilot-worker

copilot-worker

Flagged

Delegate work to GitHub Copilot instead of doing it yourself, to save Claude tokens. Use this BEFORE reading three or more files (roughly 500 lines or more) to answer a question about a codebase ("look into", "find out how", "where is", "why does", "explain how X works", "does the code do Y", "give me an overview", "summarize"), before any code review of a diff or files, and before any implementation task that touches more than a file or two. Also use when the user says "use Copilot", "delegate", "hand off", or "worker". You plan the task and verify the result; Copilot does the bulk work.

FileKindSize
README.mdmarkdown5.3 KB
SKILL.mdskill md12.2 KB
references/upgrading.mdmarkdown4.3 KB
scripts/copilot_worker.pyscript30.0 KB
scripts/pins.jsonconfig46 B
scripts/test_copilot_worker.pyscript41.4 KB
scripts/test_sdk_contract.pyscript7.0 KB
scripts/test_worker_engine.pyscript36.5 KB
scripts/worker_engine.pyscript42.7 KB

scripts/test_sdk_contract.py

View on GitHub
#!/usr/bin/env python3
"""Contract tests: the SDK and runtime in use are the pinned ones, and the SDK still
offers every name the engine calls. They cost no credits and start no worker.

They need the SDK installed, so run them in the environment the script header pins
(references/upgrading.md gives the command). Without the SDK they skip, unless
REQUIRE_SDK_CONTRACT is set, which CI sets so that a missing SDK fails the run.
"""

from __future__ import annotations

import dataclasses
from importlib.metadata import PackageNotFoundError, requires, version
import inspect
import os
from pathlib import Path
import re
import sys
import typing
import unittest

HERE = Path(__file__).parent
sys.path.insert(0, str(HERE))
import worker_engine as engine  # noqa: E402

try:
    import copilot
    import copilot.generated.session_events as events
    import copilot.rpc as rpc
except ImportError:
    if os.environ.get("REQUIRE_SDK_CONTRACT"):
        raise
    copilot = None

SAMPLE_CONFIG = {
    "mode": "implement", "model": "model", "workspace": "/workspace", "credits": 30,
    "effort": "high", "copilotHome": "/copilot-home", "timeout": 600,
}


def _normalize(name: str) -> str:
    return re.sub(r"[-_.]+", "-", name).lower()


def _header_pins() -> dict[str, str]:
    header = (HERE / "copilot_worker.py").read_text(encoding="utf-8").split("# ///", 2)[1]
    pins = {}
    for requirement in re.findall(r'^#\s+"([^"]+)",?$', header, re.MULTILINE):
        name, _, pinned = requirement.partition("==")
        pins[_normalize(name)] = pinned
    return pins


def engine_efforts() -> tuple[str, ...]:
    import copilot_worker

    return copilot_worker.EFFORTS


def _parameters(callable_: object) -> set[str]:
    return set(inspect.signature(callable_).parameters)


@unittest.skipIf(copilot is None, "github-copilot-sdk is not installed")
class SdkContractTests(unittest.TestCase):
    def test_installed_sdk_and_runtime_are_the_pinned_ones(self) -> None:
        self.assertIsNone(engine.pin_problem(engine.versions(), engine.load_pins()))

    def test_script_header_pins_every_package_the_sdk_pulls_in(self) -> None:
        pins = _header_pins()
        seen: set[str] = set()
        pending = ["github-copilot-sdk"]
        while pending:
            name = _normalize(pending.pop())
            if name in seen:
                continue
            seen.add(name)
            self.assertIn(name, pins, f"{name} is installed with the SDK but not pinned in the header")
            self.assertEqual(version(name), pins[name], f"{name} differs from its header pin")
            for requirement in requires(name) or []:
                if "extra ==" in requirement:
                    continue
                dependency = re.match(r"[A-Za-z0-9._-]+", requirement).group(0)
                try:
                    version(dependency)
                except PackageNotFoundError:
                    continue  # excluded by an environment marker on this interpreter
                pending.append(dependency)

    def test_client_accepts_every_option_the_engine_passes(self) -> None:
        options = engine.client_options(SAMPLE_CONFIG, {})
        self.assertLessEqual(set(options), _parameters(copilot.CopilotClient.__init__))

    def test_create_session_accepts_every_option_the_engine_passes(self) -> None:
        kwargs = engine.session_kwargs(SAMPLE_CONFIG, lambda *_: None, lambda *_: None, object())
        self.assertLessEqual(set(kwargs), _parameters(copilot.CopilotClient.create_session))

    def test_session_limits_use_a_field_the_sdk_defines(self) -> None:
        limits = engine.session_options(SAMPLE_CONFIG)["session_limits"]
        config_type = typing.get_type_hints(copilot.CopilotClient.create_session)["session_limits"]
        limit_type = next(arg for arg in typing.get_args(config_type) if arg is not type(None))
        fields = (
            {field.name for field in dataclasses.fields(limit_type)}
            if dataclasses.is_dataclass(limit_type) else set(typing.get_type_hints(limit_type))
        )
        self.assertLessEqual(set(limits), fields)

    def test_the_model_catalog_still_carries_what_a_profile_is_checked_against(self) -> None:
        self.assertTrue(inspect.iscoroutinefunction(copilot.CopilotClient.list_models))
        model_info = typing.get_type_hints(copilot.CopilotClient.list_models)["return"]
        (item,) = typing.get_args(model_info)
        fields = {field.name for field in dataclasses.fields(item)}
        self.assertLessEqual({"id", "supported_reasoning_efforts", "default_reasoning_effort"}, fields)

    def test_the_sdk_still_accepts_every_effort_the_worker_allows(self) -> None:
        from copilot.session import ReasoningEffort

        self.assertLessEqual(set(engine_efforts()), set(typing.get_args(ReasoningEffort)))

    def test_send_and_wait_accepts_the_timeout_the_engine_passes(self) -> None:
        self.assertLessEqual(set(engine.send_options(SAMPLE_CONFIG)), _parameters(copilot.CopilotSession.send_and_wait))

    def test_toolset_still_adds_builtin_tools(self) -> None:
        for windows in (False, True):
            tools = copilot.ToolSet()
            for name in engine.tools_for(windows)["implement"]:
                tools.add_builtin(name)

    def test_permission_decisions_the_engine_returns_still_construct(self) -> None:
        rpc.PermissionDecisionApproveOnce()
        rpc.PermissionDecisionReject(feedback="reason")

    def test_permission_request_classes_map_to_the_kinds_the_policy_decides(self) -> None:
        expected = {"PermissionRequestShell": "shell", "PermissionRequestRead": "read", "PermissionRequestWrite": "write"}
        for class_name, kind in expected.items():
            request = object.__new__(getattr(events, class_name))
            self.assertEqual(engine.request_kind(request), kind)

    def test_permission_requests_still_carry_the_fields_the_engine_reads(self) -> None:
        def names(class_name: str) -> set[str]:
            return {field.name for field in dataclasses.fields(getattr(events, class_name))}

        self.assertLessEqual({"full_command_text", "command_segments", "commands"}, names("PermissionRequestShell"))
        self.assertIn("identifier", names("PermissionRequestShellCommand"))
        self.assertLessEqual({"full_command_text", "identifier"}, names("PermissionRequestShellCommandSegment"))
        self.assertTrue({"resolved_path", "path"} & names("PermissionRequestRead"))
        self.assertTrue({"resolved_path", "file_name"} & names("PermissionRequestWrite"))

    def test_events_still_carry_the_fields_usage_and_the_response_come_from(self) -> None:
        def names(class_name: str) -> set[str]:
            return {field.name for field in dataclasses.fields(getattr(events, class_name))}

        self.assertLessEqual(
            {"model", "input_tokens", "output_tokens", "cache_read_tokens", "cache_write_tokens", "copilot_usage"},
            names("AssistantUsageData"),
        )
        self.assertIn("total_nano_aiu", names("AssistantUsageCopilotUsage"))
        self.assertIn("content", names("AssistantMessageData"))


if __name__ == "__main__":
    unittest.main()
add-product-e2e-evalpaperclipai/paperclipAdd or extend a Paperclip full-stack runner E2E workflow, fixture, matcher, or report evidence path for local or Daytona execution.Stars: 114kUpdated Claude CodeCodexVerifiedInstall
add-runner-evalpaperclipai/paperclipAdd or extend a Paperclip Runner protocol evaluation definition, roster, assertion, or report fixture with provenance and narrow validation.Stars: 114kUpdated Claude CodeCodexVerifiedInstall
diagnose-why-work-stoppedpaperclipai/paperclipCompatibility entry point for failed, stalled, looping, or over-recovered Paperclip work. Use fix-failed-paperclip-run for the full diagnosis, regression, repair, real verification, and green-PR workflow; honor an explicitly requested diagnosis-only scope.Stars: 114kUpdated Claude CodeCodexVerifiedInstall
fix-failed-paperclip-runpaperclipai/paperclipDiagnose and fix failed, stuck, slow, or incorrectly blocked Paperclip tasks and runs. Use with a task/run URL or failure report to trace the root cause, prove a regression red then green, check second-order effects, verify the real workflow, and deliver a PR with passing checks.Stars: 114kUpdated Claude CodeCodexVerifiedInstall