@bluefly/openstandardagents 0.2.4 → 0.2.5-RC

package/website/package.json

@@ -1,17 +1,21 @@
 {
   "name": "ossa-website",
-  "version": "0.2.3",
+  "version": "0.2.5-RC",
   "description": "Open Standard Agents - The OpenAPI for AI Agents",
   "private": true,
   "scripts": {
     "sync-version": "node scripts/sync-version.js",
+    "fetch-versions": "node scripts/fetch-versions.js",
     "sync-wiki": "npx tsx scripts/sync-wiki.ts",
-    "dev": "npm run sync-version && next dev",
-    "build": "npm run sync-version && npm run sync-wiki && next build",
-    "build:no-wiki": "npm run sync-version && next build",
+    "merge-docs-to-wiki": "npx tsx scripts/merge-docs-to-wiki.ts",
+    "upload-wiki": "npx tsx scripts/upload-wiki.ts",
+    "generate-examples": "node scripts/generate-examples-index.js",
+    "dev": "npm run fetch-versions && npm run sync-version && npm run generate-examples && next dev",
+    "build": "npm run fetch-versions && npm run sync-version && npm run sync-wiki && npm run generate-examples && next build",
+    "build:no-wiki": "npm run fetch-versions && npm run sync-version && npm run generate-examples && next build",
     "start": "next start",
     "lint": "next lint",
-    "export": "npm run sync-version && npm run sync-wiki && next build"
+    "export": "npm run fetch-versions && npm run sync-version && npm run sync-wiki && npm run generate-examples && next build"
   },
   "keywords": [
     "ossa",
@@ -22,6 +26,7 @@
   "author": "OSSA Community",
   "license": "MIT",
   "dependencies": {
+    "axios": "^1.7.7",
     "@monaco-editor/react": "^4.6.0",
     "@types/node": "^24.10.0",
     "@types/react": "^18.3.1",
@@ -48,6 +53,7 @@
     "@types/react-syntax-highlighter": "^15.5.13",
     "eslint": "^9.18.0",
     "eslint-config-next": "^15.5.6",
+    "sass": "^1.94.2",
     "tsx": "^4.19.0"
   }
 }

package/website/postcss.config.mjs

@@ -1,7 +1,7 @@
 /** @type {import('postcss-load-config').Config} */
 const config = {
   plugins: {
-    '@tailwindcss/postcss': {},
+    tailwindcss: {},
     autoprefixer: {},
   },
 };

package/website/scripts/fetch-versions.js

@@ -0,0 +1,166 @@
+const fs = require('fs');
+const path = require('path');
+const axios = require('axios');
+
+const NPM_PACKAGE_NAME = '@bluefly/openstandardagents';
+const NPM_REGISTRY_URL = `https://registry.npmjs.org/${NPM_PACKAGE_NAME}`;
+const SPEC_DIR = path.join(__dirname, '../../spec');
+const OUTPUT_FILE = path.join(__dirname, '../lib/versions.json');
+
+async function fetchVersions() {
+  console.log('Fetching version information...');
+
+  let npmVersions = [];
+  let distTags = {};
+
+  try {
+    console.log(`Querying npm registry: ${NPM_REGISTRY_URL}`);
+    const response = await axios.get(NPM_REGISTRY_URL);
+    const data = response.data;
+
+    npmVersions = Object.keys(data.versions || {});
+    distTags = data['dist-tags'] || {};
+    console.log(`Found ${npmVersions.length} published versions on npm`);
+    console.log('Dist tags:', distTags);
+  } catch (error) {
+    console.error('Error fetching npm versions:', error.message);
+    // Fallback to local package.json if npm registry is unreachable
+    const packageJsonPath = path.join(__dirname, '../../package.json');
+    if (fs.existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      npmVersions = [packageJson.version];
+      distTags = { latest: packageJson.version };
+      console.log('Falling back to local package.json version:', packageJson.version);
+    }
+  }
+
+  // Scan local spec directory for available schema versions
+  const localSpecVersions = [];
+  if (fs.existsSync(SPEC_DIR)) {
+    const specDirs = fs.readdirSync(SPEC_DIR)
+      .filter(dir => {
+        const dirPath = path.join(SPEC_DIR, dir);
+        return fs.statSync(dirPath).isDirectory() && dir.startsWith('v');
+      })
+      .map(dir => dir.substring(1)) // Remove 'v' prefix
+      .sort((a, b) => {
+        const [aMajor, aMinor, aPatch] = a.split('.').map(Number);
+        const [bMajor, bMinor, bPatch] = b.split('.').map(Number);
+        if (aMajor !== bMajor) return bMajor - aMajor;
+        if (aMinor !== bMinor) return bMinor - aMinor;
+        return bPatch - aPatch;
+      });
+    
+    localSpecVersions.push(...specDirs);
+    console.log(`Scanning spec directory: ${SPEC_DIR}`);
+    console.log(`Found ${localSpecVersions.length} schema versions in spec/`);
+  }
+
+  const allVersions = [];
+  const processedVersions = new Set();
+
+  // Add npm published versions
+  npmVersions.forEach(version => {
+    if (!processedVersions.has(version)) {
+      const isStable = distTags.latest === version;
+      const isDev = distTags.dev === version;
+      // Pre-release versions: -dev, -pre, -rc, alpha, beta, or version like 0.2.4-dev
+      const isPreRelease = version.includes('-dev') || version.includes('-pre') || version.includes('-rc') || version.includes('alpha') || version.includes('beta');
+      // Dev versions are specifically tagged as 'dev' in npm or end with -dev
+      const isDevVersion = isDev || (version.includes('-dev') && !version.includes('-pre'));
+      
+      allVersions.push({
+        version,
+        tag: `v${version}`,
+        apiVersion: `ossa/v${version}`,
+        type: isStable ? 'stable' : (isDevVersion ? 'dev' : (isPreRelease ? 'prerelease' : 'stable')),
+        published: true,
+        available: true,
+      });
+      processedVersions.add(version);
+    }
+  });
+
+  // Add local spec versions that are not yet in allVersions
+  localSpecVersions.forEach(version => {
+    if (!processedVersions.has(version)) {
+      const schemaPath = path.join(SPEC_DIR, `v${version}`, `ossa-${version}.schema.json`);
+      const schemaExists = fs.existsSync(schemaPath);
+      
+      // Determine version type for local versions
+      let versionType = 'local';
+      if (version === '0.2.4-dev') {
+        // v0.2.4-dev is a pre-release version
+        versionType = 'prerelease';
+      } else if (version.includes('-dev')) {
+        // Other -dev versions (like 0.2.5-dev) are dev versions
+        versionType = 'dev';
+      } else if (version.includes('-pre') || version.includes('-rc') || version.includes('alpha') || version.includes('beta')) {
+        versionType = 'prerelease';
+      } else {
+        // Stable versions (like 0.2.3)
+        versionType = 'stable';
+      }
+      
+      allVersions.push({
+        version,
+        tag: `v${version}`,
+        apiVersion: `ossa/v${version}`,
+        type: versionType,
+        published: false,
+        available: schemaExists,
+        schemaPath: schemaExists ? schemaPath : undefined,
+      });
+      processedVersions.add(version);
+    }
+  });
+
+  // Sort versions (latest stable first, then dev, then older stable, then local)
+  allVersions.sort((a, b) => {
+    // Prioritize stable, then dev, then prerelease, then local
+    const typeOrder = { stable: 0, dev: 1, prerelease: 2, local: 3 };
+    if (typeOrder[a.type] !== typeOrder[b.type]) {
+      return typeOrder[a.type] - typeOrder[b.type];
+    }
+
+    // Then sort by version number (descending)
+    const [aMajor, aMinor, aPatch] = a.version.split('.').map(Number);
+    const [bMajor, bMinor, bPatch] = b.version.split('.').map(Number);
+    if (aMajor !== bMajor) return bMajor - aMajor;
+    if (aMinor !== bMinor) return bMinor - aMinor;
+    return bPatch - aPatch;
+  });
+
+  // Prioritize npm's latest tag for stable version
+  const npmStableVersion = distTags.latest || allVersions.find(v => v.type === 'stable' && v.published)?.version;
+  const stableVersion = npmStableVersion || allVersions.find(v => v.type === 'stable')?.version || '0.2.3'; // Fallback
+  
+  // Prioritize npm's dev tag for dev version
+  const npmDevVersion = distTags.dev || allVersions.find(v => (v.type === 'dev' || v.type === 'prerelease') && v.published)?.version;
+  const devVersion = npmDevVersion || allVersions.find(v => v.type === 'dev')?.version || allVersions.find(v => v.type === 'prerelease')?.version || '0.2.5-dev'; // Fallback
+
+  const versionsData = {
+    stable: stableVersion,
+    latest: stableVersion, // 'latest' dist-tag points to stable
+    dev: devVersion, // 'dev' dist-tag points to dev
+    all: allVersions,
+    fallbackVersion: '0.2.3', // Fallback if all else fails
+  };
+
+  // Ensure output directory exists
+  const outputDir = path.dirname(OUTPUT_FILE);
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  fs.writeFileSync(OUTPUT_FILE, JSON.stringify(versionsData, null, 2));
+  console.log(`✅ Generated ${OUTPUT_FILE}`);
+  console.log(`   Stable: ${versionsData.stable}`);
+  console.log(`   Dev: ${versionsData.dev}`);
+  console.log(`   Total versions: ${versionsData.all.length}`);
+}
+
+fetchVersions().catch(error => {
+  console.error('Error in fetchVersions:', error);
+  process.exit(1);
+});

package/website/scripts/generate-examples-index.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+
+/**
+ * Generate examples index JSON for static export
+ * Run during build to create examples.json
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const examplesDir = path.join(__dirname, '../../examples');
+const outputFile = path.join(__dirname, '../public/examples.json');
+
+function getAllExamples() {
+  const examples = [];
+
+  if (!fs.existsSync(examplesDir)) {
+    console.log('⚠️  Examples directory not found:', examplesDir);
+    return examples;
+  }
+
+  // Map directories to 10 main categories
+  function getCategory(dirPath) {
+    const relativePath = path.relative(examplesDir, dirPath).toLowerCase();
+    const pathParts = relativePath.split(path.sep);
+    const topLevel = pathParts[0];
+
+    // 1. Getting Started
+    if (topLevel === 'getting-started' || topLevel === 'quickstart' || topLevel === 'minimal') {
+      return 'Getting Started';
+    }
+
+    // 2. Framework Integration
+    if (['langchain', 'crewai', 'openai', 'anthropic', 'autogen', 'langflow', 'langgraph', 'llamaindex', 'cursor', 'vercel'].includes(topLevel)) {
+      return 'Framework Integration';
+    }
+
+    // 3. Agent Types
+    if (topLevel === 'agent-manifests' || pathParts.includes('workers') || pathParts.includes('orchestrators') || 
+        pathParts.includes('critics') || pathParts.includes('judges') || pathParts.includes('monitors') || 
+        pathParts.includes('governors') || pathParts.includes('integrators')) {
+      return 'Agent Types';
+    }
+
+    // 4. Production
+    if (topLevel === 'production' || topLevel === 'enterprise' || relativePath.includes('compliance')) {
+      return 'Production';
+    }
+
+    // 5. Infrastructure
+    if (topLevel === 'kagent' || topLevel === 'bridges' || relativePath.includes('k8s') || 
+        relativePath.includes('kubernetes') || relativePath.includes('docker') || relativePath.includes('serverless')) {
+      return 'Infrastructure';
+    }
+
+    // 6. Advanced Patterns
+    if (topLevel === 'advanced' || relativePath.includes('patterns') || relativePath.includes('workflows') ||
+        relativePath.includes('model-router') || relativePath.includes('smart-model')) {
+      return 'Advanced Patterns';
+    }
+
+    // 7. Integration Patterns
+    if (topLevel === 'integration-patterns' || topLevel === 'adk-integration' || 
+        (topLevel === 'bridges' && !relativePath.includes('k8s') && !relativePath.includes('phase4'))) {
+      return 'Integration Patterns';
+    }
+
+    // 8. OpenAPI Extensions
+    if (topLevel === 'openapi-extensions' || (relativePath.includes('openapi') && topLevel !== 'openapi-extensions')) {
+      return 'OpenAPI Extensions';
+    }
+
+    // 9. Migration Guides
+    if (topLevel === 'migration-guides') {
+      return 'Migration Guides';
+    }
+
+    // 10. Spec Examples & Templates
+    if (topLevel === 'spec-examples' || topLevel === 'templates' || topLevel === 'extensions' ||
+        topLevel === 'common_npm' || topLevel === 'architecture' || topLevel === 'typescript' ||
+        topLevel === 'drupal') {
+      return 'Spec Examples & Templates';
+    }
+
+    // Handle root-level files
+    if (relativePath === '' || pathParts.length === 0 || !topLevel) {
+      return 'Getting Started';
+    }
+    
+    return 'Getting Started';
+  }
+
+  function traverseDir(dir, parentCategory = '') {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    const currentCategory = getCategory(dir);
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      const relativePath = path.relative(examplesDir, fullPath);
+
+      // Skip certain directories
+      if (entry.isDirectory()) {
+        if (entry.name === '__pycache__' || entry.name === 'node_modules' || entry.name === '.git') {
+          continue;
+        }
+        traverseDir(fullPath, currentCategory);
+      } else if (
+        entry.isFile() &&
+        (entry.name.endsWith('.yml') ||
+          entry.name.endsWith('.yaml') ||
+          entry.name.endsWith('.json') ||
+          entry.name.endsWith('.ts')) &&
+        !entry.name.startsWith('.') &&
+        entry.name !== '.gitlab-ci.yml'
+      ) {
+        try {
+          const content = fs.readFileSync(fullPath, 'utf8');
+          // Get category from file path for better categorization
+          let fileCategory = currentCategory || getCategory(path.dirname(fullPath));
+          
+          // Override category based on filename for root-level files
+          const fileName = entry.name.toLowerCase();
+          if (relativePath === entry.name) {
+            // Root-level file
+            if (fileName.includes('compliance')) {
+              fileCategory = 'Production';
+            } else if (fileName.includes('bridge')) {
+              fileCategory = 'Integration Patterns';
+            } else {
+              fileCategory = 'Getting Started';
+            }
+          } else if (fileName.includes('service-registry') || fileName.includes('registry')) {
+            fileCategory = 'Spec Examples & Templates';
+          }
+          
+          examples.push({
+            name: entry.name,
+            path: relativePath,
+            content,
+            category: fileCategory,
+          });
+        } catch (error) {
+          console.warn(`⚠️  Skipping ${fullPath}:`, error.message);
+        }
+      }
+    }
+  }
+
+  traverseDir(examplesDir);
+  return examples;
+}
+
+const examples = getAllExamples();
+
+// Ensure public directory exists
+const publicDir = path.dirname(outputFile);
+if (!fs.existsSync(publicDir)) {
+  fs.mkdirSync(publicDir, { recursive: true });
+}
+
+fs.writeFileSync(outputFile, JSON.stringify(examples, null, 2));
+console.log(`✅ Generated ${outputFile} with ${examples.length} examples`);
+

package/website/scripts/merge-docs-to-wiki.ts

@@ -0,0 +1,207 @@
+#!/usr/bin/env npx tsx
+/**
+ * Merge Local Docs to GitLab Wiki
+ *
+ * This script helps prepare content from /docs directory for merging into GitLab wiki.
+ * It reads files from the project's /docs directory and outputs them in a format
+ * suitable for GitLab wiki pages.
+ *
+ * Usage:
+ *   npx tsx scripts/merge-docs-to-wiki.ts
+ *
+ * This will:
+ * 1. Read all markdown files from ../../docs
+ * 2. Convert them to GitLab wiki format
+ * 3. Output instructions for manual wiki upload
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+const DOCS_SOURCE_DIR = path.join(process.cwd(), 'content/docs');
+const OUTPUT_DIR = path.join(process.cwd(), '.wiki-export');
+
+interface DocFile {
+  relativePath: string;
+  fullPath: string;
+  content: string;
+  wikiSlug: string;
+}
+
+function getAllDocFiles(dir: string, basePath: string = ''): DocFile[] {
+  const files: DocFile[] = [];
+
+  if (!fs.existsSync(dir)) {
+    console.log(`⚠️  Directory ${dir} does not exist`);
+    return files;
+  }
+
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    const relativePath = basePath ? `${basePath}/${entry.name}` : entry.name;
+
+    if (entry.isDirectory()) {
+      // Skip certain directories
+      if (entry.name === 'node_modules' || entry.name.startsWith('.')) {
+        continue;
+      }
+      files.push(...getAllDocFiles(fullPath, relativePath));
+    } else if (entry.isFile() && entry.name.endsWith('.md')) {
+      const content = fs.readFileSync(fullPath, 'utf-8');
+      // Convert file path to wiki slug format
+      // e.g., "getting-started.md" -> "Getting-Started"
+      // e.g., "migration/general-agent-schema.yml" -> "Migration/General-Agent-Schema"
+      const wikiSlug = relativePath
+        .replace(/\.md$/, '')
+        .split('/')
+        .map(part => part
+          .split('-')
+          .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+          .join('-')
+        )
+        .join('/');
+
+      files.push({
+        relativePath,
+        fullPath,
+        content,
+        wikiSlug,
+      });
+    }
+  }
+
+  return files;
+}
+
+function processContentForWiki(content: string, filename: string): string {
+  // Remove frontmatter if present (wiki doesn't use it)
+  if (content.startsWith('---')) {
+    const endIndex = content.indexOf('---', 3);
+    if (endIndex !== -1) {
+      content = content.substring(endIndex + 3).trim();
+    }
+  }
+
+  // Fix relative links - convert to wiki-relative format
+  // This is a basic conversion - may need manual adjustment
+  content = content.replace(/\]\(\.\.\/examples\//g, '](Examples/');
+  content = content.replace(/\]\(\.\.\/spec\//g, '](Specification/');
+  content = content.replace(/\]\(\.\.\/migration\//g, '](Migration/');
+  content = content.replace(/\]\(getting-started\.md\)/g, '](Getting-Started)');
+  content = content.replace(/\]\(openapi-extensions\.md\)/g, '](OpenAPI-Extensions)');
+
+  return content;
+}
+
+async function mergeDocsToWiki(): Promise<void> {
+  console.log('🔄 Preparing docs for GitLab wiki merge...\n');
+
+  // Read all doc files
+  const docFiles = getAllDocFiles(DOCS_SOURCE_DIR);
+
+  if (docFiles.length === 0) {
+    console.log('❌ No markdown files found in docs directory');
+    return;
+  }
+
+  console.log(`📚 Found ${docFiles.length} documentation files\n`);
+
+  // Create output directory
+  if (!fs.existsSync(OUTPUT_DIR)) {
+    fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+  }
+
+  // Process and write files
+  const manifest: Array<{ slug: string; file: string; size: number }> = [];
+
+  for (const doc of docFiles) {
+    const processedContent = processContentForWiki(doc.content, doc.relativePath);
+    const outputPath = path.join(OUTPUT_DIR, `${doc.wikiSlug}.md`);
+
+    // Ensure directory exists
+    const outputDir = path.dirname(outputPath);
+    if (!fs.existsSync(outputDir)) {
+      fs.mkdirSync(outputDir, { recursive: true });
+    }
+
+    fs.writeFileSync(outputPath, processedContent);
+    manifest.push({
+      slug: doc.wikiSlug,
+      file: doc.relativePath,
+      size: processedContent.length,
+    });
+
+    console.log(`✅ ${doc.relativePath} -> ${doc.wikiSlug}`);
+  }
+
+  // Write manifest
+  const manifestPath = path.join(OUTPUT_DIR, 'MANIFEST.json');
+  fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+
+  // Write instructions
+  const instructions = `# GitLab Wiki Merge Instructions
+
+## Files Prepared
+
+${docFiles.length} documentation files have been prepared for GitLab wiki.
+
+## How to Merge
+
+### Option 1: Manual Upload (Recommended for First Time)
+
+1. Go to your GitLab project: https://${process.env.GITLAB_HOST || 'gitlab.com'}/blueflyio/openstandardagents/-/wikis
+2. For each file in the manifest:
+   - Click "New Page"
+   - Use the slug as the page title (e.g., "Getting-Started")
+   - Copy the content from .wiki-export/[slug].md
+   - Save the page
+
+### Option 2: GitLab API (Automated)
+
+You can use the GitLab API to upload pages programmatically:
+
+\`\`\`bash
+# Set your GitLab token
+export GITLAB_TOKEN="your-token-here"
+// GITLAB_HOST should be set via environment variable or CI_SERVER_HOST
+
+# Upload each page
+for file in .wiki-export/*.md; do
+  slug=$(basename "$file" .md)
+  curl -X POST \\
+    "https://\${GITLAB_HOST}/api/v4/projects/llm%2Fopenstandardagents/wikis" \\
+    -H "PRIVATE-TOKEN: \${GITLAB_TOKEN}" \\
+    -F "title=\${slug}" \\
+    -F "content=@\${file}"
+done
+\`\`\`
+
+## Files to Upload
+
+See MANIFEST.json for the complete list of files and their wiki slugs.
+
+## Notes
+
+- Links may need manual adjustment after upload
+- Images and assets should be uploaded separately
+- Some relative links may need to be updated for wiki structure
+`;
+
+  fs.writeFileSync(path.join(OUTPUT_DIR, 'INSTRUCTIONS.md'), instructions);
+
+  console.log(`\n✨ Prepared ${docFiles.length} files for wiki merge`);
+  console.log(`📁 Output directory: ${OUTPUT_DIR}`);
+  console.log(`\n📋 Next steps:`);
+  console.log(`   1. Review files in ${OUTPUT_DIR}`);
+  console.log(`   2. Follow instructions in ${OUTPUT_DIR}/INSTRUCTIONS.md`);
+  console.log(`   3. Upload to GitLab wiki manually or via API`);
+}
+
+// Run if called directly
+mergeDocsToWiki().catch((error) => {
+  console.error('❌ Failed to prepare docs for wiki:', error.message);
+  process.exit(1);
+});
+

package/website/scripts/sync-version.js

@@ -17,16 +17,44 @@ const versionTsPath = path.join(__dirname, '..', 'lib', 'version.ts');
 const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
 const version = packageJson.version;
 
+// Read versions.json if it exists
+const versionsJsonPath = path.join(__dirname, '..', 'lib', 'versions.json');
+let versionsData = { all: [], stable: version, dev: null };
+try {
+  if (fs.existsSync(versionsJsonPath)) {
+    versionsData = JSON.parse(fs.readFileSync(versionsJsonPath, 'utf8'));
+  }
+} catch (e) {
+  // Ignore if versions.json doesn't exist yet
+}
+
 // Generate version.ts content
 const versionTsContent = `// OSSA version constants
 // AUTO-GENERATED - DO NOT EDIT DIRECTLY
 // Update package.json version instead, then run: npm run sync-version
 
+import versionsData from './versions.json';
+
 export const OSSA_VERSION = "${version}";
 export const OSSA_VERSION_TAG = \`v\${OSSA_VERSION}\`;
 export const OSSA_API_VERSION = \`ossa/v\${OSSA_VERSION}\`;
 export const OSSA_SCHEMA_VERSION = OSSA_VERSION;
 
+// Aliases for backward compatibility
+export const STABLE_VERSION = OSSA_VERSION;
+export const STABLE_VERSION_TAG = OSSA_VERSION_TAG;
+
+// Version data from versions.json
+export const STABLE_VERSIONS = versionsData.all.filter((v: any) => v.type === 'stable');
+export const DEV_VERSIONS = versionsData.all.filter((v: any) => v.type === 'dev' || v.type === 'prerelease');
+export const ALL_VERSIONS = versionsData.all;
+export const DEV_VERSION_TAG = versionsData.dev ? \`v\${versionsData.dev}\` : undefined;
+
+// Utility to get version info
+export function getVersionInfo(version: string): any {
+  return versionsData.all.find((v: any) => v.version === version);
+}
+
 // Utility to get schema path
 export function getSchemaPath(ver = OSSA_VERSION): string {
   return \`/schemas/ossa-\${ver}.schema.json\`;