@bluefly/openstandardagents 0.1.9 → 0.2.5-RC

package/website/scripts/sync-wiki.ts

@@ -0,0 +1,322 @@
+#!/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';
+import os from 'os';
+
+// Load .env.local first to get project path
+loadEnvLocal();
+
+// Get GITLAB_HOST from env or CI variables, with fallback
+const GITLAB_HOST = process.env.GITLAB_HOST || process.env.CI_SERVER_HOST || 'gitlab.com';
+// Get project path from env (GITLAB_PROJECT_PATH) or fallback to default
+const PROJECT_PATH = process.env.GITLAB_PROJECT_PATH || 'blueflyio/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;
+}
+
+function loadEnvLocal(): void {
+  // Check multiple common locations for .env.local
+  const envPaths: string[] = [];
+  
+  // If ENV_FILE is set, use that first
+  if (process.env.ENV_FILE) {
+    envPaths.push(process.env.ENV_FILE);
+  }
+  
+  // Current directory and parent directories (walk up to 5 levels)
+  let currentDir = process.cwd();
+  for (let i = 0; i < 5; i++) {
+    envPaths.push(path.join(currentDir, '.env.local'));
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) break; // Reached filesystem root
+    currentDir = parentDir;
+  }
+  
+  // User home directory
+  envPaths.push(path.join(os.homedir(), '.env.local'));
+
+  for (const envLocalPath of envPaths) {
+    if (fs.existsSync(envLocalPath)) {
+      try {
+        const envContent = fs.readFileSync(envLocalPath, 'utf-8');
+        envContent.split('\n').forEach(line => {
+          const trimmed = line.trim();
+          if (trimmed && !trimmed.startsWith('#')) {
+            const [key, ...valueParts] = trimmed.split('=');
+            if (key && valueParts.length > 0) {
+              const value = valueParts.join('=').replace(/^["']|["']$/g, '').trim();
+              if (!process.env[key] && value) {
+                process.env[key] = value;
+              }
+            }
+          }
+        });
+        // Load from first found file only
+        return;
+      } catch (error) {
+        // Continue to next location if this one fails
+        continue;
+      }
+    }
+  }
+}
+
+async function getGitLabToken(): Promise<string | null> {
+  // .env.local already loaded at top level
+
+  // Try environment variables (check multiple possible names)
+  if (process.env.GITLAB_TOKEN) {
+    return process.env.GITLAB_TOKEN;
+  }
+  if (process.env.GITLAB_PUSH_TOKEN) {
+    return process.env.GITLAB_PUSH_TOKEN;
+  }
+  if (process.env.CI_JOB_TOKEN) {
+    return process.env.CI_JOB_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/scripts/upload-wiki.ts

@@ -0,0 +1,199 @@
+#!/usr/bin/env npx tsx
+/**
+ * Upload Wiki Export to GitLab
+ *
+ * Uploads prepared wiki files from .wiki-export to GitLab wiki via API
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+// Load .env.local first to get project path
+loadEnvLocal();
+
+const GITLAB_HOST = process.env.GITLAB_HOST || process.env.CI_SERVER_HOST || 'gitlab.com';
+// Get project path from env (GITLAB_PROJECT_PATH) or fallback to default
+const PROJECT_PATH = process.env.GITLAB_PROJECT_PATH || 'blueflyio/openstandardagents';
+const EXPORT_DIR = path.join(process.cwd(), '.wiki-export');
+
+function loadEnvLocal(): void {
+  // Check multiple common locations for .env.local
+  const envPaths: string[] = [];
+  
+  // If ENV_FILE is set, use that first
+  if (process.env.ENV_FILE) {
+    envPaths.push(process.env.ENV_FILE);
+  }
+  
+  // Current directory and parent directories (walk up to 5 levels)
+  let currentDir = process.cwd();
+  for (let i = 0; i < 5; i++) {
+    envPaths.push(path.join(currentDir, '.env.local'));
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) break; // Reached filesystem root
+    currentDir = parentDir;
+  }
+  
+  // User home directory
+  envPaths.push(path.join(os.homedir(), '.env.local'));
+
+  for (const envLocalPath of envPaths) {
+    if (fs.existsSync(envLocalPath)) {
+      try {
+        const envContent = fs.readFileSync(envLocalPath, 'utf-8');
+        envContent.split('\n').forEach(line => {
+          const trimmed = line.trim();
+          if (trimmed && !trimmed.startsWith('#')) {
+            const [key, ...valueParts] = trimmed.split('=');
+            if (key && valueParts.length > 0) {
+              const value = valueParts.join('=').replace(/^["']|["']$/g, '').trim();
+              if (!process.env[key] && value) {
+                process.env[key] = value;
+              }
+            }
+          }
+        });
+        // Load from first found file only
+        return;
+      } catch (error) {
+        // Continue to next location if this one fails
+        continue;
+      }
+    }
+  }
+}
+
+async function getGitLabToken(): Promise<string | null> {
+  // .env.local already loaded at top level
+
+  // Try environment variables (check multiple possible names)
+  if (process.env.GITLAB_TOKEN) {
+    return process.env.GITLAB_TOKEN;
+  }
+  if (process.env.GITLAB_PUSH_TOKEN) {
+    return process.env.GITLAB_PUSH_TOKEN;
+  }
+  if (process.env.CI_JOB_TOKEN) {
+    return process.env.CI_JOB_TOKEN;
+  }
+
+  const tokenPath = path.join(process.env.HOME || '', '.tokens', 'gitlab');
+  if (fs.existsSync(tokenPath)) {
+    return fs.readFileSync(tokenPath, 'utf-8').trim();
+  }
+
+  return null;
+}
+
+async function uploadWikiPage(slug: string, content: string): Promise<boolean> {
+  const token = await getGitLabToken();
+  if (!token) {
+    console.error('❌ No GitLab token found');
+    console.error('   Set GITLAB_TOKEN env var or create ~/.tokens/gitlab');
+    return false;
+  }
+
+  const encodedPath = encodeURIComponent(PROJECT_PATH);
+  const url = `https://${GITLAB_HOST}/api/v4/projects/${encodedPath}/wikis`;
+
+  try {
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'PRIVATE-TOKEN': token,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        title: slug,
+        content: content,
+        format: 'markdown',
+      }),
+    });
+
+    if (response.ok) {
+      return true;
+    } else if (response.status === 409 || response.status === 400) {
+      // Page already exists, try to update it
+      const updateUrl = `${url}/${encodeURIComponent(slug)}`;
+      const updateResponse = await fetch(updateUrl, {
+        method: 'PUT',
+        headers: {
+          'PRIVATE-TOKEN': token,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          content: content,
+          format: 'markdown',
+        }),
+      });
+      if (updateResponse.ok) {
+        return true;
+      } else {
+        const errorText = await updateResponse.text();
+        console.error(`   Update error: ${updateResponse.status} ${updateResponse.statusText}`);
+        console.error(`   ${errorText.substring(0, 200)}`);
+        return false;
+      }
+    } else {
+      const errorText = await response.text();
+      console.error(`   API error: ${response.status} ${response.statusText}`);
+      console.error(`   ${errorText.substring(0, 200)}`);
+      return false;
+    }
+  } catch (error: any) {
+    console.error(`   Network error: ${error.message}`);
+    return false;
+  }
+}
+
+async function uploadWikiFiles(): Promise<void> {
+  console.log('🔄 Uploading wiki files to GitLab...\n');
+
+  if (!fs.existsSync(EXPORT_DIR)) {
+    console.error('❌ .wiki-export directory not found');
+    console.error('   Run: npm run merge-docs-to-wiki first');
+    return;
+  }
+
+  const manifestPath = path.join(EXPORT_DIR, 'MANIFEST.json');
+  if (!fs.existsSync(manifestPath)) {
+    console.error('❌ MANIFEST.json not found');
+    return;
+  }
+
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+  console.log(`📚 Found ${manifest.length} files to upload\n`);
+
+  let successCount = 0;
+  let failCount = 0;
+
+  for (const item of manifest) {
+    const filePath = path.join(EXPORT_DIR, `${item.slug}.md`);
+    if (!fs.existsSync(filePath)) {
+      console.log(`⚠️  ${item.slug} - file not found, skipping`);
+      failCount++;
+      continue;
+    }
+
+    const content = fs.readFileSync(filePath, 'utf-8');
+    console.log(`📤 Uploading ${item.slug}...`);
+
+    const success = await uploadWikiPage(item.slug, content);
+    if (success) {
+      console.log(`✅ ${item.slug} - uploaded successfully`);
+      successCount++;
+    } else {
+      console.log(`❌ ${item.slug} - upload failed`);
+      failCount++;
+    }
+  }
+
+  console.log(`\n✨ Upload complete: ${successCount} succeeded, ${failCount} failed`);
+}
+
+uploadWikiFiles().catch((error) => {
+  console.error('❌ Upload failed:', error.message);
+  process.exit(1);
+});
+

package/website/styles/_variables.scss

@@ -0,0 +1,36 @@
+// OSSA Design System - Centralized Color Variables
+// Update colors here to change them site-wide
+
+// Brand Colors
+$ossa-primary: #4A3ECD;        // Main blue-purple - OSSA hub/standard
+$ossa-secondary: #1CB9ED;     // Cyan-blue - Agent nodes
+$ossa-accent: #9060EA;        // Purple accent
+
+// Semantic Colors - Muted for better visual harmony
+$ossa-success: #10b981;        // Muted green
+$ossa-warning: #f59e0b;        // Muted amber
+$ossa-error: #ef4444;          // Muted red
+$ossa-info: #06b6d4;           // Muted cyan
+
+// Neutral Colors
+$ossa-dark: #212529;
+$ossa-gray-900: #343a40;
+$ossa-gray-700: #495057;
+$ossa-gray-500: #6c757d;
+$ossa-gray-300: #dee2e6;
+$ossa-gray-100: #f8f9fa;
+$ossa-white: #ffffff;
+
+// Gradients - Lightest blue to darkest purple, blue spans more
+// Order: secondary (lightest blue #1CB9ED) -> primary (blue-purple #4A3ECD) -> accent (darkest purple #9060EA)
+$gradient-brand: linear-gradient(135deg, $ossa-secondary 0%, $ossa-secondary 40%, $ossa-primary 70%, $ossa-accent 100%);
+$gradient-hero: linear-gradient(135deg, $ossa-secondary 0%, $ossa-secondary 35%, $ossa-primary 65%, $ossa-accent 100%);
+$gradient-button: linear-gradient(135deg, $ossa-secondary 0%, $ossa-secondary 45%, $ossa-primary 75%, $ossa-accent 100%);
+
+// Code Colors
+$code-bg: #1e1e1e;
+$code-text: #d4d4d4;
+$code-keyword: #569cd6;
+$code-string: #ce9178;
+$code-comment: #6a9955;
+

package/website/tailwind.config.ts

@@ -0,0 +1,136 @@
+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: {
+          DEFAULT: 'var(--ossa-primary)', // From SCSS variables - #4A3ECD
+          50: '#f5f4fd',
+          100: '#e8e5fa',
+          200: '#d4cff5',
+          300: '#b5abee',
+          400: '#8f7ee4',
+          500: 'var(--ossa-primary)', // #4A3ECD - from SCSS
+          600: '#3d2fb8',
+          700: '#322598',
+          800: '#2a1f7a',
+          900: '#241f65',
+          950: '#15113a',
+        },
+        secondary: {
+          DEFAULT: 'var(--ossa-secondary)', // From SCSS variables - #1CB9ED
+          50: '#ecfbff',
+          100: '#d1f5fe',
+          200: '#a8e9fd',
+          300: '#6fd8fa',
+          400: '#2ec0f5',
+          500: 'var(--ossa-secondary)', // #1CB9ED - from SCSS
+          600: '#0a9dd1',
+          700: '#087da9',
+          800: '#0c6688',
+          900: '#105570',
+          950: '#08374a',
+        },
+        accent: {
+          DEFAULT: 'var(--ossa-accent)', // From SCSS variables - #9060EA
+          50: '#f7f4fe',
+          100: '#ede9fd',
+          200: '#ddd4fb',
+          300: '#c5b3f8',
+          400: '#a887f3',
+          500: 'var(--ossa-accent)', // #9060EA - from SCSS
+          600: '#7c3aed',
+          700: '#6b28d9',
+          800: '#5923b8',
+          900: '#4b1f97',
+          950: '#2d0f5c',
+        },
+        // Semantic colors - centralized and muted
+        // These reference CSS variables which come from SCSS variables in styles/_variables.scss
+        // Update colors in ONE place: styles/_variables.scss
+        success: {
+          DEFAULT: 'var(--ossa-success)',
+          50: '#ecfdf5',
+          100: '#d1fae5',
+          200: '#a7f3d0',
+          300: '#6ee7b7',
+          400: '#34d399',
+          500: 'var(--ossa-success)', // #10b981 - from SCSS
+          600: '#059669',
+          700: '#047857',
+          800: '#065f46',
+          900: '#064e3b',
+        },
+        warning: {
+          DEFAULT: 'var(--ossa-warning)',
+          50: '#fffbeb',
+          100: '#fef3c7',
+          200: '#fde68a',
+          300: '#fcd34d',
+          400: '#fbbf24',
+          500: 'var(--ossa-warning)', // #f59e0b - from SCSS
+          600: '#d97706',
+          700: '#b45309',
+          800: '#92400e',
+          900: '#78350f',
+        },
+        error: {
+          DEFAULT: 'var(--ossa-error)',
+          50: '#fef2f2',
+          100: '#fee2e2',
+          200: '#fecaca',
+          300: '#fca5a5',
+          400: '#f87171',
+          500: 'var(--ossa-error)', // #ef4444 - from SCSS
+          600: '#dc2626',
+          700: '#b91c1c',
+          800: '#991b1b',
+          900: '#7f1d1d',
+        },
+        info: {
+          DEFAULT: 'var(--ossa-info)',
+          50: '#ecfeff',
+          100: '#cffafe',
+          200: '#a5f3fc',
+          300: '#67e8f9',
+          400: '#22d3ee',
+          500: 'var(--ossa-info)', // #06b6d4 - from SCSS
+          600: '#0891b2',
+          700: '#0e7490',
+          800: '#155e75',
+          900: '#164e63',
+        },
+      },
+      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;