container-superposition 0.1.3 → 0.1.5

package/overlays/opencode/README.md

@@ -0,0 +1,76 @@
+# opencode Overlay
+
+Adds the `opencode` AI coding agent for terminal-based development assistance.
+
+## Features
+
+- **opencode CLI** — Multi-provider AI coding agent for the terminal
+- **Provider flexibility** — Supports multiple AI providers (OpenAI, Anthropic, Google, and more)
+
+## What is opencode?
+
+opencode is an open-source, terminal-based AI coding agent that supports multiple AI providers:
+
+- **Multi-provider** — Choose from OpenAI, Anthropic, Google Gemini, and other providers
+- **Code generation** — Generate new code from natural language descriptions
+- **Codebase context** — Understands your project structure
+- **Agentic tasks** — Execute multi-step coding tasks autonomously
+
+## How It Works
+
+This overlay installs `opencode-ai` globally via npm, making the `opencode` command available in your devcontainer.
+
+## Common Commands
+
+```bash
+# Start an interactive session
+opencode
+
+# Check version
+opencode --version
+```
+
+## Use Cases
+
+- **Flexible AI assistant** — Switch between AI providers as needed
+- **Open-source first** — Works with self-hosted models via compatible APIs
+- **Spec-Driven Development** — Works with `spec-kit` overlay via `specify init --ai opencode`
+
+**Integrates well with:**
+
+- `spec-kit` — Use opencode with the SDD workflow
+- `nodejs` — Required for installation
+- `git-helpers` — Git integration for AI-generated code
+
+## Configuration
+
+Configure your AI provider API key:
+
+```bash
+# For OpenAI
+export OPENAI_API_KEY=your-key
+
+# For Anthropic
+export ANTHROPIC_API_KEY=your-key
+
+# For Google Gemini
+export GEMINI_API_KEY=your-key
+```
+
+## Verification
+
+```bash
+bash .devcontainer/scripts/verify-opencode.sh
+```
+
+## References
+
+- [opencode Website](https://opencode.ai)
+- [opencode GitHub](https://github.com/sst/opencode)
+
+**Related Overlays:**
+
+- `spec-kit` — Spec-Driven Development with opencode as the AI agent
+- `codex` — OpenAI Codex CLI (alternative AI assistant)
+- `claude-code` — Anthropic Claude Code (alternative AI assistant)
+- `nodejs` — Required for npm-based installation

package/overlays/opencode/devcontainer.patch.json

@@ -0,0 +1,3 @@
+{
+    "$schema": "https://raw.githubusercontent.com/devcontainers/spec/main/schemas/devContainer.base.schema.json"
+}

package/overlays/opencode/overlay.yml

@@ -0,0 +1,14 @@
+id: opencode
+name: opencode
+description: opencode AI coding agent for terminal-based development assistance
+category: dev
+supports: []
+requires:
+    - nodejs
+suggests: []
+conflicts: []
+tags:
+    - dev
+    - ai
+    - opencode
+ports: []

package/overlays/opencode/setup.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+# opencode setup script - Install opencode AI coding agent
+
+set -e
+
+echo "📦 Installing opencode AI coding agent..."
+
+# Install opencode-ai globally
+npm install -g opencode-ai
+
+# Verify installation
+if command -v opencode &>/dev/null; then
+    echo "✓ opencode installed successfully: $(opencode --version 2>/dev/null || echo 'installed')"
+else
+    echo "✗ opencode installation failed"
+    exit 1
+fi
+
+echo "✓ opencode setup complete"
+echo "ℹ️  opencode: https://opencode.ai"
+echo "ℹ️  Run 'opencode --help' to get started"

package/overlays/opencode/verify.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+# opencode overlay verification script
+
+set -e
+
+echo "🔍 Verifying opencode overlay setup..."
+
+# Check if opencode is installed
+if ! command -v opencode &>/dev/null; then
+    echo "✗ opencode is not installed or not in PATH"
+    exit 1
+fi
+
+echo "✓ opencode is installed: $(opencode --version 2>/dev/null || echo 'installed')"
+
+echo ""
+echo "✅ opencode overlay verification complete!"
+echo ""
+echo "💡 Tips:"
+echo "  - Run 'opencode --help' to see available commands"
+echo "  - Configure your AI provider API key"

package/overlays/python/README.md

@@ -5,67 +5,84 @@ Adds Python 3.12 with development tools, linting, and formatting.
 ## Features
 
 - **Python 3.12** with pip, setuptools, and wheel
+- **Virtual environment** (`.venv`) created automatically in the workspace root
 - **VS Code Extensions:**
     - Python (ms-python.python)
     - Pylance (ms-python.vscode-pylance)
     - Black Formatter (ms-python.black-formatter)
     - Ruff (charliermarsh.ruff)
-- **Automatic dependency installation** from:
-    - `requirements.txt`
-    - `requirements-dev.txt`
+- **Automatic dependency installation** into `.venv` from:
+    - `requirements.txt` (project production dependencies)
+    - `requirements-dev.txt` (project development dependencies)
     - `pyproject.toml` (editable install)
     - `setup.py` (legacy support)
 - **Pre-configured settings:**
+    - VS Code interpreter pointed at `.venv/bin/python`
     - Black as default formatter
     - Format on save enabled
     - Auto-organize imports
-    - PYTHONPATH set to workspace root
+    - `PYTHONPATH`, `VIRTUAL_ENV`, and `PATH` set for the venv
+- **`.gitignore`** — `.venv/`, `__pycache__/`, `*.pyc`, `.pytest_cache/`, and build artefacts added to the project root `.gitignore` automatically
 
-## Virtual Environment Philosophy
+## Virtual Environment
 
-This overlay uses **user-level pip installations** (`pip install --user`) instead of virtual environments inside the container for these reasons:
+This overlay automatically creates a `.venv` virtual environment in the workspace root on container creation and installs all dependencies into it.
 
-### Why Not venv in Container?
+### Why venv?
 
-1. **Container IS the environment** - The devcontainer already provides isolation
-2. **Simpler workflow** - No need to activate/deactivate venv
-3. **Better VS Code integration** - Python extension finds packages automatically
-4. **Fewer moving parts** - Less to go wrong
+1. **Clean isolation** — Dependencies are scoped to the project, not the system Python
+2. **Production parity** — Matches how the app runs in CI/CD and production
+3. **Tool compatibility** — Works seamlessly with pytest, mypy, ruff, and other dev tools
+4. **VS Code integration** — The Python extension is pre-configured to use `.venv/bin/python`
 
-### When to Use venv
+### How It Works
 
-Use a virtual environment if you need:
+On container creation, the setup script:
 
-- Multiple Python versions in the same container
-- Strict dependency isolation for testing
-- Exact production parity (though containers already provide this)
+1. Creates `.venv` at `${workspaceFolder}/.venv` using `python -m venv`
+2. Upgrades `pip`, `setuptools`, and `wheel` inside the venv
+3. Installs overlay default packages from `.devcontainer/requirements-overlay-python.txt`
+4. Installs project dependencies from `requirements.txt` (if present)
+5. Installs dev dependencies from `requirements-dev.txt` (if present)
+6. Installs project in editable mode if `pyproject.toml` or `setup.py` is present
 
-To create a venv manually:
+### Activating the Virtual Environment
+
+The `.venv/bin` directory is prepended to `PATH` automatically in the devcontainer, so tools like `python`, `pip`, `pytest`, and `ruff` resolve to the venv by default. You can also activate explicitly:
 
 ```bash
-python -m venv .venv
 source .venv/bin/activate
-pip install -r requirements.txt
 ```
 
-Then update VS Code settings:
+### Gitignore
 
-```json
-{
-    "python.defaultInterpreterPath": "${workspaceFolder}/.venv/bin/python"
-}
+When the Python overlay is selected, the composer automatically adds Python-specific entries to the **project root** `.gitignore` (creating the file if it doesn’t exist, and never duplicating existing entries):
+
+```gitignore
+# python (container-superposition)
+.venv/
+__pycache__/
+*.pyc
+*.pyo
+.pytest_cache/
+*.egg-info/
+dist/
+build/
 ```
 
+This happens at generation time — no container startup required.
+
 ## Automatic Setup
 
 The overlay automatically runs on container creation:
 
-1. ✅ Installs overlay packages from `.devcontainer/requirements-overlay.txt`
-2. ✅ Checks for `requirements.txt` → installs with pip
-3. ✅ Checks for `requirements-dev.txt` → installs dev dependencies
-4. ✅ Checks for `pyproject.toml` → installs project in editable mode
-5. ✅ Checks for `setup.py` → installs legacy projects
-6. ✅ Upgrades pip, setuptools, and wheel to latest
+1. ✅ Creates `.venv` virtual environment in the workspace root
+2. ✅ Upgrades pip, setuptools, and wheel inside the venv
+3. ✅ Installs overlay packages from `.devcontainer/requirements-overlay-python.txt`
+4. ✅ Checks for `requirements.txt` → installs into venv
+5. ✅ Checks for `requirements-dev.txt` → installs dev dependencies into venv
+6. ✅ Checks for `pyproject.toml` → installs project in editable mode
+7. ✅ Checks for `setup.py` → installs legacy projects in editable mode
 
 ## Customizing Overlay Packages
 
@@ -176,7 +193,7 @@ mytool = "mytool.cli:main"
 1. **Pin versions** in requirements.txt for reproducibility
 2. **Separate dev dependencies** in requirements-dev.txt
 3. **Use pyproject.toml** for modern Python projects
-4. **Add `.gitignore`** for `__pycache__`, `.pytest_cache`, etc.
+4. **Add `.gitignore`** — handled automatically by the overlay
 
 ## Troubleshooting
 
@@ -200,17 +217,16 @@ Update `devcontainer.patch.json`:
 }
 ```
 
-### Want to use venv anyway?
+### Customizing the Interpreter Path
 
-Add to your project's `.devcontainer/devcontainer.json`:
+The overlay pre-configures VS Code to use `${workspaceFolder}/.venv/bin/python`. If your venv is elsewhere, update `python.defaultInterpreterPath` in your workspace settings or `.devcontainer/custom/devcontainer.patch.json`:
 
 ```json
 {
-    "postCreateCommand": "python -m venv .venv && .venv/bin/pip install -r requirements.txt",
     "customizations": {
         "vscode": {
             "settings": {
-                "python.defaultInterpreterPath": "${workspaceFolder}/.venv/bin/python"
+                "python.defaultInterpreterPath": "${workspaceFolder}/my-custom-venv/bin/python"
             }
         }
     }

package/overlays/python/devcontainer.patch.json

@@ -26,16 +26,19 @@
                         "source.organizeImports": "explicit"
                     }
                 },
-                "python.defaultInterpreterPath": "/usr/local/bin/python",
+                "python.defaultInterpreterPath": "${workspaceFolder}/.venv/bin/python",
+                "python.terminal.activateEnvironment": true,
                 "files.exclude": {
                     "**/__pycache__": true,
-                    "**/.pytest_cache": true
+                    "**/.pytest_cache": true,
+                    "**/.venv": true
                 }
             }
         }
     },
     "remoteEnv": {
-        "PATH": "${containerEnv:HOME}/.local/bin:${containerEnv:PATH}",
-        "PYTHONPATH": "${containerWorkspaceFolder}"
+        "PATH": "${containerWorkspaceFolder}/.venv/bin:${containerEnv:HOME}/.local/bin:${containerEnv:PATH}",
+        "PYTHONPATH": "${containerWorkspaceFolder}",
+        "VIRTUAL_ENV": "${containerWorkspaceFolder}/.venv"
     }
 }

package/overlays/python/setup.sh

@@ -1,47 +1,74 @@
 #!/bin/bash
-# Python setup script - Install Python packages
+# Python setup script - Create virtual environment and install dependencies
 
 set -e
 
 # Extract overlay name from script filename (setup-<overlay>.sh -> <overlay>)
 OVERLAY_NAME=$(basename "$0" | sed 's/setup-//;s/\.sh$//')
 
-echo "🐍 Setting up Python environment..."
+echo "🐍 Setting up Python virtual environment..."
+
+# Determine workspace root (script is run from workspace root via postCreateCommand)
+WORKSPACE_ROOT="${PWD}"
+VENV_DIR="${WORKSPACE_ROOT}/.venv"
+
+# Create virtual environment if it doesn't exist
+if [ ! -d "${VENV_DIR}" ]; then
+    echo "📦 Creating virtual environment at .venv..."
+    if ! command -v python3 >/dev/null 2>&1; then
+        echo "❌ python3 is not available on PATH. Please ensure python3 is installed."
+        exit 1
+    fi
+    python3 -m venv "${VENV_DIR}"
+    echo "✓ Virtual environment created"
+else
+    echo "✓ Virtual environment already exists at .venv"
+fi
+
+# Activate virtual environment
+# shellcheck source=/dev/null
+source "${VENV_DIR}/bin/activate"
+
+# Upgrade pip, setuptools, and wheel inside the venv
+echo "⬆️  Upgrading pip, setuptools, and wheel..."
+pip install --upgrade pip setuptools wheel
+echo "✓ pip, setuptools, and wheel upgraded"
 
 # Install overlay-specific packages (if requirements-overlay.txt exists)
 if [ -f ".devcontainer/requirements-overlay-${OVERLAY_NAME}.txt" ]; then
     echo "📦 Installing overlay packages from requirements-overlay-${OVERLAY_NAME}.txt..."
-    pip install --user -r .devcontainer/requirements-overlay-${OVERLAY_NAME}.txt
+    pip install -r ".devcontainer/requirements-overlay-${OVERLAY_NAME}.txt"
     echo "✓ Overlay packages installed"
 fi
 
-# Check if requirements.txt exists (project dependencies)
+# Install from root requirements.txt (project production dependencies)
 if [ -f "requirements.txt" ]; then
-    echo "📦 Found requirements.txt, installing dependencies..."
-    pip install --user -r requirements.txt
+    echo "📦 Installing dependencies from requirements.txt..."
+    pip install -r requirements.txt
     echo "✓ Dependencies installed from requirements.txt"
-elif [ -f "requirements-dev.txt" ]; then
-    echo "📦 Found requirements-dev.txt, installing dev dependencies..."
-    pip install --user -r requirements-dev.txt
+fi
+
+# Install from requirements-dev.txt (project development dependencies)
+if [ -f "requirements-dev.txt" ]; then
+    echo "📦 Installing dev dependencies from requirements-dev.txt..."
+    pip install -r requirements-dev.txt
     echo "✓ Dev dependencies installed from requirements-dev.txt"
 fi
 
-# Check if pyproject.toml exists (modern Python projects)
+# Install project in editable mode if pyproject.toml exists (modern Python projects)
 if [ -f "pyproject.toml" ]; then
-    echo "📦 Found pyproject.toml, installing project..."
-    pip install --user -e .
+    echo "📦 Found pyproject.toml, installing project in editable mode..."
+    pip install -e .
     echo "✓ Project installed in editable mode"
-fi
-
-# Check if setup.py exists (legacy Python projects)
-if [ -f "setup.py" ] && [ ! -f "pyproject.toml" ]; then
-    echo "📦 Found setup.py, installing project..."
-    pip install --user -e .
+elif [ -f "setup.py" ]; then
+    # Fallback for legacy Python projects
+    echo "📦 Found setup.py, installing project in editable mode..."
+    pip install -e .
     echo "✓ Project installed in editable mode"
 fi
 
-# Upgrade pip, setuptools, and wheel
-echo "⬆️  Upgrading pip, setuptools, and wheel..."
-pip install --user --upgrade pip setuptools wheel
-
-echo "✓ Python setup complete"
+echo ""
+echo "✓ Python virtual environment setup complete"
+echo "  Virtual environment: ${VENV_DIR}"
+echo "  Python interpreter: ${VENV_DIR}/bin/python"
+echo "  Activate manually:  source .venv/bin/activate"

package/overlays/python/verify.sh

@@ -1,6 +1,6 @@
 #!/bin/bash
 # Verification script for Python overlay
-# Confirms Python and pip are installed
+# Confirms Python, pip, and virtual environment are installed and functional
 
 set -e
 
@@ -28,5 +28,33 @@ else
     exit 1
 fi
 
+# Check venv module is available
+echo ""
+echo "3️⃣ Checking venv module..."
+if python3 -m venv --help &> /dev/null; then
+    echo "   ✅ venv module available"
+else
+    echo "   ❌ venv module not available"
+    exit 1
+fi
+
+# Check virtual environment was created (only if we are inside a devcontainer)
+echo ""
+echo "4️⃣ Checking virtual environment..."
+VENV_DIR="${PWD}/.venv"
+if [ -d "${VENV_DIR}" ]; then
+    if [ -f "${VENV_DIR}/bin/python" ]; then
+        VENV_PYTHON_VERSION=$("${VENV_DIR}/bin/python" --version 2>&1)
+        echo "   Virtual environment: ${VENV_DIR}"
+        echo "   Python version: ${VENV_PYTHON_VERSION}"
+        echo "   ✅ Virtual environment is functional"
+    else
+        echo "   ⚠️  Virtual environment directory exists but python not found"
+        echo "   ℹ️  Run setup script to create it: bash .devcontainer/scripts/setup-python.sh"
+    fi
+else
+    echo "   ℹ️  No .venv found — will be created on container start by setup-python.sh"
+fi
+
 echo ""
 echo "✅ Python overlay verification complete"

package/overlays/spec-kit/README.md

@@ -0,0 +1,181 @@
+# Spec Kit (SDD) Overlay
+
+Installs the `specify` CLI and its prerequisites (`uv`) for **Spec-Driven Development** — a disciplined workflow that elevates specifications to first-class artifacts driving AI-powered implementation.
+
+## Features
+
+- **`specify` CLI** — Interactive SDD workflow commands for any supported AI coding agent
+- **`uv`** — Fast Python package manager used to install and run `specify`
+- **20+ AI agent integrations** — Works with Codex, Claude Code, Gemini CLI, GitHub Copilot, Cursor, Windsurf, Amp, and more
+
+## What is Spec-Driven Development?
+
+Spec-Driven Development (SDD) flips the traditional workflow: instead of vibe-coding, you author rich specifications that become executable artifacts driving AI agents through a disciplined multi-step process:
+
+| Step | Command                 | Description                               |
+| ---- | ----------------------- | ----------------------------------------- |
+| 1    | `/speckit.constitution` | Create project governing principles       |
+| 2    | `/speckit.specify`      | Define requirements (what & why, not how) |
+| 3    | `/speckit.clarify`      | Clarify underspecified areas              |
+| 4    | `/speckit.plan`         | Create a technical implementation plan    |
+| 5    | `/speckit.analyze`      | Cross-artifact consistency analysis       |
+| 6    | `/speckit.tasks`        | Break plan into actionable tasks          |
+| 7    | `/speckit.implement`    | Execute tasks with an AI agent            |
+
+## How It Works
+
+This overlay:
+
+1. Installs `uv` (Astral's fast Python package manager) if not already present
+2. Uses `uv tool install` to install `specify-cli` from the [github/spec-kit](https://github.com/github/spec-kit) repository
+3. Makes `specify` available on the PATH inside the devcontainer
+
+**Why `uv`?** Spec Kit uses `uv` as its package manager for fast, isolated tool installation — it avoids the overhead of creating a full virtual environment while keeping `specify` globally accessible.
+
+## Common Commands
+
+### Initialize a project
+
+```bash
+# Initialize SDD for a project with a specific AI agent
+specify init . --here --ai codex
+specify init . --here --ai claude
+specify init . --here --ai gemini
+specify init . --here --ai copilot
+specify init . --here --ai amp
+```
+
+### SDD Workflow
+
+```bash
+# After initializing, use the installed slash commands in your AI agent:
+# /speckit.constitution  — Define project principles
+# /speckit.specify       — Author requirements spec
+# /speckit.clarify       — Clarify ambiguities
+# /speckit.plan          — Generate implementation plan
+# /speckit.analyze       — Check consistency
+# /speckit.tasks         — Break into tasks
+# /speckit.implement     — Implement with AI
+```
+
+### Utility Commands
+
+```bash
+# Check specify is available
+specify --version
+
+# List supported agents
+specify --help
+```
+
+## Supported AI Agents
+
+The `specify` CLI supports the following agents (pass as `--ai <agent>`):
+
+| Agent                 | `--ai` flag    | Notes                                   |
+| --------------------- | -------------- | --------------------------------------- |
+| OpenAI Codex          | `codex`        | Requires `codex` overlay                |
+| Anthropic Claude Code | `claude`       | Requires `claude-code` overlay          |
+| Google Gemini CLI     | `gemini`       | Requires `gemini-cli` overlay           |
+| GitHub Copilot        | `copilot`      | IDE-integrated, no extra overlay needed |
+| Cursor Agent          | `cursor-agent` | IDE-integrated                          |
+| Codeium Windsurf      | `windsurf`     | Requires `windsurf-cli` overlay         |
+| Sourcegraph Amp       | `amp`          | Requires `amp` overlay                  |
+| opencode              | `opencode`     | Requires `opencode` overlay             |
+| Roo Code              | `roo-code`     | IDE-integrated                          |
+| Kiro CLI              | `kiro`         | Check upstream docs                     |
+| Generic (BYOA)        | `generic`      | Bring your own agent                    |
+
+For the full list see the [spec-kit supported agents documentation](https://github.com/github/spec-kit#-supported-ai-agents).
+
+## Use Cases
+
+- **Greenfield projects** — Start with a specification before writing any code
+- **Feature development** — Spec out new features before asking AI to implement them
+- **Team alignment** — Share specifications as structured artifacts
+- **AI-assisted refactoring** — Spec the desired end state, let AI plan the migration
+- **Documentation-driven development** — Specifications become living documentation
+
+**Integrates well with:**
+
+- `codex` — OpenAI Codex CLI (most common with SDD)
+- `claude-code` — Anthropic Claude Code
+- `gemini-cli` — Google Gemini CLI
+- `amp` — Sourcegraph Amp
+- `git-helpers` — Git integration for specification artifacts
+- `pre-commit` — Quality gates for specification files
+
+## Configuration
+
+The `specify` tool stores its slash-command templates in your project directory after running `specify init`. These files are committed to your repository.
+
+**Environment variable (optional):**
+
+```bash
+# Set a default AI agent to avoid passing --ai on every command
+export SPECIFY_AI_AGENT=codex
+```
+
+## Verification
+
+After setup, run the verification script to ensure proper installation:
+
+```bash
+bash .devcontainer/scripts/verify-spec-kit.sh
+```
+
+This checks:
+
+- `uv` is installed
+- `specify` CLI is available on PATH
+
+## Troubleshooting
+
+### `specify` command not found
+
+**Solution:**
+
+Ensure `$HOME/.local/bin` is on your PATH:
+
+```bash
+export PATH="$HOME/.local/bin:$PATH"
+
+# Or add to your shell profile:
+echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
+```
+
+### `uv` not found
+
+**Solution:**
+
+```bash
+curl -LsSf https://astral.sh/uv/install.sh | sh
+export PATH="$HOME/.local/bin:$PATH"
+```
+
+### `specify` fails to install
+
+**Solution:**
+
+Check internet connectivity and try reinstalling:
+
+```bash
+uv tool install specify-cli --from git+https://github.com/github/spec-kit.git --force
+```
+
+## References
+
+- [Spec Kit GitHub](https://github.com/github/spec-kit)
+- [Spec-Driven Development Methodology](https://github.com/github/spec-kit/blob/main/spec-driven.md)
+- [Specify CLI Reference](https://github.com/github/spec-kit#-specify-cli-reference)
+- [Supported AI Agents](https://github.com/github/spec-kit#-supported-ai-agents)
+- [uv Documentation](https://docs.astral.sh/uv/)
+
+**Related Overlays:**
+
+- `codex` — OpenAI Codex CLI
+- `claude-code` — Anthropic Claude Code
+- `gemini-cli` — Google Gemini CLI
+- `amp` — Sourcegraph Amp
+- `opencode` — opencode CLI
+- `windsurf-cli` — Codeium Windsurf CLI

package/overlays/spec-kit/devcontainer.patch.json

@@ -0,0 +1,6 @@
+{
+    "$schema": "https://raw.githubusercontent.com/devcontainers/spec/main/schemas/devContainer.base.schema.json",
+    "remoteEnv": {
+        "PATH": "${containerEnv:PATH}:${containerEnv:HOME}/.local/bin"
+    }
+}

package/overlays/spec-kit/overlay.yml

@@ -0,0 +1,19 @@
+id: spec-kit
+name: Spec Kit (SDD)
+description: Specify CLI for Spec-Driven Development with any AI coding agent
+category: dev
+supports: []
+requires: []
+suggests:
+    - python
+    - codex
+conflicts: []
+tags:
+    - dev
+    - ai
+    - sdd
+    - spec-driven
+    - specify
+    - spec-kit
+ports: []
+order: 20