diff --git a/src/specify_cli/__init__.py b/src/specify_cli/__init__.py index ccd670d20e..abbda1247c 100644 --- a/src/specify_cli/__init__.py +++ b/src/specify_cli/__init__.py @@ -1931,8 +1931,8 @@ def _read_integration_json(project_root: Path) -> dict[str, Any]: return {} try: data = json.loads(path.read_text(encoding="utf-8")) - except json.JSONDecodeError as exc: - console.print(f"[red]Error:[/red] {path} contains invalid JSON.") + except (json.JSONDecodeError, UnicodeDecodeError) as exc: + console.print(f"[red]Error:[/red] {path} contains invalid JSON or is not valid UTF-8.") console.print(f"Please fix or delete {INTEGRATION_JSON} and retry.") console.print(f"[dim]Details:[/dim] {exc}") raise typer.Exit(1) diff --git a/src/specify_cli/workflows/engine.py b/src/specify_cli/workflows/engine.py index d6a73bbeb0..25de351ed4 100644 --- a/src/specify_cli/workflows/engine.py +++ b/src/specify_cli/workflows/engine.py @@ -19,6 +19,12 @@ import yaml +from ..integration_state import ( + INTEGRATION_JSON, + INTEGRATION_STATE_SCHEMA, + default_integration_key, + normalize_integration_state, +) from .base import RunStatus, StepContext, StepResult, StepStatus @@ -143,6 +149,35 @@ def validate_workflow(definition: WorkflowDefinition) -> list[str]: f"Must be 'string', 'number', or 'boolean'." ) + # Validate the default eagerly so authoring mistakes (e.g. a + # default not in the declared enum, or a non-numeric default for + # a number input) surface at install/validation time instead of + # at workflow-execution time. ``"auto"`` for the integration + # input is a runtime-resolved sentinel, so only the + # enum-membership check is exempted for that exact case — the + # declared type is still enforced (e.g. ``type: number`` paired + # with ``default: "auto"`` is still rejected). + if "default" in input_def: + default_value = input_def["default"] + is_auto_integration = ( + input_name == "integration" and default_value == "auto" + ) + validation_input_def: dict[str, Any] = input_def + if is_auto_integration and "enum" in input_def: + validation_input_def = { + key: value + for key, value in input_def.items() + if key != "enum" + } + try: + WorkflowEngine._coerce_input( + input_name, default_value, validation_input_def + ) + except ValueError as exc: + errors.append( + f"Input {input_name!r} has invalid default: {exc}" + ) + # -- Steps ------------------------------------------------------------ if not isinstance(definition.steps, list): errors.append("'steps' must be a list.") @@ -715,12 +750,74 @@ def _resolve_inputs( name, provided[name], input_def ) elif "default" in input_def: - resolved[name] = input_def["default"] + default_value = self._resolve_default(name, input_def["default"]) + # If the integration default could not be resolved against + # project state and falls back to the literal ``"auto"`` + # sentinel, exempt it from enum-membership coercion so a + # workflow that lists specific integrations in ``enum`` does + # not crash at runtime — declared type is still enforced. + coerce_input_def = input_def + if ( + name == "integration" + and default_value == "auto" + and "enum" in input_def + ): + coerce_input_def = { + key: value + for key, value in input_def.items() + if key != "enum" + } + resolved[name] = self._coerce_input( + name, default_value, coerce_input_def + ) elif input_def.get("required", False): msg = f"Required input {name!r} not provided." raise ValueError(msg) return resolved + def _resolve_default(self, name: str, default: Any) -> Any: + """Resolve special default sentinels against project state. + + For the ``integration`` input, ``"auto"`` resolves to the integration + recorded in ``.specify/integration.json`` so workflows dispatch to the + AI the project was actually initialized with, instead of a hardcoded + value baked into the workflow YAML. + """ + if name == "integration" and default == "auto": + resolved = self._load_project_integration() + if resolved is not None: + return resolved + return default + + def _load_project_integration(self) -> str | None: + """Read the default integration key from ``.specify/integration.json``. + + Honors the same schema guard as ``_read_integration_json`` (rejects + files whose ``integration_state_schema`` is newer than this CLI + supports) and reads the canonical normalized state, so modern + installs that record ``default_integration`` / ``installed_integrations`` + resolve correctly under ``integration: auto``. Returns None when the + file is missing, malformed, or written by a newer CLI; callers are + expected to fall back to a literal default. + """ + path = self.project_root / INTEGRATION_JSON + if not path.is_file(): + return None + try: + data = json.loads(path.read_text(encoding="utf-8")) + except (json.JSONDecodeError, OSError, UnicodeDecodeError): + return None + if not isinstance(data, dict): + return None + schema = data.get("integration_state_schema") + if ( + isinstance(schema, int) + and not isinstance(schema, bool) + and schema > INTEGRATION_STATE_SCHEMA + ): + return None + return default_integration_key(normalize_integration_state(data)) + @staticmethod def _coerce_input( name: str, value: Any, input_def: dict[str, Any] diff --git a/tests/integrations/test_cli.py b/tests/integrations/test_cli.py index 7732d57300..562afd488d 100644 --- a/tests/integrations/test_cli.py +++ b/tests/integrations/test_cli.py @@ -1191,6 +1191,30 @@ def fail_search(self, **kwargs): assert "contains invalid JSON" in normalized_output assert "integration.json" in normalized_output + def test_search_rejects_non_utf8_integration_json_before_catalog_lookup( + self, tmp_path, monkeypatch + ): + """A non-UTF8 ``integration.json`` must surface a clear error and + avoid falling through to the catalog lookup, mirroring the malformed-JSON + case but for the ``UnicodeDecodeError`` branch in ``_read_integration_json``.""" + project = self._make_project(tmp_path) + # 0xFF is invalid as the leading byte of any UTF-8 sequence, so + # ``Path.read_text(encoding="utf-8")`` raises ``UnicodeDecodeError``. + (project / ".specify" / "integration.json").write_bytes(b"\xff\xfe\x00\x00") + + from specify_cli.integrations.catalog import IntegrationCatalog + + def fail_search(self, **kwargs): + raise AssertionError("catalog search should not be called") + + monkeypatch.setattr(IntegrationCatalog, "search", fail_search) + + result = self._invoke(["integration", "search"], project) + normalized_output = _normalize_cli_output(result.output) + assert result.exit_code == 1 + assert "not valid UTF-8" in normalized_output + assert "integration.json" in normalized_output + def test_search_filters_by_tag(self, tmp_path, monkeypatch): project = self._make_project(tmp_path) self._patch_catalog(monkeypatch) diff --git a/tests/test_workflows.py b/tests/test_workflows.py index 4c042fc7d5..653b3e3ca2 100644 --- a/tests/test_workflows.py +++ b/tests/test_workflows.py @@ -1495,6 +1495,314 @@ def test_execute_missing_required_input(self, project_dir): with pytest.raises(ValueError, match="Required input"): engine.execute(definition, {}) + def test_integration_auto_default_uses_project_integration(self, project_dir): + """`integration: auto` should resolve to .specify/integration.json's integration.""" + from specify_cli.workflows.engine import WorkflowEngine, WorkflowDefinition + + specify_dir = project_dir / ".specify" + specify_dir.mkdir(parents=True, exist_ok=True) + (specify_dir / "integration.json").write_text( + json.dumps({"integration": "opencode", "version": "0.7.4"}), + encoding="utf-8", + ) + + definition = WorkflowDefinition.from_string(""" +schema_version: "1.0" +workflow: + id: "auto-default" + name: "Auto Default" + version: "1.0.0" +inputs: + integration: + type: string + default: "auto" +""") + engine = WorkflowEngine(project_dir) + resolved = engine._resolve_inputs(definition, {}) + assert resolved["integration"] == "opencode" + + def test_integration_auto_default_falls_back_when_no_integration_json(self, project_dir): + """`integration: auto` should keep the literal "auto" when project state is missing. + + The engine itself must not invent an integration when + ``.specify/integration.json`` is absent; any later validation or + command resolution will handle an unresolved ``"auto"`` value. + """ + from specify_cli.workflows.engine import WorkflowEngine, WorkflowDefinition + + definition = WorkflowDefinition.from_string(""" +schema_version: "1.0" +workflow: + id: "auto-fallback" + name: "Auto Fallback" + version: "1.0.0" +inputs: + integration: + type: string + default: "auto" +""") + engine = WorkflowEngine(project_dir) + resolved = engine._resolve_inputs(definition, {}) + assert resolved["integration"] == "auto" + + def test_integration_explicit_input_overrides_auto(self, project_dir): + """An explicit --input integration=X must win over `auto` even when integration.json exists.""" + from specify_cli.workflows.engine import WorkflowEngine, WorkflowDefinition + + specify_dir = project_dir / ".specify" + specify_dir.mkdir(parents=True, exist_ok=True) + (specify_dir / "integration.json").write_text( + json.dumps({"integration": "opencode"}), + encoding="utf-8", + ) + + definition = WorkflowDefinition.from_string(""" +schema_version: "1.0" +workflow: + id: "explicit-wins" + name: "Explicit Wins" + version: "1.0.0" +inputs: + integration: + type: string + default: "auto" +""") + engine = WorkflowEngine(project_dir) + resolved = engine._resolve_inputs(definition, {"integration": "claude"}) + assert resolved["integration"] == "claude" + + def test_integration_auto_ignores_malformed_integration_json(self, project_dir): + """A malformed integration.json must not crash — fall back to the literal default.""" + from specify_cli.workflows.engine import WorkflowEngine, WorkflowDefinition + + specify_dir = project_dir / ".specify" + specify_dir.mkdir(parents=True, exist_ok=True) + (specify_dir / "integration.json").write_text("{not json", encoding="utf-8") + + definition = WorkflowDefinition.from_string(""" +schema_version: "1.0" +workflow: + id: "auto-malformed" + name: "Auto Malformed" + version: "1.0.0" +inputs: + integration: + type: string + default: "auto" +""") + engine = WorkflowEngine(project_dir) + resolved = engine._resolve_inputs(definition, {}) + assert resolved["integration"] == "auto" + + def test_integration_auto_ignores_non_utf8_integration_json(self, project_dir): + """A non-UTF8 integration.json must not crash — fall back to the literal default.""" + from specify_cli.workflows.engine import WorkflowEngine, WorkflowDefinition + + specify_dir = project_dir / ".specify" + specify_dir.mkdir(parents=True, exist_ok=True) + # 0xFF is invalid as the leading byte of a UTF-8 sequence, so + # ``Path.read_text(encoding="utf-8")`` raises UnicodeDecodeError. + (specify_dir / "integration.json").write_bytes(b"\xff\xfe\x00\x00") + + definition = WorkflowDefinition.from_string(""" +schema_version: "1.0" +workflow: + id: "auto-non-utf8" + name: "Auto Non UTF-8" + version: "1.0.0" +inputs: + integration: + type: string + default: "auto" +""") + engine = WorkflowEngine(project_dir) + resolved = engine._resolve_inputs(definition, {}) + assert resolved["integration"] == "auto" + + def test_integration_auto_resolves_modern_normalized_state(self, project_dir): + """`integration: auto` must resolve modern state files that record + ``default_integration`` / ``installed_integrations`` and omit the + legacy ``integration`` field.""" + from specify_cli.workflows.engine import WorkflowEngine, WorkflowDefinition + + specify_dir = project_dir / ".specify" + specify_dir.mkdir(parents=True, exist_ok=True) + (specify_dir / "integration.json").write_text( + json.dumps( + { + "version": "0.8.3", + "integration_state_schema": 1, + "default_integration": "claude", + "installed_integrations": ["claude", "copilot"], + "integration_settings": {}, + } + ), + encoding="utf-8", + ) + + definition = WorkflowDefinition.from_string(""" +schema_version: "1.0" +workflow: + id: "auto-modern" + name: "Auto Modern" + version: "1.0.0" +inputs: + integration: + type: string + default: "auto" +""") + engine = WorkflowEngine(project_dir) + resolved = engine._resolve_inputs(definition, {}) + assert resolved["integration"] == "claude" + + def test_integration_auto_rejects_future_state_schema(self, project_dir): + """`integration: auto` must not silently use a state file written by a newer + CLI (``integration_state_schema`` greater than the current supported value); + the resolver falls back to the literal default rather than guessing.""" + from specify_cli.workflows.engine import WorkflowEngine, WorkflowDefinition + from specify_cli.integration_state import INTEGRATION_STATE_SCHEMA + + specify_dir = project_dir / ".specify" + specify_dir.mkdir(parents=True, exist_ok=True) + (specify_dir / "integration.json").write_text( + json.dumps( + { + "version": "99.0.0", + "integration_state_schema": INTEGRATION_STATE_SCHEMA + 1, + "default_integration": "claude", + "installed_integrations": ["claude"], + "integration_settings": {}, + } + ), + encoding="utf-8", + ) + + definition = WorkflowDefinition.from_string(""" +schema_version: "1.0" +workflow: + id: "auto-future-schema" + name: "Auto Future Schema" + version: "1.0.0" +inputs: + integration: + type: string + default: "auto" +""") + engine = WorkflowEngine(project_dir) + resolved = engine._resolve_inputs(definition, {}) + assert resolved["integration"] == "auto" + + def test_default_value_is_validated_against_enum(self, project_dir): + """Defaults must run through the same coercion/enum check as provided inputs.""" + from specify_cli.workflows.engine import WorkflowEngine, WorkflowDefinition + + definition = WorkflowDefinition.from_string(""" +schema_version: "1.0" +workflow: + id: "default-enum" + name: "Default Enum" + version: "1.0.0" +inputs: + scope: + type: string + default: "not-in-enum" + enum: ["full", "backend-only", "frontend-only"] +""") + engine = WorkflowEngine(project_dir) + with pytest.raises(ValueError, match="not in allowed values"): + engine._resolve_inputs(definition, {}) + + def test_default_value_is_coerced_to_declared_type(self, project_dir): + """A numeric default declared as a string should still be coerced like a provided input.""" + from specify_cli.workflows.engine import WorkflowEngine, WorkflowDefinition + + definition = WorkflowDefinition.from_string(""" +schema_version: "1.0" +workflow: + id: "default-coerce" + name: "Default Coerce" + version: "1.0.0" +inputs: + retries: + type: number + default: "3" +""") + engine = WorkflowEngine(project_dir) + resolved = engine._resolve_inputs(definition, {}) + assert resolved["retries"] == 3 + assert isinstance(resolved["retries"], int) + + def test_validate_workflow_rejects_invalid_default(self): + """Authoring-time validation should reject defaults that violate enum.""" + from specify_cli.workflows.engine import WorkflowDefinition, validate_workflow + + definition = WorkflowDefinition.from_string(""" +schema_version: "1.0" +workflow: + id: "bad-default" + name: "Bad Default" + version: "1.0.0" +inputs: + scope: + type: string + default: "not-in-enum" + enum: ["full", "backend-only", "frontend-only"] +steps: + - id: noop + type: gate + message: "noop" + options: [approve] +""") + errors = validate_workflow(definition) + assert any("invalid default" in e for e in errors), errors + + def test_validate_workflow_exempts_integration_auto_sentinel(self): + """``integration: auto`` is a runtime-resolved sentinel and must not fail validation.""" + from specify_cli.workflows.engine import WorkflowDefinition, validate_workflow + + definition = WorkflowDefinition.from_string(""" +schema_version: "1.0" +workflow: + id: "auto-ok" + name: "Auto OK" + version: "1.0.0" +inputs: + integration: + type: string + default: "auto" + enum: ["copilot", "claude", "gemini"] +steps: + - id: noop + type: gate + message: "noop" + options: [approve] +""") + errors = validate_workflow(definition) + assert not any("invalid default" in e for e in errors), errors + + def test_validate_workflow_still_checks_type_for_auto_sentinel(self): + """The ``auto`` exemption only skips enum-membership; declared type is still enforced.""" + from specify_cli.workflows.engine import WorkflowDefinition, validate_workflow + + definition = WorkflowDefinition.from_string(""" +schema_version: "1.0" +workflow: + id: "auto-bad-type" + name: "Auto Bad Type" + version: "1.0.0" +inputs: + integration: + type: number + default: "auto" +steps: + - id: noop + type: gate + message: "noop" + options: [approve] +""") + errors = validate_workflow(definition) + assert any("invalid default" in e for e in errors), errors + # ===== State Persistence Tests ===== diff --git a/workflows/speckit/workflow.yml b/workflows/speckit/workflow.yml index bf18451029..4acf5a915d 100644 --- a/workflows/speckit/workflow.yml +++ b/workflows/speckit/workflow.yml @@ -7,9 +7,22 @@ workflow: description: "Runs specify → plan → tasks → implement with review gates" requires: - speckit_version: ">=0.7.2" + # 0.8.3 is the first release with engine-side resolution of the + # ``integration: "auto"`` default. Older versions would treat "auto" + # as a literal integration key and fail at dispatch. + speckit_version: ">=0.8.5" integrations: - any: ["copilot", "claude", "gemini"] + # The four commands below (specify, plan, tasks, implement) are core + # spec-kit commands provided by every integration. The list here is an + # explicit non-exhaustive compatibility hint following the documented + # ``any: [...]`` schema; the workflow is intended to run against any + # integration the project was initialized with, including ones not + # listed below. + any: + - "claude" + - "copilot" + - "gemini" + - "opencode" inputs: spec: @@ -18,8 +31,8 @@ inputs: prompt: "Describe what you want to build" integration: type: string - default: "copilot" - prompt: "Integration to use (e.g. claude, copilot, gemini)" + default: "auto" + prompt: "Integration to use (e.g. claude, copilot, gemini; 'auto' uses the project's initialized integration)" scope: type: string default: "full"