ai-dev-workflow 0.1.0__py3-none-any.whl

ado_mcp.py

@@ -0,0 +1,49 @@
+"""Microsoft Azure DevOps MCP configuration helpers."""
+from __future__ import annotations
+
+AUTH_MODES = {"interactive", "azcli", "env", "envvar", "pat"}
+
+
+def build_ado_mcp(organization: str, mode="remote", auth="interactive", project=None, team=None) -> dict:
+    if mode not in ("remote", "local"):
+        raise ValueError("ADO MCP mode must be remote or local")
+    if auth not in AUTH_MODES:
+        raise ValueError(f"unsupported ADO MCP auth: {auth}")
+    if mode == "remote":
+        return {
+            "mode": "remote",
+            "url": f"https://mcp.dev.azure.com/{organization}",
+            "auth": {"type": auth},
+            "defaults": {"project": project, "team": team},
+        }
+    args = ["-y", "@azure-devops/mcp", organization]
+    if auth != "interactive":
+        args += ["--authentication", auth]
+    env = {}
+    if project:
+        env["ado_mcp_project"] = project
+    if team:
+        env["ado_mcp_team"] = team
+    return {
+        "mode": "local",
+        "transport": "stdio",
+        "command": "npx",
+        "args": args,
+        "env": env,
+        "auth": {"type": auth},
+    }
+
+
+def ado_mcp_credentials(config: dict) -> list[dict]:
+    auth = (config.get("auth") or {}).get("type")
+    if auth == "envvar":
+        return [{"name":"ADO_MCP_AUTH_TOKEN","purpose":"Bearer token for Azure DevOps MCP","store":"environment/secret store"}]
+    if auth == "pat":
+        return [{"name":"PERSONAL_ACCESS_TOKEN","purpose":"Base64 email:PAT for Azure DevOps MCP","store":"environment/secret store"}]
+    if auth == "azcli":
+        return [{"name":"az login","purpose":"Active Azure CLI login session","store":"local credential cache"}]
+    if auth == "env":
+        return [{"name":"Azure Identity environment","purpose":"DefaultAzureCredential inputs","store":"environment/managed identity"}]
+    if auth == "interactive":
+        return [{"name":"Microsoft sign-in","purpose":"Interactive Azure DevOps MCP authentication","store":"client auth session"}]
+    return []

ado_provider.py

@@ -0,0 +1,245 @@
+"""Azure DevOps WorkItemProvider discovery and state mapping."""
+from __future__ import annotations
+
+import base64
+import json
+import re
+from urllib.parse import quote
+from urllib.request import Request, urlopen
+from urllib.error import HTTPError
+
+from work_item_provider import CANONICAL_STATES
+
+API_VERSION = "7.1"
+
+
+class AzureDevOps:
+    def __init__(self, organization: str, token: str, base_url="https://dev.azure.com"):
+        self.organization = organization
+        self.base = f"{base_url.rstrip('/')}/{quote(organization, safe='')}"
+        self.token = token
+
+    def request(self, path: str):
+        auth = base64.b64encode((":" + self.token).encode()).decode()
+        req = Request(
+            self.base + path,
+            headers={
+                "Authorization": "Basic " + auth,
+                "Accept": "application/json",
+            },
+        )
+        try:
+            with urlopen(req, timeout=30) as response:
+                return json.load(response)
+        except HTTPError as exc:
+            body = exc.read().decode("utf-8", "replace")
+            raise RuntimeError(f"Azure DevOps API {exc.code}: {body}") from exc
+
+    def project(self, project: str):
+        return self.request(
+            f"/_apis/projects/{quote(project, safe='')}?includeCapabilities=true&api-version={API_VERSION}"
+        )
+
+    def project_properties(self, project_id: str):
+        return self.request(
+            f"/_apis/projects/{quote(project_id, safe='')}/properties"
+            f"?keys=System.CurrentProcessTemplateId&api-version=7.1-preview.1"
+        )
+
+    def work_item_types(self, project: str):
+        return self.request(
+            f"/{quote(project, safe='')}/_apis/wit/workitemtypes?api-version={API_VERSION}"
+        ).get("value", [])
+
+    def states(self, process_id: str, wit_ref_name: str):
+        return self.request(
+            f"/_apis/work/processes/{quote(process_id, safe='')}/workItemTypes/"
+            f"{quote(wit_ref_name, safe='')}/states?api-version={API_VERSION}"
+        ).get("value", [])
+
+    def fields(self, project: str, wit_name: str):
+        return self.request(
+            f"/{quote(project, safe='')}/_apis/wit/workitemtypes/"
+            f"{quote(wit_name, safe='')}/fields?api-version={API_VERSION}"
+        ).get("value", [])
+
+    def discover(self, project_name: str) -> dict:
+        project = self.project(project_name)
+        props = self.project_properties(project["id"]).get("value", [])
+        process_id = next(
+            (str(item.get("value")) for item in props
+             if item.get("name") == "System.CurrentProcessTemplateId"),
+            None,
+        )
+        if not process_id:
+            raise RuntimeError("Azure DevOps project process ID was not found")
+
+        work_item_types = []
+        for wit in self.work_item_types(project_name):
+            ref = wit.get("referenceName")
+            name = wit.get("name")
+            if not ref or not name:
+                continue
+            states = [
+                {
+                    "name": state.get("name"),
+                    "category": state.get("stateCategory"),
+                    "hidden": bool(state.get("hidden", False)),
+                    "customization_type": state.get("customizationType"),
+                }
+                for state in self.states(process_id, ref)
+                if state.get("name")
+            ]
+            fields = [
+                {
+                    "name": field.get("name"),
+                    "reference_name": field.get("referenceName"),
+                    "type": field.get("type"),
+                    "required": bool(field.get("alwaysRequired", False)),
+                    "read_only": bool(field.get("readOnly", False)),
+                }
+                for field in self.fields(project_name, name)
+                if field.get("referenceName")
+            ]
+            work_item_types.append({
+                "name": name,
+                "reference_name": ref,
+                "states": states,
+                "fields": sorted(fields, key=lambda x: x["reference_name"]),
+            })
+
+        return {
+            "organization": self.organization,
+            "project": project_name,
+            "project_id": project["id"],
+            "process_id": process_id,
+            "work_item_types": sorted(work_item_types, key=lambda x: x["reference_name"]),
+        }
+
+
+def suggest_state(state_name: str, category: str | None) -> str:
+    name = re.sub(r"\s+", " ", state_name.strip().lower())
+    if any(token in name for token in ("block", "reject", "hold", "waiting external")):
+        return "blocked"
+    if "runtime" in name or "uat" in name:
+        return "runtime-pending"
+    if any(token in name for token in ("review", "qa", "verify", "validation", "test")):
+        return "in-review"
+    if any(token in name for token in ("release", "deploy", "staging")):
+        return "release-pending"
+    if any(token in name for token in ("ready", "approved", "to do", "todo", "committed")):
+        return "ready"
+    if any(token in name for token in ("doing", "active", "progress", "development", "implement")):
+        return "in-progress"
+    if any(token in name for token in ("done", "closed", "complete", "completed")):
+        return "completed"
+
+    normalized_category = (category or "").replace(" ", "").lower()
+    if normalized_category == "completed":
+        return "completed"
+    if normalized_category == "resolved":
+        return "release-pending"
+    if normalized_category == "inprogress":
+        return "in-progress"
+    if normalized_category == "proposed":
+        return "draft"
+    return "draft"
+
+
+def build_state_mapping(discovery: dict) -> dict:
+    mapping = {}
+    for wit in discovery.get("work_item_types", []):
+        states = {}
+        for state in wit.get("states", []):
+            if state.get("hidden"):
+                continue
+            states[state["name"]] = suggest_state(state["name"], state.get("category"))
+        mapping[wit["reference_name"]] = states
+    return mapping
+
+
+def validate_mapping(discovery: dict, mapping: dict) -> list[str]:
+    errors = []
+    for wit in discovery.get("work_item_types", []):
+        ref = wit["reference_name"]
+        configured = mapping.get(ref, {})
+        for state in wit.get("states", []):
+            if state.get("hidden"):
+                continue
+            name = state["name"]
+            if name not in configured:
+                errors.append(f"unmapped ADO state: {ref} / {name}")
+                continue
+            if configured[name] not in CANONICAL_STATES:
+                errors.append(
+                    f"invalid canonical state for {ref} / {name}: {configured[name]}"
+                )
+    return errors
+
+
+FIELD_KEYS = (
+    "workflow_phase",
+    "github_issue",
+    "worker",
+    "agent_role",
+    "pull_request",
+    "test_status",
+    "runtime_status",
+    "workflow_profile",
+)
+
+
+def available_fields(discovery: dict, wit_ref: str) -> list[dict]:
+    wit = next((w for w in discovery.get("work_item_types", [])
+                if w.get("reference_name") == wit_ref), None)
+    return list((wit or {}).get("fields", []))
+
+
+def validate_field_mapping(discovery: dict, field_mapping: dict) -> list[str]:
+    """Validate mappings against existing ADO fields. Never creates schema."""
+    errors = []
+    by_wit = {w["reference_name"]: w for w in discovery.get("work_item_types", [])}
+    for wit_ref, mappings in (field_mapping or {}).items():
+        wit = by_wit.get(wit_ref)
+        if not wit:
+            errors.append(f"unknown ADO WIT in field mapping: {wit_ref}")
+            continue
+        fields = {f["reference_name"]: f for f in wit.get("fields", [])}
+        for key, config in (mappings or {}).items():
+            if key not in FIELD_KEYS:
+                errors.append(f"unsupported ADO execution field key: {key}")
+                continue
+            if not isinstance(config, dict):
+                errors.append(f"invalid ADO field mapping for {wit_ref} / {key}")
+                continue
+            ref = config.get("field")
+            if not ref:
+                errors.append(f"missing ADO field reference for {wit_ref} / {key}")
+                continue
+            field = fields.get(ref)
+            if not field:
+                errors.append(f"ADO field does not exist: {wit_ref} / {ref}")
+                continue
+            if field.get("read_only"):
+                errors.append(f"ADO field is read-only: {wit_ref} / {ref}")
+    return errors
+
+
+def defaults_for_wit(field_mapping: dict, wit_ref: str) -> dict:
+    result = {}
+    for config in (field_mapping or {}).get(wit_ref, {}).values():
+        if not isinstance(config, dict) or not config.get("field"):
+            continue
+        if "default" in config:
+            result[config["field"]] = config.get("default")
+    return result
+
+
+def execution_field_updates(field_mapping: dict, wit_ref: str, values: dict) -> dict:
+    result = {}
+    for key, value in values.items():
+        config = (field_mapping or {}).get(wit_ref, {}).get(key)
+        if not config or not config.get("field"):
+            continue
+        result[config["field"]] = value
+    return result

ai_dev_workflow-0.1.0.dist-info/METADATA

@@ -0,0 +1,348 @@
+Metadata-Version: 2.4
+Name: ai-dev-workflow
+Version: 0.1.0
+Summary: Provider-neutral AI-assisted development workflow and CLI
+Author: vuthethienlong
+Project-URL: Homepage, https://github.com/vuthethienlong/ai-dev-workflow
+Project-URL: Repository, https://github.com/vuthethienlong/ai-dev-workflow
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: PyYAML>=6.0
+
+# AI Dev Workflow
+
+Reusable, provider-neutral workflow for AI-assisted software development.
+
+This repository starts from the workflow proven in the Dragon's Dogma 2 project and keeps Superpowers-style artifacts as first-class inputs: brainstorming, spec, ADR, implementation plan, tests, PR evidence and runtime verification.
+
+## Default lifecycle
+
+```text
+Brainstorm
+  -> Spec
+  -> ADR (when needed)
+  -> Issue Ready Freeze
+  -> Implementation Plan
+  -> TesterAgent writes executable tests
+  -> RED
+  -> ImplementerAgent implements
+  -> GREEN + regression
+  -> ReviewerAgent (optional/manual by default)
+  -> Integration
+  -> Runtime verification batch when required
+  -> Promotion / Done
+```
+
+## Roles
+
+- `ArchitectAgent`: brainstorm, spec, ADR and acceptance criteria.
+- `TesterAgent`: derives tests from the frozen contract and proves RED before implementation.
+- `ImplementerAgent`: implements without changing the frozen test contract; must reach GREEN and run applicable regression checks.
+- `ReviewerAgent`: optional semantic/architecture reviewer. Disabled/manual by default in v1.
+- `RuntimeVerifierAgent`: optional, project-specific runtime verification role.
+
+A role is not a model. GPT, Codex, Claude, local models or future providers are replaceable adapters under these contracts.
+
+## Core rules
+
+- Work item is the task source of truth through a configurable WorkItemProvider (GitHub Issues or Azure DevOps).
+- `Ready` is the commitment/freeze boundary.
+- Test design happens before implementation.
+- Implementer may report a bad test/spec as blocked, but must not rewrite expectations merely to make tests pass.
+- Deterministic CI gates run before optional semantic AI review.
+- Runtime verification is separate from offline/CI verification.
+- Projects consume versioned reusable workflows such as `@v1`; they do not copy the engine.
+
+## Consumer project
+
+A project keeps only project-specific context/config:
+
+```text
+AGENTS.md
+CURRENT.md (optional bootstrap/router)
+.ai-workflow.yml
+.github/workflows/ai.yml
+project tests/runtime rules
+```
+
+Its caller workflow will reference this repository's reusable workflow.
+
+See:
+- `AGENTS.md`
+- `docs/lifecycle.md`
+- `docs/agent-contracts.md`
+- `docs/tdd-handoff.md`
+- `.ai-workflow.example.yml`
+
+Refs #1
+
+
+## Execution environments
+
+Execution environments are provider-neutral. The first supported project contract is GitHub Codespaces with three modes:
+
+- `off`: never use Codespaces.
+- `on-demand`: provision/start a Codespace only when a routed task requires it.
+- `always-on`: keep a Codespace available according to project policy.
+
+The recommended default is `on-demand`.
+
+Agent role, provider and environment are independent dimensions. For example, `ImplementerAgent` may run through different provider adapters while using the same Codespaces workspace.
+
+
+## Project bootstrap
+
+The central framework owns the shared repository metadata contract.
+
+Consumer repositories can run the reusable `bootstrap-project.yml` workflow to create or update the managed workflow labels. Bootstrap is idempotent and does not delete project-specific labels.
+
+Managed labels currently include:
+- workflow states: `status:ready`, `status:in-progress`, `status:blocked`, `status:in-review`, `status:runtime-pending`, `status:release-pending`;
+- priorities: `priority:P0`, `priority:P1`, `priority:P2`.
+
+This keeps label semantics portable when the framework or a project is copied to another repository/account.
+
+
+## Workspace planning context
+
+Multi-repository brainstorming uses a workspace registry in `.ai-workspace.yml`.
+
+Before a work item is published, the Planning Context Resolver normalizes:
+- repositories and their purpose/ref/access;
+- context paths relevant to architecture/brainstorming;
+- the default target repository;
+- GitHub Project identity;
+- logical initiatives and repository-local milestone mappings.
+
+ArchitectAgent then emits a planning decision identifying the correct target repository, affected repositories, initiative/release, dependencies, issue type, and runtime requirement.
+
+This keeps brainstorming portable across ChatGPT, Claude, Codex, local models, or future providers and prevents repository selection from depending on model memory.
+
+
+## Azure DevOps initialization
+
+Azure DevOps is supported through the provider-neutral WorkItemProvider boundary.
+
+Run:
+
+```bash
+AZURE_DEVOPS_TOKEN=... ./bin/ai-workflow init-ado \
+  --organization <org> \
+  --project <project>
+```
+
+The initializer discovers the project's current process, Work Item Types, and all visible states through Azure DevOps REST API 7.1. It writes explicit per-WIT state mappings into `.ai-workflow.yml`; runtime execution does not guess custom state meanings.
+
+Role/provider assignments can be supplied during init:
+
+```bash
+./bin/ai-workflow init-ado \
+  --organization <org> \
+  --project <project> \
+  --role-provider ArchitectAgent=claude \
+  --role-provider TesterAgent=codex \
+  --role-provider ImplementerAgent=codex
+```
+
+Validate later with:
+
+```bash
+./bin/ai-workflow doctor \
+  --config .ai-workflow.yml \
+  --discovery .ai-workflow.yml.ado-discovery.json
+```
+
+Doctor fails when ADO introduces a visible state that has no explicit mapping, when no ADO state maps to the canonical `ready` or `completed` state, or when required agent roles have no provider.
+
+
+## Plugin-style repository initialization
+
+Existing repositories can install the workflow with one command:
+
+```bash
+./bin/ai-workflow init \
+  --work-items github-issues \
+  --environment codespaces \
+  --codespaces-mode on-demand
+```
+
+For Azure DevOps:
+
+```bash
+AZURE_DEVOPS_TOKEN=... ./bin/ai-workflow init \
+  --work-items azure-devops \
+  --ado-organization <org> \
+  --ado-project <project> \
+  --environment codespaces \
+  --role-provider ArchitectAgent=claude \
+  --role-provider TesterAgent=codex \
+  --role-provider ImplementerAgent=codex
+```
+
+The initializer updates only workflow-owned configuration sections and preserves unrelated custom YAML. It creates missing `AGENTS.md`, `CURRENT.md`, Codespaces devcontainer, and GitHub workflow caller stubs without overwriting existing project files unless `--force` is supplied. Doctor validation runs after init.
+
+
+## Guided setup wizard
+
+For first-time installation, prefer the step-by-step setup flow over raw `init` flags:
+
+```bash
+GH_TOKEN=... ./bin/ai-workflow setup \
+  --work-items github-issues \
+  --github-repository owner/repo \
+  --environment codespaces
+```
+
+For Azure DevOps:
+
+```bash
+AZURE_DEVOPS_TOKEN=... ./bin/ai-workflow setup \
+  --work-items azure-devops \
+  --ado-organization <org> \
+  --ado-project <project> \
+  --environment codespaces
+```
+
+Setup runs eight phases: repository context analysis, provider selection, current-status discovery, mapping confirmation, workflow policy, agent assignment, environment/credential guidance, then doctor/apply.
+
+The setup context is exposed through a provider-neutral `SetupAgent` contract so an AI provider can recommend project-specific defaults after reading existing docs/tests/workflows. GitHub setup discovers existing labels and maps status-like labels; Azure DevOps setup discovers states per Work Item Type. Mapping is persisted explicitly and is never guessed during runtime.
+
+Use `--plan-only` to generate `.ai-setup-plan.yml` without applying repository changes, or `--non-interactive` for automation.
+
+
+## AI provider registry
+
+Agent roles reference provider IDs. Provider type, endpoint, model and authentication are configured separately.
+
+Examples:
+
+```bash
+./bin/ai-workflow setup ... \
+  --ai-provider codex=chatgpt-codex,model=gpt-5.6-codex \
+  --ai-provider openai=openai,model=gpt-5.6,auth=api-key-env,env=OPENAI_API_KEY \
+  --ai-provider claude=anthropic,model=claude-sonnet,auth=api-key-env,env=ANTHROPIC_API_KEY \
+  --ai-provider litellm=litellm,base_url=http://litellm:4000/v1,auth=bearer-env,env=LITELLM_API_KEY \
+  --ai-provider local=local-openai-compatible,base_url=http://host.docker.internal:11434/v1,model=qwen-local,auth=none \
+  --role-provider ImplementerAgent=local
+```
+
+Supported provider types are `openai`, `chatgpt-codex`, `anthropic`, `litellm`, `openai-compatible`, `local-openai-compatible`, and `interactive`.
+
+Authentication is an independent strategy: `chatgpt-oauth`, `api-key-env`, `bearer-env`, or `none`. Secrets are never written into project configuration; configuration stores only the environment variable name or interactive auth strategy.
+
+
+## Connection-first setup
+
+Guided setup now connects the source host before repository/provider discovery.
+
+GitHub authentication supports:
+
+- `gh-cli` (default): reuse the authenticated GitHub CLI OAuth session from `gh auth login`;
+- `token-env`: read a PAT/token from an environment variable such as `GH_TOKEN`.
+
+SSH keys remain valid for Git fetch/push but are not used as GitHub API/WorkItem authentication.
+
+Example:
+
+```bash
+gh auth login
+./bin/ai-workflow setup \
+  --github-auth gh-cli \
+  --github-repository owner/repo \
+  --work-items github-issues
+```
+
+The WorkItemProvider is selected from a registry. Built-ins are currently `github-issues` and `azure-devops`; core validation is registry-based so future providers can be added without changing canonical workflow states.
+
+### Azure DevOps MCP
+
+When Azure DevOps is the WorkItemProvider, setup can also configure Microsoft's Azure DevOps MCP connection for agents.
+
+Remote MCP is the default:
+
+```bash
+./bin/ai-workflow setup \
+  --github-repository owner/repo \
+  --work-items azure-devops \
+  --ado-organization contoso \
+  --ado-project App \
+  --ado-mcp-mode remote \
+  --ado-mcp-auth interactive
+```
+
+Local stdio MCP remains available with `--ado-mcp-mode local`. Supported MCP auth modes are `interactive`, `azcli`, `env`, `envvar`, and `pat`. Secrets are represented only by auth strategy/environment requirements and are never written to project configuration.
+
+
+## Worker registration
+
+Setup can register local, Codespaces, or cloud workers separately from AI provider configuration.
+
+Example local hybrid worker:
+
+```bash
+./bin/ai-workflow setup ... \
+  --worker desktop=hybrid,provider=local,environment=local,roles=ArchitectAgent|ImplementerAgent,assignee=my-github-login,planning_updates=approval-required
+```
+
+Example Codespaces executor:
+
+```bash
+./bin/ai-workflow setup ... \
+  --worker cs=executor,provider=codex,environment=codespaces,roles=TesterAgent|ImplementerAgent,capacity=2
+```
+
+Planner/hybrid workers can connect directly to the configured WorkItemProvider (for example Azure DevOps MCP) to read current work items, analyze repository/work-item context, brainstorm, and propose updates. Planning mutations default to approval-required; frozen ready contracts cannot be silently changed. Executor/hybrid workers project into the existing queue-dispatcher worker registry and follow the reservation → provider accepted → in-progress lifecycle.
+
+
+## Complete setup documentation
+
+For the full first-run and customization guide, see:
+
+- `docs/setup-guide.md` — human-readable step-by-step setup, examples, credentials, providers, workers, ADO/GitHub, Codespaces/local and multi-repo.
+- `docs/setup-agent-playbook.md` — canonical AI-readable SetupAgent playbook, invariants, approval boundaries and customization contract.
+
+Recommended workflow:
+
+```text
+AI or user reads setup guide/playbook
+→ run setup --plan-only
+→ review discovered status/WIT mappings and recommendations
+→ approve/customize
+→ run setup/apply
+→ configure required secrets/sign-ins
+→ doctor
+```
+
+The setup flow is customizable, but provider-specific states, credential values and frozen-contract changes must never be silently guessed.
+
+
+## Updating the framework
+
+Use `./bin/ai-workflow update --check` to inspect the configured framework ref, and `./bin/ai-workflow update --to <ref>` to update framework-managed files and schema metadata. Project-owned configuration and files are preserved; locally modified managed files are skipped unless `--force` is explicitly used. See `docs/setup-guide.md` for the full update and migration rules.
+
+
+## Install from PyPI
+
+Once a release is published to PyPI, consumers do not need to clone this repository:
+
+```bash
+python -m pip install --upgrade ai-dev-workflow
+ai-workflow --help
+ai-workflow setup
+```
+
+The GitHub repository may remain private because normal consumers install the built distribution from PyPI rather than cloning the source repository.
+
+On another machine, install Python 3.10+ and run the same `pip install ai-dev-workflow` command. Project-specific configuration remains in each consumer repository.
+
+Framework CLI/package upgrades and project installation upgrades are separate:
+
+```bash
+python -m pip install --upgrade ai-dev-workflow
+ai-workflow update
+```
+
+The first command upgrades the installed CLI package. The second migrates/updates the workflow installation in the current project.

ai_dev_workflow-0.1.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+ado_mcp.py,sha256=Jv1zUVyAMvRKVcNPphdHq8CgnNnq34M46AFnAHE7HFQ,2006
+ado_provider.py,sha256=nE12VIG2nvHAM4rBhaSFmQmMu1yk1aj5jfvl4g-p9v0,9213
+ai_provider.py,sha256=lKHb95_zwqs4isohAGT9a8ZJDHr5l5SuTCS4qjw5snY,5072
+ai_workflow_cli.py,sha256=gVbCwFfvqNC0cB4l0PK65YNVujhDjGK5UcVr7_8q9vw,28544
+composite_work_item.py,sha256=_t4opeewAR8QXguFl-wuNfWSZjkcxFr2fTHcRbktDa0,1703
+framework_update.py,sha256=0G6L_hwl1gTLlqIw2pzsYJuKHWAEXnbKkuxouHqBImE,5053
+github_work_item_provider.py,sha256=fXoKBUjNksFVcj3wFdzdpmxZjg-xn7Rt8wPnmB7-SZs,5179
+issue_publisher.py,sha256=azt08D1WmPZThMMvz5eROyUx2DxsDqoOX4giIXQmmbc,8814
+planning_context.py,sha256=LNe9qO7CLWVJwih3JEfRlrtamDxOvEHdxsnFQe7tdNA,6176
+setup_context.py,sha256=6WOvZJztCo-17NFpRnD2jvdUbjb-9hXOiPxA3de0R9I,3268
+setup_wizard.py,sha256=BUB0fGWh7svUfYEtlKQSjTZy2TAyw1MVjKOm-9moRZM,9320
+source_connection.py,sha256=lFoYE1uJ2eT1EH8WXgY2qFyg7_UhmKjSuV5q9yNIDEM,790
+work_item_provider.py,sha256=EPXIfYi5SNY38q-D5zL-DPFmP0LCr12W_HarvJXrxuU,386
+work_item_registry.py,sha256=Rh5-Bsp02sS4C9EXakg-kSlB8C-kMcXg3PfSjyFKHZ8,764
+worker_registry.py,sha256=Fp-9RKXgoqfoodpRt3omY7mrd3YkCiDDe2HXZyIiwcs,6432
+ai_dev_workflow-0.1.0.dist-info/METADATA,sha256=BVycJM0AlmVUPrWOoQjnwJ88HvbPT4khas7KQi-X7aA,13420
+ai_dev_workflow-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+ai_dev_workflow-0.1.0.dist-info/entry_points.txt,sha256=-Zva2sernbyUqrpaeQ0ZLFTGlSmr0d8r8h2y_jxV1aI,53
+ai_dev_workflow-0.1.0.dist-info/top_level.txt,sha256=PQfFXz0WHllSxP_Jv50BbKdYV5AB8fxk2xjcLWcBjnE,244
+ai_dev_workflow-0.1.0.dist-info/RECORD,,

ai_dev_workflow-0.1.0.dist-info/WHEEL

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

ai_dev_workflow-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ai-workflow = ai_workflow_cli:main

ai_dev_workflow-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,15 @@
+ado_mcp
+ado_provider
+ai_provider
+ai_workflow_cli
+composite_work_item
+framework_update
+github_work_item_provider
+issue_publisher
+planning_context
+setup_context
+setup_wizard
+source_connection
+work_item_provider
+work_item_registry
+worker_registry