specify-cli 0.13.0__tar.gz → 0.13.1__tar.gz

{specify_cli-0.13.0 → specify_cli-0.13.1}/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 <!-- insert new changelog below this comment -->
 
+## [0.13.1] - 2026-07-21
+
+### Changed
+
+- fix(integrations): catch OverflowError on a `priority: .inf` in add/remove (#3589)
+- fix(workflows): reject bool / .inf catalog priority in workflow & step catalog loaders (#3526)
+- fix(catalogs): 'priority: .inf' yields a clean validation error instead of crashing (#3525)
+- docs(integrations): document the 'integration list --catalog' flag (#3530)
+- fix(workflows): fail fan-in loudly on a non-string wait_for entry (#3579)
+- fix(workflows): fail fan-out loudly on a truthy non-mapping step template (#3537)
+- fix(workflows): reject a non-string prompt in prompt-step validate() (#3582)
+- fix(workflows): route 'workflow status --json' errors to stderr (#3520)
+- fix(integrations): Forge dispatches hyphenated /speckit-<cmd> invocations (#3529)
+- chore: release 0.13.0, begin 0.13.1.dev0 development (#3588)
+
 ## [0.13.0] - 2026-07-17
 
 ### Changed

{specify_cli-0.13.0 → specify_cli-0.13.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specify-cli
-Version: 0.13.0
+Version: 0.13.1
 Summary: Specify CLI, part of GitHub Spec Kit. A tool to bootstrap your projects for Spec-Driven Development (SDD).
 License-File: LICENSE
 Requires-Python: >=3.11

{specify_cli-0.13.0 → specify_cli-0.13.1}/docs/reference/integrations.md

@@ -48,7 +48,11 @@ The Specify CLI supports a wide range of AI coding agents. When you run `specify
 specify integration list
 ```
 
-Shows all available integrations, which one is currently installed, and whether each requires a CLI tool or is IDE-based.
+| Option      | Description                                                                                                             |
+| ----------- | ----------------------------------------------------------------------------------------------------------------------- |
+| `--catalog` | Also browse the catalog (built-in **and** community). Community integrations that are not built in are only shown here.  |
+
+Shows the built-in integrations, which one is currently installed, and whether each requires a CLI tool or is IDE-based.
 When multiple integrations are installed, the list marks the default integration separately from the other installed integrations.
 The list also shows whether each built-in integration is declared multi-install safe.
 

{specify_cli-0.13.0 → specify_cli-0.13.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "specify-cli"
-version = "0.13.0"
+version = "0.13.1"
 description = "Specify CLI, part of GitHub Spec Kit. A tool to bootstrap your projects for Spec-Driven Development (SDD)."
 readme = "README.md"
 requires-python = ">=3.11"

{specify_cli-0.13.0 → specify_cli-0.13.1}/src/specify_cli/catalogs.py

@@ -149,7 +149,10 @@ class CatalogStackBase:
                 )
             try:
                 priority = int(raw_priority)
-            except (TypeError, ValueError):
+            except (TypeError, ValueError, OverflowError):
+                # OverflowError: int(float("inf")) — a YAML ``priority: .inf``
+                # would otherwise escape as an uncaught traceback instead of the
+                # clean validation error.
                 raise self._validation_error(
                     f"Invalid catalog config {config_path}: "
                     f"Invalid priority for catalog '{item.get('name', idx + 1)}': "

{specify_cli-0.13.0 → specify_cli-0.13.1}/src/specify_cli/integrations/catalog.py

@@ -429,7 +429,8 @@ class IntegrationCatalog(CatalogStackBase):
                     )
                 try:
                     normalized_priority = int(raw_priority)
-                except (TypeError, ValueError):
+                except (TypeError, ValueError, OverflowError):
+                    # OverflowError: int(float("inf")) — a ``priority: .inf``.
                     raise IntegrationValidationError(
                         f"Invalid catalog entry at index {idx} in {config_path}: "
                         f"'priority' must be an integer, got "
@@ -537,7 +538,8 @@ class IntegrationCatalog(CatalogStackBase):
             else:
                 try:
                     priority = int(raw_priority)
-                except (TypeError, ValueError):
+                except (TypeError, ValueError, OverflowError):
+                    # OverflowError: int(float("inf")) — a ``priority: .inf``.
                     priority = yaml_idx + 1
             priority_pairs.append((priority, yaml_idx))
         if not priority_pairs:

{specify_cli-0.13.0 → specify_cli-0.13.1}/src/specify_cli/integrations/forge/__init__.py

@@ -91,6 +91,18 @@ class ForgeIntegration(MarkdownIntegration):
     }
     invoke_separator = "-"
 
+    def build_command_invocation(self, command_name: str, args: str = "") -> str:
+        """Forge installs hyphenated slash-commands (``/speckit-<name>``), so the
+        dispatch invocation must match. The inherited MarkdownIntegration default
+        builds the dotted ``/speckit.<name>``, which references a command Forge
+        never registered. Reuse the same hyphenation as the installed frontmatter
+        ``name`` (see ``format_forge_command_name``), mirroring the skills agents.
+        """
+        invocation = "/" + format_forge_command_name(command_name)
+        if args:
+            invocation = f"{invocation} {args}"
+        return invocation
+
     def setup(
         self,
         project_root: Path,

{specify_cli-0.13.0 → specify_cli-0.13.1}/src/specify_cli/presets/__init__.py

@@ -2235,7 +2235,10 @@ class PresetCatalog:
                 )
             try:
                 priority = int(raw_priority)
-            except (TypeError, ValueError):
+            except (TypeError, ValueError, OverflowError):
+                # OverflowError: int(float("inf")) — a YAML ``priority: .inf``
+                # would otherwise escape as an uncaught traceback instead of the
+                # clean validation error (mirrors catalogs.py).
                 raise PresetValidationError(
                     f"Invalid priority for catalog '{item.get('name', idx + 1)}': "
                     f"expected integer, got {raw_priority!r}"

{specify_cli-0.13.0 → specify_cli-0.13.1}/src/specify_cli/workflows/_commands.py

@@ -1262,14 +1262,18 @@ def workflow_status(
     engine = WorkflowEngine(project_root)
 
     if run_id:
+        # Route errors to stderr under --json so the stdout JSON stream stays
+        # parseable (mirrors `workflow run`/`workflow resume`); both handlers
+        # fire before the json_output branch below.
+        err = _error_console(json_output)
         try:
             from .engine import RunState
             state = RunState.load(run_id, project_root)
         except FileNotFoundError:
-            console.print(f"[red]Error:[/red] Run not found: {run_id}")
+            err.print(f"[red]Error:[/red] Run not found: {run_id}")
             raise typer.Exit(1)
         except ValueError as exc:
-            console.print(f"[red]Error:[/red] {_escape_markup(str(exc))}")
+            err.print(f"[red]Error:[/red] {_escape_markup(str(exc))}")
             raise typer.Exit(1)
 
         if json_output:

{specify_cli-0.13.0 → specify_cli-0.13.1}/src/specify_cli/workflows/catalog.py

@@ -364,13 +364,24 @@ class WorkflowCatalog:
             if not url:
                 continue
             self._validate_catalog_url(url)
+            raw_priority = item.get("priority", idx + 1)
+            # bool is an int subclass: int(True) == 1 would silently accept a
+            # ``priority: true`` as priority 1. Reject it explicitly, mirroring
+            # the base CatalogStackBase loader.
+            if isinstance(raw_priority, bool):
+                raise WorkflowValidationError(
+                    f"Invalid priority for catalog "
+                    f"'{item.get('name', idx + 1)}': "
+                    f"expected integer, got {raw_priority!r}"
+                )
             try:
-                priority = int(item.get("priority", idx + 1))
-            except (TypeError, ValueError):
+                priority = int(raw_priority)
+            except (TypeError, ValueError, OverflowError):
+                # OverflowError: int(float("inf")) — a ``priority: .inf``.
                 raise WorkflowValidationError(
                     f"Invalid priority for catalog "
                     f"'{item.get('name', idx + 1)}': "
-                    f"expected integer, got {item.get('priority')!r}"
+                    f"expected integer, got {raw_priority!r}"
                 )
             raw_install = item.get("install_allowed", False)
             if isinstance(raw_install, str):
@@ -685,7 +696,9 @@ class WorkflowCatalog:
         def _coerce_priority(value: Any) -> int:
             try:
                 return int(value)
-            except (TypeError, ValueError):
+            except (TypeError, ValueError, OverflowError):
+                # OverflowError: int(float("inf")) — treat an uncoercible
+                # existing priority as 0 rather than crashing 'catalog add'.
                 return 0
 
         max_priority = max(
@@ -1007,13 +1020,23 @@ class StepCatalog:
             if not url:
                 continue
             self._validate_catalog_url(url)
+            raw_priority = item.get("priority", idx + 1)
+            # bool is an int subclass: reject ``priority: true`` explicitly rather
+            # than silently coercing it to 1 (mirrors CatalogStackBase).
+            if isinstance(raw_priority, bool):
+                raise StepValidationError(
+                    f"Invalid priority for catalog "
+                    f"'{item.get('name', idx + 1)}': "
+                    f"expected integer, got {raw_priority!r}"
+                )
             try:
-                priority = int(item.get("priority", idx + 1))
-            except (TypeError, ValueError):
+                priority = int(raw_priority)
+            except (TypeError, ValueError, OverflowError):
+                # OverflowError: int(float("inf")) — a ``priority: .inf``.
                 raise StepValidationError(
                     f"Invalid priority for catalog "
                     f"'{item.get('name', idx + 1)}': "
-                    f"expected integer, got {item.get('priority')!r}"
+                    f"expected integer, got {raw_priority!r}"
                 )
             raw_install = item.get("install_allowed", False)
             if isinstance(raw_install, str):
@@ -1314,7 +1337,9 @@ class StepCatalog:
         def _coerce_priority(value: Any) -> int:
             try:
                 return int(value)
-            except (TypeError, ValueError):
+            except (TypeError, ValueError, OverflowError):
+                # OverflowError: int(float("inf")) — treat an uncoercible
+                # existing priority as 0 rather than crashing 'catalog add'.
                 return 0
 
         max_priority = max(

{specify_cli-0.13.0 → specify_cli-0.13.1}/src/specify_cli/workflows/steps/fan_in/__init__.py

@@ -42,6 +42,28 @@ class FanInStep(StepBase):
                 output={"results": []},
             )
 
+        # A non-string entry can never match a real step id. An unhashable one
+        # (a list/dict from a YAML indentation slip like ``wait_for: [[a, b]]``)
+        # crashes the whole run at ``context.steps.get(step_id, ...)`` below with
+        # a raw TypeError; a hashable-but-non-string one (``wait_for: [123]``)
+        # silently joins an empty ``{}`` and still reports COMPLETED — the exact
+        # "silent empty result + COMPLETED" wiring bug the whole-list guard above
+        # and the engine's fan-in validation (engine.py) both reject. The engine
+        # does not auto-validate step config, so fail this step loudly on an
+        # unvalidated run too, using the engine's phrasing.
+        bad_entries = [w for w in wait_for if not isinstance(w, str)]
+        if bad_entries:
+            first = bad_entries[0]
+            return StepResult(
+                status=StepStatus.FAILED,
+                error=(
+                    f"Fan-in step {config.get('id', '?')!r}: 'wait_for' entries "
+                    f"must be step-id strings, got {type(first).__name__} "
+                    f"({first!r})."
+                ),
+                output={"results": []},
+            )
+
         # Collect results from referenced steps
         results = []
         for step_id in wait_for:

{specify_cli-0.13.0 → specify_cli-0.13.1}/src/specify_cli/workflows/steps/fan_out/__init__.py

@@ -25,6 +25,33 @@ class FanOutStep(StepBase):
         max_concurrency = config.get("max_concurrency", 1)
         step_template = config.get("step", {})
 
+        # The engine does not auto-validate step config (see
+        # ``WorkflowEngine.load_workflow``). On a COMPLETED fan-out it reads the
+        # ``step_template`` back out and, when it is truthy, calls
+        # ``template.get("id", ...)`` in ``_run_fan_out``. A truthy non-mapping
+        # ``step`` (a scalar or list authoring mistake) would crash the whole
+        # run with AttributeError there — the engine invokes ``execute`` and
+        # ``_run_fan_out`` with no surrounding try/except. ``validate`` already
+        # rejects a non-mapping ``step``; fail this step loudly on an
+        # unvalidated run instead, mirroring the ``items`` guard below. An empty
+        # or absent ``step`` defaults to ``{}`` (falsy) and the engine's
+        # ``if template and items`` skips fan-out, so it stays valid here.
+        if not isinstance(step_template, dict):
+            return StepResult(
+                status=StepStatus.FAILED,
+                error=(
+                    f"Fan-out step {config.get('id', '?')!r}: 'step' must be a "
+                    f"mapping (nested step template), got "
+                    f"{type(step_template).__name__}."
+                ),
+                output={
+                    "items": [],
+                    "max_concurrency": max_concurrency,
+                    "step_template": {},
+                    "item_count": 0,
+                },
+            )
+
         if not isinstance(items, list):
             # A non-list here is a wiring error (the expression did not
             # resolve to a collection); silently fanning out over zero
@@ -66,8 +93,13 @@ class FanOutStep(StepBase):
                 f"Fan-out step {config.get('id', '?')!r} is missing "
                 f"'step' field (nested step template)."
             )
-        step = config.get("step")
-        if step is not None and not isinstance(step, dict):
+        elif not isinstance(config["step"], dict):
+            # A present-but-non-mapping ``step`` (including an explicit
+            # ``step: null``) is an authoring mistake. ``config.get("step", {})``
+            # in ``execute`` only substitutes the ``{}`` default for an *absent*
+            # key, so an explicit ``None`` reaches the runtime guard and FAILS
+            # the step. Reject it here too so a workflow cannot pass validation
+            # and then fail during execution.
             errors.append(
                 f"Fan-out step {config.get('id', '?')!r}: 'step' must be a mapping."
             )

{specify_cli-0.13.0 → specify_cli-0.13.1}/src/specify_cli/workflows/steps/prompt/__init__.py

@@ -160,4 +160,16 @@ class PromptStep(StepBase):
             errors.append(
                 f"Prompt step {config.get('id', '?')!r} is missing 'prompt' field."
             )
+        elif not isinstance(config["prompt"], str):
+            # execute() str()-coerces prompt and dispatches it to the
+            # integration CLI, so a null or list 'prompt' would send the Python
+            # repr ('None', "['review', 'this']") to the model as instructions —
+            # silently wrong, with no error. Reject non-strings at validation,
+            # mirroring the shell-step 'run' and command-step input/options type
+            # checks. An expression like "{{ ... }}" is still a str, so it stays
+            # valid.
+            errors.append(
+                f"Prompt step {config.get('id', '?')!r}: 'prompt' must be a "
+                f"string, got {type(config['prompt']).__name__}."
+            )
         return errors

{specify_cli-0.13.0 → specify_cli-0.13.1}/tests/integrations/test_base.py

@@ -216,6 +216,24 @@ class TestBuildCommandInvocation:
         i = get_integration("codex")
         assert i.build_command_invocation("speckit.git.commit", "fix typo") == "/speckit-git-commit fix typo"
 
+    def test_forge_core_command_hyphenated(self):
+        """Forge installs hyphenated slash-commands (/speckit-<name>), so the
+        dispatch invocation must be hyphenated too — not the dotted default it
+        would inherit from MarkdownIntegration."""
+        from specify_cli.integrations import get_integration
+        i = get_integration("forge")
+        assert i.build_command_invocation("speckit.plan") == "/speckit-plan"
+        assert i.build_command_invocation("plan") == "/speckit-plan"
+
+    def test_forge_extension_command_hyphenated(self):
+        from specify_cli.integrations import get_integration
+        i = get_integration("forge")
+        assert i.build_command_invocation("speckit.git.commit") == "/speckit-git-commit"
+        assert (
+            i.build_command_invocation("speckit.git.commit", "fix typo")
+            == "/speckit-git-commit fix typo"
+        )
+
 
 class TestResolveCommandRefs:
     """Tests for __SPECKIT_COMMAND_<NAME>__ placeholder resolution."""

{specify_cli-0.13.0 → specify_cli-0.13.1}/tests/integrations/test_integration_catalog.py

@@ -922,6 +922,57 @@ class TestCatalogSourceManagement:
         assert str(cfg_path) in message
         assert "expected a mapping" in message
 
+    def test_add_catalog_rejects_inf_priority_in_existing_entry(
+        self, tmp_path, monkeypatch
+    ):
+        # ``priority: .inf`` loads as float('inf'); int() on it raises
+        # OverflowError, which used to escape the IntegrationValidationError
+        # contract as a raw traceback (github/spec-kit#3526 fixed the sibling
+        # workflow/step loaders the same way).
+        self._isolate(tmp_path, monkeypatch)
+        cfg_path = tmp_path / ".specify" / "integration-catalogs.yml"
+        cfg_path.write_text(
+            yaml.dump(
+                {
+                    "catalogs": [
+                        {
+                            "url": "https://a.example.com/catalog.json",
+                            "priority": float("inf"),
+                        }
+                    ]
+                }
+            ),
+            encoding="utf-8",
+        )
+        cat = IntegrationCatalog(tmp_path)
+        with pytest.raises(
+            IntegrationValidationError, match="must be an integer"
+        ):
+            cat.add_catalog("https://new.example.com/catalog.json")
+
+    def test_remove_catalog_tolerates_inf_priority(self, tmp_path, monkeypatch):
+        # Building the remove display order must not crash on a ``priority:
+        # .inf`` entry; it falls back to positional order like the other
+        # non-integer priorities do.
+        self._isolate(tmp_path, monkeypatch)
+        cfg_path = tmp_path / ".specify" / "integration-catalogs.yml"
+        cfg_path.write_text(
+            yaml.dump(
+                {
+                    "catalogs": [
+                        {
+                            "url": "https://a.example.com/catalog.json",
+                            "priority": float("inf"),
+                        },
+                        {"url": "https://b.example.com/catalog.json", "priority": 2},
+                    ]
+                }
+            ),
+            encoding="utf-8",
+        )
+        cat = IntegrationCatalog(tmp_path)
+        cat.remove_catalog(0)  # must not raise OverflowError
+
     def test_add_catalog_skips_blank_url_entries(self, tmp_path, monkeypatch):
         self._isolate(tmp_path, monkeypatch)
         cfg_path = tmp_path / ".specify" / "integration-catalogs.yml"

{specify_cli-0.13.0 → specify_cli-0.13.1}/tests/test_extensions.py

@@ -4542,6 +4542,36 @@ class TestCatalogStack:
             catalog.get_active_catalogs()
         assert str(config_path) in str(exc_info.value)
 
+    def test_load_catalog_config_rejects_infinite_priority(self, temp_dir):
+        """A ``priority: .inf`` yields a clean validation error, not an uncaught
+        OverflowError from int(float('inf'))."""
+        import yaml as yaml_module
+
+        project_dir = self._make_project(temp_dir)
+        config_path = project_dir / ".specify" / "extension-catalogs.yml"
+        config_path.write_text(
+            yaml_module.dump(
+                {
+                    "catalogs": [
+                        {
+                            "name": "inf-priority",
+                            "url": "https://example.com/catalog.json",
+                            "priority": float("inf"),
+                        }
+                    ]
+                }
+            ),
+            encoding="utf-8",
+        )
+
+        catalog = ExtensionCatalog(project_dir)
+
+        with pytest.raises(
+            ValidationError, match="Invalid priority|expected integer"
+        ) as exc_info:
+            catalog.get_active_catalogs()
+        assert str(config_path) in str(exc_info.value)
+
     def test_load_catalog_config_defaults_blank_names(self, temp_dir):
         """Blank and null names normalize by valid catalog order."""
         import yaml as yaml_module

{specify_cli-0.13.0 → specify_cli-0.13.1}/tests/test_presets.py

@@ -2671,6 +2671,24 @@ class TestPresetCatalogMultiCatalog:
         with pytest.raises(PresetValidationError, match="Invalid priority|expected integer"):
             catalog._load_catalog_config(config_path)
 
+    def test_load_catalog_config_rejects_infinite_priority(self, project_dir):
+        """A ``priority: .inf`` yields a clean validation error, not an uncaught
+        OverflowError from int(float('inf'))."""
+        config_path = project_dir / ".specify" / "preset-catalogs.yml"
+        config_path.write_text(yaml.dump({
+            "catalogs": [
+                {
+                    "name": "inf-priority",
+                    "url": "https://example.com/catalog.json",
+                    "priority": float("inf"),
+                }
+            ]
+        }))
+
+        catalog = PresetCatalog(project_dir)
+        with pytest.raises(PresetValidationError, match="Invalid priority|expected integer"):
+            catalog._load_catalog_config(config_path)
+
     def test_load_catalog_config_install_allowed_string(self, project_dir):
         """Test that install_allowed accepts string values."""
         config_path = project_dir / ".specify" / "preset-catalogs.yml"