@devcxl/opencode-cabbage 1.2.0 → 2.0.0

package/vendor/cabbage/cabbage_cli/assets/templates/tasks.md

@@ -0,0 +1,62 @@
+---
+change: {{CHANGE_ID}}
+cabbage_stage: {{STAGE_ID}}
+change_type: {{CHANGE_TYPE}}
+---
+
+<!-- Replace every marked prompt before verifying this stage. Split work into vertical tracer-bullet tasks with an explicit DAG dependency graph and complete every checkbox. -->
+
+# Preparation
+
+```mermaid
+flowchart TD
+    Pre["Prerequisites / Pre-Refactor"] --> Task1["Task 1: Core Behavior Slice"]
+    Task1 --> Task2["Task 2: Parallel Behavior Slice A"]
+    Task1 --> Task3["Task 3: Parallel Behavior Slice B"]
+    Task2 --> Final["Convergence & Sync"]
+    Task3 --> Final
+```
+
+## Parallel Execution Strategy
+
+- **Sequential Baseline**: Prerequisites, data models, or behavior-preserving pre-refactors.
+- **Parallel Slices**: Independent vertical feature slices executing concurrently in isolated contexts.
+- **Convergence & Verification**: Integration tests, docs synchronization, and release checks.
+
+- [ ] <!-- CABBAGE: Record prerequisite verification, baseline fixtures, or behavior-preserving pre-refactors. -->
+
+# Tasks
+
+## Task 1: <!-- CABBAGE: Primary Feature Slice Slug -->
+- **Builds**: <!-- CABBAGE: Observable end-to-end user/system capability delivered by this task. -->
+- **Blocked By**: None (or Preparation)
+- **Parallel Group**: Group 1
+- **Verification**: `<!-- CABBAGE: targeted test command -->`
+- **Standard Operating Procedure (Task SOP)**:
+  1. *[RED]* Define public test seam and write failing test.
+  2. *[GREEN]* Implement minimal code to pass the test.
+  3. *[REFACTOR]* Clean code, verify lint/types, maintain behavior.
+  4. *[VERIFY]* Run verification command and confirm passing.
+- [ ] <!-- CABBAGE: Implement behavior slice 1 through public test seam. -->
+- [ ] <!-- CABBAGE: Add failing test (RED) then minimal implementation (GREEN). -->
+
+## Task 2: <!-- CABBAGE: Secondary Feature / Extension Slice Slug -->
+- **Builds**: <!-- CABBAGE: Observable end-to-end capability delivered by this task. -->
+- **Blocked By**: Task 1
+- **Parallel Group**: Group 2
+- **Verification**: `<!-- CABBAGE: targeted test command -->`
+- **Standard Operating Procedure (Task SOP)**:
+  1. *[RED]* Define public test seam and write failing test.
+  2. *[GREEN]* Implement minimal code to pass the test.
+  3. *[REFACTOR]* Clean code, verify lint/types, maintain behavior.
+  4. *[VERIFY]* Run verification command and confirm passing.
+- [ ] <!-- CABBAGE: Implement behavior slice 2 through public test seam. -->
+- [ ] <!-- CABBAGE: Add failing test (RED) then minimal implementation (GREEN). -->
+
+- [ ] Add or update automated regression tests
+- [ ] Update affected current-state documentation under docs/
+
+# Verification
+
+- [ ] <!-- CABBAGE: Record the exact test, validation, and build commands to run. -->
+- [ ] Verify rollout and rollback readiness when applicable

package/vendor/cabbage/cabbage_cli/assets/templates/tech-spec.md

@@ -0,0 +1,87 @@
+---
+change: {{CHANGE_ID}}
+cabbage_stage: {{STAGE_ID}}
+change_type: {{CHANGE_TYPE}}
+---
+
+<!-- Replace every marked prompt before verifying this stage. Use N/A with a reason when a section does not apply. -->
+
+# Context
+
+## Current State
+
+<!-- CABBAGE: Describe the current implementation, constraints, and the reason for change. -->
+
+## Goals and Non-goals
+
+- Goal: <!-- CABBAGE: State the technical outcome. -->
+- Non-goal: <!-- CABBAGE: State what this design intentionally excludes. -->
+
+# Requirements
+
+| ID | Technical requirement | Source |
+|---|---|---|
+| TR-1 | <!-- CABBAGE: Record a functional or non-functional requirement. --> | <!-- CABBAGE: Link it to a requirement, constraint, or risk. --> |
+
+# Design
+
+## Overview
+
+<!-- CABBAGE: Explain the proposed design and the responsibilities of each affected component. -->
+
+<!-- CABBAGE: Add a Mermaid component, sequence, or state diagram when it improves reviewability; otherwise state N/A. -->
+
+## Interfaces and Data
+
+<!-- CABBAGE: Describe interface changes, data flow, state transitions, invariants, and compatibility constraints. -->
+
+## Decision Boundaries
+
+### AI Autonomous Decisions
+
+- <!-- CABBAGE: List internal implementation decisions AI can independently make (e.g. private helpers, internal data structures, local refactoring). -->
+
+### Human Gate Decisions
+
+- <!-- CABBAGE: List critical decisions requiring explicit human review/approval (e.g. breaking API changes, storage migration, security policies). -->
+
+# Alternatives
+
+## Architecture Options Comparison
+
+| Option | Architecture Approach | Benefits | Costs & Risks | Recommendation |
+|---|---|---|---|---|
+| Option A (Recommended) | <!-- CABBAGE: Describe primary approach. --> | <!-- CABBAGE: List advantages and trade-offs. --> | <!-- CABBAGE: List costs and risks. --> | Chosen |
+| Option B (Alternative) | <!-- CABBAGE: Describe alternative approach (e.g. minimal vs decoupled). --> | <!-- CABBAGE: List advantages. --> | <!-- CABBAGE: List trade-offs/drawbacks. --> | Rejected |
+
+## Selected Decision & Trade-off Rationale
+
+<!-- CABBAGE: Explain why the chosen option won over alternatives and state accepted trade-offs. -->
+
+# Security and Privacy
+
+<!-- CABBAGE: Describe trust boundaries, authorization, sensitive data, validation, and privacy impact, or state N/A. -->
+
+# Observability
+
+| Signal | Purpose | Alert or dashboard |
+|---|---|---|
+| <!-- CABBAGE: Name a log, metric, trace, or audit event. --> | <!-- CABBAGE: Explain what it proves. --> | <!-- CABBAGE: Describe how operators use it. --> |
+
+# Failure Modes
+
+| Failure mode | Detection | Handling | Recovery |
+|---|---|---|---|
+| <!-- CABBAGE: Describe a credible failure. --> | <!-- CABBAGE: Describe the signal. --> | <!-- CABBAGE: Describe runtime behavior. --> | <!-- CABBAGE: Describe recovery steps. --> |
+
+# Rollout
+
+<!-- CABBAGE: Describe sequencing, feature flags, compatibility windows, migration, and success criteria. -->
+
+# Rollback
+
+<!-- CABBAGE: Define rollback triggers, steps, and data-safety constraints. -->
+
+# Open Questions
+
+- <!-- CABBAGE: Record unresolved technical decisions and an owner, or state N/A. -->

package/vendor/cabbage/cabbage_cli/assets/templates/test-plan.md

@@ -0,0 +1,44 @@
+---
+change: {{CHANGE_ID}}
+cabbage_stage: {{STAGE_ID}}
+change_type: {{CHANGE_TYPE}}
+---
+
+<!-- Replace every marked prompt before verifying this stage. Use N/A with a reason when a section does not apply. -->
+
+# Strategy
+
+<!-- CABBAGE: Define the scope, test levels, public test seams, and key quality risks. -->
+
+| Level | Scope | Test seam | Owner |
+|---|---|---|---|
+| <!-- CABBAGE: Unit, integration, contract, E2E, or manual. --> | <!-- CABBAGE: State what is covered. --> | <!-- CABBAGE: Name the public interface or observable result. --> | <!-- CABBAGE: Name the owner. --> |
+
+# Test Environment and Data
+
+<!-- CABBAGE: Describe required environments, fixtures, accounts, data setup, isolation, and cleanup. -->
+
+# Cases
+
+| ID | Scenario | Level | Expected result | Priority |
+|---|---|---|---|---|
+| T-1 | <!-- CABBAGE: Describe a critical happy path or failure case. --> | <!-- CABBAGE: Name the test level. --> | <!-- CABBAGE: State the observable outcome. --> | High |
+
+# Regression Coverage
+
+- <!-- CABBAGE: Identify existing behavior and tests that protect it from regression. -->
+
+# Non-functional Testing
+
+| Quality attribute | Method | Threshold |
+|---|---|---|
+| <!-- CABBAGE: Performance, security, resilience, accessibility, or another attribute. --> | <!-- CABBAGE: Describe the verification method. --> | <!-- CABBAGE: Define the pass threshold. --> |
+
+# Entry and Exit Criteria
+
+- Entry: <!-- CABBAGE: Define prerequisites for starting verification. -->
+- Exit: <!-- CABBAGE: Define evidence required to finish verification. -->
+
+# Risks
+
+- <!-- CABBAGE: Record coverage gaps, flaky dependencies, or untestable assumptions and their mitigations. -->

package/vendor/cabbage/cabbage_cli/assets/workflows/change.yaml

@@ -0,0 +1,11 @@
+# One change record; specialist documents open only for declared risks.
+record_covers: [product, testing]
+stages:
+  - {id: design, artifact: tech-spec.md, template: tech-spec.md, when: impact.design, required_headings: [Context, Design, Failure Modes, Rollout]}
+  - {id: rfc, artifact: rfc.md, template: rfc.md, when: impact.rfc, required_headings: [Problem, Proposal, Alternatives]}
+  - {id: adr, artifact: adr.md, template: adr.md, when: impact.architecture, required_headings: [Context, Decision, Consequences]}
+  - {id: api, artifact: api-design.md, template: api-design.md, when: impact.api, required_headings: [Contract, Compatibility]}
+  - {id: database, artifact: database-design.md, template: database-design.md, when: impact.database, required_headings: [Schema, Migration, Rollback]}
+  - {id: security, artifact: security-review.md, template: security-review.md, when: impact.security, required_headings: [Threats, Controls]}
+  - {id: release, artifact: release-plan.md, template: release-plan.md, when: impact.deployment, required_headings: [Deployment, Rollback, Verification]}
+  - {id: tasks, artifact: tasks.md, template: change-record.md, depends_on: [design, rfc, adr, api, database, security, release], validator: checklist, required_headings: [Goal, Design, Tasks, Verification]}

package/vendor/cabbage/cabbage_cli/assets/workflows/incident.yaml

@@ -0,0 +1,4 @@
+stages:
+  - {id: incident, artifact: incident.md, template: incident.md, required_headings: [Impact, Timeline, Mitigation]}
+  - {id: postmortem, artifact: postmortem.md, template: postmortem.md, depends_on: [incident], required_headings: [Root Cause, Contributing Factors, Corrective Actions]}
+  - {id: tasks, artifact: tasks.md, template: tasks.md, depends_on: [postmortem], validator: checklist, required_headings: [Tasks]}

package/vendor/cabbage/cabbage_cli/cli.py

@@ -0,0 +1,283 @@
+from __future__ import annotations
+import argparse, json, shutil, subprocess, sys
+from datetime import datetime
+from pathlib import Path
+from . import __version__
+from .core import (CabbageError, archive_root, change_dir, change_spec, changes_root,
+                   ci_check, condition_enabled, dump_yaml, gate, get_change_tasks_dag,
+                   load_config, load_yaml, project_root, ready_to_archive, stage_map, stage_statuses,
+                   sync_change_to_docs, validate_change, verify_stage, workflow)
+from .scaffold import init_project, new_change, ensure_artifacts, adopt_project, discard_change
+
+def emit(data):
+    # Every caller only wants JSON here; human-readable text is printed explicitly.
+    print(json.dumps(data,ensure_ascii=False,indent=2))
+
+def cmd_init(a):
+    root=Path.cwd().resolve(); init_project(root,a.force,not a.no_vendor_cli)
+    print("initialized cabbage")
+    print("next: cabbage new change <change-id>")
+    print("existing docs to onboard? run: cabbage adopt")
+
+def cmd_adopt(a):
+    root=project_root(); data=adopt_project(root, apply=a.apply)
+    if a.json: emit(data); return 0
+    if data.get("applied"):
+        print(f"migrated {len(data['applied'])} document(s):")
+        for item in data["applied"]:
+            print(f"  {item['from']}  ->  {item['to']}")
+    for w in data.get("warnings", []):
+        print(f"warning: {w}")
+    counts=data["counts"]
+    print(f"adoption report written to {data['report']}")
+    print(f"documents: {sum(counts.values())} total; keep={counts['keep']} migrate={counts['migrate']} import={counts['import']} review={counts['review']}")
+    for r in data["documents"]:
+        if r["action"] in {"migrate","import","review"}:
+            target=r["target"] or "-"
+            print(f"  {r['action']:8} {r['path']}  ->  {target}")
+    print("next: resolve review rows, then follow the cabbage-adopt skill")
+    return 0
+
+def cmd_discard(a):
+    root=project_root(); discard_change(root, a.change)
+    print(f"discarded change `{a.change}`")
+    return 0
+
+def cmd_doctor(a):
+    results = {}
+    # 1. Python
+    py_ok = sys.version_info >= (3, 10)
+    results["python"] = {
+        "ok": py_ok,
+        "version": f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
+        "message": "Python >= 3.10 required" if not py_ok else "OK",
+    }
+    # 2. PyYAML
+    try:
+        import yaml
+        results["pyyaml"] = {"ok": True, "version": getattr(yaml, "__version__", "unknown")}
+    except ImportError:
+        results["pyyaml"] = {"ok": False, "message": "PyYAML is not installed"}
+
+    # 3. Git
+    git_which = shutil.which("git")
+    if git_which:
+        try:
+            p = subprocess.run(["git", "--version"], capture_output=True, text=True)
+            results["git"] = {"ok": True, "version": p.stdout.strip()}
+        except Exception as e:
+            results["git"] = {"ok": False, "message": str(e)}
+    else:
+        results["git"] = {"ok": False, "message": "git executable not found in PATH"}
+
+    # 4. pnpm
+    pnpm_which = shutil.which("pnpm")
+    if pnpm_which:
+        try:
+            p = subprocess.run(["pnpm", "--version"], capture_output=True, text=True)
+            results["pnpm"] = {"ok": True, "version": p.stdout.strip()}
+        except Exception as e:
+            results["pnpm"] = {"ok": False, "message": str(e)}
+    else:
+        results["pnpm"] = {"ok": True, "version": "not installed (optional for docs dev/build)"}
+
+    # 5. Cabbage Project
+    try:
+        r = project_root()
+        cfg = load_config(r)
+        results["project"] = {"ok": True, "path": str(r), "version": cfg.get("version", 1)}
+    except Exception as e:
+        results["project"] = {"ok": False, "message": str(e)}
+
+    all_ok = results["python"]["ok"] and results["pyyaml"]["ok"] and results["git"]["ok"]
+    if a.json:
+        emit({"ok": all_ok, "checks": results})
+    else:
+        print("Cabbage Doctor Diagnosis:")
+        for name, info in results.items():
+            status = "✓" if info["ok"] else "✗"
+            ver = f"({info.get('version', '')})" if info.get('version') else ""
+            msg = f"- {info.get('message')}" if not info["ok"] or 'message' in info else ""
+            print(f"  {status} {name:10} {ver} {msg}".rstrip())
+        if all_ok:
+            print("\nAll essential dependencies and environment checks passed.")
+        else:
+            print("\nSome environment checks failed.")
+    return 0 if all_ok else 1
+
+def cmd_new(a):
+    root=project_root(); new_change(root,a.type,a.change); print(f"created {a.change}"); cmd_status(argparse.Namespace(change=a.change,json=False))
+
+def cmd_status(a):
+    root=project_root()
+    if a.change:
+        items=stage_statuses(root,a.change)
+        if a.json: emit({"change":a.change,"stages":items})
+        else:
+            for x in items: print(f"{x['status']:7} {x['id']:16} {x.get('artifact') or ''}")
+    else:
+        dirs=changes_root(root); rows=[]
+        for p in sorted(dirs.iterdir() if dirs.exists() else []):
+            if p.is_dir() and (p/"change.yaml").exists():
+                st=stage_statuses(root,p.name)
+                done=sum(x['status']=='done' for x in st)
+                total=sum(x['status']!='skipped' for x in st)
+                stale=sum(x['status']=='stale' for x in st)
+                rows.append({"change":p.name,"done":done,"total":total,"stale":stale,
+                             "ready_to_archive":ready_to_archive(st)})
+        if a.json: emit(rows)
+        elif not rows: print("no active changes")
+        else:
+            for r in rows: print(f"{r['change']:<20} {r['done']}/{r['total']} done  {r['stale']} stale")
+            ready=[r["change"] for r in rows if r["ready_to_archive"]]
+            if ready:
+                print(f"\n{len(ready)} change(s) fully verified and ready to archive.")
+                print("After confirming the merge, run: cabbage archive <change-id>")
+
+def cmd_next(a):
+    root=project_root(); sts=stage_statuses(root,a.change); status={x['id']:x['status'] for x in sts}; spec=change_spec(root,a.change); wf,_=workflow(root,spec['type']); sm=stage_map(wf)
+    ready=[]
+    for x in sts:
+        if x['status'] not in {'pending','stale'}: continue
+        deps=[d for d in sm[x['id']].get('depends_on',[]) if d in sm and condition_enabled(sm[d],spec)]
+        if all(status.get(d)=='done' for d in deps): ready.append(x)
+    data={"change":a.change,"ready":ready,"blocked":[x for x in sts if x['status'] in {'pending','stale'} and x not in ready]}
+    if a.json: emit(data)
+    else:
+        if data["ready"]:
+            print("ready:"); [print(f"  {x['id']:<16} {x.get('artifact') or ''}") for x in data["ready"]]
+        else: print("no ready stages")
+        if data["blocked"]:
+            print("blocked:"); [print(f"  {x['id']:<16} {x.get('artifact') or ''}") for x in data["blocked"]]
+    return 0 if ready or all(x['status'] in {'done','skipped'} for x in sts) else 2
+
+def cmd_impact(a):
+    root=project_root(); p=change_dir(root,a.change)/"change.yaml"; spec=load_yaml(p); cfg=load_config(root)
+    for pair in a.set or []:
+        if '=' not in pair: raise CabbageError("--set expects field=true|false")
+        k,v=pair.split('=',1)
+        if k not in cfg.get('impact_fields',[]): raise CabbageError(f"unknown impact field: {k}")
+        if v.lower() not in {'true','false'}: raise CabbageError("impact value must be true or false")
+        spec.setdefault('impact',{})[k]=v.lower()=='true'
+    if a.set:
+        dump_yaml(p,spec); ensure_artifacts(root,a.change)
+    if a.json: emit({"change":a.change,"impact":spec.get('impact',{})})
+    else:
+        for k,v in spec.get('impact',{}).items(): print(f"  {k:<12} {'Yes' if v else 'No'}")
+
+def cmd_validate(a):
+    root=project_root(); errors=[]
+    ids=[]
+    if a.all:
+        ids=[p.name for p in changes_root(root).iterdir() if p.is_dir() and (p/'change.yaml').exists()]
+    elif a.change: ids=[a.change]
+    else: raise CabbageError("provide a change id or --all")
+    for cid in ids: errors.extend(f"{cid}: {e}" for e in validate_change(root,cid))
+    if a.json: emit({"ok":not errors,"errors":errors})
+    elif errors:
+        print("INVALID"); [print(f"- {e}") for e in errors]
+    else: print("VALID")
+    return 1 if errors else 0
+
+def cmd_verify(a):
+    root=project_root(); verify_stage(root,a.change,a.stage); print(f"verified {a.change}:{a.stage}")
+
+def cmd_sync(a):
+    root=project_root(); synced=sync_change_to_docs(root,a.change)
+    if a.json: emit({"change":a.change,"synced":synced})
+    else:
+        if synced:
+            print(f"synced {len(synced)} document(s) to current-state docs:")
+            for path in synced: print(f"  {path}")
+        else:
+            print("no documents to sync")
+
+def cmd_gate(a):
+    root=project_root(); errors=gate(root,a.change,a.target)
+    if a.json: emit({"ok":not errors,"errors":errors})
+    elif errors:
+        print("BLOCKED"); [print(f"- {e}") for e in errors]
+    else: print("ALLOWED")
+    return 1 if errors else 0
+
+def cmd_archive(a):
+    root=project_root(); errors=gate(root,a.change,'archive')
+    if errors: raise CabbageError("archive gate blocked:\n"+'\n'.join(errors))
+    synced=sync_change_to_docs(root,a.change)
+    d=change_dir(root,a.change); spec=load_yaml(d/'change.yaml'); spec['status']='archived'; dump_yaml(d/'change.yaml',spec)
+    dest=archive_root(root)/datetime.now().strftime('%Y')/a.change; dest.parent.mkdir(parents=True,exist_ok=True)
+    if dest.exists(): raise CabbageError(f"archive destination exists: {dest}")
+    shutil.move(str(d),str(dest))
+    if synced:
+        print(f"synced {len(synced)} document(s) to current-state docs")
+    print(f"archived to {dest.relative_to(root)}")
+
+def cmd_ci(a):
+    root=project_root(); errors=ci_check(root,a.base)
+    if errors:
+        print("CABBAGE CI FAILED"); [print(f"- {e}") for e in errors]; return 1
+    print("CABBAGE CI PASSED"); return 0
+
+def cmd_docs(a):
+    root=project_root(); docs=root/load_config(root).get('docs',{}).get('dir','docs')
+    if a.action=='install': cmd=['pnpm','install']
+    elif a.action=='dev': cmd=['pnpm','run','dev']
+    else: cmd=['pnpm','run','build']
+    if shutil.which('pnpm') is None: raise CabbageError('pnpm not found')
+    return subprocess.call(cmd,cwd=docs)
+
+def cmd_tasks(a):
+    root=project_root(); data=get_change_tasks_dag(root, a.change)
+    if a.json: emit(data); return 0
+
+    print(f"Task DAG for `{data['change']}`:")
+    print(f"  Summary: {data['total_tasks']} total | {data['completed_tasks']} completed | {data['ready_tasks']} ready | {data['blocked_tasks']} blocked\n")
+    for grp, grp_tasks in data["parallel_groups"].items():
+        print(f"  [{grp}]")
+        for t in grp_tasks:
+            status_tag = "[DONE]   " if t["is_completed"] else ("[READY]  " if t["is_ready"] else "[BLOCKED]")
+            blocked_info = f" (Blocked by: {', '.join(t['blocked_by'])})" if t["blocked_by"] and not t["is_completed"] else ""
+            print(f"    {status_tag} {t['task_id']}: {t['title']}{blocked_info}")
+            if t["verification"] and t["verification"] != "N/A":
+                print(f"              Verification: {t['verification']}")
+        print()
+
+    if not data.get("structured"):
+        print("Plain checklist: no declared dependencies or verification commands.")
+        print("Verification results belong in the record's Verification section;")
+        print("use `## Task <id>: <title>` sections only when parallelism or blocking matters.")
+    elif data["completed_tasks"] == data["total_tasks"] and data["total_tasks"] > 0:
+        print("All tasks in DAG completed. Ready for verification & gate.")
+    elif data["ready_tasks"] == 0:
+        print("No tasks currently ready (check prerequisites or dependencies).")
+    return 0
+
+def parser():
+    p=argparse.ArgumentParser(prog='cabbage'); p.add_argument('--version',action='version',version=__version__); sp=p.add_subparsers(dest='cmd',required=True)
+    x=sp.add_parser('init'); x.add_argument('--force',action='store_true'); x.add_argument('--no-vendor-cli',action='store_true'); x.set_defaults(func=cmd_init)
+    x=sp.add_parser('adopt'); x.add_argument('--apply',action='store_true'); x.add_argument('--json',action='store_true'); x.set_defaults(func=cmd_adopt)
+    x=sp.add_parser('doctor'); x.add_argument('--json',action='store_true'); x.set_defaults(func=cmd_doctor)
+    x=sp.add_parser('new'); x.add_argument('type'); x.add_argument('change'); x.set_defaults(func=cmd_new)
+    x=sp.add_parser('discard'); x.add_argument('change'); x.set_defaults(func=cmd_discard)
+    x=sp.add_parser('status'); x.add_argument('change',nargs='?'); x.add_argument('--json',action='store_true'); x.set_defaults(func=cmd_status)
+    x=sp.add_parser('next'); x.add_argument('change'); x.add_argument('--json',action='store_true'); x.set_defaults(func=cmd_next)
+    x=sp.add_parser('impact'); x.add_argument('change'); x.add_argument('--set',action='append'); x.add_argument('--json',action='store_true'); x.set_defaults(func=cmd_impact)
+    x=sp.add_parser('validate'); x.add_argument('change',nargs='?'); x.add_argument('--all',action='store_true'); x.add_argument('--json',action='store_true'); x.set_defaults(func=cmd_validate)
+    x=sp.add_parser('verify'); x.add_argument('change'); x.add_argument('stage'); x.set_defaults(func=cmd_verify)
+    x=sp.add_parser('sync'); x.add_argument('change'); x.add_argument('--json',action='store_true'); x.set_defaults(func=cmd_sync)
+    x=sp.add_parser('gate'); x.add_argument('change'); x.add_argument('target'); x.add_argument('--json',action='store_true'); x.set_defaults(func=cmd_gate)
+    x=sp.add_parser('archive'); x.add_argument('change'); x.set_defaults(func=cmd_archive)
+    x=sp.add_parser('ci'); x.add_argument('--base',required=True); x.set_defaults(func=cmd_ci)
+    x=sp.add_parser('tasks'); x.add_argument('change'); x.add_argument('--json',action='store_true'); x.set_defaults(func=cmd_tasks)
+    x=sp.add_parser('docs'); x.add_argument('action',choices=['install','dev','build']); x.set_defaults(func=cmd_docs)
+    return p
+
+def main(argv=None):
+    try:
+        a=parser().parse_args(argv); return a.func(a) or 0
+    except CabbageError as e:
+        print(f"cabbage: {e}",file=sys.stderr); return 2
+    except KeyboardInterrupt:
+        print("\naborted by user",file=sys.stderr); return 130
+
+if __name__=='__main__': raise SystemExit(main())