atdd 0.4.5__py3-none-any.whl → 0.4.7__py3-none-any.whl

atdd/cli.py

@@ -110,16 +110,60 @@ class ATDDCoach:
             parallel=True
         )
 
-    def update_registries(self, registry_type: str = "all") -> int:
-        """Update registries from source files."""
-        if registry_type == "wagons":
-            self.registry_updater.update_wagon_registry()
-        elif registry_type == "contracts":
-            self.registry_updater.update_contract_registry()
-        elif registry_type == "telemetry":
-            self.registry_updater.update_telemetry_registry()
-        else:  # all
-            self.registry_updater.update_all()
+    def update_registries(
+        self,
+        registry_type: str = "all",
+        apply: bool = False,
+        check: bool = False
+    ) -> int:
+        """Update registries from source files.
+
+        Args:
+            registry_type: Which registry to update (all, wagons, trains, contracts, etc.)
+            apply: If True, apply changes without prompting (CI mode)
+            check: If True, only check for drift without applying (exit 1 if drift)
+
+        Returns:
+            0 on success, 1 if --check and drift detected
+        """
+        # Convert flags to mode string
+        if check:
+            mode = "check"
+        elif apply:
+            mode = "apply"
+        else:
+            mode = "interactive"
+
+        # Registry type handlers
+        handlers = {
+            "wagons": self.registry_updater.update_wagon_registry,
+            "trains": self.registry_updater.build_trains,
+            "contracts": self.registry_updater.update_contract_registry,
+            "telemetry": self.registry_updater.update_telemetry_registry,
+            "tester": self.registry_updater.build_tester,
+            "coder": self.registry_updater.build_coder,
+            "supabase": self.registry_updater.build_supabase,
+        }
+
+        if registry_type == "all":
+            result = self.registry_updater.build_all(mode=mode)
+            # In check mode, return 1 if any registry has changes
+            if check:
+                has_changes = any(
+                    r.get("has_changes", False) or r.get("new", 0) > 0 or len(r.get("changes", [])) > 0
+                    for r in result.values()
+                )
+                return 1 if has_changes else 0
+        elif registry_type in handlers:
+            result = handlers[registry_type](mode=mode)
+            # In check mode, return 1 if this registry has changes
+            if check:
+                has_changes = result.get("has_changes", False) or result.get("new", 0) > 0 or len(result.get("changes", [])) > 0
+                return 1 if has_changes else 0
+        else:
+            print(f"Unknown registry type: {registry_type}")
+            return 1
+
         return 0
 
     def show_status(self) -> int:
@@ -285,9 +329,20 @@ Phase descriptions:
         nargs="?",
         type=str,
         default="all",
-        choices=["all", "wagons", "contracts", "telemetry"],
+        choices=["all", "wagons", "trains", "contracts", "telemetry", "tester", "coder", "supabase"],
         help="Registry type to update (default: all)"
     )
+    registry_update_parser.add_argument(
+        "--yes", "--apply",
+        action="store_true",
+        dest="apply",
+        help="Apply changes without prompting (for CI/automation)"
+    )
+    registry_update_parser.add_argument(
+        "--check",
+        action="store_true",
+        help="Check for drift without applying (exit 1 if changes detected)"
+    )
 
     # ----- atdd init -----
     init_parser = subparsers.add_parser(
@@ -497,7 +552,11 @@ Phase descriptions:
         coach = ATDDCoach(repo_root=repo_path)
 
         if args.registry_command == "update":
-            return coach.update_registries(registry_type=args.type)
+            return coach.update_registries(
+                registry_type=args.type,
+                apply=args.apply,
+                check=args.check
+            )
         else:
             registry_parser.print_help()
             return 0

atdd/coach/commands/inventory.py

@@ -75,11 +75,32 @@ class RepositoryInventory:
         }
 
     def scan_trains(self) -> Dict[str, Any]:
-        """Scan plan/ for train manifests (aggregations of wagons)."""
+        """
+        Scan plan/ for train manifests (aggregations of wagons).
+
+        Train First-Class Spec v0.6 Section 14: Gap Reporting
+        Reports missing test/code for each platform (backend/frontend/frontend_python).
+        """
         plan_dir = self.repo_root / "plan"
 
         if not plan_dir.exists():
-            return {"total": 0, "trains": []}
+            return {
+                "total": 0,
+                "trains": [],
+                "by_theme": {},
+                "train_ids": [],
+                "detail_files": 0,
+                "missing_test_backend": [],
+                "missing_test_frontend": [],
+                "missing_test_frontend_python": [],
+                "missing_code_backend": [],
+                "missing_code_frontend": [],
+                "missing_code_frontend_python": [],
+                "gaps": {
+                    "test": {"backend": 0, "frontend": 0, "frontend_python": 0},
+                    "code": {"backend": 0, "frontend": 0, "frontend_python": 0}
+                }
+            }
 
         # Load trains registry
         trains_file = plan_dir / "_trains.yaml"
@@ -103,6 +124,14 @@ class RepositoryInventory:
         by_theme = defaultdict(int)
         train_ids = []
 
+        # Gap tracking (Section 14)
+        missing_test_backend = []
+        missing_test_frontend = []
+        missing_test_frontend_python = []
+        missing_code_backend = []
+        missing_code_frontend = []
+        missing_code_frontend_python = []
+
         for train in all_trains:
             train_id = train.get("train_id", "unknown")
             train_ids.append(train_id)
@@ -118,6 +147,46 @@ class RepositoryInventory:
                 theme = theme_map.get(theme_digit, "unknown")
                 by_theme[theme] += 1
 
+            # Gap analysis
+            expectations = train.get("expectations", {})
+            test_fields = train.get("test", {})
+            code_fields = train.get("code", {})
+
+            # Normalize test/code to dict form
+            if isinstance(test_fields, str):
+                test_fields = {"backend": [test_fields]}
+            elif isinstance(test_fields, list):
+                test_fields = {"backend": test_fields}
+
+            if isinstance(code_fields, str):
+                code_fields = {"backend": [code_fields]}
+            elif isinstance(code_fields, list):
+                code_fields = {"backend": code_fields}
+
+            # Check backend gaps (default expectation is True for backend)
+            expects_backend = expectations.get("backend", True)
+            if expects_backend:
+                if not test_fields.get("backend"):
+                    missing_test_backend.append(train_id)
+                if not code_fields.get("backend"):
+                    missing_code_backend.append(train_id)
+
+            # Check frontend gaps
+            expects_frontend = expectations.get("frontend", False)
+            if expects_frontend:
+                if not test_fields.get("frontend"):
+                    missing_test_frontend.append(train_id)
+                if not code_fields.get("frontend"):
+                    missing_code_frontend.append(train_id)
+
+            # Check frontend_python gaps
+            expects_frontend_python = expectations.get("frontend_python", False)
+            if expects_frontend_python:
+                if not test_fields.get("frontend_python"):
+                    missing_test_frontend_python.append(train_id)
+                if not code_fields.get("frontend_python"):
+                    missing_code_frontend_python.append(train_id)
+
         # Find train detail files
         train_detail_files = list((plan_dir / "_trains").glob("*.yaml")) if (plan_dir / "_trains").exists() else []
 
@@ -125,7 +194,26 @@ class RepositoryInventory:
             "total": len(all_trains),
             "by_theme": dict(by_theme),
             "train_ids": train_ids,
-            "detail_files": len(train_detail_files)
+            "detail_files": len(train_detail_files),
+            # Gap reporting (Section 14)
+            "missing_test_backend": missing_test_backend,
+            "missing_test_frontend": missing_test_frontend,
+            "missing_test_frontend_python": missing_test_frontend_python,
+            "missing_code_backend": missing_code_backend,
+            "missing_code_frontend": missing_code_frontend,
+            "missing_code_frontend_python": missing_code_frontend_python,
+            "gaps": {
+                "test": {
+                    "backend": len(missing_test_backend),
+                    "frontend": len(missing_test_frontend),
+                    "frontend_python": len(missing_test_frontend_python)
+                },
+                "code": {
+                    "backend": len(missing_code_backend),
+                    "frontend": len(missing_code_frontend),
+                    "frontend_python": len(missing_code_frontend_python)
+                }
+            }
         }
 
     def scan_wagons(self) -> Dict[str, Any]: