coprogrammer 0.1.0__py3-none-any.whl

coprogrammer/mcp_server.py

@@ -0,0 +1,371 @@
+"""Zero-dependency MCP (Model Context Protocol) stdio server.
+
+Exposes the CoProgrammer Manager Plane and digest tooling as MCP tools so any
+MCP client (Claude Code, Codex, Cursor, Cowork, ...) can coordinate
+multi-agent work without shelling out to the CLI.
+
+Transport: newline-delimited JSON-RPC 2.0 over stdio, per the MCP spec.
+No third-party dependencies; reuses cli.py internals.
+
+Run:
+    python -m coprogrammer mcp serve [--cwd .] [--state-dir .coprogrammer]
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+from . import cli
+
+PROTOCOL_VERSION = "2025-06-18"
+SERVER_INFO = {"name": "coprogrammer", "version": "0.1.0"}
+
+TOOLS: list[dict[str, Any]] = [
+    {
+        "name": "digest_branch",
+        "description": (
+            "Generate a CoProgrammer branch digest (intent, changed files, "
+            "commits, contract/architecture risk signals, protected-path "
+            "matches, risk level) for a base..head range or the working tree."
+        ),
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "base": {"type": "string", "default": "origin/main"},
+                "head": {"type": "string", "default": "HEAD"},
+                "working_tree": {"type": "boolean", "default": False},
+                "language": {"type": "string", "enum": ["en", "zh-CN"]},
+            },
+        },
+    },
+    {
+        "name": "manager_status",
+        "description": (
+            "Show reconstructed Manager Plane state: active leases, open "
+            "decisions, contract changes, and latest agent heartbeats."
+        ),
+        "inputSchema": {"type": "object", "properties": {}},
+    },
+    {
+        "name": "manager_forecast",
+        "description": (
+            "Forecast conflicts before PR time: overlapping agent leases, "
+            "breaking/unknown contract proposals, protected-path pressure, "
+            "and optionally which changed files collide with other agents."
+        ),
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "changed_files": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "Changed file paths to check.",
+                }
+            },
+        },
+    },
+    {
+        "name": "lease_request",
+        "description": (
+            "Request an advisory workspace lease for path patterns before "
+            "editing. Overlapping leases automatically open a decision."
+        ),
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "holder": {"type": "string"},
+                "patterns": {"type": "array", "items": {"type": "string"}},
+                "kind": {
+                    "type": "string",
+                    "enum": list(cli.LEASE_KINDS),
+                    "default": "path",
+                },
+                "task": {"type": "string", "default": ""},
+            },
+            "required": ["holder", "patterns"],
+        },
+    },
+    {
+        "name": "heartbeat",
+        "description": "Publish an agent heartbeat (current task and status).",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "agent": {"type": "string"},
+                "task": {"type": "string"},
+            },
+            "required": ["agent", "task"],
+        },
+    },
+    {
+        "name": "contract_propose",
+        "description": (
+            "Propose a shared contract change (api/schema/database/...) so "
+            "other agents see it before merge time. Breaking changes open a "
+            "human decision automatically."
+        ),
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "proposer": {"type": "string"},
+                "kind": {"type": "string", "enum": list(cli.CONTRACT_KINDS)},
+                "name": {"type": "string"},
+                "summary": {"type": "string"},
+                "compatibility": {
+                    "type": "string",
+                    "enum": list(cli.CONTRACT_COMPATIBILITY),
+                    "default": "unknown",
+                },
+            },
+            "required": ["proposer", "kind", "name", "summary"],
+        },
+    },
+]
+
+
+class ManagerContext:
+    def __init__(self, cwd: Path, state_dir: str):
+        self.cwd = cwd
+        self.state_dir = state_dir
+
+    @property
+    def log_path(self) -> Path:
+        return cli.event_log_path(self.cwd, self.state_dir)
+
+    def events(self) -> list[dict[str, Any]]:
+        return cli.load_events(self.log_path)
+
+    def config(self) -> dict[str, Any]:
+        return cli.load_config(self.cwd)
+
+
+def tool_digest_branch(ctx: ManagerContext, args: dict[str, Any]) -> str:
+    base = args.get("base", "origin/main")
+    head = args.get("head", "HEAD")
+    if args.get("working_tree"):
+        files = cli.get_working_tree_changed_files(base, ctx.cwd)
+        commits: list[str] = []
+        head_label = "working-tree"
+    else:
+        files = cli.get_changed_files(base, head, ctx.cwd)
+        commits = cli.get_commits(base, head, ctx.cwd)
+        head_label = head
+    config = ctx.config()
+    language = cli.resolve_language(args.get("language") or config.get("language"))
+    return cli.render_digest(
+        base=base,
+        head=head_label,
+        files=files,
+        commits=commits,
+        language=language,
+        config=config,
+    )
+
+
+def tool_manager_status(ctx: ManagerContext, args: dict[str, Any]) -> str:
+    events = ctx.events()
+    return json.dumps(
+        {
+            "event_count": len(events),
+            "active_leases": list(cli.active_leases(events).values()),
+            "open_decisions": list(cli.open_decisions(events).values()),
+            "contract_changes": list(cli.contract_changes(events).values()),
+            "latest_heartbeats": cli.latest_heartbeats(events),
+        },
+        indent=2,
+        ensure_ascii=False,
+    )
+
+
+def tool_manager_forecast(ctx: ManagerContext, args: dict[str, Any]) -> str:
+    report = cli.forecast_report(
+        ctx.events(), ctx.config(), args.get("changed_files")
+    )
+    return json.dumps(report, indent=2, ensure_ascii=False)
+
+
+def tool_lease_request(ctx: ManagerContext, args: dict[str, Any]) -> str:
+    path = ctx.log_path
+    events = ctx.events()
+    lease = cli.new_lease(
+        args["holder"],
+        args.get("kind", "path"),
+        list(args["patterns"]),
+        args.get("task", ""),
+    )
+    cli.append_event(
+        path,
+        cli.make_event("lease.requested", args["holder"], "repo:mcp", {"lease": lease}),
+    )
+    conflicts = cli.find_lease_conflicts(lease, cli.active_leases(events))
+    if conflicts:
+        decision = cli.new_decision(
+            question=(
+                f"Should {args['holder']} proceed with "
+                f"{', '.join(args['patterns'])} despite active lease overlap?"
+            ),
+            context=json.dumps(
+                {"requested_lease": lease, "conflicting_leases": conflicts},
+                ensure_ascii=False,
+                sort_keys=True,
+            ),
+            related_artifacts=[lease["id"], *[c["id"] for c in conflicts]],
+        )
+        cli.append_event(
+            path,
+            cli.make_event(
+                "decision.requested", "manager", "repo:mcp", {"decision": decision}
+            ),
+        )
+        return json.dumps(
+            {
+                "granted": False,
+                "lease": lease,
+                "conflicts": conflicts,
+                "decision_requested": decision["id"],
+            },
+            indent=2,
+            ensure_ascii=False,
+        )
+    lease["status"] = "active"
+    cli.append_event(
+        path,
+        cli.make_event("lease.granted", "manager", "repo:mcp", {"lease": lease}),
+    )
+    return json.dumps({"granted": True, "lease": lease}, indent=2, ensure_ascii=False)
+
+
+def tool_heartbeat(ctx: ManagerContext, args: dict[str, Any]) -> str:
+    heartbeat = cli.new_heartbeat(args["agent"], args["task"])
+    cli.append_event(
+        ctx.log_path,
+        cli.make_event(
+            "agent.heartbeat", args["agent"], "repo:mcp", {"heartbeat": heartbeat}
+        ),
+    )
+    return json.dumps(heartbeat, indent=2, ensure_ascii=False)
+
+
+def tool_contract_propose(ctx: ManagerContext, args: dict[str, Any]) -> str:
+    path = ctx.log_path
+    change = cli.new_contract_change(
+        proposer=args["proposer"],
+        kind=args["kind"],
+        name=args["name"],
+        summary=args["summary"],
+        compatibility=args.get("compatibility", "unknown"),
+    )
+    cli.append_event(
+        path,
+        cli.make_event(
+            "contract.change.proposed",
+            args["proposer"],
+            "repo:mcp",
+            {"contract_change": change},
+        ),
+    )
+    result: dict[str, Any] = {"contract_change": change}
+    if change["compatibility"] == "breaking":
+        decision = cli.new_decision(
+            question=f"Should breaking contract change proceed: {args['name']}?",
+            context=json.dumps(change, ensure_ascii=False, sort_keys=True),
+            related_artifacts=[change["id"]],
+            risk="high",
+        )
+        cli.append_event(
+            path,
+            cli.make_event(
+                "decision.requested", "manager", "repo:mcp", {"decision": decision}
+            ),
+        )
+        result["decision_requested"] = decision["id"]
+    return json.dumps(result, indent=2, ensure_ascii=False)
+
+
+TOOL_HANDLERS = {
+    "digest_branch": tool_digest_branch,
+    "manager_status": tool_manager_status,
+    "manager_forecast": tool_manager_forecast,
+    "lease_request": tool_lease_request,
+    "heartbeat": tool_heartbeat,
+    "contract_propose": tool_contract_propose,
+}
+
+
+def handle_request(ctx: ManagerContext, request: dict[str, Any]) -> dict[str, Any] | None:
+    method = request.get("method")
+    request_id = request.get("id")
+
+    if method == "initialize":
+        return {
+            "jsonrpc": "2.0",
+            "id": request_id,
+            "result": {
+                "protocolVersion": PROTOCOL_VERSION,
+                "capabilities": {"tools": {}},
+                "serverInfo": SERVER_INFO,
+            },
+        }
+    if method in ("notifications/initialized", "notifications/cancelled"):
+        return None
+    if method == "ping":
+        return {"jsonrpc": "2.0", "id": request_id, "result": {}}
+    if method == "tools/list":
+        return {"jsonrpc": "2.0", "id": request_id, "result": {"tools": TOOLS}}
+    if method == "tools/call":
+        params = request.get("params", {})
+        name = params.get("name")
+        handler = TOOL_HANDLERS.get(name)
+        if handler is None:
+            return {
+                "jsonrpc": "2.0",
+                "id": request_id,
+                "error": {"code": -32602, "message": f"unknown tool: {name}"},
+            }
+        try:
+            text = handler(ctx, params.get("arguments") or {})
+            result = {"content": [{"type": "text", "text": text}], "isError": False}
+        except Exception as exc:  # noqa: BLE001 - report tool failure to client
+            result = {
+                "content": [{"type": "text", "text": f"error: {exc}"}],
+                "isError": True,
+            }
+        return {"jsonrpc": "2.0", "id": request_id, "result": result}
+
+    if request_id is not None:
+        return {
+            "jsonrpc": "2.0",
+            "id": request_id,
+            "error": {"code": -32601, "message": f"method not found: {method}"},
+        }
+    return None
+
+
+def serve(cwd: Path, state_dir: str, stdin=None, stdout=None) -> int:
+    """Serve newline-delimited JSON-RPC over stdio until EOF."""
+    stdin = stdin or sys.stdin
+    stdout = stdout or sys.stdout
+    ctx = ManagerContext(cwd, state_dir)
+    for line in stdin:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            request = json.loads(line)
+        except json.JSONDecodeError:
+            response = {
+                "jsonrpc": "2.0",
+                "id": None,
+                "error": {"code": -32700, "message": "parse error"},
+            }
+            stdout.write(json.dumps(response) + "\n")
+            stdout.flush()
+            continue
+        response = handle_request(ctx, request)
+        if response is not None:
+            stdout.write(json.dumps(response, ensure_ascii=False) + "\n")
+            stdout.flush()
+    return 0

coprogrammer-0.1.0.dist-info/METADATA

@@ -0,0 +1,250 @@
+Metadata-Version: 2.4
+Name: coprogrammer
+Version: 0.1.0
+Summary: Open protocol and toolkit for semantic integration in multi-agent software development.
+Author: Qiu Guanzong
+License: MIT License
+        
+        Copyright (c) 2026 Qiu Guanzong
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/QIU-Guanzong/CoProgrammer
+Project-URL: Repository, https://github.com/QIU-Guanzong/CoProgrammer
+Project-URL: Issues, https://github.com/QIU-Guanzong/CoProgrammer/issues
+Keywords: ai,software-development,multi-agent,merge,code-review
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# CoProgrammer
+
+CoProgrammer is an open protocol and toolkit for multi-agent software
+development in the AI coding era.
+
+CoProgrammer 同时支持中文团队协作场景：PR 分支消化报告可以用
+`zh-CN` 输出，也可以通过仓库变量切回英文。
+
+The project starts from one practical belief:
+
+> AI-era merging is not only a text conflict problem. It is a semantic
+> integration problem.
+
+When several humans and AI agents work in parallel, the hard part is no longer
+choosing one side of a merge conflict. The hard part is understanding what each
+branch learned, preserving the useful insight, discarding noise, and rebuilding
+the smallest safe patch on top of the current main branch.
+
+## Where CoProgrammer Sits
+
+CoProgrammer is **not** another parallel-agent orchestrator. It is the missing
+layer between orchestrators and the merge queue:
+
+```text
+UPSTREAM      agent runtimes & orchestrators
+              (Conductor, Sculptor, Vibe Kanban, Claude Squad,
+               Codex, Copilot Cloud Agent, OpenHands, ...)
+              → produce parallel branches
+                      │
+COPROGRAMMER  integration & governance layer
+              protocol → telemetry → conflict forecast →
+              branch digest → integration plan →
+              minimal patch → integration record → policy update
+                      │
+DOWNSTREAM    landing infrastructure
+              (Merge Queue / Merge Trains / Mergify / Graphite,
+               CI, CODEOWNERS, branch protection)
+```
+
+Orchestrators solve "run N agents in parallel without stepping on each other."
+CoProgrammer solves "when N branches come back, decide what deserves to reach
+`main`, and rebuild it safely under main-branch constraints." See
+`docs/ORCHESTRATOR_INTEGRATION.md` for concrete hookup recipes.
+
+## Core Loop
+
+CoProgrammer organizes collaboration as a continuous loop:
+
+1. **Protocol before coding**: define main-branch principles, module
+   boundaries, shared contracts, protected files, and agent permissions.
+2. **Telemetry during coding**: agents publish heartbeats, contract changes,
+   current file ownership, experiments, and blockers.
+3. **Digest after coding**: a feature branch is summarized by intent, core
+   contribution, noise, contract changes, risks, and integration plan.
+4. **Semantic integration**: instead of directly merging a large AI branch, an
+   integration patch is rebuilt from latest `main` under main-branch
+   constraints.
+5. **Validation and feedback**: tests, contract checks, owner review, and merge
+   records update the protocol for the next cycle.
+
+## Repository Map
+
+```text
+.
+├── docs/                 Research route, framework, and MVP design
+├── protocols/            Human-readable collaboration protocols
+├── research/             Structured research leads and prior-art data
+├── schemas/              JSON schemas for machine-readable agent artifacts
+├── templates/            Task, heartbeat, digest, and integration templates
+├── src/coprogrammer/     First CLI scaffold
+├── tests/                Unit tests for the CLI scaffold
+├── AGENTS.md             Minimal stable instructions for coding agents
+├── .coprogrammer.json    Project policy config
+└── .github/              PR template, issue templates, CI, and PR digest workflow
+```
+
+Start with:
+
+- `docs/COORDINATION_LIFECYCLE.md` for the before/during/after collaboration
+  loop: project covenant, Manager Plane synchronization, and post-PR semantic
+  integration;
+- `docs/ECOSYSTEM_EXTENSION_STRATEGY.md` for the research method and MCP,
+  skill, plugin, GitHub automation, and open-source library integration plan;
+- `docs/PLUGIN_QUICKSTART.md` for installing and using the repo-local
+  CoProgrammer Codex plugin;
+- `docs/COMPREHENSIVE_RESEARCH_PLAN.md` for the research program and six-week sprint;
+- `docs/RESEARCH_UPDATE_2026-05-25.md` for the latest Manager Plane evidence update;
+- `docs/RESEARCH_PROTOCOL.md` for how to capture and evaluate research leads;
+- `docs/FAILURE_TAXONOMY.md` for the failure modes CoProgrammer targets;
+- `docs/RESEARCH_LANDSCAPE.md` for current tool landscape and gaps;
+- `docs/OPEN_SOURCE_SCAN.md` for adjacent open-source projects and reusable features;
+- `docs/FEATURE_GAP_MATRIX.md` for product-level comparison;
+- `docs/DISCUSSIONS.md` for discussion categories and research intake;
+- `docs/ARCHITECTURE.md` for the system architecture;
+- `docs/MANAGER_PLANE.md` for the cloud/self-hosted control plane hypothesis;
+- `docs/MANAGER_API_SKETCH.md` for the first Manager API surface;
+- `docs/EVENT_LOG_PROTOTYPE.md` for the local Manager Plane prototype;
+- `docs/AGENT_RUNTIME_INTEROP.md` for integrating with Codex, Copilot, OpenHands, and other runtimes;
+- `docs/CONTEXT_FILE_STRATEGY.md` for keeping `AGENTS.md` small and structured state separate;
+- `docs/INTEGRATION_PATCH_DESIGN.md` for the minimal-patch reconstruction design;
+- `docs/MODEL_ROUTING_POLICY.md` for routing simple work to `codex-5.3` and high-risk work to review;
+- `docs/HIGH_STAR_PROJECT_SCAN_2026-05-26.md` for high-star project patterns to borrow;
+- `docs/FRAMEWORK.md` for the research framework;
+- `docs/ORCHESTRATOR_INTEGRATION.md` for feeding Conductor, Sculptor, Vibe
+  Kanban, and cloud-agent branches into CoProgrammer;
+- `docs/STRATEGY_MEMO_2026-06-10.md` for the latest positioning and priority
+  decisions;
+- `docs/EVAL_PLAN.md` for the AgenticFlict-based evaluation plan;
+- `ACKNOWLEDGMENTS.md` for the projects we learn from and how we credit them.
+
+## Install (pick your surface)
+
+CoProgrammer ships one core through several thin wrappers — use whichever
+your stack already speaks (details: `docs/DISTRIBUTION_STRATEGY.md`):
+
+**MCP server** (Claude Code, Codex, Cursor, any MCP client):
+
+```json
+{ "mcpServers": { "coprogrammer": {
+    "command": "uvx", "args": ["coprogrammer", "mcp", "serve"] } } }
+```
+
+Tools exposed: `digest_branch`, `manager_status`, `manager_forecast`,
+`lease_request`, `heartbeat`, `contract_propose`.
+
+**Agent Skills** (SKILL.md open standard — Claude Code, Codex CLI, Gemini
+CLI, Copilot, Cursor, 35+ tools): copy `plugins/coprogrammer/skills/*` into
+your agent's skills directory.
+
+**GitHub Action** (PR branch digest, zero setup):
+
+```yaml
+- uses: actions/checkout@v4
+  with: { fetch-depth: 0 }
+- uses: QIU-Guanzong/CoProgrammer@v0
+  with: { language: zh-CN }
+```
+
+**CLI**: `pipx install coprogrammer` (or from source:
+`python -m pip install -e .`).
+
+**Codex plugin**: `codex plugin marketplace add <this repo>` — see
+`docs/PLUGIN_QUICKSTART.md`.
+
+## First MVP
+
+The first useful version is a **Branch Digest Bot**:
+
+- reads a PR diff and commit history;
+- detects contract-sensitive files and architecture risk signals;
+- generates a branch digest draft;
+- asks reviewers to approve an integration plan before merging;
+- keeps direct AI-generated mega-branches out of `main`.
+
+The first GitHub Actions version is included in
+`.github/workflows/pr-digest.yml`. It generates `branch-digest.md`, uploads it
+as an artifact, and updates a stable PR comment for same-repository PRs.
+
+This repository already contains a minimal local CLI prototype:
+
+```bash
+python -m coprogrammer digest --base origin/main --head HEAD --output branch-digest.md
+python -m coprogrammer digest --base origin/main --head HEAD --language zh-CN
+python -m coprogrammer digest --base origin/main --working-tree
+python -m coprogrammer config validate
+python -m coprogrammer agents check
+python -m coprogrammer manifest validate templates/change-manifest.json
+python -m coprogrammer integration-plan validate templates/integration-plan.json
+python -m coprogrammer heartbeat new --agent agent-a --task "Implement login API"
+python -m coprogrammer manager lease request --holder agent-a --pattern "src/api/**"
+python -m coprogrammer manager contract propose --proposer agent-a --kind api --name "POST /login" --summary "Add login endpoint"
+python -m coprogrammer manager forecast --base origin/main --fail-on-conflict
+python -m coprogrammer manager status
+```
+
+Language can also be controlled by `COPROGRAMMER_LANGUAGE=en|zh-CN`.
+
+For local development:
+
+```bash
+python -m pip install -e .
+python -m unittest discover -s tests
+```
+
+## Project Goals
+
+- Create an open protocol for AI-assisted multi-agent collaboration.
+- Make branch intent, contracts, and insights first-class artifacts.
+- Reduce merge conflicts by forecasting ownership and contract collisions early.
+- Preserve useful experiments without merging noisy generated code.
+- Help reviewers inspect integration plans instead of massive raw diffs.
+
+## Non-Goals
+
+- CoProgrammer is not a replacement for Git, GitHub, GitLab, or CI.
+- CoProgrammer does not blindly auto-merge AI output.
+- CoProgrammer does not treat formatting churn, dependency upgrades, and feature
+  logic as the same kind of change.
+
+## Status
+
+This is an early research and tooling scaffold. The current focus is:
+
+1. protocol design;
+2. branch digest format;
+3. lightweight CLI;
+4. GitHub Action integration;
+5. project policy and risk scoring;
+6. later: semantic integration bot and multi-agent orchestrator.

coprogrammer-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+coprogrammer/__init__.py,sha256=-QXUKZ4e8_F-nGCLBYAmQcZ3ttTHLQ0m7tu5Uc1mY5A,87
+coprogrammer/__main__.py,sha256=PSQ4rpL0dG6f-qH4N7H-gD9igQkdHzH4yVZDcW8lfZo,80
+coprogrammer/cli.py,sha256=Bb46tmI-3A7ycOvPDv9c795KyZi_Q6u5OAoo4jVpTsA,63981
+coprogrammer/mcp_server.py,sha256=6R5lVjZteF8O1jmcnIykBHOgROU4p4Fd2nCl9zbcsSc,12491
+coprogrammer-0.1.0.dist-info/licenses/LICENSE,sha256=eIX-QyKEWaCSPjCtPSJJOqEwa6UyYpR25VL9YvNb9VY,1069
+coprogrammer-0.1.0.dist-info/METADATA,sha256=tywyvQ51QqiR6oXTr0vFlCAs2VslvGsSBx7GnF5rOoM,11193
+coprogrammer-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+coprogrammer-0.1.0.dist-info/entry_points.txt,sha256=y6O0mHB5Q-kNyN6fS6jNoOYZVWDQZhhSCxqInd67jU0,55
+coprogrammer-0.1.0.dist-info/top_level.txt,sha256=Rv0-pipBsieJUXEoaIiPHHxVlqJtlrZCI-wp3JQ0-tg,13
+coprogrammer-0.1.0.dist-info/RECORD,,

coprogrammer-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

coprogrammer-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+coprogrammer = coprogrammer.cli:main

coprogrammer-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Qiu Guanzong
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

coprogrammer-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+coprogrammer