@stackwright-pro/otters 0.3.0-alpha.1 → 1.0.0-alpha.3

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "@stackwright-pro/otters",
-  "version": "0.3.0-alpha.1",
+  "version": "1.0.0-alpha.3",
   "description": "Stackwright Pro Otter Raft - AI agents for enterprise features (CAC auth, API dashboards, government use cases)",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/Per-Aspera-LLC/stackwright-pro"
   },
+  "devDependencies": {
+    "vitest": "^1.4.0",
+    "zod": "^3.22.4"
+  },
   "exports": {
     "./src": "./src",
     "./pro-foreman": "./src/stackwright-pro-foreman-otter.json"
@@ -16,10 +20,14 @@
     "src"
   ],
   "peerDependencies": {
-    "@stackwright-pro/mcp": "*"
+    "@stackwright-pro/mcp": "0.2.0-alpha.0"
   },
   "scripts": {
+    "generate-checksums": "node scripts/generate-checksums.js",
+    "verify-checksums": "node scripts/verify-checksums.js",
     "postinstall": "node scripts/install-agents.js",
-    "test": "echo 'Pro otters are configuration-only'"
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
   }
 }

package/scripts/generate-checksums.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+/**
+ * generate-checksums.js
+ * Computes SHA-256 for every *-otter.json in src/ and writes src/checksums.json
+ * Run: node scripts/generate-checksums.js
+ * Auto-run: npm prepare (before publish), npm pretest (before tests)
+ */
+
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+const scriptDir = __dirname;
+const packageRoot = path.resolve(scriptDir, '..');
+const srcDir = path.join(packageRoot, 'src');
+const outputFile = path.join(srcDir, 'checksums.json');
+
+async function generateChecksums() {
+  const entries = await fs.promises.readdir(srcDir);
+
+  const otterFiles = entries
+    .filter((f) => f.endsWith('-otter.json'))
+    .sort(); // alphabetical — deterministic output, no excuses
+
+  const files = {};
+  for (const filename of otterFiles) {
+    const filePath = path.join(srcDir, filename);
+    const raw = await fs.promises.readFile(filePath); // raw Buffer → utf-8 bytes, no funny business
+    const digest = crypto.createHash('sha256').update(raw).digest('hex');
+    files[filename] = digest;
+  }
+
+  const manifest = {
+    version: '1.0',
+    algorithm: 'sha256',
+    generated: new Date().toISOString(),
+    files,
+  };
+
+  await fs.promises.writeFile(outputFile, JSON.stringify(manifest, null, 2) + '\n', 'utf8');
+
+  console.log(`✅ checksums.json written with ${otterFiles.length} entr${otterFiles.length === 1 ? 'y' : 'ies'}:`);
+  for (const [name, hash] of Object.entries(files)) {
+    console.log(`   ${name}: ${hash}`);
+  }
+}
+
+generateChecksums().catch((err) => {
+  console.error('❌ generate-checksums failed:', err.message);
+  process.exit(1);
+});

package/scripts/install-agents.js

@@ -12,12 +12,10 @@ const AGENTS_DIR = path.join(os.homedir(), '.code_puppy', 'agents');
 
 // Resolve package root relative to this script's location
 const scriptDir = __dirname;
-const packageRoot = scriptDir.endsWith('/scripts')
-  ? path.dirname(scriptDir)  // Running from within the package
-  : path.join(scriptDir, 'packages', 'otters');  // Running from monorepo root
+const packageRoot = path.resolve(scriptDir, '..');
 
 // All Pro otters are in the src/ directory
-const OTTERS_DIR = path.join(packageRoot, 'src');
+const srcDir = path.join(packageRoot, 'src');
 
 async function installAgents() {
   try {
@@ -25,29 +23,37 @@ async function installAgents() {
     await fs.promises.mkdir(AGENTS_DIR, { recursive: true });
 
     // Copy all JSON files from src/ to ~/.code_puppy/agents/
-    const files = await fs.promises.readdir(OTTERS_DIR);
+    const files = await fs.promises.readdir(srcDir);
 
     let installedCount = 0;
     for (const file of files) {
       if (file.endsWith('-otter.json')) {
-        const srcPath = path.join(OTTERS_DIR, file);
+        const srcPath = path.join(srcDir, file);
         const destPath = path.join(AGENTS_DIR, file);
 
         await fs.promises.copyFile(srcPath, destPath);
-        console.log(`✅ Installed Pro agent: ${file}`);
+        console.log(`✅ Installed: ${file}`);
         installedCount++;
       }
     }
 
+    // Also install checksums manifest (informational — Python coordinator uses hardcoded constants)
+    const checksumsSource = path.join(packageRoot, 'src', 'checksums.json');
+    const checksumsDest = path.join(AGENTS_DIR, 'otter-checksums.REFERENCE-ONLY.json');
+    if (fs.existsSync(checksumsSource)) {
+      await fs.promises.copyFile(checksumsSource, checksumsDest);
+      console.log('✅ Installed: otter-checksums.REFERENCE-ONLY.json');
+    }
+
     if (installedCount > 0) {
+      console.log(`Installing otters from: ${srcDir}`);
       console.log(`\n🦦🦦 Pro otters installed to ${AGENTS_DIR}`);
-      console.log('   Run "code-puppy -i -a stackwright-pro-foreman-otter" to start!');
     } else {
       console.log('⚠️  No Pro otter files found to install');
     }
   } catch (error) {
-    // Don't fail the install if this script has issues
-    console.warn(`⚠️  Failed to install Pro otters: ${error.message}`);
+    console.error(`❌  FATAL: Failed to install Pro otters: ${error.message}`);
+    process.exit(1);  // Fail the npm install — surface it early
   }
 }
 

package/scripts/verify-checksums.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+/**
+ * verify-checksums.js
+ * Read-only: verifies that *-otter.json files match the committed checksums.json
+ * Does NOT regenerate. For regeneration: node scripts/generate-checksums.js
+ *
+ * Exit codes:
+ *   0 = all checksums match
+ *   1 = one or more mismatches detected (tamper detected or file missing)
+ */
+
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+const packageRoot = path.resolve(__dirname, '..');
+const srcDir = path.join(packageRoot, 'src');
+const checksumsPath = path.join(srcDir, 'checksums.json');
+
+// Read checksums manifest
+let manifest;
+try {
+  manifest = JSON.parse(fs.readFileSync(checksumsPath, 'utf8'));
+} catch (err) {
+  console.error(`❌  Cannot read checksums.json: ${err.message}`);
+  console.error('Run: node scripts/generate-checksums.js');
+  process.exit(1);
+}
+
+const expected = manifest.files || {};
+let failures = 0;
+let verified = 0;
+
+for (const [filename, expectedHash] of Object.entries(expected)) {
+  const filePath = path.join(srcDir, filename);
+  try {
+    const raw = fs.readFileSync(filePath);
+    const actual = crypto.createHash('sha256').update(raw).digest('hex');
+    if (actual !== expectedHash) {
+      console.error(`❌  MISMATCH: ${filename}`);
+      console.error(`   Expected: ${expectedHash.substring(0, 16)}...`);
+      console.error(`   Actual:   ${actual.substring(0, 16)}...`);
+      failures++;
+    } else {
+      console.log(`✅  ${filename}`);
+      verified++;
+    }
+  } catch (err) {
+    console.error(`❌  MISSING: ${filename} — ${err.message}`);
+    failures++;
+  }
+}
+
+if (failures > 0) {
+  console.error(`\n🚨  ${failures} checksum failure(s) detected. Run \`npm install @stackwright-pro/otters\` to restore.`);
+  process.exit(1);
+} else {
+  console.log(`\n✅  All ${verified} otter checksums verified.`);
+}

package/src/checksums.json

@@ -0,0 +1,13 @@
+{
+  "version": "1.0",
+  "algorithm": "sha256",
+  "generated": "2026-04-15T13:32:12.453Z",
+  "files": {
+    "stackwright-pro-api-otter.json": "ad0c3694af41000420229edce4108f860eaa58ab321f8618565d03ebce80bcac",
+    "stackwright-pro-auth-otter.json": "e8e02ef1389e0d5e55bfa6d960a050ab976bf7960fda4ae805675020874ce4c6",
+    "stackwright-pro-dashboard-otter.json": "0b4100afef4946bae259f5759aea872d7b1a25a00af191e1ead32bf9ee304d08",
+    "stackwright-pro-data-otter.json": "38ae3a26f064499a5f9773dfea1e2c21f9f358207110224a8e94c19443d236f1",
+    "stackwright-pro-foreman-otter.json": "bf8f0b411c5415afe0766dcfa051a0c3cb0eeea8f248a9ce44d017c104a9a314",
+    "stackwright-pro-page-otter.json": "0973f1b75a481fd177c5ada1a965f8c32e07f97fc28bbbf03b51d9e6d2af2f74"
+  }
+}

package/src/question-adapter.ts

@@ -0,0 +1,296 @@
+/**
+ * Question Adapter - Converts between Question Manifest format and ask_user_question format
+ *
+ * The ask_user_question MCP tool requires:
+ *   - question: string (full text)
+ *   - header: string (max 12 chars, short label)
+ *   - multi_select: boolean
+ *   - options: {label, description}[] (REQUIRED, min 2)
+ *
+ * Our Question Manifest format has:
+ *   - id: string (e.g., "api-1")
+ *   - question: string
+ *   - type: 'text' | 'select' | 'multi-select' | 'confirm'
+ *   - options?: {label, value}[]  (optional for text/confirm)
+ *   - required?: boolean
+ *   - default?: string | boolean | string[]
+ *   - dependsOn?: {questionId, value}
+ */
+
+export interface QuestionManifestQuestion {
+  id: string;
+  question: string;
+  type: 'text' | 'select' | 'multi-select' | 'confirm';
+  required?: boolean;
+  options?: { label: string; value: string }[];
+  default?: string | boolean | string[];
+  help?: string;
+  dependsOn?: {
+    questionId: string;
+    value: string | string[];
+  };
+}
+
+export interface AskUserQuestionOption {
+  label: string;
+  description?: string;
+}
+
+export interface AskUserQuestion {
+  question: string;
+  header: string;
+  multi_select: boolean;
+  options: AskUserQuestionOption[];
+}
+
+/**
+ * Truncate string to max length, adding ellipsis if needed
+ */
+function truncate(str: string, maxLength: number): string {
+  if (str.length <= maxLength) return str;
+  return str.substring(0, maxLength - 1) + '…';
+}
+
+/**
+ * Generate a valid header from a question ID
+ * Headers must be max 12 chars, alphanumeric with hyphens
+ */
+function generateHeader(id: string): string {
+  // Remove numbers and prefix, keep meaningful part
+  // e.g., "api-1" -> "API-1", "auth-3" -> "AUTH-3"
+  const parts = id.split('-');
+  if (parts.length >= 2) {
+    const prefix = parts[0].toUpperCase().substring(0, 4);
+    const num = parts[1];
+    return truncate(`${prefix}-${num}`, 12);
+  }
+  return truncate(
+    id
+      .toUpperCase()
+      .replace(/[^A-Z0-9]/g, '')
+      .substring(0, 12),
+    12
+  );
+}
+
+/**
+ * Generate default options for question types that don't have options
+ */
+function generateDefaultOptions(type: string): AskUserQuestionOption[] {
+  switch (type) {
+    case 'confirm':
+      return [
+        { label: 'Yes', description: 'Enable or confirm this option' },
+        { label: 'No', description: 'Disable or decline this option' },
+      ];
+    case 'text':
+      return [
+        { label: 'Specify', description: 'I will provide a specific value' },
+        { label: 'Skip', description: 'Use default or skip this question' },
+      ];
+    default:
+      return [
+        { label: 'Option 1', description: 'First option' },
+        { label: 'Option 2', description: 'Second option' },
+      ];
+  }
+}
+
+/**
+ * Convert a single QuestionManifest question to ask_user_question format
+ */
+export function adaptQuestion(q: QuestionManifestQuestion): AskUserQuestion {
+  // Generate header from ID
+  const header = generateHeader(q.id);
+
+  // Determine multi_select
+  const multiSelect = q.type === 'multi-select';
+
+  // Handle options - use provided or generate defaults
+  let options: AskUserQuestionOption[];
+
+  if (q.options && q.options.length >= 2) {
+    // Use provided options, adapt format
+    options = q.options.map((opt) => ({
+      label: truncate(opt.label, 50),
+      description: opt.value !== opt.label ? opt.value : undefined,
+    }));
+  } else if (q.options && q.options.length === 1) {
+    // Single option - add a default
+    options = [
+      ...q.options.map((opt) => ({ label: truncate(opt.label, 50), description: opt.value })),
+      { label: 'Other', description: 'Specify a different value' },
+    ];
+  } else {
+    // No options - generate defaults based on type
+    options = generateDefaultOptions(q.type);
+  }
+
+  // Ensure minimum 2 options (MCP tool requirement)
+  if (options.length < 2) {
+    options.push({ label: 'Other', description: 'Alternative option' });
+  }
+
+  // Limit to 6 options (MCP tool max)
+  options = options.slice(0, 6);
+
+  return {
+    question: q.question + (q.help ? `\n\n${q.help}` : ''),
+    header,
+    multi_select: multiSelect,
+    options,
+  };
+}
+
+/**
+ * Adapt multiple questions, filtering by dependsOn
+ *
+ * @param questions - All questions from manifest
+ * @param answers - Previously answered questions (for filtering conditionals)
+ * @returns Questions adapted for ask_user_question, with conditionals resolved
+ */
+export function adaptQuestions(
+  questions: QuestionManifestQuestion[],
+  answers: Record<string, string | string[] | boolean> = {}
+): AskUserQuestion[] {
+  const adapted: AskUserQuestion[] = [];
+
+  for (const q of questions) {
+    // Check dependsOn condition
+    if (q.dependsOn) {
+      const dependsAnswer = answers[q.dependsOn.questionId];
+      if (dependsAnswer === undefined) {
+        // Parent question not answered yet - skip this conditional question
+        continue;
+      }
+
+      // Check if the answer matches the condition
+      const expectedValues = Array.isArray(q.dependsOn.value)
+        ? q.dependsOn.value
+        : [q.dependsOn.value];
+
+      const answerValue = Array.isArray(dependsAnswer) ? dependsAnswer[0] : dependsAnswer;
+
+      if (!expectedValues.includes(answerValue as string)) {
+        // Condition not met - skip this question
+        continue;
+      }
+    }
+
+    adapted.push(adaptQuestion(q));
+  }
+
+  return adapted;
+}
+
+/**
+ * Parse JSON response from LLM (handles various formats)
+ */
+export function parseLLMQuestionsResponse(text: string): QuestionManifestQuestion[] {
+  // Try to extract JSON from the response
+  let jsonStr = text;
+
+  // Remove markdown code blocks
+  jsonStr = jsonStr.replace(/```(?:json|javascript)?\s*/gi, '');
+  jsonStr = jsonStr.replace(/```\s*$/gm, '');
+
+  // Find JSON object or array
+  const firstBrace = jsonStr.indexOf('{');
+  const firstBracket = jsonStr.indexOf('[');
+
+  let start = -1;
+  if (firstBrace !== -1 && firstBracket !== -1) {
+    start = Math.min(firstBrace, firstBracket);
+  } else if (firstBrace !== -1) {
+    start = firstBrace;
+  } else if (firstBracket !== -1) {
+    start = firstBracket;
+  }
+
+  if (start === -1) {
+    throw new Error('No JSON found in response');
+  }
+
+  jsonStr = jsonStr.substring(start);
+
+  // Handle trailing text after JSON
+  const lastBrace = jsonStr.lastIndexOf('}');
+  const lastBracket = jsonStr.lastIndexOf(']');
+  const end = Math.max(lastBrace, lastBracket);
+
+  if (end === -1) {
+    throw new Error('Invalid JSON structure');
+  }
+
+  jsonStr = jsonStr.substring(0, end + 1);
+
+  // Fix common issues
+  jsonStr = jsonStr.replace(/,(\s*[}\]])/g, '$1'); // Remove trailing commas
+  jsonStr = jsonStr.replace(/'/g, '"'); // Single quotes to double
+
+  const parsed = JSON.parse(jsonStr);
+
+  // Handle various JSON structures
+  let questions: unknown[];
+
+  if (Array.isArray(parsed)) {
+    questions = parsed;
+  } else if (parsed.questions && Array.isArray(parsed.questions)) {
+    questions = parsed.questions;
+  } else if (parsed.data && Array.isArray((parsed.data as Record<string, unknown>).questions)) {
+    questions = (parsed.data as Record<string, unknown>).questions as unknown[];
+  } else {
+    throw new Error('No questions array found in response');
+  }
+
+  return questions as QuestionManifestQuestion[];
+}
+
+/**
+ * Convert ask_user_question answers back to manifest format
+ */
+export function answersToManifestFormat(
+  answers: { question_header: string; selected_options: string[]; other_text?: string | null }[],
+  questions: QuestionManifestQuestion[]
+): Record<string, string | string[] | boolean> {
+  const result: Record<string, string | string[] | boolean> = {};
+
+  for (const answer of answers) {
+    // Find matching question by header
+    const headerLower = answer.question_header.toLowerCase();
+    const question = questions.find((q) => {
+      const qHeader = generateHeader(q.id).toLowerCase();
+      return qHeader === headerLower || q.id.toLowerCase().includes(headerLower);
+    });
+
+    if (!question) {
+      // Try to match by header prefix
+      const matched = questions.find((q) => {
+        const qHeader = generateHeader(q.id).toLowerCase();
+        return qHeader.startsWith(headerLower.split('-')[0]);
+      });
+      if (matched) {
+        result[matched.id] = answer.selected_options[0] || '';
+      }
+      continue;
+    }
+
+    // Handle multi-select vs single select
+    if (question.type === 'multi-select' || answer.selected_options.length > 1) {
+      result[question.id] = answer.selected_options;
+    } else if (question.type === 'confirm') {
+      result[question.id] = answer.selected_options[0] === 'Yes';
+    } else {
+      // For text or single select, use first option or other_text
+      if (answer.other_text) {
+        result[question.id] = answer.other_text;
+      } else if (answer.selected_options.length > 0) {
+        // Map label back to value if possible
+        const option = question.options?.find((o) => o.label === answer.selected_options[0]);
+        result[question.id] = option?.value ?? answer.selected_options[0];
+      }
+    }
+  }
+
+  return result;
+}

package/src/stackwright-pro-api-otter.json

@@ -21,12 +21,138 @@
     "4. List available entities for user selection",
     "",
     "## OUTPUT FORMAT",
-    "Report findings as a simple list:",
-    "- Entities: {list}",
-    "- Auth: {type}",
-    "- Base URL: {url}",
     "",
-    "## PASS TO DATA OTTER",
-    "After analysis, invoke pro-data-otter to wire collections."
+    "**You return a JSON artifact to the Foreman. You do NOT create files.**",
+    "",
+    "Return ONLY valid JSON \u2014 no markdown fences, no prose, no comments. Use one of these two shapes:",
+    "",
+    "SUCCESS SHAPE:",
+    "```json",
+    "{",
+    "  \"entities\": [",
+    "    {",
+    "      \"name\": \"Shipment\",",
+    "      \"endpoint\": \"/shipments\",",
+    "      \"method\": \"GET\",",
+    "      \"revalidate\": 60,",
+    "      \"mutationType\": null",
+    "    }",
+    "  ],",
+    "  \"auth\": {",
+    "    \"type\": \"bearer\",",
+    "    \"header\": \"Authorization\",",
+    "    \"envVar\": \"MARINE_LOGISTICS_API_TOKEN\"",
+    "  },",
+    "  \"baseUrl\": \"https://api.marine-logistics.mil/v2\",",
+    "  \"specPath\": \"./specs/marine-combat-logistics.yaml\"",
+    "}",
+    "```",
+    "",
+    "ERROR SHAPE (use if spec is missing, unreadable, or unsupported format):",
+    "```json",
+    "{",
+    "  \"error\": \"Spec file not found at ./specs/missing.yaml\",",
+    "  \"specPath\": \"./specs/missing.yaml\"",
+    "}",
+    "```",
+    "",
+    "Field notes:",
+    "- entities[].revalidate: seconds for ISR cache (from x-revalidate extension), or null",
+    "- entities[].mutationType: \"create\"|\"update\"|\"delete\" for mutations, null for GET",
+    "- auth.type: one of \"none\" | \"api-key\" | \"bearer\" | \"oauth2\" | \"cac\"",
+    "  (cac = DoD Common Access Card / PKI certificate authentication)",
+    "- auth.envVar: environment variable name that will hold the credential",
+    "",
+    "---",
+    "",
+    "## SCOPE BOUNDARIES",
+    "",
+    "✅ **You DO:**",
+    "- Read and parse OpenAPI/GraphQL/AsyncAPI specs",
+    "- Extract entity names, endpoint paths, auth schemes, and base URLs",
+    "- Return a structured JSON artifact to the Foreman",
+    "",
+    "❌ **You DON'T:**",
+    "- Create any files (no .ts, no .js, no .json files on disk)",
+    "- Write TypeScript types, interfaces, or classes",
+    "- Write Zod schemas",
+    "- Generate API client classes (BaseApiClient, etc.)",
+    "- Write to src/generated/ or any other directory",
+    "",
+    "**WHY:** TypeScript type generation is @stackwright-pro/openapi's job at build time.",
+    "The otter's job is discovery and configuration — not code generation.",
+    "If you find yourself about to call create_file or replace_in_file, STOP.",
+    "Return your JSON artifact to the Foreman instead.",
+    "---",
+    "",
+    "## TERMINATION",
+    "",
+    "Once you have returned your JSON artifact, your job is complete.",
+    "Do NOT invoke other agents. Do NOT create files. Do NOT send follow-up messages.",
+    "The Foreman handles all routing after receiving your artifact.",
+    "",
+    "You are invoked ONE TIME by the Foreman with full context in this prompt.",
+    "The spec path will be provided in the prompt \u2014 you do not need to ask the user for it.",
+    "",
+    "---",
+    "",
+    "## QUESTION_COLLECTION_MODE",
+    "",
+    "When invoked with QUESTION_COLLECTION_MODE=true, return questions for the user INSTEAD of doing work.",
+    "",
+    "If the prompt contains \"QUESTION_COLLECTION_MODE=true\", respond ONLY with this JSON (no other text):",
+    "",
+    "**IMPORTANT**: Your response MUST include a `requiredPackages` field alongside the `questions` array. This tells the Foreman which npm packages this otter needs — it is how we do inversion of control for dependency management.",
+    "",
+    "{",
+    "  \"questions\": [",
+    "    {",
+    "      \"id\": \"api-1\",",
+    "      \"question\": \"Do you have an existing OpenAPI spec?\",",
+    "      \"type\": \"confirm\",",
+    "      \"required\": true,",
+    "      \"default\": \"no\"",
+    "    },",
+    "    {",
+    "      \"id\": \"api-2\",",
+    "      \"question\": \"What is the URL or path to your OpenAPI spec?\",",
+    "      \"type\": \"text\",",
+    "      \"required\": true,",
+    "      \"dependsOn\": { \"questionId\": \"api-1\", \"value\": \"yes\" }",
+    "    },",
+    "    {",
+    "      \"id\": \"api-3\",",
+    "      \"question\": \"What is your API authentication method?\",",
+    "      \"type\": \"select\",",
+    "      \"options\": [",
+    "        { \"label\": \"No auth\", \"value\": \"none\" },",
+    "        { \"label\": \"API Key\", \"value\": \"api-key\" },",
+    "        { \"label\": \"OAuth2\", \"value\": \"oauth2\" },",
+    "        { \"label\": \"OIDC/SAML\", \"value\": \"oidc\" },",
+    "        { \"label\": \"CAC/PIV (DoD)\", \"value\": \"cac\" }",
+    "      ],",
+    "      \"required\": true",
+    "    },",
+    "    {",
+    "      \"id\": \"api-4\",",
+    "      \"question\": \"Which entities from the spec do you need?\",",
+    "      \"type\": \"multi-select\",",
+    "      \"options\": [",
+    "        { \"label\": \"I will tell you after you parse it\", \"value\": \"discover\" }",
+    "      ],",
+    "      \"required\": false,",
+    "      \"help\": \"You can select specific entities or let me discover them after parsing the spec.\"",
+    "    }",
+    "  ],",
+    "  \"requiredPackages\": {",
+    "    \"dependencies\": {",
+    "      \"@stackwright-pro/openapi\": \"latest\",",
+    "      \"zod\": \"^3.23.0\"",
+    "    },",
+    "    \"devPackages\": {",
+    "      \"@stoplight/prism-cli\": \"^5.14.2\"",
+    "    }",
+    "  }",
+    "}"
   ]
 }