delimit-cli 2.3.1 → 2.4.0

package/adapters/gemini-forge.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+/**
+ * Delimit™ Gemini CLI Forge Adapter
+ * Layer: Forge (execution governance)
+ * Used as: command handler called from Gemini CLI hooks and @commands
+ */
+
+'use strict';
+
+const axios = require('axios');
+const AGENT_URL = `http://127.0.0.1:${process.env.DELIMIT_AGENT_PORT || 7823}`;
+
+class DelimitGeminiForge {
+    constructor() {
+        this.id = 'delimit-forge';
+        this.version = '1.0.0';
+    }
+
+    /**
+     * Pre-generation: surface test failures and deploy locks to Gemini before it generates code.
+     */
+    async beforeCodeGeneration(request) {
+        const [testState, deployState, releaseState] = await Promise.allSettled([
+            axios.get(`${AGENT_URL}/test/status`, { timeout: 3000 }),
+            axios.get(`${AGENT_URL}/deploy/status`, { timeout: 3000 }),
+            axios.get(`${AGENT_URL}/release/status`, { timeout: 3000 }),
+        ]);
+
+        const warnings = [];
+
+        if (testState.status === 'fulfilled') {
+            const t = testState.value.data;
+            if (t?.failing > 0) warnings.push(`[FORGE] ${t.failing} test(s) failing`);
+        }
+
+        if (deployState.status === 'fulfilled') {
+            const d = deployState.value.data;
+            if (d?.locked) warnings.push(`[FORGE] Deploy locked: ${d.reason || 'release in progress'}`);
+        }
+
+        if (releaseState.status === 'fulfilled') {
+            const rel = releaseState.value.data;
+            if (rel?.in_progress) warnings.push(`[FORGE] Release in progress: ${rel.version || 'unknown'}`);
+        }
+
+        if (warnings.length > 0) {
+            console.warn(warnings.join('\n'));
+            // Inject warnings into system prompt context
+            request._forgeWarnings = warnings;
+        }
+
+        return request;
+    }
+
+    async afterResponse(response) {
+        try {
+            await axios.post(`${AGENT_URL}/audit`, {
+                action: 'gemini_forge_response',
+                response: {
+                    model: response.model,
+                    tokens: response.usage,
+                    timestamp: new Date().toISOString(),
+                },
+            }, { timeout: 2000 });
+        } catch (_) { /* silent */ }
+        return response;
+    }
+
+    async handleCommand(command, _args) {
+        const { execSync } = require('child_process');
+        const commands = {
+            '@forge':   'delimit status --layer=forge',
+            '@tests':   'delimit test --summary',
+            '@deploy':  'delimit deploy --status',
+            '@release': 'delimit release --status',
+        };
+        if (commands[command]) {
+            try {
+                return execSync(commands[command], { timeout: 10000 }).toString();
+            } catch (e) {
+                return `[FORGE] Command failed: ${e.message}`;
+            }
+        }
+    }
+
+    /**
+     * Structured context for consensus — call this from hooks or consensus runners.
+     */
+    async getContext() {
+        const [tests, deploy, release] = await Promise.allSettled([
+            axios.get(`${AGENT_URL}/test/status`, { timeout: 3000 }),
+            axios.get(`${AGENT_URL}/deploy/status`, { timeout: 3000 }),
+            axios.get(`${AGENT_URL}/release/status`, { timeout: 3000 }),
+        ]);
+        return {
+            layer: 'forge',
+            tool: 'gemini',
+            tests: tests.status === 'fulfilled' ? tests.value.data : null,
+            deploy: deploy.status === 'fulfilled' ? deploy.value.data : null,
+            release: release.status === 'fulfilled' ? release.value.data : null,
+        };
+    }
+}
+
+module.exports = new DelimitGeminiForge();
+
+if (typeof registerExtension === 'function') {
+    registerExtension(new DelimitGeminiForge());
+}

package/bin/delimit-cli.js

@@ -50,7 +50,7 @@ async function ensureAgent() {
 program
     .name('delimit')
     .description('Prevent breaking API changes before they reach production')
-    .version('2.3.0');
+    .version(require('../package.json').version);
 
 // Install command with modes
 program
@@ -803,7 +803,7 @@ program
             const specPath = foundSpecs[0];
             console.log(`  Detected spec: ${chalk.bold(specPath)}`);
             console.log('');
-            console.log(chalk.bold('  Add this to .github/workflows/api-governance.yml:\n'));
+            console.log(chalk.bold('  Workflow template:\n'));
             console.log(chalk.gray(`  name: API Governance
   on:
     pull_request:
@@ -827,6 +827,48 @@ program
             new_spec: ${specPath}
             mode: advisory`));
             console.log('');
+
+            // Auto-write the workflow file
+            const workflowDir = path.join(process.cwd(), '.github', 'workflows');
+            const workflowFile = path.join(workflowDir, 'api-governance.yml');
+
+            if (!fs.existsSync(workflowFile)) {
+                try {
+                    fs.mkdirSync(workflowDir, { recursive: true });
+                    const workflowContent = `name: API Governance
+on:
+  pull_request:
+    paths:
+      - '${specPath}'
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  api-governance:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/checkout@v4
+        with:
+          ref: \${{ github.event.pull_request.base.sha }}
+          path: _base
+      - uses: delimit-ai/delimit@v1
+        with:
+          old_spec: _base/${specPath}
+          new_spec: ${specPath}
+          mode: advisory
+`;
+                    fs.writeFileSync(workflowFile, workflowContent);
+                    console.log(chalk.green(`  Created .github/workflows/api-governance.yml\n`));
+                } catch (err) {
+                    console.log(chalk.yellow(`  Could not write workflow file: ${err.message}`));
+                    console.log(chalk.bold('  Add this to .github/workflows/api-governance.yml manually (shown above)\n'));
+                }
+            } else {
+                console.log(chalk.yellow('  .github/workflows/api-governance.yml already exists — skipped\n'));
+            }
         } else {
             console.log('  No OpenAPI spec file detected.');
             console.log(`  Delimit also supports ${chalk.bold('Zero-Spec Mode')} — run ${chalk.bold('delimit lint')} in a FastAPI/NestJS/Express project.`);
@@ -950,7 +992,7 @@ program
 program
     .command('lint [old_spec] [new_spec]')
     .description('Lint API specs for breaking changes and policy violations')
-    .option('-p, --policy <file>', 'Custom policy file')
+    .option('-p, --policy <preset|file>', 'Policy preset (strict/default/relaxed) or file path')
     .option('--current-version <ver>', 'Current API version for semver bump')
     .option('-n, --name <name>', 'API name for context')
     .option('--json', 'Output raw JSON')
@@ -1000,9 +1042,21 @@ program
                     { policy: options.policy, version: options.currentVersion, name: options.name }
                 );
             } else {
+                const resolvedOld = path.resolve(oldSpec);
+                const resolvedNew = path.resolve(newSpec);
+                if (!fs.existsSync(resolvedOld)) {
+                    console.error(chalk.red(`\n  File not found: ${resolvedOld}\n`));
+                    process.exit(1);
+                    return;
+                }
+                if (!fs.existsSync(resolvedNew)) {
+                    console.error(chalk.red(`\n  File not found: ${resolvedNew}\n`));
+                    process.exit(1);
+                    return;
+                }
                 result = apiEngine.lint(
-                    path.resolve(oldSpec),
-                    path.resolve(newSpec),
+                    resolvedOld,
+                    resolvedNew,
                     { policy: options.policy, version: options.currentVersion, name: options.name }
                 );
             }
@@ -1068,10 +1122,11 @@ program
     .option('--json', 'Output raw JSON')
     .action(async (oldSpec, newSpec, options) => {
         try {
-            const result = apiEngine.diff(
-                path.resolve(oldSpec),
-                path.resolve(newSpec)
-            );
+            const resolvedOld = path.resolve(oldSpec);
+            const resolvedNew = path.resolve(newSpec);
+            if (!fs.existsSync(resolvedOld)) { console.error(chalk.red(`\n  File not found: ${resolvedOld}\n`)); process.exit(1); return; }
+            if (!fs.existsSync(resolvedNew)) { console.error(chalk.red(`\n  File not found: ${resolvedNew}\n`)); process.exit(1); return; }
+            const result = apiEngine.diff(resolvedOld, resolvedNew);
 
             if (options.json) {
                 console.log(JSON.stringify(result, null, 2));
@@ -1102,9 +1157,13 @@ program
     .option('--json', 'Output raw JSON')
     .action(async (oldSpec, newSpec, options) => {
         try {
+            const resolvedOld = path.resolve(oldSpec);
+            const resolvedNew = path.resolve(newSpec);
+            if (!fs.existsSync(resolvedOld)) { console.error(chalk.red(`\n  File not found: ${resolvedOld}\n`)); process.exit(1); return; }
+            if (!fs.existsSync(resolvedNew)) { console.error(chalk.red(`\n  File not found: ${resolvedNew}\n`)); process.exit(1); return; }
             const result = apiEngine.explain(
-                path.resolve(oldSpec),
-                path.resolve(newSpec),
+                resolvedOld,
+                resolvedNew,
                 {
                     template: options.template,
                     oldVersion: options.oldVersion,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "delimit-cli",
-  "version": "2.3.1",
+  "version": "2.4.0",
   "description": "Prevent breaking API changes before they reach production. Deterministic diff engine + policy enforcement + semver classification.",
   "main": "index.js",
   "bin": {
@@ -12,7 +12,7 @@
     "install-mcp": "bash ./hooks/install-hooks.sh mcp-only",
     "test-mcp": "bash ./hooks/install-hooks.sh troubleshoot",
     "fix-mcp": "bash ./hooks/install-hooks.sh fix-mcp",
-    "test": "echo 'Governance is context-aware' && exit 0"
+    "test": "node --test tests/cli.test.js"
   },
   "keywords": [
     "openapi",

package/tests/cli.test.js

@@ -0,0 +1,359 @@
+/**
+ * Delimit CLI Tests
+ *
+ * Uses Node.js built-in test runner (node:test).
+ * Run with: node --test tests/cli.test.js
+ */
+
+const { describe, it, before, after } = require('node:test');
+const assert = require('node:assert/strict');
+const { execSync } = require('node:child_process');
+const path = require('node:path');
+const fs = require('node:fs');
+const os = require('node:os');
+
+const CLI = path.join(__dirname, '..', 'bin', 'delimit-cli.js');
+const FIXTURES = path.join(__dirname, 'fixtures');
+const SPEC_CLEAN = path.join(FIXTURES, 'openapi.yaml');
+const SPEC_BREAKING = path.join(FIXTURES, 'openapi-changed.yaml');
+
+/**
+ * Run the CLI and return { stdout, stderr, exitCode }.
+ * Does not throw on non-zero exit.
+ */
+function run(args, opts = {}) {
+    const cwd = opts.cwd || os.tmpdir();
+    try {
+        const stdout = execSync(`node "${CLI}" ${args}`, {
+            cwd,
+            encoding: 'utf-8',
+            timeout: 30000,
+            env: { ...process.env, FORCE_COLOR: '0', NO_COLOR: '1' },
+        });
+        return { stdout, stderr: '', exitCode: 0 };
+    } catch (err) {
+        return {
+            stdout: err.stdout || '',
+            stderr: err.stderr || '',
+            exitCode: err.status ?? 1,
+        };
+    }
+}
+
+// ---------------------------------------------------------------------------
+// 1. CLI entry point loads without error
+// ---------------------------------------------------------------------------
+describe('CLI entry point', () => {
+    it('loads the module without throwing', () => {
+        assert.doesNotThrow(() => {
+            execSync(`node --check "${CLI}"`, { encoding: 'utf-8' });
+        });
+    });
+});
+
+// ---------------------------------------------------------------------------
+// 2. --version returns the version from package.json
+// ---------------------------------------------------------------------------
+describe('--version', () => {
+    it('prints the version from package.json', () => {
+        const pkg = require(path.join(__dirname, '..', 'package.json'));
+        const { stdout } = run('--version');
+        assert.equal(stdout.trim(), pkg.version);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// 3. --help works at top level
+// ---------------------------------------------------------------------------
+describe('--help (top level)', () => {
+    it('shows usage and lists commands', () => {
+        const { stdout } = run('--help');
+        assert.match(stdout, /Usage:/);
+        assert.match(stdout, /init/);
+        assert.match(stdout, /lint/);
+        assert.match(stdout, /diff/);
+        assert.match(stdout, /explain/);
+        assert.match(stdout, /doctor/);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// 4. Each command has help text
+// ---------------------------------------------------------------------------
+describe('subcommand --help', () => {
+    for (const cmd of ['init', 'lint', 'diff', 'explain', 'doctor']) {
+        it(`"help ${cmd}" shows description`, () => {
+            const { stdout } = run(`help ${cmd}`);
+            assert.match(stdout, /Usage:/);
+            assert.match(stdout, new RegExp(cmd));
+        });
+    }
+});
+
+// ---------------------------------------------------------------------------
+// 5. init creates .delimit/policies.yml with default preset
+// ---------------------------------------------------------------------------
+describe('init command', () => {
+    let tmpDir;
+
+    before(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'delimit-test-init-'));
+    });
+
+    after(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    it('creates .delimit/policies.yml with default preset', () => {
+        const { stdout, exitCode } = run('init', { cwd: tmpDir });
+        assert.equal(exitCode, 0);
+        const policyPath = path.join(tmpDir, '.delimit', 'policies.yml');
+        assert.ok(fs.existsSync(policyPath), 'policies.yml should exist');
+        const content = fs.readFileSync(policyPath, 'utf-8');
+        assert.match(content, /Delimit Policy Preset: default/);
+        assert.match(content, /override_defaults: false/);
+    });
+
+    it('reports already initialized on second run', () => {
+        const { stdout, exitCode } = run('init', { cwd: tmpDir });
+        assert.equal(exitCode, 0);
+        assert.match(stdout, /Already initialized/);
+    });
+});
+
+describe('init --preset strict', () => {
+    let tmpDir;
+
+    before(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'delimit-test-init-strict-'));
+    });
+
+    after(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    it('creates policies.yml with strict preset', () => {
+        const { stdout, exitCode } = run('init --preset strict', { cwd: tmpDir });
+        assert.equal(exitCode, 0);
+        const content = fs.readFileSync(
+            path.join(tmpDir, '.delimit', 'policies.yml'),
+            'utf-8'
+        );
+        assert.match(content, /Delimit Policy Preset: strict/);
+        assert.match(content, /no_endpoint_removal/);
+    });
+});
+
+describe('init --preset relaxed', () => {
+    let tmpDir;
+
+    before(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'delimit-test-init-relaxed-'));
+    });
+
+    after(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    it('creates policies.yml with relaxed preset', () => {
+        const { stdout, exitCode } = run('init --preset relaxed', { cwd: tmpDir });
+        assert.equal(exitCode, 0);
+        const content = fs.readFileSync(
+            path.join(tmpDir, '.delimit', 'policies.yml'),
+            'utf-8'
+        );
+        assert.match(content, /Delimit Policy Preset: relaxed/);
+        assert.match(content, /warn_endpoint_removal/);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// 6. lint with identical specs returns clean (exit 0)
+// ---------------------------------------------------------------------------
+describe('lint (clean)', () => {
+    it('returns exit 0 with no violations for identical specs', () => {
+        const { stdout, exitCode } = run(
+            `lint "${SPEC_CLEAN}" "${SPEC_CLEAN}" --json`
+        );
+        assert.equal(exitCode, 0);
+        const result = JSON.parse(stdout);
+        assert.equal(result.decision, 'pass');
+        assert.equal(result.exit_code, 0);
+        assert.equal(result.summary.breaking_changes, 0);
+        assert.equal(result.violations.length, 0);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// 7. lint with breaking change returns exit 1
+// ---------------------------------------------------------------------------
+describe('lint (breaking)', () => {
+    it('returns exit 1 when breaking changes are detected', () => {
+        const { stdout, exitCode } = run(
+            `lint "${SPEC_CLEAN}" "${SPEC_BREAKING}" --json`
+        );
+        assert.equal(exitCode, 1);
+        const result = JSON.parse(stdout);
+        assert.equal(result.decision, 'fail');
+        assert.equal(result.exit_code, 1);
+        assert.ok(result.summary.breaking_changes > 0, 'should have breaking changes');
+        assert.ok(result.violations.length > 0, 'should have violations');
+    });
+
+    it('includes endpoint_removed in changes', () => {
+        const { stdout } = run(
+            `lint "${SPEC_CLEAN}" "${SPEC_BREAKING}" --json`
+        );
+        const result = JSON.parse(stdout);
+        const types = result.all_changes.map(c => c.type);
+        assert.ok(types.includes('endpoint_removed'), 'should detect endpoint removal');
+    });
+
+    it('includes semver bump classification', () => {
+        const { stdout } = run(
+            `lint "${SPEC_CLEAN}" "${SPEC_BREAKING}" --json`
+        );
+        const result = JSON.parse(stdout);
+        assert.ok(result.semver, 'should have semver field');
+        assert.equal(result.semver.bump, 'major');
+    });
+});
+
+// ---------------------------------------------------------------------------
+// 8. diff outputs change types
+// ---------------------------------------------------------------------------
+describe('diff command', () => {
+    it('outputs changes between two specs', () => {
+        const { stdout, exitCode } = run(
+            `diff "${SPEC_CLEAN}" "${SPEC_BREAKING}" --json`
+        );
+        assert.equal(exitCode, 0);
+        const result = JSON.parse(stdout);
+        assert.ok(result.total_changes > 0, 'should have changes');
+        assert.ok(result.breaking_changes > 0, 'should have breaking changes');
+        assert.ok(Array.isArray(result.changes), 'changes should be an array');
+    });
+
+    it('reports change types correctly', () => {
+        const { stdout } = run(
+            `diff "${SPEC_CLEAN}" "${SPEC_BREAKING}" --json`
+        );
+        const result = JSON.parse(stdout);
+        const types = result.changes.map(c => c.type);
+        assert.ok(types.includes('endpoint_removed'));
+        assert.ok(types.includes('type_changed'));
+        assert.ok(types.includes('enum_value_removed'));
+    });
+
+    it('marks breaking changes with is_breaking flag', () => {
+        const { stdout } = run(
+            `diff "${SPEC_CLEAN}" "${SPEC_BREAKING}" --json`
+        );
+        const result = JSON.parse(stdout);
+        const breakingChanges = result.changes.filter(c => c.is_breaking);
+        assert.equal(breakingChanges.length, result.breaking_changes);
+    });
+
+    it('returns no changes for identical specs', () => {
+        const { stdout, exitCode } = run(
+            `diff "${SPEC_CLEAN}" "${SPEC_CLEAN}" --json`
+        );
+        assert.equal(exitCode, 0);
+        const result = JSON.parse(stdout);
+        assert.equal(result.total_changes, 0);
+        assert.equal(result.breaking_changes, 0);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// 9. explain command
+// ---------------------------------------------------------------------------
+describe('explain command', () => {
+    it('generates human-readable explanation', () => {
+        const { stdout, exitCode } = run(
+            `explain "${SPEC_CLEAN}" "${SPEC_BREAKING}" --json`
+        );
+        assert.equal(exitCode, 0);
+        const result = JSON.parse(stdout);
+        assert.ok(result.output, 'should have output text');
+        assert.ok(result.output.length > 0, 'output should not be empty');
+        assert.ok(result.template, 'should report template used');
+    });
+
+    it('supports --template flag', () => {
+        const { stdout, exitCode } = run(
+            `explain "${SPEC_CLEAN}" "${SPEC_BREAKING}" --template migration --json`
+        );
+        assert.equal(exitCode, 0);
+        const result = JSON.parse(stdout);
+        assert.equal(result.template, 'migration');
+    });
+});
+
+// ---------------------------------------------------------------------------
+// 10. lint with --policy preset
+// ---------------------------------------------------------------------------
+describe('lint --policy', () => {
+    it('accepts relaxed preset and does not fail on breaking changes', () => {
+        // relaxed preset uses action:warn, so decision is "warn" not "fail"
+        const { stdout, exitCode } = run(
+            `lint "${SPEC_CLEAN}" "${SPEC_BREAKING}" --policy relaxed --json`
+        );
+        assert.equal(exitCode, 0, 'relaxed preset should exit 0');
+        const result = JSON.parse(stdout);
+        assert.notEqual(result.decision, 'fail', 'relaxed should not produce fail decision');
+    });
+
+    it('accepts strict preset and fails on breaking changes', () => {
+        const { stdout, exitCode } = run(
+            `lint "${SPEC_CLEAN}" "${SPEC_BREAKING}" --policy strict --json`
+        );
+        assert.equal(exitCode, 1);
+        const result = JSON.parse(stdout);
+        assert.equal(result.decision, 'fail');
+        assert.ok(result.violations.length > 0);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// 11. Error handling -- missing files
+// ---------------------------------------------------------------------------
+describe('error handling', () => {
+    it('lint with nonexistent spec file reports error', () => {
+        const { exitCode } = run('lint /nonexistent/old.yaml /nonexistent/new.yaml --json');
+        assert.notEqual(exitCode, 0);
+    });
+
+    it('diff with nonexistent spec file reports error', () => {
+        const { exitCode } = run('diff /nonexistent/old.yaml /nonexistent/new.yaml --json');
+        assert.notEqual(exitCode, 0);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// 12. api-engine module exports
+// ---------------------------------------------------------------------------
+describe('api-engine module', () => {
+    it('exports lint, diff, explain, semver, zeroSpec functions', () => {
+        const engine = require(path.join(__dirname, '..', 'lib', 'api-engine.js'));
+        assert.equal(typeof engine.lint, 'function');
+        assert.equal(typeof engine.diff, 'function');
+        assert.equal(typeof engine.explain, 'function');
+        assert.equal(typeof engine.semver, 'function');
+        assert.equal(typeof engine.zeroSpec, 'function');
+    });
+
+    it('lint returns parsed JSON with decision field', () => {
+        const engine = require(path.join(__dirname, '..', 'lib', 'api-engine.js'));
+        const result = engine.lint(SPEC_CLEAN, SPEC_CLEAN);
+        assert.ok(result.decision, 'should have decision field');
+        assert.equal(result.decision, 'pass');
+    });
+
+    it('diff returns parsed JSON with changes array', () => {
+        const engine = require(path.join(__dirname, '..', 'lib', 'api-engine.js'));
+        const result = engine.diff(SPEC_CLEAN, SPEC_BREAKING);
+        assert.ok(Array.isArray(result.changes), 'should have changes array');
+        assert.ok(result.total_changes > 0);
+    });
+});

package/tests/fixtures/openapi-changed.yaml

@@ -0,0 +1,56 @@
+openapi: "3.0.3"
+info:
+  title: Pet Store API
+  version: "2.0.0"
+  description: Sample API for Delimit quickstart
+paths:
+  /pets:
+    get:
+      summary: List all pets
+      operationId: listPets
+      parameters:
+        - name: limit
+          in: query
+          required: false
+          schema:
+            type: integer
+            format: int32
+      responses:
+        "200":
+          description: A list of pets
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  $ref: "#/components/schemas/Pet"
+    post:
+      summary: Create a pet
+      operationId: createPet
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: "#/components/schemas/Pet"
+      responses:
+        "201":
+          description: Pet created
+  # /pets/{petId} removed -- this is the breaking change
+components:
+  schemas:
+    Pet:
+      type: object
+      required:
+        - id
+        - name
+      properties:
+        id:
+          type: integer
+        name:
+          type: string
+        status:
+          type: string
+          enum:
+            - available
+            - adopted