Skip to content

πŸ’« Toolkit to help you get started with SDD or any other process!

Stage 4: TOML integrations β€” gemini and tabnine migrated to plugin architecture (#2050)

Manfred Riem682ffbfc0d0a
diff --git a/src/specify_cli/integrations/__init__.py b/src/specify_cli/integrations/__init__.py
index 0d7a71242..ed131103c 100644
--- a/src/specify_cli/integrations/__init__.py
+++ b/src/specify_cli/integrations/__init__.py
@@ -53,6 +53,7 @@ def _register_builtins() -> None:
from .codebuddy import CodebuddyIntegration
from .copilot import CopilotIntegration
from .cursor_agent import CursorAgentIntegration
+ from .gemini import GeminiIntegration
from .iflow import IflowIntegration
from .junie import JunieIntegration
from .kilocode import KilocodeIntegration
@@ -63,6 +64,7 @@ def _register_builtins() -> None:
from .qwen import QwenIntegration
from .roo import RooIntegration
from .shai import ShaiIntegration
+ from .tabnine import TabnineIntegration
from .trae import TraeIntegration
from .vibe import VibeIntegration
from .windsurf import WindsurfIntegration
@@ -75,6 +77,7 @@ def _register_builtins() -> None:
_register(CodebuddyIntegration())
_register(CopilotIntegration())
_register(CursorAgentIntegration())
+ _register(GeminiIntegration())
_register(IflowIntegration())
_register(JunieIntegration())
_register(KilocodeIntegration())
@@ -85,6 +88,7 @@ def _register_builtins() -> None:
_register(QwenIntegration())
_register(RooIntegration())
_register(ShaiIntegration())
+ _register(TabnineIntegration())
_register(TraeIntegration())
_register(VibeIntegration())
_register(WindsurfIntegration())
diff --git a/src/specify_cli/integrations/base.py b/src/specify_cli/integrations/base.py
index 0320d7f7a..a88039b9a 100644
--- a/src/specify_cli/integrations/base.py
+++ b/src/specify_cli/integrations/base.py
@@ -5,6 +5,8 @@ Provides:
- ``IntegrationBase`` β€” abstract base every integration must implement.
- ``MarkdownIntegration`` β€” concrete base for standard Markdown-format
integrations (the common case β€” subclass, set three class attrs, done).
+- ``TomlIntegration`` β€” concrete base for TOML-format integrations
+ (Gemini, Tabnine β€” subclass, set three class attrs, done).
"""
from __future__ import annotations
@@ -498,3 +500,136 @@ class MarkdownIntegration(IntegrationBase):
created.extend(self.install_scripts(project_root, manifest))
return created
+
+
+# ---------------------------------------------------------------------------
+# TomlIntegration β€” TOML-format agents (Gemini, Tabnine)
+# ---------------------------------------------------------------------------
+
+class TomlIntegration(IntegrationBase):
+ """Concrete base for integrations that use TOML command format.
+
+ Mirrors ``MarkdownIntegration`` closely: subclasses only need to set
+ ``key``, ``config``, ``registrar_config`` (and optionally
+ ``context_file``). Everything else is inherited.
+
+ ``setup()`` processes command templates through the same placeholder
+ pipeline as ``MarkdownIntegration``, then converts the result to
+ TOML format (``description`` key + ``prompt`` multiline string).
+ """
+
+ def command_filename(self, template_name: str) -> str:
+ """TOML commands use ``.toml`` extension."""
+ return f"speckit.{template_name}.toml"
+
+ @staticmethod
+ def _extract_description(content: str) -> str:
+ """Extract the ``description`` value from YAML frontmatter.
+
+ Scans lines between the first pair of ``---`` delimiters for a
+ top-level ``description:`` key. Returns the value (with
+ surrounding quotes stripped) or an empty string if not found.
+ """
+ in_frontmatter = False
+ for line in content.splitlines():
+ stripped = line.rstrip("\n\r")
+ if stripped == "---":
+ if not in_frontmatter:
+ in_frontmatter = True
+ continue
+ break # second ---
+ if in_frontmatter and stripped.startswith("description:"):
+ _, _, value = stripped.partition(":")
+ return value.strip().strip('"').strip("'")
+ return ""
+
+ @staticmethod
+ def _render_toml(description: str, body: str) -> str:
+ """Render a TOML command file from description and body.
+
+ Uses multiline basic strings (``\"\"\"``) with backslashes
+ escaped, matching the output of the release script. Falls back
+ to multiline literal strings (``'''``) if the body contains
+ ``\"\"\"``, then to an escaped basic string as a last resort.
+
+ The body is rstrip'd so the closing delimiter appears on the line
+ immediately after the last content line β€” matching the release
+ script's ``echo "$body"; echo '\"\"\"'`` pattern.
+ """
+ toml_lines: list[str] = []
+
+ if description:
+ desc = description.replace('"', '\\"')
+ toml_lines.append(f'description = "{desc}"')
+ toml_lines.append("")
+
+ body = body.rstrip("\n")
+
+ # Escape backslashes for basic multiline strings.
+ escaped = body.replace("\\", "\\\\")
+
+ if '"""' not in escaped:
+ toml_lines.append('prompt = """')
+ toml_lines.append(escaped)
+ toml_lines.append('"""')
+ elif "'''" not in body:
+ toml_lines.append("prompt = '''")
+ toml_lines.append(body)
+ toml_lines.append("'''")
+ else:
+ escaped_body = (
+ body.replace("\\", "\\\\")
+ .replace('"', '\\"')
+ .replace("\n", "\\n")
+ .replace("\r", "\\r")
+ .replace("\t", "\\t")
+ )
+ toml_lines.append(f'prompt = "{escaped_body}"')
+
+ return "\n".join(toml_lines) + "\n"
+
+ def setup(
+ self,
+ project_root: Path,
+ manifest: IntegrationManifest,
+ parsed_options: dict[str, Any] | None = None,
+ **opts: Any,
+ ) -> list[Path]:
+ templates = self.list_command_templates()
+ if not templates:
+ return []
+
+ project_root_resolved = project_root.resolve()
+ if manifest.project_root != project_root_resolved:
+ raise ValueError(
+ f"manifest.project_root ({manifest.project_root}) does not match "
+ f"project_root ({project_root_resolved})"
+ )
+
+ dest = self.commands_dest(project_root).resolve()
+ try:
+ dest.relative_to(project_root_resolved)
+ except ValueError as exc:
+ raise ValueError(
+ f"Integration destination {dest} escapes "
+ f"project root {project_root_resolved}"
+ ) from exc
+ dest.mkdir(parents=True, exist_ok=True)
+
+ script_type = opts.get("script_type", "sh")
+ arg_placeholder = self.registrar_config.get("args", "{{args}}") if self.registrar_config else "{{args}}"
+ created: list[Path] = []
+
+ for src_file in templates:
+ raw = src_file.read_text(encoding="utf-8")
+ description = self._extract_description(raw)
+ processed = self.process_template(raw, self.key, script_type, arg_placeholder)
+ toml_content = self._render_toml(description, processed)
+ dst_name = self.command_filename(src_file.stem)
+ dst_file = self.write_file_and_record(
+ toml_content, dest / dst_name, project_root, manifest
+ )
+ created.append(dst_file)
+
+ created.extend(self.install_scripts(project_root, manifest))
+ return created
diff --git a/src/specify_cli/integrations/gemini/__init__.py b/src/specify_cli/integrations/gemini/__init__.py
new file mode 100644
index 000000000..d66f0b80b
--- /dev/null
+++ b/src/specify_cli/integrations/gemini/__init__.py
@@ -0,0 +1,21 @@
+"""Gemini CLI integration."""
+
+from ..base import TomlIntegration
+
+
+class GeminiIntegration(TomlIntegration):
+ key = "gemini"
+ config = {
+ "name": "Gemini CLI",
+ "folder": ".gemini/",
+ "commands_subdir": "commands",
+ "install_url": "https://github.com/google-gemini/gemini-cli",
+ "requires_cli": True,
+ }
+ registrar_config = {
+ "dir": ".gemini/commands",
+ "format": "toml",
+ "args": "{{args}}",
+ "extension": ".toml",
+ }
+ context_file = "GEMINI.md"
diff --git a/src/specify_cli/integrations/gemini/scripts/update-context.ps1 b/src/specify_cli/integrations/gemini/scripts/update-context.ps1
new file mode 100644
index 000000000..51c9e0bc8
--- /dev/null
+++ b/src/specify_cli/integrations/gemini/scripts/update-context.ps1
@@ -0,0 +1,23 @@
+# update-context.ps1 β€” Gemini CLI integration: create/update GEMINI.md
+#
+# Thin wrapper that delegates to the shared update-agent-context script.
+# Activated in Stage 7 when the shared script uses integration.json dispatch.
+#
+# Until then, this delegates to the shared script as a subprocess.
+
+$ErrorActionPreference = 'Stop'
+
+# Derive repo root from script location (walks up to find .specify/)
+$scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Definition
+$repoRoot = try { git rev-parse --show-toplevel 2>$null } catch { $null }
+# If git did not return a repo root, or the git root does not contain .specify,
+# fall back to walking up from the script directory to find the initialized project root.
+if (-not $repoRoot -or -not (Test-Path (Join-Path $repoRoot '.specify'))) {
+ $repoRoot = $scriptDir
+ $fsRoot = [System.IO.Path]::GetPathRoot($repoRoot)
+ while ($repoRoot -and $repoRoot -ne $fsRoot -and -not (Test-Path (Join-Path $repoRoot '.specify'))) {
+ $repoRoot = Split-Path -Parent $repoRoot
+ }
+}
+
+& "$repoRoot/.specify/scripts/powershell/update-agent-context.ps1" -AgentType gemini
diff --git a/src/specify_cli/integrations/gemini/scripts/update-context.sh b/src/specify_cli/integrations/gemini/scripts/update-context.sh
new file mode 100644
index 000000000..c4e5003a5
--- /dev/null
+++ b/src/specify_cli/integrations/gemini/scripts/update-context.sh
@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+# update-context.sh β€” Gemini CLI integration: create/update GEMINI.md
+#
+# Thin wrapper that delegates to the shared update-agent-context script.
+# Activated in Stage 7 when the shared script uses integration.json dispatch.
+#
+# Until then, this delegates to the shared script as a subprocess.
+
+set -euo pipefail
+
+# Derive repo root from script location (walks up to find .specify/)
+_script_dir="$(cd "$(dirname "$0")" && pwd)"
+_root="$_script_dir"
+while [ "$_root" != "/" ] && [ ! -d "$_root/.specify" ]; do _root="$(dirname "$_root")"; done
+if [ -z "${REPO_ROOT:-}" ]; then
+ if [ -d "$_root/.specify" ]; then
+ REPO_ROOT="$_root"
+ else
+ git_root="$(git rev-parse --show-toplevel 2>/dev/null || true)"
+ if [ -n "$git_root" ] && [ -d "$git_root/.specify" ]; then
+ REPO_ROOT="$git_root"
+ else
+ REPO_ROOT="$_root"
+ fi
+ fi
+fi
+
+exec "$REPO_ROOT/.specify/scripts/bash/update-agent-context.sh" gemini
diff --git a/src/specify_cli/integrations/tabnine/__init__.py b/src/specify_cli/integrations/tabnine/__init__.py
new file mode 100644
index 000000000..2928a214a
--- /dev/null
+++ b/src/specify_cli/integrations/tabnine/__init__.py
@@ -0,0 +1,21 @@
+"""Tabnine CLI integration."""
+
+from ..base import TomlIntegration
+
+
+class TabnineIntegration(TomlIntegration):
+ key = "tabnine"
+ config = {
+ "name": "Tabnine CLI",
+ "folder": ".tabnine/agent/",
+ "commands_subdir": "commands",
+ "install_url": "https://docs.tabnine.com/main/getting-started/tabnine-cli",
+ "requires_cli": True,
+ }
+ registrar_config = {
+ "dir": ".tabnine/agent/commands",
+ "format": "toml",
+ "args": "{{args}}",
+ "extension": ".toml",
+ }
+ context_file = "TABNINE.md"
diff --git a/src/specify_cli/integrations/tabnine/scripts/update-context.ps1 b/src/specify_cli/integrations/tabnine/scripts/update-context.ps1
new file mode 100644
index 000000000..0ffb3a164
--- /dev/null
+++ b/src/specify_cli/integrations/tabnine/scripts/update-context.ps1
@@ -0,0 +1,23 @@
+# update-context.ps1 β€” Tabnine CLI integration: create/update TABNINE.md
+#
+# Thin wrapper that delegates to the shared update-agent-context script.
+# Activated in Stage 7 when the shared script uses integration.json dispatch.
+#
+# Until then, this delegates to the shared script as a subprocess.
+
+$ErrorActionPreference = 'Stop'
+
+# Derive repo root from script location (walks up to find .specify/)
+$scriptDir = Split-Path -Parent $MyInvocation.MyCommand.Definition
+$repoRoot = try { git rev-parse --show-toplevel 2>$null } catch { $null }
+# If git did not return a repo root, or the git root does not contain .specify,
+# fall back to walking up from the script directory to find the initialized project root.
+if (-not $repoRoot -or -not (Test-Path (Join-Path $repoRoot '.specify'))) {
+ $repoRoot = $scriptDir
+ $fsRoot = [System.IO.Path]::GetPathRoot($repoRoot)
+ while ($repoRoot -and $repoRoot -ne $fsRoot -and -not (Test-Path (Join-Path $repoRoot '.specify'))) {
+ $repoRoot = Split-Path -Parent $repoRoot
+ }
+}
+
+& "$repoRoot/.specify/scripts/powershell/update-agent-context.ps1" -AgentType tabnine
diff --git a/src/specify_cli/integrations/tabnine/scripts/update-context.sh b/src/specify_cli/integrations/tabnine/scripts/update-context.sh
new file mode 100644
index 000000000..fe5050b6e
--- /dev/null
+++ b/src/specify_cli/integrations/tabnine/scripts/update-context.sh
@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+# update-context.sh β€” Tabnine CLI integration: create/update TABNINE.md
+#
+# Thin wrapper that delegates to the shared update-agent-context script.
+# Activated in Stage 7 when the shared script uses integration.json dispatch.
+#
+# Until then, this delegates to the shared script as a subprocess.
+
+set -euo pipefail
+
+# Derive repo root from script location (walks up to find .specify/)
+_script_dir="$(cd "$(dirname "$0")" && pwd)"
+_root="$_script_dir"
+while [ "$_root" != "/" ] && [ ! -d "$_root/.specify" ]; do _root="$(dirname "$_root")"; done
+if [ -z "${REPO_ROOT:-}" ]; then
+ if [ -d "$_root/.specify" ]; then
+ REPO_ROOT="$_root"
+ else
+ git_root="$(git rev-parse --show-toplevel 2>/dev/null || true)"
+ if [ -n "$git_root" ] && [ -d "$git_root/.specify" ]; then
+ REPO_ROOT="$git_root"
+ else
+ REPO_ROOT="$_root"
+ fi
+ fi
+fi
+
+exec "$REPO_ROOT/.specify/scripts/bash/update-agent-context.sh" tabnine
diff --git a/tests/integrations/test_integration_base_toml.py b/tests/integrations/test_integration_base_toml.py
new file mode 100644
index 000000000..e7b506782
--- /dev/null
+++ b/tests/integrations/test_integration_base_toml.py
@@ -0,0 +1,346 @@
+"""Reusable test mixin for standard TomlIntegration subclasses.
+
+Each per-agent test file sets ``KEY``, ``FOLDER``, ``COMMANDS_SUBDIR``,
+``REGISTRAR_DIR``, and ``CONTEXT_FILE``, then inherits all verification
+logic from ``TomlIntegrationTests``.
+
+Mirrors ``MarkdownIntegrationTests`` closely β€” same test structure,
+adapted for TOML output format.
+"""
+
+import os
+
+from specify_cli.integrations import INTEGRATION_REGISTRY, get_integration
+from specify_cli.integrations.base import TomlIntegration
+from specify_cli.integrations.manifest import IntegrationManifest
+
+
+class TomlIntegrationTests:
+ """Mixin β€” set class-level constants and inherit these tests.
+
+ Required class attrs on subclass::
+
+ KEY: str β€” integration registry key
+ FOLDER: str β€” e.g. ".gemini/"
+ COMMANDS_SUBDIR: str β€” e.g. "commands"
+ REGISTRAR_DIR: str β€” e.g. ".gemini/commands"
+ CONTEXT_FILE: str β€” e.g. "GEMINI.md"
+ """
+
+ KEY: str
+ FOLDER: str
+ COMMANDS_SUBDIR: str
+ REGISTRAR_DIR: str
+ CONTEXT_FILE: str
+
+ # -- Registration -----------------------------------------------------
+
+ def test_registered(self):
+ assert self.KEY in INTEGRATION_REGISTRY
+ assert get_integration(self.KEY) is not None
+
+ def test_is_toml_integration(self):
+ assert isinstance(get_integration(self.KEY), TomlIntegration)
+
+ # -- Config -----------------------------------------------------------
+
+ def test_config_folder(self):
+ i = get_integration(self.KEY)
+ assert i.config["folder"] == self.FOLDER
+
+ def test_config_commands_subdir(self):
+ i = get_integration(self.KEY)
+ assert i.config["commands_subdir"] == self.COMMANDS_SUBDIR
+
+ def test_registrar_config(self):
+ i = get_integration(self.KEY)
+ assert i.registrar_config["dir"] == self.REGISTRAR_DIR
+ assert i.registrar_config["format"] == "toml"
+ assert i.registrar_config["args"] == "{{args}}"
+ assert i.registrar_config["extension"] == ".toml"
+
+ def test_context_file(self):
+ i = get_integration(self.KEY)
+ assert i.context_file == self.CONTEXT_FILE
+
+ # -- Setup / teardown -------------------------------------------------
+
+ def test_setup_creates_files(self, tmp_path):
+ i = get_integration(self.KEY)
+ m = IntegrationManifest(self.KEY, tmp_path)
+ created = i.setup(tmp_path, m)
+ assert len(created) > 0
+ cmd_files = [f for f in created if "scripts" not in f.parts]
+ for f in cmd_files:
+ assert f.exists()
+ assert f.name.startswith("speckit.")
+ assert f.name.endswith(".toml")
+
+ def test_setup_writes_to_correct_directory(self, tmp_path):
+ i = get_integration(self.KEY)
+ m = IntegrationManifest(self.KEY, tmp_path)
+ created = i.setup(tmp_path, m)
+ expected_dir = i.commands_dest(tmp_path)
+ assert expected_dir.exists(), f"Expected directory {expected_dir} was not created"
+ cmd_files = [f for f in created if "scripts" not in f.parts]
+ assert len(cmd_files) > 0, "No command files were created"
+ for f in cmd_files:
+ assert f.resolve().parent == expected_dir.resolve(), (
+ f"{f} is not under {expected_dir}"
+ )
+
+ def test_templates_are_processed(self, tmp_path):
+ """Command files must have placeholders replaced and be valid TOML."""
+ i = get_integration(self.KEY)
+ m = IntegrationManifest(self.KEY, tmp_path)
+ created = i.setup(tmp_path, m)
+ cmd_files = [f for f in created if "scripts" not in f.parts]
+ assert len(cmd_files) > 0
+ for f in cmd_files:
+ content = f.read_text(encoding="utf-8")
+ assert "{SCRIPT}" not in content, f"{f.name} has unprocessed {{SCRIPT}}"
+ assert "__AGENT__" not in content, f"{f.name} has unprocessed __AGENT__"
+ assert "{ARGS}" not in content, f"{f.name} has unprocessed {{ARGS}}"
+
+ def test_toml_has_description(self, tmp_path):
+ """Every TOML command file should have a description key."""
+ i = get_integration(self.KEY)
+ m = IntegrationManifest(self.KEY, tmp_path)
+ created = i.setup(tmp_path, m)
+ cmd_files = [f for f in created if "scripts" not in f.parts]
+ for f in cmd_files:
+ content = f.read_text(encoding="utf-8")
+ assert 'description = "' in content, f"{f.name} missing description key"
+
+ def test_toml_has_prompt(self, tmp_path):
+ """Every TOML command file should have a prompt key."""
+ i = get_integration(self.KEY)
+ m = IntegrationManifest(self.KEY, tmp_path)
+ created = i.setup(tmp_path, m)
+ cmd_files = [f for f in created if "scripts" not in f.parts]
+ for f in cmd_files:
+ content = f.read_text(encoding="utf-8")
+ assert "prompt = " in content, f"{f.name} missing prompt key"
+
+ def test_toml_uses_correct_arg_placeholder(self, tmp_path):
+ """TOML commands must use {{args}} (from {ARGS} replacement)."""
+ i = get_integration(self.KEY)
+ m = IntegrationManifest(self.KEY, tmp_path)
+ created = i.setup(tmp_path, m)
+ cmd_files = [f for f in created if "scripts" not in f.parts]
+ # At least one file should contain {{args}} from the {ARGS} placeholder
+ has_args = any("{{args}}" in f.read_text(encoding="utf-8") for f in cmd_files)
+ assert has_args, "No TOML command file contains {{args}} placeholder"
+
+ def test_toml_is_valid(self, tmp_path):
+ """Every generated TOML file must parse without errors."""
+ try:
+ import tomllib
+ except ModuleNotFoundError:
+ import tomli as tomllib # type: ignore[no-redef]
+
+ i = get_integration(self.KEY)
+ m = IntegrationManifest(self.KEY, tmp_path)
+ created = i.setup(tmp_path, m)
+ cmd_files = [f for f in created if "scripts" not in f.parts]
+ for f in cmd_files:
+ raw = f.read_bytes()
+ try:
+ parsed = tomllib.loads(raw.decode("utf-8"))
+ except Exception as exc:
+ raise AssertionError(f"{f.name} is not valid TOML: {exc}") from exc
+ assert "prompt" in parsed, f"{f.name} parsed TOML has no 'prompt' key"
+
+ def test_all_files_tracked_in_manifest(self, tmp_path):
+ i = get_integration(self.KEY)
+ m = IntegrationManifest(self.KEY, tmp_path)
+ created = i.setup(tmp_path, m)
+ for f in created:
+ rel = f.resolve().relative_to(tmp_path.resolve()).as_posix()
+ assert rel in m.files, f"{rel} not tracked in manifest"
+
+ def test_install_uninstall_roundtrip(self, tmp_path):
+ i = get_integration(self.KEY)
+ m = IntegrationManifest(self.KEY, tmp_path)
+ created = i.install(tmp_path, m)
+ assert len(created) > 0
+ m.save()
+ for f in created:
+ assert f.exists()
+ removed, skipped = i.uninstall(tmp_path, m)
+ assert len(removed) == len(created)
+ assert skipped == []
+
+ def test_modified_file_survives_uninstall(self, tmp_path):
+ i = get_integration(self.KEY)
+ m = IntegrationManifest(self.KEY, tmp_path)
+ created = i.install(tmp_path, m)
+ m.save()
+ modified_file = created[0]
+ modified_file.write_text("user modified this", encoding="utf-8")
+ removed, skipped = i.uninstall(tmp_path, m)
+ assert modified_file.exists()
+ assert modified_file in skipped
+
+ # -- Scripts ----------------------------------------------------------
+
+ def test_setup_installs_update_context_scripts(self, tmp_path):
+ i = get_integration(self.KEY)
+ m = IntegrationManifest(self.KEY, tmp_path)
+ created = i.setup(tmp_path, m)
+ scripts_dir = tmp_path / ".specify" / "integrations" / self.KEY / "scripts"
+ assert scripts_dir.is_dir(), f"Scripts directory not created for {self.KEY}"
+ assert (scripts_dir / "update-context.sh").exists()
+ assert (scripts_dir / "update-context.ps1").exists()
+
+ def test_scripts_tracked_in_manifest(self, tmp_path):
+ i = get_integration(self.KEY)
+ m = IntegrationManifest(self.KEY, tmp_path)
+ i.setup(tmp_path, m)
+ script_rels = [k for k in m.files if "update-context" in k]
+ assert len(script_rels) >= 2
+
+ def test_sh_script_is_executable(self, tmp_path):
+ i = get_integration(self.KEY)
+ m = IntegrationManifest(self.KEY, tmp_path)
+ i.setup(tmp_path, m)
+ sh = tmp_path / ".specify" / "integrations" / self.KEY / "scripts" / "update-context.sh"
+ assert os.access(sh, os.X_OK)
+
+ # -- CLI auto-promote -------------------------------------------------
+
+ def test_ai_flag_auto_promotes(self, tmp_path):
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ project = tmp_path / f"promote-{self.KEY}"
+ project.mkdir()
+ old_cwd = os.getcwd()
+ try:
+ os.chdir(project)
+ runner = CliRunner()
+ result = runner.invoke(app, [
+ "init", "--here", "--ai", self.KEY, "--script", "sh", "--no-git",
+ "--ignore-agent-tools",
+ ], catch_exceptions=False)
+ finally:
+ os.chdir(old_cwd)
+ assert result.exit_code == 0, f"init --ai {self.KEY} failed: {result.output}"
+ assert f"--integration {self.KEY}" in result.output
+
+ def test_integration_flag_creates_files(self, tmp_path):
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ project = tmp_path / f"int-{self.KEY}"
+ project.mkdir()
+ old_cwd = os.getcwd()
+ try:
+ os.chdir(project)
+ runner = CliRunner()
+ result = runner.invoke(app, [
+ "init", "--here", "--integration", self.KEY, "--script", "sh", "--no-git",
+ "--ignore-agent-tools",
+ ], catch_exceptions=False)
+ finally:
+ os.chdir(old_cwd)
+ assert result.exit_code == 0, f"init --integration {self.KEY} failed: {result.output}"
+ i = get_integration(self.KEY)
+ cmd_dir = i.commands_dest(project)
+ assert cmd_dir.is_dir(), f"Commands directory {cmd_dir} not created"
+ commands = sorted(cmd_dir.glob("speckit.*.toml"))
+ assert len(commands) > 0, f"No command files in {cmd_dir}"
+
+ # -- Complete file inventory ------------------------------------------
+
+ COMMAND_STEMS = [
+ "analyze", "checklist", "clarify", "constitution",
+ "implement", "plan", "specify", "tasks", "taskstoissues",
+ ]
+
+ def _expected_files(self, script_variant: str) -> list[str]:
+ """Build the expected file list for this integration + script variant."""
+ i = get_integration(self.KEY)
+ cmd_dir = i.registrar_config["dir"]
+ files = []
+
+ # Command files (.toml)
+ for stem in self.COMMAND_STEMS:
+ files.append(f"{cmd_dir}/speckit.{stem}.toml")
+
+ # Integration scripts
+ files.append(f".specify/integrations/{self.KEY}/scripts/update-context.ps1")
+ files.append(f".specify/integrations/{self.KEY}/scripts/update-context.sh")
+
+ # Framework files
+ files.append(f".specify/integration.json")
+ files.append(f".specify/init-options.json")
+ files.append(f".specify/integrations/{self.KEY}.manifest.json")
+ files.append(f".specify/integrations/speckit.manifest.json")
+
+ if script_variant == "sh":
+ for name in ["check-prerequisites.sh", "common.sh", "create-new-feature.sh",
+ "setup-plan.sh", "update-agent-context.sh"]:
+ files.append(f".specify/scripts/bash/{name}")
+ else:
+ for name in ["check-prerequisites.ps1", "common.ps1", "create-new-feature.ps1",
+ "setup-plan.ps1", "update-agent-context.ps1"]:
+ files.append(f".specify/scripts/powershell/{name}")
+
+ for name in ["agent-file-template.md", "checklist-template.md",
+ "constitution-template.md", "plan-template.md",
+ "spec-template.md", "tasks-template.md"]:
+ files.append(f".specify/templates/{name}")
+
+ files.append(".specify/memory/constitution.md")
+ return sorted(files)
+
+ def test_complete_file_inventory_sh(self, tmp_path):
+ """Every file produced by specify init --integration <key> --script sh."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ project = tmp_path / f"inventory-sh-{self.KEY}"
+ project.mkdir()
+ old_cwd = os.getcwd()
+ try:
+ os.chdir(project)
+ result = CliRunner().invoke(app, [
+ "init", "--here", "--integration", self.KEY, "--script", "sh",
+ "--no-git", "--ignore-agent-tools",
+ ], catch_exceptions=False)
+ finally:
+ os.chdir(old_cwd)
+ assert result.exit_code == 0, f"init failed: {result.output}"
+ actual = sorted(p.relative_to(project).as_posix()
+ for p in project.rglob("*") if p.is_file())
+ expected = self._expected_files("sh")
+ assert actual == expected, (
+ f"Missing: {sorted(set(expected) - set(actual))}\n"
+ f"Extra: {sorted(set(actual) - set(expected))}"
+ )
+
+ def test_complete_file_inventory_ps(self, tmp_path):
+ """Every file produced by specify init --integration <key> --script ps."""
+ from typer.testing import CliRunner
+ from specify_cli import app
+
+ project = tmp_path / f"inventory-ps-{self.KEY}"
+ project.mkdir()
+ old_cwd = os.getcwd()
+ try:
+ os.chdir(project)
+ result = CliRunner().invoke(app, [
+ "init", "--here", "--integration", self.KEY, "--script", "ps",
+ "--no-git", "--ignore-agent-tools",
+ ], catch_exceptions=False)
+ finally:
+ os.chdir(old_cwd)
+ assert result.exit_code == 0, f"init failed: {result.output}"
+ actual = sorted(p.relative_to(project).as_posix()
+ for p in project.rglob("*") if p.is_file())
+ expected = self._expected_files("ps")
+ assert actual == expected, (
+ f"Missing: {sorted(set(expected) - set(actual))}\n"
+ f"Extra: {sorted(set(actual) - set(expected))}"
+ )
diff --git a/tests/integrations/test_integration_gemini.py b/tests/integrations/test_integration_gemini.py
new file mode 100644
index 000000000..9be5985e2
--- /dev/null
+++ b/tests/integrations/test_integration_gemini.py
@@ -0,0 +1,11 @@
+"""Tests for GeminiIntegration."""
+
+from .test_integration_base_toml import TomlIntegrationTests
+
+
+class TestGeminiIntegration(TomlIntegrationTests):
+ KEY = "gemini"
+ FOLDER = ".gemini/"
+ COMMANDS_SUBDIR = "commands"
+ REGISTRAR_DIR = ".gemini/commands"
+ CONTEXT_FILE = "GEMINI.md"
diff --git a/tests/integrations/test_integration_tabnine.py b/tests/integrations/test_integration_tabnine.py
new file mode 100644
index 000000000..95eb47cc1
--- /dev/null
+++ b/tests/integrations/test_integration_tabnine.py
@@ -0,0 +1,11 @@
+"""Tests for TabnineIntegration."""
+
+from .test_integration_base_toml import TomlIntegrationTests
+
+
+class TestTabnineIntegration(TomlIntegrationTests):
+ KEY = "tabnine"
+ FOLDER = ".tabnine/agent/"
+ COMMANDS_SUBDIR = "commands"
+ REGISTRAR_DIR = ".tabnine/agent/commands"
+ CONTEXT_FILE = "TABNINE.md"