atdd 0.2.1__py3-none-any.whl

atdd/coach/commands/infer_governance_status.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+"""
+Infer and set governance.status for contract schemas.
+
+Inference rules:
+- version 0.x.x → "draft" (still iterating)
+- wagon_ref = "plan/unknown/_unknown.yaml" → "draft" (no real wagon)
+- version 1.x.x+ with real wagon → "active" (stable)
+
+Usage:
+    python3 atdd/coach/commands/infer_governance_status.py [--dry-run]
+"""
+
+import sys
+import json
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[4]
+CONTRACTS_DIR = REPO_ROOT / "contracts"
+
+
+def infer_status(contract: dict) -> str:
+    """Infer governance status from contract metadata."""
+    version = contract.get("version", "0.0.0")
+    metadata = contract.get("x-artifact-metadata", {})
+    traceability = metadata.get("traceability", {})
+    wagon_ref = traceability.get("wagon_ref", "")
+
+    # Rule 1: Version-based
+    if version.startswith("0."):
+        return "draft"
+
+    # Rule 2: Traceability-based
+    if wagon_ref == "plan/unknown/_unknown.yaml" or not wagon_ref:
+        return "draft"
+
+    # Rule 3: Active (1.x.x+ with real wagon)
+    return "active"
+
+
+def infer_stability(contract: dict, status: str) -> str:
+    """Infer governance stability."""
+    if status == "draft":
+        return "experimental"
+
+    # For active contracts, use stable (meta-schema only allows: experimental, stable, frozen)
+    return "stable"
+
+
+def set_governance_status(contract_path: Path, dry_run: bool = False) -> dict:
+    """Set governance.status for a contract."""
+    try:
+        with open(contract_path) as f:
+            contract = json.load(f)
+
+        metadata = contract.get("x-artifact-metadata", {})
+        if not metadata:
+            return {"status": "skip", "reason": "No x-artifact-metadata"}
+
+        governance = metadata.get("governance", {})
+
+        # Infer status
+        inferred_status = infer_status(contract)
+        inferred_stability = infer_stability(contract, inferred_status)
+
+        current_status = governance.get("status")
+        current_stability = governance.get("stability")
+
+        # Check if update needed
+        changes = []
+        if current_status != inferred_status:
+            governance["status"] = inferred_status
+            changes.append(f"status: {current_status} → {inferred_status}")
+
+        if current_stability != inferred_stability:
+            governance["stability"] = inferred_stability
+            changes.append(f"stability: {current_stability} → {inferred_stability}")
+
+        if not changes:
+            return {"status": "skip", "reason": "Already correct"}
+
+        # Update contract
+        metadata["governance"] = governance
+        contract["x-artifact-metadata"] = metadata
+
+        if not dry_run:
+            with open(contract_path, 'w') as f:
+                json.dump(contract, f, indent=2)
+                f.write('\n')
+
+        return {
+            "status": "updated",
+            "changes": changes
+        }
+
+    except Exception as e:
+        return {"status": "error", "reason": str(e)}
+
+
+def main():
+    """Infer governance status for all contracts."""
+    dry_run = "--dry-run" in sys.argv
+    mode = "DRY RUN" if dry_run else "APPLY CHANGES"
+
+    print("=" * 80)
+    print(f"Infer Governance Status for Contracts ({mode})")
+    print("=" * 80)
+    print()
+
+    contract_files = list(CONTRACTS_DIR.rglob("*.schema.json"))
+
+    updated = 0
+    skipped = 0
+    errors = 0
+
+    for contract_path in sorted(contract_files):
+        result = set_governance_status(contract_path, dry_run)
+
+        if result["status"] == "updated":
+            rel_path = contract_path.relative_to(REPO_ROOT)
+            print(f"✅ {rel_path}")
+            for change in result["changes"]:
+                print(f"   {change}")
+            updated += 1
+        elif result["status"] == "skip":
+            skipped += 1
+        elif result["status"] == "error":
+            print(f"❌ {contract_path.relative_to(REPO_ROOT)}: {result['reason']}")
+            errors += 1
+
+    print()
+    print("=" * 80)
+    print("SUMMARY")
+    print("=" * 80)
+    print(f"Total contracts: {len(contract_files)}")
+    print(f"✅ Updated: {updated}")
+    print(f"⏭️  Skipped: {skipped}")
+    print(f"❌ Errors: {errors}")
+    print("=" * 80)
+
+    if dry_run:
+        print()
+        print("This was a DRY RUN. No files were modified.")
+        print("Run without --dry-run to apply changes:")
+        print("  python3 atdd/coach/commands/infer_governance_status.py")
+
+
+if __name__ == "__main__":
+    main()

atdd/coach/commands/initializer.py

@@ -0,0 +1,177 @@
+"""
+Project initializer for ATDD structure in consumer repos.
+
+Creates the following structure:
+    consumer-repo/
+    ├── CLAUDE.md                (with managed ATDD block)
+    ├── atdd-sessions/
+    │   ├── SESSION-TEMPLATE.md  (copied from package)
+    │   └── archive/
+    └── .atdd/
+        ├── manifest.yaml        (machine-readable session tracking)
+        └── config.yaml          (agent sync configuration)
+
+Usage:
+    atdd init                    # Initialize ATDD structure
+    atdd init --force            # Overwrite existing files
+
+Convention: src/atdd/coach/conventions/session.convention.yaml
+"""
+import shutil
+from datetime import date
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+
+class ProjectInitializer:
+    """Initialize ATDD structure in consumer repo."""
+
+    def __init__(self, target_dir: Optional[Path] = None):
+        """
+        Initialize the ProjectInitializer.
+
+        Args:
+            target_dir: Target directory for initialization. Defaults to cwd.
+        """
+        self.target_dir = target_dir or Path.cwd()
+        self.sessions_dir = self.target_dir / "atdd-sessions"
+        self.archive_dir = self.sessions_dir / "archive"
+        self.atdd_config_dir = self.target_dir / ".atdd"
+        self.manifest_file = self.atdd_config_dir / "manifest.yaml"
+        self.config_file = self.atdd_config_dir / "config.yaml"
+
+        # Package template location
+        self.package_root = Path(__file__).parent.parent  # src/atdd/coach
+        self.template_source = self.package_root / "templates" / "SESSION-TEMPLATE.md"
+
+    def init(self, force: bool = False) -> int:
+        """
+        Create atdd-sessions/ and .atdd/ structure.
+
+        Args:
+            force: If True, overwrite existing files.
+
+        Returns:
+            0 on success, 1 on error.
+        """
+        # Check if already initialized
+        if self.sessions_dir.exists() and not force:
+            print(f"ATDD already initialized at {self.target_dir}")
+            print("Use --force to reinitialize")
+            return 1
+
+        try:
+            # Create atdd-sessions/ directory
+            self.sessions_dir.mkdir(parents=True, exist_ok=True)
+            print(f"Created: {self.sessions_dir}")
+
+            # Create archive subdirectory
+            self.archive_dir.mkdir(parents=True, exist_ok=True)
+            print(f"Created: {self.archive_dir}")
+
+            # Create .atdd/ config directory
+            self.atdd_config_dir.mkdir(parents=True, exist_ok=True)
+            print(f"Created: {self.atdd_config_dir}")
+
+            # Copy SESSION-TEMPLATE.md to atdd-sessions/
+            template_dest = self.sessions_dir / "SESSION-TEMPLATE.md"
+            if self.template_source.exists():
+                shutil.copy2(self.template_source, template_dest)
+                print(f"Copied: SESSION-TEMPLATE.md -> {template_dest}")
+            else:
+                print(f"Warning: Template not found at {self.template_source}")
+
+            # Create manifest.yaml
+            self._create_manifest(force)
+
+            # Create config.yaml
+            self._create_config(force)
+
+            # Sync agent config files
+            from atdd.coach.commands.sync import AgentConfigSync
+            syncer = AgentConfigSync(self.target_dir)
+            syncer.sync()
+
+            # Print next steps
+            print("\n" + "=" * 60)
+            print("ATDD initialized successfully!")
+            print("=" * 60)
+            print("\nNext steps:")
+            print("  1. Create a new session:")
+            print("     atdd session new my-feature")
+            print("")
+            print("  2. List existing sessions:")
+            print("     atdd session list")
+            print("")
+            print("  3. Archive completed sessions:")
+            print("     atdd session archive 01")
+            print("")
+            print("Structure created:")
+            print(f"  {self.sessions_dir}/")
+            print(f"  {self.sessions_dir}/archive/")
+            print(f"  {self.sessions_dir}/SESSION-TEMPLATE.md")
+            print(f"  {self.atdd_config_dir}/")
+            print(f"  {self.manifest_file}")
+            print(f"  {self.config_file}")
+            print(f"  CLAUDE.md (with ATDD managed block)")
+
+            return 0
+
+        except PermissionError as e:
+            print(f"Error: Permission denied - {e}")
+            return 1
+        except OSError as e:
+            print(f"Error: {e}")
+            return 1
+
+    def _create_manifest(self, force: bool = False) -> None:
+        """
+        Create or update .atdd/manifest.yaml.
+
+        Args:
+            force: If True, overwrite existing manifest.
+        """
+        if self.manifest_file.exists() and not force:
+            print(f"Manifest already exists: {self.manifest_file}")
+            return
+
+        manifest = {
+            "version": "1.0",
+            "sessions_dir": "atdd-sessions",
+            "created": date.today().isoformat(),
+            "sessions": [],
+        }
+
+        with open(self.manifest_file, "w") as f:
+            yaml.dump(manifest, f, default_flow_style=False, sort_keys=False)
+
+        print(f"Created: {self.manifest_file}")
+
+    def _create_config(self, force: bool = False) -> None:
+        """
+        Create or update .atdd/config.yaml.
+
+        Args:
+            force: If True, overwrite existing config.
+        """
+        if self.config_file.exists() and not force:
+            print(f"Config already exists: {self.config_file}")
+            return
+
+        config = {
+            "version": "1.0",
+            "sync": {
+                "agents": ["claude"],  # Default: only Claude
+            },
+        }
+
+        with open(self.config_file, "w") as f:
+            yaml.dump(config, f, default_flow_style=False, sort_keys=False)
+
+        print(f"Created: {self.config_file}")
+
+    def is_initialized(self) -> bool:
+        """Check if ATDD is already initialized in target directory."""
+        return self.sessions_dir.exists() and self.manifest_file.exists()