@bluefly/openstandardagents 0.2.4

package/website/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "ossa-website",
+  "version": "0.2.3",
+  "description": "Open Standard Agents - The OpenAPI for AI Agents",
+  "private": true,
+  "scripts": {
+    "sync-version": "node scripts/sync-version.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",
+    "start": "next start",
+    "lint": "next lint",
+    "export": "npm run sync-version && npm run sync-wiki && next build"
+  },
+  "keywords": [
+    "ossa",
+    "ai-agents",
+    "standard",
+    "specification"
+  ],
+  "author": "OSSA Community",
+  "license": "MIT",
+  "dependencies": {
+    "@monaco-editor/react": "^4.6.0",
+    "@types/node": "^24.10.0",
+    "@types/react": "^18.3.1",
+    "ajv": "^8.17.1",
+    "ajv-formats": "^3.0.1",
+    "autoprefixer": "^10.4.22",
+    "date-fns": "^4.1.0",
+    "gray-matter": "^4.0.3",
+    "lucide-react": "^0.294.0",
+    "next": "^15.5.6",
+    "postcss": "^8.5.6",
+    "prism-react-renderer": "^2.3.1",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-markdown": "^9.0.1",
+    "react-syntax-highlighter": "^15.5.0",
+    "remark-gfm": "^4.0.0",
+    "tailwindcss": "^3.4.1",
+    "typescript": "^5.9.3",
+    "yaml": "^2.8.1"
+  },
+  "devDependencies": {
+    "@types/react-dom": "^18.3.1",
+    "@types/react-syntax-highlighter": "^15.5.13",
+    "eslint": "^9.18.0",
+    "eslint-config-next": "^15.5.6",
+    "tsx": "^4.19.0"
+  }
+}

package/website/postcss.config.js

@@ -0,0 +1,7 @@
+module.exports = {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+};
+

package/website/postcss.config.mjs

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

package/website/scripts/sync-version.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+
+/**
+ * Sync version from package.json to lib/version.ts
+ *
+ * Run: npm run sync-version
+ * Automatically runs on: npm run dev, npm run build
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const packageJsonPath = path.join(__dirname, '..', 'package.json');
+const versionTsPath = path.join(__dirname, '..', 'lib', 'version.ts');
+
+// Read package.json
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+const version = packageJson.version;
+
+// 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
+
+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;
+
+// Utility to get schema path
+export function getSchemaPath(ver = OSSA_VERSION): string {
+  return \`/schemas/ossa-\${ver}.schema.json\`;
+}
+
+// Utility to get spec path
+export function getSpecPath(ver = OSSA_VERSION): string {
+  return \`/spec/v\${ver}/ossa-\${ver}.schema.json\`;
+}
+`;
+
+// Write version.ts
+fs.writeFileSync(versionTsPath, versionTsContent);
+
+console.log(`✅ Synced version ${version} to lib/version.ts`);

package/website/scripts/sync-wiki.ts

@@ -0,0 +1,261 @@
+#!/usr/bin/env npx tsx
+/**
+ * GitLab Wiki Sync Script
+ *
+ * Fetches wiki pages from GitLab and saves them to content/docs for static site generation.
+ * Run this during build or manually with: npx tsx scripts/sync-wiki.ts
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+const GITLAB_HOST = process.env.GITLAB_HOST || 'gitlab.bluefly.io';
+const PROJECT_PATH = 'llm/openstandardagents';
+const DOCS_DIR = path.join(process.cwd(), 'content/docs');
+const BLOG_DIR = path.join(process.cwd(), 'content/blog');
+
+interface WikiPage {
+  slug: string;
+  title: string;
+  content: string;
+  format: string;
+}
+
+async function getGitLabToken(): Promise<string | null> {
+  // Try environment variable first
+  if (process.env.GITLAB_TOKEN) {
+    return process.env.GITLAB_TOKEN;
+  }
+
+  // Try reading from ~/.tokens/gitlab
+  const tokenPath = path.join(process.env.HOME || '', '.tokens', 'gitlab');
+  if (fs.existsSync(tokenPath)) {
+    return fs.readFileSync(tokenPath, 'utf-8').trim();
+  }
+
+  return null;
+}
+
+async function fetchWikiPages(): Promise<WikiPage[]> {
+  const token = await getGitLabToken();
+
+  if (!token) {
+    console.log('⚠️  No GitLab token found - skipping wiki sync');
+    console.log('   Set GITLAB_TOKEN env var or create ~/.tokens/gitlab to enable sync');
+    return [];
+  }
+
+  const encodedPath = encodeURIComponent(PROJECT_PATH);
+
+  const response = await fetch(
+    `https://${GITLAB_HOST}/api/v4/projects/${encodedPath}/wikis?with_content=1`,
+    {
+      headers: {
+        'PRIVATE-TOKEN': token,
+      },
+    }
+  );
+
+  if (!response.ok) {
+    // Handle auth errors gracefully - use existing content
+    if (response.status === 401 || response.status === 403) {
+      console.log(`⚠️  Wiki API returned ${response.status} - using existing content`);
+      console.log('   Token may lack wiki read permission');
+      return [];
+    }
+    throw new Error(`Failed to fetch wiki pages: ${response.status} ${response.statusText}`);
+  }
+
+  return response.json();
+}
+
+function slugToFilePath(slug: string): string {
+  // Convert GitLab wiki slug to local file path
+  // e.g., "Getting-Started/5-Minute-Overview" -> "getting-started/5-minute-overview.md"
+  const parts = slug.split('/');
+
+  // Lowercase everything for URL-friendly paths
+  if (parts.length > 1) {
+    const dirs = parts.slice(0, -1).map(d => d.toLowerCase());
+    const filename = parts[parts.length - 1].toLowerCase();
+    return path.join(...dirs, `${filename}.md`);
+  }
+
+  return `${slug.toLowerCase()}.md`;
+}
+
+function processContent(content: string, title: string): string {
+  // Add frontmatter if not present
+  if (!content.startsWith('---')) {
+    const frontmatter = `---
+title: "${title.replace(/"/g, '\\"')}"
+---
+
+`;
+    return frontmatter + content;
+  }
+  return content;
+}
+
+function processBlogContent(content: string, title: string): string {
+  // Extract or generate blog metadata from content
+  let bodyContent = content;
+  let existingMeta: Record<string, string> = {};
+
+  // Parse existing frontmatter if present
+  if (content.startsWith('---')) {
+    const endIndex = content.indexOf('---', 3);
+    if (endIndex !== -1) {
+      const frontmatterText = content.substring(3, endIndex).trim();
+      bodyContent = content.substring(endIndex + 3).trim();
+
+      // Parse simple key: value frontmatter
+      frontmatterText.split('\n').forEach(line => {
+        const colonIndex = line.indexOf(':');
+        if (colonIndex > 0) {
+          const key = line.substring(0, colonIndex).trim();
+          const value = line.substring(colonIndex + 1).trim();
+          existingMeta[key] = value;
+        }
+      });
+    }
+  }
+
+  // Look for author in content (e.g., "**Thomas Scola**")
+  const authorMatch = bodyContent.match(/\*\*([^*]+)\*\*\s*\n\s*\*([^*]+)\*/);
+  const extractedAuthor = authorMatch ? authorMatch[1].trim() : null;
+
+  // Try to extract excerpt from abstract or first paragraph
+  let excerpt = '';
+  const abstractMatch = bodyContent.match(/###\s*Abstract\s*\n+([^\n#]+)/i);
+  if (abstractMatch) {
+    excerpt = abstractMatch[1].substring(0, 200).trim();
+    if (abstractMatch[1].length > 200) excerpt += '...';
+  } else {
+    const lines = bodyContent.split('\n');
+    const firstPara = lines.find(line =>
+      line.trim() &&
+      !line.startsWith('#') &&
+      !line.startsWith('*') &&
+      !line.startsWith('[')
+    );
+    if (firstPara) {
+      excerpt = firstPara.substring(0, 200).trim();
+      if (firstPara.length > 200) excerpt += '...';
+    }
+  }
+
+  // Build final frontmatter with blog-specific fields
+  const finalTitle = existingMeta.title || title;
+  const date = existingMeta.date || new Date().toISOString().split('T')[0];
+  const author = existingMeta.author || extractedAuthor || 'OSSA Team';
+  const category = existingMeta.category || 'Research';
+  const tags = existingMeta.tags || '["OSSA", "AI Agents", "Standards"]';
+  const finalExcerpt = existingMeta.excerpt || excerpt;
+
+  const frontmatter = `---
+title: "${finalTitle.replace(/"/g, '\\"').replace(/\\/g, '')}"
+date: "${date}"
+author: "${author}"
+category: "${category}"
+tags: ${tags}
+excerpt: "${finalExcerpt.replace(/"/g, '\\"')}"
+---
+
+`;
+  return frontmatter + bodyContent;
+}
+
+async function syncWiki(): Promise<void> {
+  console.log('🔄 Syncing GitLab wiki...');
+
+  // Fetch all wiki pages
+  const pages = await fetchWikiPages();
+
+  // If no pages returned (no token or empty wiki), skip sync
+  if (pages.length === 0) {
+    console.log('📋 No pages to sync - using existing content');
+    return;
+  }
+
+  console.log(`📚 Found ${pages.length} wiki pages`);
+
+  // Track synced files for cleanup
+  const syncedDocs = new Set<string>();
+  const syncedBlogs = new Set<string>();
+
+  for (const page of pages) {
+    // Skip Home page (we have our own docs landing)
+    if (page.slug === 'Home') {
+      console.log(`⏭️  Skipping Home page (using custom landing)`);
+      continue;
+    }
+
+    // Handle Blog pages separately
+    if (page.slug === 'Blog' || page.slug.startsWith('Blog/')) {
+      // Skip the Blog index and template pages
+      if (page.slug === 'Blog' || page.slug === 'Blog/Template') {
+        console.log(`⏭️  Skipping ${page.slug} (not a blog post)`);
+        continue;
+      }
+
+      // Extract blog post name from slug (Blog/My-Post -> My-Post)
+      const blogSlug = page.slug.replace('Blog/', '');
+      const filename = `${blogSlug}.md`;
+      const fullPath = path.join(BLOG_DIR, filename);
+
+      // Ensure blog directory exists
+      if (!fs.existsSync(BLOG_DIR)) {
+        fs.mkdirSync(BLOG_DIR, { recursive: true });
+      }
+
+      // Process and write blog content
+      const processedContent = processBlogContent(page.content, page.title);
+      fs.writeFileSync(fullPath, processedContent);
+      syncedBlogs.add(filename);
+
+      console.log(`📝 Blog: ${page.slug} -> content/blog/${filename}`);
+      continue;
+    }
+
+    // Regular docs pages
+    const relativePath = slugToFilePath(page.slug);
+    const fullPath = path.join(DOCS_DIR, relativePath);
+    const dirPath = path.dirname(fullPath);
+
+    // Ensure directory exists
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+
+    // Process and write content
+    const processedContent = processContent(page.content, page.title);
+    fs.writeFileSync(fullPath, processedContent);
+    syncedDocs.add(relativePath);
+
+    console.log(`✅ ${page.slug} -> ${relativePath}`);
+  }
+
+  console.log(`\n✨ Synced ${syncedDocs.size} docs + ${syncedBlogs.size} blog posts`);
+
+  // Write manifest for tracking
+  const manifest = {
+    lastSync: new Date().toISOString(),
+    source: `https://${GITLAB_HOST}/${PROJECT_PATH}/-/wikis/home`,
+    docs: Array.from(syncedDocs).sort(),
+    blogs: Array.from(syncedBlogs).sort(),
+  };
+
+  fs.writeFileSync(
+    path.join(DOCS_DIR, '.wiki-sync-manifest.json'),
+    JSON.stringify(manifest, null, 2)
+  );
+
+  console.log('📋 Updated .wiki-sync-manifest.json');
+}
+
+// Run if called directly
+syncWiki().catch((error) => {
+  console.error('❌ Wiki sync failed:', error.message);
+  process.exit(1);
+});

package/website/tailwind.config.js

@@ -0,0 +1,58 @@
+/** @type {import('tailwindcss').Config} */
+module.exports = {
+  content: [
+    './app/**/*.{js,ts,jsx,tsx,mdx}',
+    './components/**/*.{js,ts,jsx,tsx,mdx}',
+  ],
+  theme: {
+    extend: {
+      colors: {
+        primary: {
+          DEFAULT: '#2B3E96',
+          dark: '#1A2B5C',
+        },
+        secondary: {
+          DEFAULT: '#00C9A7',
+        },
+        success: '#28A745',
+        warning: '#FFC107',
+        error: '#DC3545',
+        info: '#17A2B8',
+        gray: {
+          100: '#F8F9FA',
+          300: '#DEE2E6',
+          500: '#6C757D',
+          700: '#495057',
+          900: '#343A40',
+        },
+        dark: '#212529',
+        code: {
+          bg: '#1E1E1E',
+          text: '#D4D4D4',
+          keyword: '#569CD6',
+          string: '#CE9178',
+          comment: '#6A9955',
+        },
+      },
+      fontFamily: {
+        heading: ['Inter', '-apple-system', 'BlinkMacSystemFont', 'Segoe UI', 'sans-serif'],
+        body: ['Inter', '-apple-system', 'BlinkMacSystemFont', 'Segoe UI', 'sans-serif'],
+        code: ['Fira Code', 'SF Mono', 'Monaco', 'Inconsolata', 'monospace'],
+      },
+      fontSize: {
+        h1: '3rem',
+        h2: '2.25rem',
+        h3: '1.875rem',
+        h4: '1.5rem',
+        h5: '1.25rem',
+        h6: '1rem',
+      },
+      backgroundImage: {
+        'gradient-primary': 'linear-gradient(135deg, #2B3E96 0%, #00C9A7 100%)',
+        'gradient-hero': 'linear-gradient(180deg, #2B3E96 0%, #1A2B5C 100%)',
+      },
+    },
+  },
+  plugins: [],
+};
+

package/website/tailwind.config.ts

@@ -0,0 +1,65 @@
+import type { Config } from 'tailwindcss';
+
+const config: Config = {
+  content: [
+    './pages/**/*.{js,ts,jsx,tsx,mdx}',
+    './components/**/*.{js,ts,jsx,tsx,mdx}',
+    './app/**/*.{js,ts,jsx,tsx,mdx}',
+  ],
+  theme: {
+    extend: {
+      colors: {
+        primary: {
+          50: '#f0f9ff',
+          100: '#e0f2fe',
+          200: '#bae6fd',
+          300: '#7dd3fc',
+          400: '#38bdf8',
+          500: '#0ea5e9',
+          600: '#0284c7',
+          700: '#0369a1',
+          800: '#075985',
+          900: '#0c4a6e',
+          950: '#082f49',
+        },
+        accent: {
+          50: '#faf5ff',
+          100: '#f3e8ff',
+          200: '#e9d5ff',
+          300: '#d8b4fe',
+          400: '#c084fc',
+          500: '#a855f7',
+          600: '#9333ea',
+          700: '#7e22ce',
+          800: '#6b21a8',
+          900: '#581c87',
+          950: '#3b0764',
+        },
+      },
+      fontFamily: {
+        sans: ['Inter', 'system-ui', '-apple-system', 'sans-serif'],
+        mono: ['JetBrains Mono', 'Menlo', 'Monaco', 'Courier New', 'monospace'],
+        body: ['Inter', 'system-ui', '-apple-system', 'sans-serif'],
+        heading: ['Inter', 'system-ui', '-apple-system', 'sans-serif'],
+        code: ['JetBrains Mono', 'Menlo', 'Monaco', 'Courier New', 'monospace'],
+      },
+      typography: {
+        DEFAULT: {
+          css: {
+            maxWidth: 'none',
+            color: '#334155',
+            a: {
+              color: '#0284c7',
+              '&:hover': {
+                color: '#0369a1',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  plugins: [],
+};
+
+export default config;