@opensaas/stack-cli 0.4.0 → 0.6.0

package/src/mcp/lib/documentation-provider.ts

@@ -1,203 +0,0 @@
-/**
- * Documentation provider - Fetches documentation from the hosted docs site
- */
-
-import type { DocumentationLookup } from './types.js'
-
-interface SearchResult {
-  content: string
-  metadata: {
-    title?: string
-    slug?: string
-    section?: string
-  }
-  score: number
-}
-
-interface SearchResponse {
-  results: SearchResult[]
-  query: string
-  count: number
-}
-
-export class OpenSaasDocumentationProvider {
-  private readonly DOCS_API = 'https://stack.opensaas.au/api/search'
-  private cache = new Map<string, { data: DocumentationLookup; timestamp: number }>()
-  private readonly CACHE_TTL = 1000 * 60 * 30 // 30 minutes
-
-  // Topic mappings for user-friendly queries
-  private topicMappings: Record<string, string> = {
-    fields: 'field-types',
-    'field types': 'field-types',
-    'field type': 'field-types',
-    access: 'access-control',
-    'access control': 'access-control',
-    permissions: 'access-control',
-    auth: 'authentication',
-    authentication: 'authentication',
-    login: 'authentication',
-    'sign in': 'authentication',
-    hooks: 'hooks',
-    hook: 'hooks',
-    lifecycle: 'hooks',
-    plugins: 'plugin-system',
-    plugin: 'plugin-system',
-    rag: 'rag',
-    search: 'semantic-search',
-    'semantic search': 'semantic-search',
-    storage: 'file-storage',
-    files: 'file-storage',
-    upload: 'file-storage',
-    config: 'configuration',
-    configuration: 'configuration',
-    prisma: 'prisma-integration',
-    database: 'database-setup',
-    deployment: 'deployment',
-    deploy: 'deployment',
-  }
-
-  /**
-   * Search documentation by query
-   */
-  async searchDocs(query: string, limit = 5, minScore = 0.7): Promise<DocumentationLookup> {
-    const cacheKey = `search:${query}:${limit}:${minScore}`
-
-    // Check cache
-    const cached = this.cache.get(cacheKey)
-    if (cached && Date.now() - cached.timestamp < this.CACHE_TTL) {
-      return cached.data
-    }
-
-    try {
-      const response = await fetch(this.DOCS_API, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ query, limit, minScore }),
-      })
-
-      if (!response.ok) {
-        throw new Error(`Docs API error: ${response.statusText}`)
-      }
-
-      const data = (await response.json()) as SearchResponse
-
-      const docLookup: DocumentationLookup = {
-        topic: query,
-        content: this.formatSearchResults(data.results),
-        url: 'https://stack.opensaas.au/',
-        codeExamples: this.extractCodeExamples(data.results),
-        relatedTopics: this.extractRelatedTopics(data.results),
-      }
-
-      // Cache the result
-      this.cache.set(cacheKey, { data: docLookup, timestamp: Date.now() })
-
-      return docLookup
-    } catch (error) {
-      console.error('Error fetching documentation:', error)
-      return this.getFallbackDocs(query)
-    }
-  }
-
-  /**
-   * Get documentation for a specific topic
-   */
-  async getTopicDocs(topic: string): Promise<DocumentationLookup> {
-    // Normalize topic using mappings
-    const normalizedTopic = this.topicMappings[topic.toLowerCase()] || topic
-
-    return this.searchDocs(normalizedTopic, 3, 0.8)
-  }
-
-  /**
-   * Format search results into readable content
-   */
-  private formatSearchResults(results: SearchResult[]): string {
-    if (results.length === 0) {
-      return 'No documentation found for this query.'
-    }
-
-    return results
-      .map((result, index) => {
-        const title = result.metadata.title || `Section ${index + 1}`
-        const section = result.metadata.section || ''
-        const score = (result.score * 100).toFixed(0)
-
-        return `### ${title}${section ? ` (${section})` : ''} [Relevance: ${score}%]\n\n${result.content}\n`
-      })
-      .join('\n---\n\n')
-  }
-
-  /**
-   * Extract code examples from search results
-   */
-  private extractCodeExamples(results: SearchResult[]): string[] {
-    const codeExamples: string[] = []
-    const codeBlockRegex = /```[\s\S]*?```/g
-
-    for (const result of results) {
-      const matches = result.content.match(codeBlockRegex)
-      if (matches) {
-        codeExamples.push(...matches)
-      }
-    }
-
-    return codeExamples
-  }
-
-  /**
-   * Extract related topics from search results
-   */
-  private extractRelatedTopics(results: SearchResult[]): string[] {
-    const topics = new Set<string>()
-
-    for (const result of results) {
-      if (result.metadata.section) {
-        topics.add(result.metadata.section)
-      }
-    }
-
-    return Array.from(topics)
-  }
-
-  /**
-   * Fallback documentation when API is unavailable
-   */
-  private getFallbackDocs(query: string): DocumentationLookup {
-    return {
-      topic: query,
-      content: `Unable to fetch documentation from the docs site at this time.
-
-Please visit the OpenSaaS Stack documentation directly:
-https://stack.opensaas.au/
-
-For ${query}, you can also check:
-- GitHub repository: https://github.com/OpenSaasAU/stack
-- Example projects in the examples/ directory`,
-      url: 'https://stack.opensaas.au/',
-      codeExamples: [],
-      relatedTopics: [],
-    }
-  }
-
-  /**
-   * Clear expired cache entries
-   */
-  clearExpiredCache(): void {
-    const now = Date.now()
-    for (const [key, value] of this.cache.entries()) {
-      if (now - value.timestamp >= this.CACHE_TTL) {
-        this.cache.delete(key)
-      }
-    }
-  }
-
-  /**
-   * Clear all cache
-   */
-  clearCache(): void {
-    this.cache.clear()
-  }
-}

package/src/mcp/lib/features/catalog.ts

@@ -1,301 +0,0 @@
-/**
- * Feature catalog - Defines all available features with their configuration wizards
- */
-
-import type { Feature } from '../types.js'
-
-export const AUTHENTICATION_FEATURE: Feature = {
-  id: 'authentication',
-  name: 'User Authentication',
-  description: 'Complete authentication system with sessions, sign-up/sign-in, and access control',
-  category: 'authentication',
-  includes: [
-    'User list with email, password, name, and optional fields',
-    'Better-auth integration with session management',
-    'Sign-up and sign-in pages with form validation',
-    'Access control helpers (isAuthenticated, isAdmin, isOwner)',
-    'OAuth providers (optional)',
-    'Email verification (optional)',
-  ],
-  questions: [
-    {
-      id: 'auth-methods',
-      text: 'Which authentication methods do you want to support?',
-      type: 'multiselect',
-      required: true,
-      options: ['Email & Password', 'Google OAuth', 'GitHub OAuth', 'Magic Links'],
-      defaultValue: ['Email & Password'],
-    },
-    {
-      id: 'user-roles',
-      text: 'Do you need user roles for access control?',
-      type: 'boolean',
-      required: true,
-      defaultValue: true,
-      followUp: {
-        if: true,
-        ask: 'What roles do you need? (Enter comma-separated, e.g., admin,editor,user)',
-        type: 'text',
-      },
-    },
-    {
-      id: 'user-fields',
-      text: 'Select additional user profile fields',
-      type: 'multiselect',
-      required: false,
-      options: ['Avatar', 'Bio', 'Phone', 'Location', 'Website'],
-      defaultValue: [],
-    },
-    {
-      id: 'email-verification',
-      text: 'Require email verification for new accounts?',
-      type: 'boolean',
-      required: true,
-      defaultValue: false,
-    },
-  ],
-}
-
-export const BLOG_FEATURE: Feature = {
-  id: 'blog',
-  name: 'Blog System',
-  description: 'Complete blog with posts, authors, and rich content editing',
-  category: 'content',
-  includes: [
-    'Post list with title, content, and metadata',
-    'Author relationship to User',
-    'Draft/publish workflow with status field',
-    'Access control (authors can edit own posts)',
-    'Rich text editor or markdown support',
-    'SEO-friendly slugs',
-  ],
-  dependsOn: ['authentication'],
-  questions: [
-    {
-      id: 'content-editor',
-      text: 'How should users write posts?',
-      type: 'select',
-      required: true,
-      options: ['Rich text editor (Tiptap)', 'Markdown', 'Plain text'],
-      defaultValue: 'Rich text editor (Tiptap)',
-    },
-    {
-      id: 'post-status',
-      text: 'Enable draft/publish workflow?',
-      type: 'boolean',
-      required: true,
-      defaultValue: true,
-    },
-    {
-      id: 'taxonomy',
-      text: 'Add categories or tags for organizing posts?',
-      type: 'multiselect',
-      required: false,
-      options: ['Categories', 'Tags'],
-      defaultValue: [],
-    },
-    {
-      id: 'post-fields',
-      text: 'Select additional post fields',
-      type: 'multiselect',
-      required: false,
-      options: [
-        'Featured image',
-        'Excerpt/summary',
-        'SEO metadata (title, description)',
-        'Published date',
-        'Reading time estimate',
-      ],
-      defaultValue: ['Featured image', 'Excerpt/summary'],
-    },
-    {
-      id: 'comments-enabled',
-      text: 'Enable comments on blog posts?',
-      type: 'boolean',
-      required: false,
-      defaultValue: false,
-    },
-  ],
-}
-
-export const COMMENTS_FEATURE: Feature = {
-  id: 'comments',
-  name: 'Comments System',
-  description: 'Add threaded comments to your content with moderation',
-  category: 'content',
-  includes: [
-    'Comment list with content and author',
-    'Relationship to commentable content',
-    'Nested replies support (optional)',
-    'Moderation workflow',
-    'Access control for comment management',
-  ],
-  dependsOn: ['authentication'],
-  questions: [
-    {
-      id: 'comment-targets',
-      text: 'What content types can users comment on?',
-      type: 'multiselect',
-      required: true,
-      options: ['Posts', 'Products', 'Other'],
-      defaultValue: ['Posts'],
-    },
-    {
-      id: 'nested-replies',
-      text: 'Allow nested/threaded replies?',
-      type: 'boolean',
-      required: true,
-      defaultValue: true,
-    },
-    {
-      id: 'moderation',
-      text: 'Comment moderation approach?',
-      type: 'select',
-      required: true,
-      options: [
-        'Auto-approve all comments',
-        'Require admin approval',
-        'Auto-approve for verified users only',
-      ],
-      defaultValue: 'Auto-approve all comments',
-    },
-    {
-      id: 'comment-features',
-      text: 'Additional comment features?',
-      type: 'multiselect',
-      required: false,
-      options: ['Upvotes/downvotes', 'Report/flag comments', 'Markdown support'],
-      defaultValue: [],
-    },
-  ],
-}
-
-export const FILE_UPLOAD_FEATURE: Feature = {
-  id: 'file-upload',
-  name: 'File Uploads',
-  description: 'Upload and manage files with cloud storage integration',
-  category: 'storage',
-  includes: [
-    'File list with name, URL, size, and type',
-    'Storage plugin integration',
-    'Upload UI components',
-    'Access control for files',
-    'Image optimization (optional)',
-  ],
-  questions: [
-    {
-      id: 'storage-provider',
-      text: 'Which storage provider do you want to use?',
-      type: 'select',
-      required: true,
-      options: ['AWS S3', 'Cloudflare R2', 'Vercel Blob', 'Local filesystem (development only)'],
-      defaultValue: 'Vercel Blob',
-    },
-    {
-      id: 'file-associations',
-      text: 'Where will files be used?',
-      type: 'multiselect',
-      required: true,
-      options: ['User avatars', 'Post featured images', 'General attachments', 'Product images'],
-      defaultValue: ['User avatars'],
-    },
-    {
-      id: 'file-types',
-      text: 'What file types should be allowed?',
-      type: 'multiselect',
-      required: true,
-      options: ['Images (jpg, png, webp)', 'PDFs', 'Videos', 'Any file type'],
-      defaultValue: ['Images (jpg, png, webp)'],
-    },
-    {
-      id: 'image-processing',
-      text: 'Enable automatic image optimization and resizing?',
-      type: 'boolean',
-      required: false,
-      defaultValue: true,
-      dependsOn: {
-        questionId: 'file-types',
-        value: 'Images (jpg, png, webp)',
-      },
-    },
-  ],
-}
-
-export const SEMANTIC_SEARCH_FEATURE: Feature = {
-  id: 'semantic-search',
-  name: 'Semantic Search',
-  description: 'AI-powered search using RAG (Retrieval Augmented Generation)',
-  category: 'search',
-  includes: [
-    'RAG plugin integration',
-    'Automatic embeddings generation',
-    'Search API endpoint',
-    'Search UI component',
-    'Relevance scoring',
-  ],
-  questions: [
-    {
-      id: 'searchable-content',
-      text: 'What content should be searchable?',
-      type: 'multiselect',
-      required: true,
-      options: ['Posts', 'Products', 'Documentation', 'User profiles'],
-      defaultValue: ['Posts'],
-    },
-    {
-      id: 'embedding-provider',
-      text: 'Which embedding provider?',
-      type: 'select',
-      required: true,
-      options: ['OpenAI (text-embedding-3-small)', 'Cohere', 'Anthropic'],
-      defaultValue: 'OpenAI (text-embedding-3-small)',
-    },
-    {
-      id: 'search-fields',
-      text: 'Which fields should be indexed for search?',
-      type: 'multiselect',
-      required: true,
-      options: ['Title', 'Content/body', 'Excerpt', 'Tags/categories'],
-      defaultValue: ['Title', 'Content/body'],
-    },
-    {
-      id: 'real-time-indexing',
-      text: 'Update search index in real-time when content changes?',
-      type: 'boolean',
-      required: true,
-      defaultValue: true,
-    },
-  ],
-}
-
-/**
- * Feature catalog - maps feature IDs to feature definitions
- */
-export const FeatureCatalog = new Map<string, Feature>([
-  ['authentication', AUTHENTICATION_FEATURE],
-  ['blog', BLOG_FEATURE],
-  ['comments', COMMENTS_FEATURE],
-  ['file-upload', FILE_UPLOAD_FEATURE],
-  ['semantic-search', SEMANTIC_SEARCH_FEATURE],
-])
-
-/**
- * Get feature by ID
- */
-export function getFeature(featureId: string): Feature | undefined {
-  return FeatureCatalog.get(featureId)
-}
-
-/**
- * Get all available features
- */
-export function getAllFeatures(): Feature[] {
-  return Array.from(FeatureCatalog.values())
-}
-
-/**
- * Get features by category
- */
-export function getFeaturesByCategory(category: Feature['category']): Feature[] {
-  return getAllFeatures().filter((f) => f.category === category)
-}