How long does the integration take?

Change one base URL in an OpenAI-compatible client, or install the Python or TypeScript SDK; the quickstart routes a first request in a few minutes.

Will this lock us into another vendor?

No. The router is Apache-2.0 open source, your provider keys stay yours, and the API is OpenAI-compatible, so leaving is a change of base URL.

What happens when a provider fails?

The router falls back to the next model your policy allows and records the fallback in the trace, so an outage costs a retry, not an incident.

sdd-migrate - Prompt - OpenSmartRoute

Name: sdd-migrate
Author: AdrianRogowski

Prompt file imported from AdrianRogowski/auto-sdd (.cursor/commands/sdd-migrate.md). Copyright stays with the author.

/sdd-migrate - Upgrade SDD to latest version

Upgrade an existing SDD project to the latest version from the staged template files.

If .sdd-upgrade/ doesn't exist yet, this command automatically runs git auto-upgrade to stage the files first.

Step 0: Check Prerequisites

Check for .specs/ directory
├── If exists → SDD project, continue
└── If missing → ERROR: "Not an SDD project. Use 'git auto' for fresh install"

Check for .sdd-upgrade/ directory
├── If exists → Continue to version check
└── If missing → Auto-stage by running: git auto-upgrade
    ├── If succeeds → Continue to version check
    └── If fails → ERROR: "Failed to stage upgrade files. Check your network connection and try 'git auto-upgrade' manually."

Version Check

Read CURRENT version from: VERSION or .specs/.sdd-version (or "1.0.0" if neither exists)
Read TARGET version from: .sdd-upgrade/VERSION (or "2.0.0" if missing)

Compare versions:
├── TARGET > CURRENT → Proceed with upgrade (label: UPGRADE)
├── TARGET = CURRENT → Proceed with re-sync (label: RE-SYNC)
└── TARGET < CURRENT → "Installed version is newer than template. Skipping."

Re-sync rationale: Even at the same version, files may have drifted (partial previous migration, manual edits, or template patches without a version bump). A re-sync ensures all stock files match the template.

Step 1: Inventory Commands and Rules

Do NOT use a hardcoded list of stock commands. Instead, determine stock vs custom dynamically:

List all .md files in .sdd-upgrade/.cursor/commands/ → these are the stock commands (the template's commands)
List all .md files in the project's .cursor/commands/ → these are the installed commands
Stock (to sync): any file that exists in .sdd-upgrade/.cursor/commands/
Custom (to preserve): any file in the project's .cursor/commands/ that does NOT exist in .sdd-upgrade/.cursor/commands/

Do the same for:

.cursor/rules/*.mdc vs .sdd-upgrade/.cursor/rules/*.mdc

.claude/commands/ is GENERATED from .cursor/commands/ by scripts/sync-commands.sh — do not inventory or merge it separately. It gets regenerated in Step 5.

Output inventory:

Command Inventory:
├── Stock commands to update: [count]
│   • spec-first.md, tdd.md, refactor.md, ... (all from staging)
├── New commands to add: [count]
│   • [commands in staging but not installed]
├── Custom commands to preserve: [count]
│   • [commands installed but not in staging]
└── Rules to update: [count]
    • specs-workflow.mdc, design-tokens.mdc, ...

Step 2: Create Missing Directories

Ensure these exist (create if missing, skip if present):

mkdir -p .specs/learnings
mkdir -p .specs/design-system/components
mkdir -p .specs/personas
mkdir -p logs

Step 3: Sync Learnings Templates

If .specs/learnings/index.md doesn't exist, copy learnings templates from staging:

cp -n .sdd-upgrade/.specs/learnings/*.md .specs/learnings/

Use -n (no-clobber) to avoid overwriting existing learnings files that may have content.

Step 4: Add YAML Frontmatter to Existing Specs

For each .specs/features/**/*.feature.md:

Check if it already starts with --- (has frontmatter) → skip
Extract feature name from first # heading
Extract domain from file path
Look for **Source File**: to extract source path
Prepend frontmatter:

---
feature: { extracted name }
domain: { from path }
source: { from Source File line or empty }
tests: []
components: []
design_refs: []
status: implemented
created: { today's date }
updated: { today's date }
---

Important: Do NOT modify any other content. Just prepend frontmatter to specs that lack it.

Step 5: Sync Stock Commands

For each .md file in .sdd-upgrade/.cursor/commands/:

cp .sdd-upgrade/.cursor/commands/{name}.md .cursor/commands/{name}.md

This replaces existing stock commands AND adds new ones.

Then regenerate .claude/commands/ from the canonical .cursor/commands/:

./scripts/sync-commands.sh

(If the project predates sync-commands.sh, it was just copied in with the other scripts in the previous step. The sync is safe for custom commands: a file that exists only in .claude/commands/ is adopted back into .cursor/commands/, never deleted.)

Do NOT touch files that only exist in the project's .cursor/commands/ (custom commands).

Step 6: Sync Stock Rules

For each .mdc file in .sdd-upgrade/.cursor/rules/:

cp .sdd-upgrade/.cursor/rules/{name}.mdc .cursor/rules/{name}.mdc

Do NOT touch custom rules.

Step 7: Sync Hooks

If .sdd-upgrade/.cursor/hooks.json exists:

cp .sdd-upgrade/.cursor/hooks.json .cursor/hooks.json
cp -r .sdd-upgrade/.cursor/hooks .cursor/hooks
chmod +x .cursor/hooks/*.sh 2>/dev/null || true

Step 8: Sync Automation Scripts

cp -r .sdd-upgrade/scripts .
chmod +x scripts/*.sh

Also copy supporting files:

cp .sdd-upgrade/.env.local.example . 2>/dev/null || true

Step 9: Sync CLAUDE.md and .gitignore

cp .sdd-upgrade/CLAUDE.md CLAUDE.md
cp .sdd-upgrade/.gitignore .gitignore 2>/dev/null || true

Step 10: Regenerate Mapping

cp .specs/mapping.md .specs/mapping.md.backup 2>/dev/null || true
./scripts/generate-mapping.sh

Step 11: Update Version

cp .sdd-upgrade/VERSION . 2>/dev/null || echo "2.1.0" > VERSION
cp VERSION .specs/.sdd-version

Step 12: Cleanup Staging Directory

rm -rf .sdd-upgrade

Step 13: Summary

Output final summary. Use the label from the version check (UPGRADE or RE-SYNC):

═══════════════════════════════════════════════════════════════════
          {UPGRADE|RE-SYNC} COMPLETE: {old} → {new}
═══════════════════════════════════════════════════════════════════

✓ Synced [N] stock commands (replaced/added)
✓ Preserved [N] custom commands (untouched)
✓ Synced [N] stock rules
✓ Synced automation scripts
✓ Synced hooks
✓ Updated CLAUDE.md
✓ Backed up mapping.md → mapping.md.backup
✓ Regenerated mapping.md
✓ Cleaned up staging directory
✓ Version: {new version}

Custom commands preserved (untouched):
  • [list any custom commands]

Custom rules preserved (untouched):
  • [list any custom rules]

What's new in this version:
  [Read .sdd-upgrade/CHANGELOG.md if it exists, otherwise skip this section]

Error Handling

Error	Message
No `.sdd-upgrade/`	"Run 'git auto-upgrade' first to stage the latest files"
No `.specs/`	"Not an SDD project. Use 'git auto' for fresh install"
Same version	Re-sync all stock files (files may have drifted)
Script fails	Show error, don't delete staging dir so user can retry

Rollback

If something goes wrong:

# Restore mapping
mv .specs/mapping.md.backup .specs/mapping.md

# Re-run git auto-upgrade to get fresh staging
git auto-upgrade

# Re-run migration
/sdd-migrate

Install sdd-migrate and it becomes one more candidate the router can pick - when it fits.

A listing is a routing target with a manifest: what it does, which domains it covers, what it costs and who publishes it. Once installed it sits beside your own models and tools, is scored like any other candidate for each request, and shows up in the trace when it wins. Ratings come from workspaces that installed it, one per account.

# /sdd-migrate - Upgrade SDD to latest version Upgrade an existing SDD project to the latest version from the staged template files. If `.sdd-upgrade/` doesn't exist yet, this command automatically runs `git auto-upgrade` to stage the files first. ## Step 0: Check Prerequisites ``` Check for .specs/ directory ├── If exists → SDD project, continue └── If missing → ERROR: "Not an SDD project. Use 'git auto' for fresh install" Check for .sdd-upgrade/ directory ├── If exists → Continue to version check └── If missing → Auto-stage by running: git auto-upgrade ├── If succeeds → Continue to version check └── If fails → ERROR: "Failed to stage upgrade files. Check your network connection and try 'git auto-upgrade' manually." ``` ### Version Check ``` Read CURRENT version from: VERSION or .specs/.sdd-version (or "1.0.0" if neither exists) Read TARGET version from: .sdd-upgrade/VERSION (or "2.0.0" if missing) Compare versions: ├── TARGET > CURRENT → Proceed with upgrade (label: UPGRADE) ├── TARGET = CURRENT → Proceed with re-sync (label: RE-SYNC) └── TARGET < CURRENT → "Installed version is newer than template. Skipping." ``` **Re-sync rationale:** Even at the same version, files may have drifted (partial previous migration, manual edits, or template patches without a version bump). A re-sync ensures all stock files match the template. --- ## Step 1: Inventory Commands and Rules **Do NOT use a hardcoded list of stock commands.** Instead, determine stock vs custom dynamically: 1. List all `.md` files in `.sdd-upgrade/.cursor/commands/` → these are the **stock commands** (the template's commands) 2. List all `.md` files in the project's `.cursor/commands/` → these are the **installed commands** 3. **Stock (to sync)**: any file that exists in `.sdd-upgrade/.cursor/commands/` 4. **Custom (to preserve)**: any file in the project's `.cursor/commands/` that does NOT exist in `.sdd-upgrade/.cursor/commands/` Do the same for: - `.cursor/rules/*.mdc` vs `.sdd-upgrade/.cursor/rules/*.mdc` `.claude/commands/` is GENERATED from `.cursor/commands/` by `scripts/sync-commands.sh` — do not inventory or merge it separately. It gets regenerated in Step 5. Output inventory: ``` Command Inventory: ├── Stock commands to update: [count] │ • spec-first.md, tdd.md, refactor.md, ... (all from staging) ├── New commands to add: [count] │ • [commands in staging but not installed] ├── Custom commands to preserve: [count] │ • [commands installed but not in staging] └── Rules to update: [count] • specs-workflow.mdc, design-tokens.mdc, ... ``` --- ## Step 2: Create Missing Directories Ensure these exist (create if missing, skip if present): ```bash mkdir -p .specs/learnings mkdir -p .specs/design-system/components mkdir -p .specs/personas mkdir -p logs ``` --- ## Step 3: Sync Learnings Templates If `.specs/learnings/index.md` doesn't exist, copy learnings templates from staging: ```bash cp -n .sdd-upgrade/.specs/learnings/*.md .specs/learnings/ ``` Use `-n` (no-clobber) to avoid overwriting existing learnings files that may have content. --- ## Step 4: Add YAML Frontmatter to Existing Specs For each `.specs/features/**/*.feature.md`: 1. Check if it already starts with `---` (has frontmatter) → skip 2. Extract feature name from first `# ` heading 3. Extract domain from file path 4. Look for `**Source File**:` to extract source path 5. Prepend frontmatter: ```yaml --- feature: { extracted name } domain: { from path } source: { from Source File line or empty } tests: [] components: [] design_refs: [] status: implemented created: { today's date } updated: { today's date } --- ``` **Important**: Do NOT modify any other content. Just prepend frontmatter to specs that lack it. --- ## Step 5: Sync Stock Commands For each `.md` file in `.sdd-upgrade/.cursor/commands/`: ```bash cp .sdd-upgrade/.cursor/commands/{name}.md .cursor/commands/{name}.md ``` This replaces existing stock commands AND adds new ones. Then regenerate `.claude/commands/` from the canonical `.cursor/commands/`: ```bash ./scripts/sync-commands.sh ``` (If the project predates sync-commands.sh, it was just copied in with the other scripts in the previous step. The sync is safe for custom commands: a file that exists only in `.claude/commands/` is adopted back into `.cursor/commands/`, never deleted.) **Do NOT touch files that only exist in the project's `.cursor/commands/` (custom commands).** --- ## Step 6: Sync Stock Rules For each `.mdc` file in `.sdd-upgrade/.cursor/rules/`: ```bash cp .sdd-upgrade/.cursor/rules/{name}.mdc .cursor/rules/{name}.mdc ``` **Do NOT touch custom rules.** --- ## Step 7: Sync Hooks If `.sdd-upgrade/.cursor/hooks.json` exists: ```bash cp .sdd-upgrade/.cursor/hooks.json .cursor/hooks.json cp -r .sdd-upgrade/.cursor/hooks .cursor/hooks chmod +x .cursor/hooks/*.sh 2>/dev/null || true ``` --- ## Step 8: Sync Automation Scripts ```bash cp -r .sdd-upgrade/scripts . chmod +x scripts/*.sh ``` Also copy supporting files: ```bash cp .sdd-upgrade/.env.local.example . 2>/dev/null || true ``` --- ## Step 9: Sync CLAUDE.md and .gitignore ```bash cp .sdd-upgrade/CLAUDE.md CLAUDE.md cp .sdd-upgrade/.gitignore .gitignore 2>/dev/null || true ``` --- ## Step 10: Regenerate Mapping ```bash cp .specs/mapping.md .specs/mapping.md.backup 2>/dev/null || true ./scripts/generate-mapping.sh ``` --- ## Step 11: Update Version ```bash cp .sdd-upgrade/VERSION . 2>/dev/null || echo "2.1.0" > VERSION cp VERSION .specs/.sdd-version ``` --- ## Step 12: Cleanup Staging Directory ```bash rm -rf .sdd-upgrade ``` --- ## Step 13: Summary Output final summary. Use the label from the version check (UPGRADE or RE-SYNC): ``` ═══════════════════════════════════════════════════════════════════ {UPGRADE|RE-SYNC} COMPLETE: {old} → {new} ═══════════════════════════════════════════════════════════════════ ✓ Synced [N] stock commands (replaced/added) ✓ Preserved [N] custom commands (untouched) ✓ Synced [N] stock rules ✓ Synced automation scripts ✓ Synced hooks ✓ Updated CLAUDE.md ✓ Backed up mapping.md → mapping.md.backup ✓ Regenerated mapping.md ✓ Cleaned up staging directory ✓ Version: {new version} Custom commands preserved (untouched): • [list any custom commands] Custom rules preserved (untouched): • [list any custom rules] What's new in this version: [Read .sdd-upgrade/CHANGELOG.md if it exists, otherwise skip this section] ``` --- ## Error Handling | Error | Message | |-------|---------| | No `.sdd-upgrade/` | "Run 'git auto-upgrade' first to stage the latest files" | | No `.specs/` | "Not an SDD project. Use 'git auto' for fresh install" | | Same version | Re-sync all stock files (files may have drifted) | | Script fails | Show error, don't delete staging dir so user can retry | --- ## Rollback If something goes wrong: ```bash # Restore mapping mv .specs/mapping.md.backup .specs/mapping.md # Re-run git auto-upgrade to get fresh staging git auto-upgrade # Re-run migration /sdd-migrate ```

{ "prompt": "# /sdd-migrate - Upgrade SDD to latest version\n\nUpgrade an existing SDD project to the latest version from the staged template files.\n\nIf `.sdd-upgrade/` doesn't exist yet, this command automatically runs `git auto-upgrade` to stage the files first.\n\n## Step 0: Check Prerequisites\n\n```\nCheck for .specs/ directory\n├── If exists → SDD project, continue\n└── If missing → ERROR: \"Not an SDD project. Use 'git auto' for fresh install\"\n\nCheck for .sdd-upgrade/ directory\n├── If exists → Continue to version check\n└── If missing → Auto-stage by running: git auto-upgrade\n ├── If succeeds → Continue to version check\n └── If fails → ERROR: \"Failed to stage upgrade files. Check your network connection and try 'git auto-upgrade' manually.\"\n```\n\n### Version Check\n\n```\nRead CURRENT version from: VERSION or .specs/.sdd-version (or \"1.0.0\" if neither exists)\nRead TARGET version from: .sdd-upgrade/VERSION (or \"2.0.0\" if missing)\n\nCompare versions:\n├── TARGET > CURRENT → Proceed with upgrade (label: UPGRADE)\n├── TARGET = CURRENT → Proceed with re-sync (label: RE-SYNC)\n└── TARGET < CURRENT → \"Installed version is newer than template. Skipping.\"\n```\n\n**Re-sync rationale:** Even at the same version, files may have drifted (partial previous migration, manual edits, or template patches without a version bump). A re-sync ensures all stock files match the template.\n\n---\n\n## Step 1: Inventory Commands and Rules\n\n**Do NOT use a hardcoded list of stock commands.** Instead, determine stock vs custom dynamically:\n\n1. List all `.md` files in `.sdd-upgrade/.cursor/commands/` → these are the **stock commands** (the template's commands)\n2. List all `.md` files in the project's `.cursor/commands/` → these are the **installed commands**\n3. **Stock (to sync)**: any file that exists in `.sdd-upgrade/.cursor/commands/`\n4. **Custom (to preserve)**: any file in the project's `.cursor/commands/` that does NOT exist in `.sdd-upgrade/.cursor/commands/`\n\nDo the same for:\n- `.cursor/rules/*.mdc` vs `.sdd-upgrade/.cursor/rules/*.mdc`\n\n`.claude/commands/` is GENERATED from `.cursor/commands/` by `scripts/sync-commands.sh` — do not inventory or merge it separately. It gets regenerated in Step 5.\n\nOutput inventory:\n\n```\nCommand Inventory:\n├── Stock commands to update: [count]\n│ • spec-first.md, tdd.md, refactor.md, ... (all from staging)\n├── New commands to add: [count]\n│ • [commands in staging but not installed]\n├── Custom commands to preserve: [count]\n│ • [commands installed but not in staging]\n└── Rules to update: [count]\n • specs-workflow.mdc, design-tokens.mdc, ...\n```\n\n---\n\n## Step 2: Create Missing Directories\n\nEnsure these exist (create if missing, skip if present):\n\n```bash\nmkdir -p .specs/learnings\nmkdir -p .specs/design-system/components\nmkdir -p .specs/personas\nmkdir -p logs\n```\n\n---\n\n## Step 3: Sync Learnings Templates\n\nIf `.specs/learnings/index.md` doesn't exist, copy learnings templates from staging:\n\n```bash\ncp -n .sdd-upgrade/.specs/learnings/*.md .specs/learnings/\n```\n\nUse `-n` (no-clobber) to avoid overwriting existing learnings files that may have content.\n\n---\n\n## Step 4: Add YAML Frontmatter to Existing Specs\n\nFor each `.specs/features/**/*.feature.md`:\n\n1. Check if it already starts with `---` (has frontmatter) → skip\n2. Extract feature name from first `# ` heading\n3. Extract domain from file path\n4. Look for `**Source File**:` to extract source path\n5. Prepend frontmatter:\n\n```yaml\n---\nfeature: { extracted name }\ndomain: { from path }\nsource: { from Source File line or empty }\ntests: []\ncomponents: []\ndesign_refs: []\nstatus: implemented\ncreated: { today's date }\nupdated: { today's date }\n---\n```\n\n**Important**: Do NOT modify any other content. Just prepend frontmatter to specs that lack it.\n\n---\n\n## Step 5: Sync Stock Commands\n\nFor each `.md` file in `.sdd-upgrade/.cursor/commands/`:\n\n```bash\ncp .sdd-upgrade/.cursor/commands/{name}.md .cursor/commands/{name}.md\n```\n\nThis replaces existing stock commands AND adds new ones.\n\nThen regenerate `.claude/commands/` from the canonical `.cursor/commands/`:\n\n```bash\n./scripts/sync-commands.sh\n```\n\n(If the project predates sync-commands.sh, it was just copied in with the other scripts in the previous step. The sync is safe for custom commands: a file that exists only in `.claude/commands/` is adopted back into `.cursor/commands/`, never deleted.)\n\n**Do NOT touch files that only exist in the project's `.cursor/commands/` (custom commands).**\n\n---\n\n## Step 6: Sync Stock Rules\n\nFor each `.mdc` file in `.sdd-upgrade/.cursor/rules/`:\n\n```bash\ncp .sdd-upgrade/.cursor/rules/{name}.mdc .cursor/rules/{name}.mdc\n```\n\n**Do NOT touch custom rules.**\n\n---\n\n## Step 7: Sync Hooks\n\nIf `.sdd-upgrade/.cursor/hooks.json` exists:\n\n```bash\ncp .sdd-upgrade/.cursor/hooks.json .cursor/hooks.json\ncp -r .sdd-upgrade/.cursor/hooks .cursor/hooks\nchmod +x .cursor/hooks/*.sh 2>/dev/null || true\n```\n\n---\n\n## Step 8: Sync Automation Scripts\n\n```bash\ncp -r .sdd-upgrade/scripts .\nchmod +x scripts/*.sh\n```\n\nAlso copy supporting files:\n\n```bash\ncp .sdd-upgrade/.env.local.example . 2>/dev/null || true\n```\n\n---\n\n## Step 9: Sync CLAUDE.md and .gitignore\n\n```bash\ncp .sdd-upgrade/CLAUDE.md CLAUDE.md\ncp .sdd-upgrade/.gitignore .gitignore 2>/dev/null || true\n```\n\n---\n\n## Step 10: Regenerate Mapping\n\n```bash\ncp .specs/mapping.md .specs/mapping.md.backup 2>/dev/null || true\n./scripts/generate-mapping.sh\n```\n\n---\n\n## Step 11: Update Version\n\n```bash\ncp .sdd-upgrade/VERSION . 2>/dev/null || echo \"2.1.0\" > VERSION\ncp VERSION .specs/.sdd-version\n```\n\n---\n\n## Step 12: Cleanup Staging Directory\n\n```bash\nrm -rf .sdd-upgrade\n```\n\n---\n\n## Step 13: Summary\n\nOutput final summary. Use the label from the version check (UPGRADE or RE-SYNC):\n\n```\n═══════════════════════════════════════════════════════════════════\n {UPGRADE|RE-SYNC} COMPLETE: {old} → {new}\n═══════════════════════════════════════════════════════════════════\n\n✓ Synced [N] stock commands (replaced/added)\n✓ Preserved [N] custom commands (untouched)\n✓ Synced [N] stock rules\n✓ Synced automation scripts\n✓ Synced hooks\n✓ Updated CLAUDE.md\n✓ Backed up mapping.md → mapping.md.backup\n✓ Regenerated mapping.md\n✓ Cleaned up staging directory\n✓ Version: {new version}\n\nCustom commands preserved (untouched):\n • [list any custom commands]\n\nCustom rules preserved (untouched):\n • [list any custom rules]\n\nWhat's new in this version:\n [Read .sdd-upgrade/CHANGELOG.md if it exists, otherwise skip this section]\n```\n\n---\n\n## Error Handling\n\n| Error | Message |\n|-------|---------|\n| No `.sdd-upgrade/` | \"Run 'git auto-upgrade' first to stage the latest files\" |\n| No `.specs/` | \"Not an SDD project. Use 'git auto' for fresh install\" |\n| Same version | Re-sync all stock files (files may have drifted) |\n| Script fails | Show error, don't delete staging dir so user can retry |\n\n---\n\n## Rollback\n\nIf something goes wrong:\n\n```bash\n# Restore mapping\nmv .specs/mapping.md.backup .specs/mapping.md\n\n# Re-run git auto-upgrade to get fresh staging\ngit auto-upgrade\n\n# Re-run migration\n/sdd-migrate\n```", "variables": [], "notes": "Upgrade an existing SDD project to the latest version from the staged template files.", "metadata": { "source": { "provider": "github-cursor-commands", "repository": "https://github.com/AdrianRogowski/auto-sdd", "path": ".cursor/commands/sdd-migrate.md", "ref": "69ff0aaa63496bdbf484f562965e69ee50153c22", "url": "https://github.com/AdrianRogowski/auto-sdd/blob/69ff0aaa63496bdbf484f562965e69ee50153c22/.cursor/commands/sdd-migrate.md", "key": "AdrianRogowski/auto-sdd/.cursor/commands/sdd-migrate.md" } } }

sdd-migrate

About