@brainfish-ai/devdoc 0.1.42 → 0.1.44

package/renderer/lib/api-docs/codegen/index.js

@@ -0,0 +1,118 @@
+/**
+ * Code Generation Utility
+ * Generates code snippets for API requests in various languages
+ * Uses server-side API route to run httpsnippet (avoids browser compatibility issues)
+ */ import { buildHarRequest } from './har';
+import { CodegenDefinitions, findCodegenByName } from './definitions';
+export { CodegenDefinitions, findCodegenByName, getCodegenByCategory } from './definitions';
+/**
+ * Generate code snippet for a request (async - calls server API)
+ * @param codegenName The codegen target name (e.g., 'shell-curl', 'javascript-fetch')
+ * @param request The Brainfish REST request to generate code for
+ * @returns Promise<CodegenResult> with generated code or error
+ */ export async function generateCodeAsync(codegenName, request) {
+    try {
+        const codegenInfo = findCodegenByName(codegenName);
+        if (!codegenInfo) {
+            return {
+                success: false,
+                error: `Unknown code generator: ${codegenName}`
+            };
+        }
+        // Build HAR request from Brainfish request
+        const harRequest = buildHarRequest(request);
+        // Call server-side API to generate code
+        const response = await fetch('/api/codegen', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                harRequest,
+                lang: codegenInfo.lang,
+                client: codegenInfo.client
+            })
+        });
+        const result = await response.json();
+        if (result.success) {
+            return {
+                success: true,
+                code: result.code
+            };
+        }
+        return {
+            success: false,
+            error: result.error || 'Code generation failed'
+        };
+    } catch (error) {
+        console.error('Code generation error:', error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error during code generation'
+        };
+    }
+}
+/**
+ * Synchronous version that returns a placeholder - use generateCodeAsync for actual code
+ * This exists for backwards compatibility with synchronous code
+ */ export function generateCode(codegenName, request) {
+    // For synchronous calls, we can't make API requests
+    // Return a placeholder that indicates async is needed
+    const codegenInfo = findCodegenByName(codegenName);
+    if (!codegenInfo) {
+        return {
+            success: false,
+            error: `Unknown code generator: ${codegenName}`
+        };
+    }
+    // Generate a simple placeholder based on the request
+    // This will be replaced by the async version in the UI
+    const url = request.endpoint;
+    const method = request.method;
+    // Simple cURL as fallback
+    let code = `curl --request ${method} \\\n  --url '${url}'`;
+    request.headers.filter((h)=>h.active).forEach((h)=>{
+        code += ` \\\n  --header '${h.key}: ${h.value}'`;
+    });
+    if (request.body.body && method !== 'GET' && method !== 'HEAD') {
+        const bodyStr = typeof request.body.body === 'string' ? request.body.body : JSON.stringify(request.body.body);
+        code += ` \\\n  --data '${bodyStr}'`;
+    }
+    return {
+        success: true,
+        code
+    };
+}
+/**
+ * Get the Monaco editor language for a codegen target
+ */ export function getMonacoLanguage(codegenName) {
+    const def = findCodegenByName(codegenName);
+    if (!def) return 'plaintext';
+    const languageMap = {
+        shell: 'shell',
+        javascript: 'javascript',
+        node: 'javascript',
+        python: 'python',
+        go: 'go',
+        java: 'java',
+        csharp: 'csharp',
+        ruby: 'ruby',
+        php: 'php',
+        swift: 'swift',
+        kotlin: 'kotlin',
+        rust: 'rust',
+        c: 'c',
+        powershell: 'powershell',
+        clojure: 'clojure',
+        objc: 'objective-c',
+        ocaml: 'plaintext',
+        r: 'r',
+        http: 'plaintext'
+    };
+    return languageMap[def.lang] || 'plaintext';
+}
+/**
+ * Get all available codegen targets
+ */ export function getAvailableCodegens() {
+    return CodegenDefinitions;
+}

package/renderer/lib/api-docs/factories.js

@@ -0,0 +1,136 @@
+/**
+ * Factory Functions for Brainfish API Documentation
+ * 
+ * Creates instances of BrainfishCollection and BrainfishRESTRequest
+ * with proper defaults and unique IDs.
+ */ /**
+ * Generates a URL-friendly slug from a string
+ * Converts to lowercase, replaces spaces and special chars with hyphens
+ */ function slugify(str) {
+    return str.toLowerCase().replace(/[{}]/g, '') // Remove braces from path params
+    .replace(/[^a-z0-9]+/g, '-') // Replace non-alphanumeric with hyphens
+    .replace(/^-+|-+$/g, '') // Remove leading/trailing hyphens
+    .replace(/-+/g, '-') // Collapse multiple hyphens
+    ;
+}
+/**
+ * Generates a human-readable, deterministic ID for requests
+ * Uses operationId if available, otherwise method + path
+ */ function generateRequestId(method, path, operationId) {
+    if (operationId) {
+        // Use operationId directly (it's already unique per spec)
+        return slugify(operationId);
+    }
+    // Generate from method + path: "get-users-id" for "GET /users/{id}"
+    const pathSlug = slugify(path);
+    return `${method.toLowerCase()}-${pathSlug}`;
+}
+/**
+ * Generates a unique ID for collections
+ * If a seed is provided, generates a deterministic slug-based ID
+ */ function generateCollectionId(name) {
+    if (name) {
+        return `coll-${slugify(name)}`;
+    }
+    return `coll_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+}
+/**
+ * Creates a BrainfishRESTRequest with defaults
+ * Generates human-readable, deterministic IDs based on operationId or method+path
+ */ export function makeBrainfishRESTRequest(request) {
+    // Extract path from endpoint (remove base URL)
+    const path = request.endpoint ? request.endpoint.replace(/^https?:\/\/[^/]+/, '') || '/' : '/';
+    // Generate human-readable ID
+    const id = generateRequestId(request.method || 'GET', path, request.operationId);
+    return {
+        id,
+        name: request.name || 'Untitled Request',
+        description: request.description ?? null,
+        method: request.method || 'GET',
+        endpoint: request.endpoint || '',
+        params: request.params || [],
+        headers: request.headers || [],
+        auth: request.auth || {
+            authType: 'none',
+            authActive: true
+        },
+        body: request.body || {
+            contentType: null,
+            body: null
+        },
+        requestVariables: request.requestVariables || [],
+        responses: request.responses || {},
+        tags: request.tags || []
+    };
+}
+/**
+ * Creates a BrainfishCollection with defaults
+ * If name is provided, generates a deterministic ID
+ */ export function makeBrainfishCollection(collection) {
+    return {
+        id: generateCollectionId(collection.name),
+        name: collection.name || 'Untitled Collection',
+        description: collection.description ?? null,
+        folders: collection.folders || [],
+        requests: collection.requests || [],
+        variables: collection.variables || [],
+        auth: collection.auth || {
+            authType: 'inherit',
+            authActive: true
+        },
+        headers: collection.headers || []
+    };
+}
+/**
+ * Creates a default BrainfishRESTRequest
+ */ export function getDefaultBrainfishRESTRequest() {
+    return makeBrainfishRESTRequest({
+        name: 'Untitled Request',
+        description: null,
+        method: 'GET',
+        endpoint: '',
+        params: [],
+        headers: [],
+        auth: {
+            authType: 'none',
+            authActive: true
+        },
+        body: {
+            contentType: null,
+            body: null
+        },
+        requestVariables: [],
+        responses: {},
+        tags: []
+    });
+}
+/**
+ * Creates a default BrainfishCollection
+ */ export function getDefaultBrainfishCollection() {
+    return makeBrainfishCollection({
+        name: 'Untitled Collection',
+        description: null,
+        folders: [],
+        requests: [],
+        variables: [],
+        auth: {
+            authType: 'inherit',
+            authActive: true
+        },
+        headers: []
+    });
+}
+/**
+ * Creates a BrainfishRESTResponseOriginalRequest
+ */ export function makeBrainfishRESTResponseOriginalRequest(request) {
+    return {
+        name: request.name,
+        method: request.method,
+        endpoint: request.endpoint,
+        params: request.params,
+        headers: request.headers,
+        body: request.body,
+        auth: request.auth,
+        requestVariables: request.requestVariables
+    };
+}

package/renderer/lib/api-docs/{index.ts → index.js}

@@ -2,16 +2,11 @@
  * Brainfish API Documentation - Main Export
  * 
  * This module exports all types, factories, and utilities for the API documentation system.
- */
-
-// Types
-export * from './types'
-
+ */ // Types
+export * from './types';
 // Factories
-export * from './factories'
-
+export * from './factories';
 // Utils
-export * from './utils'
-
+export * from './utils';
 // Parsers
-export * from './parsers/openapi'
+export * from './parsers/openapi';

package/renderer/lib/api-docs/mobile-context.js

@@ -0,0 +1,116 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useState, useCallback, useEffect } from 'react';
+const AGENT_ASSIST_STORAGE_KEY = 'devdoc-agent-assist-open';
+const MobileContext = /*#__PURE__*/ createContext(null);
+// Helper to get initial state from localStorage (default to true)
+function getInitialAgentAssistState() {
+    if (typeof window === 'undefined') return true;
+    const stored = localStorage.getItem(AGENT_ASSIST_STORAGE_KEY);
+    // Default to true (open) if not set
+    return stored === null ? true : stored === 'true';
+}
+export function MobileProvider({ children }) {
+    const [isLeftSidebarOpen, setIsLeftSidebarOpen] = useState(false);
+    const [isRightSidebarOpen, setIsRightSidebarOpen] = useState(false);
+    const [isMobile, setIsMobile] = useState(false);
+    const [isHydrated, setIsHydrated] = useState(false);
+    // Initialize from localStorage after hydration (only on desktop)
+    useEffect(()=>{
+        const isMobileView = window.innerWidth < 1024;
+        if (!isMobileView) {
+            const savedState = getInitialAgentAssistState();
+            setIsRightSidebarOpen(savedState);
+        }
+        setIsHydrated(true);
+    }, []);
+    // Detect mobile on mount and window resize
+    useEffect(()=>{
+        const checkMobile = ()=>{
+            setIsMobile(window.innerWidth < 1024); // lg breakpoint
+        };
+        // Initial check
+        checkMobile();
+        // Listen for resize
+        window.addEventListener('resize', checkMobile);
+        return ()=>window.removeEventListener('resize', checkMobile);
+    }, []);
+    // Close left sidebar when switching to desktop (left sidebar is mobile-only)
+    // Note: Right sidebar can stay open on desktop as it's now a toggleable panel
+    useEffect(()=>{
+        if (!isMobile) {
+            setIsLeftSidebarOpen(false);
+        }
+    }, [
+        isMobile
+    ]);
+    const toggleLeftSidebar = useCallback(()=>{
+        setIsLeftSidebarOpen((prev)=>!prev);
+        // Close right sidebar when opening left
+        setIsRightSidebarOpen(false);
+    }, []);
+    const toggleRightSidebar = useCallback(()=>{
+        setIsRightSidebarOpen((prev)=>{
+            const newState = !prev;
+            // Persist to localStorage (only on desktop)
+            if (typeof window !== 'undefined' && window.innerWidth >= 1024) {
+                localStorage.setItem(AGENT_ASSIST_STORAGE_KEY, String(newState));
+            }
+            return newState;
+        });
+        // Close left sidebar when opening right
+        setIsLeftSidebarOpen(false);
+    }, []);
+    const openLeftSidebar = useCallback(()=>{
+        setIsLeftSidebarOpen(true);
+        setIsRightSidebarOpen(false);
+    }, []);
+    const closeLeftSidebar = useCallback(()=>{
+        setIsLeftSidebarOpen(false);
+    }, []);
+    const openRightSidebar = useCallback(()=>{
+        setIsRightSidebarOpen(true);
+        setIsLeftSidebarOpen(false);
+        // Persist to localStorage (only on desktop)
+        if (typeof window !== 'undefined' && window.innerWidth >= 1024) {
+            localStorage.setItem(AGENT_ASSIST_STORAGE_KEY, 'true');
+        }
+    }, []);
+    const closeRightSidebar = useCallback(()=>{
+        setIsRightSidebarOpen(false);
+        // Persist to localStorage (only on desktop)
+        if (typeof window !== 'undefined' && window.innerWidth >= 1024) {
+            localStorage.setItem(AGENT_ASSIST_STORAGE_KEY, 'false');
+        }
+    }, []);
+    const closeAllSidebars = useCallback(()=>{
+        setIsLeftSidebarOpen(false);
+        setIsRightSidebarOpen(false);
+        // Persist to localStorage (only on desktop)
+        if (typeof window !== 'undefined' && window.innerWidth >= 1024) {
+            localStorage.setItem(AGENT_ASSIST_STORAGE_KEY, 'false');
+        }
+    }, []);
+    return /*#__PURE__*/ _jsx(MobileContext.Provider, {
+        value: {
+            isLeftSidebarOpen,
+            isRightSidebarOpen,
+            toggleLeftSidebar,
+            toggleRightSidebar,
+            openLeftSidebar,
+            closeLeftSidebar,
+            openRightSidebar,
+            closeRightSidebar,
+            closeAllSidebars,
+            isMobile
+        },
+        children: children
+    });
+}
+export function useMobile() {
+    const context = useContext(MobileContext);
+    if (!context) {
+        throw new Error('useMobile must be used within a MobileProvider');
+    }
+    return context;
+}

package/renderer/lib/api-docs/navigation-context.js

@@ -0,0 +1,62 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useCallback } from 'react';
+const NavigationContext = /*#__PURE__*/ createContext(null);
+/**
+ * Helper to find request by operationId (name) or ID in collection
+ */ function findRequestByOperationIdOrId(collection, operationIdOrId) {
+    // Normalize the search term (handle both snake_case and the formatted name)
+    const normalizedSearch = operationIdOrId.toLowerCase().replace(/[\s-]/g, '_');
+    // Check direct requests
+    for (const request of collection.requests){
+        // Check by ID
+        if (request.id === operationIdOrId) return request;
+        // Check by name (operationId) - exact match
+        if (request.name.toLowerCase().replace(/[\s-]/g, '_') === normalizedSearch) return request;
+        // Check by name - partial match (for formatted names like "Post Carts" -> "post_carts")
+        const requestNameNormalized = request.name.toLowerCase().replace(/[\s-]/g, '_');
+        if (requestNameNormalized === normalizedSearch) return request;
+    }
+    // Check folders recursively
+    for (const folder of collection.folders){
+        const request = findRequestByOperationIdOrId(folder, operationIdOrId);
+        if (request) return request;
+    }
+    return null;
+}
+export function NavigationProvider({ children, collection, onSelectRequest }) {
+    const navigateToEndpoint = useCallback((operationIdOrId)=>{
+        if (!collection) {
+            console.warn('[Navigation] No collection available');
+            return;
+        }
+        const request = findRequestByOperationIdOrId(collection, operationIdOrId);
+        if (request) {
+            console.log('[Navigation] Navigating to endpoint:', request.name);
+            onSelectRequest(request);
+        } else {
+            console.warn('[Navigation] Endpoint not found:', operationIdOrId);
+        }
+    }, [
+        collection,
+        onSelectRequest
+    ]);
+    return /*#__PURE__*/ _jsx(NavigationContext.Provider, {
+        value: {
+            navigateToEndpoint,
+            collection
+        },
+        children: children
+    });
+}
+export function useNavigation() {
+    const context = useContext(NavigationContext);
+    if (!context) {
+        // Return a no-op function if not in provider (for backwards compatibility)
+        return {
+            navigateToEndpoint: ()=>{},
+            collection: null
+        };
+    }
+    return context;
+}

package/renderer/lib/api-docs/parsers/graphql/index.js

@@ -0,0 +1,50 @@
+/**
+ * GraphQL Parser Module
+ * 
+ * Main entry point for GraphQL schema parsing and transformation.
+ */ export * from './types';
+export * from './parser';
+export * from './transformer';
+import { parseGraphQLSchema, validateGraphQLSchema } from './parser';
+import { convertGraphQLToBrainfishCollection, convertGraphQLToCollection } from './transformer';
+export const GRAPHQL_INVALID_SCHEMA = 'graphql/invalid_schema';
+/**
+ * Import a GraphQL schema from SDL string or file content
+ * Returns a BrainfishCollection for integration with existing UI
+ */ export async function importGraphQLSchema(input, options = {}) {
+    const { name = 'GraphQL API', endpoint = '/graphql', description } = options;
+    // Validate the schema
+    const validation = validateGraphQLSchema(input);
+    if (!validation.valid) {
+        throw new Error(`${GRAPHQL_INVALID_SCHEMA}: ${validation.error}`);
+    }
+    // Parse the schema
+    const schema = parseGraphQLSchema(input);
+    // Convert to BrainfishCollection
+    return convertGraphQLToBrainfishCollection(schema, name, endpoint, description);
+}
+/**
+ * Import a GraphQL schema and return the full GraphQL collection
+ * with schema information preserved
+ */ export async function importGraphQLSchemaFull(input, options = {}) {
+    const { name = 'GraphQL API', endpoint = '/graphql', description } = options;
+    // Validate the schema
+    const validation = validateGraphQLSchema(input);
+    if (!validation.valid) {
+        throw new Error(`${GRAPHQL_INVALID_SCHEMA}: ${validation.error}`);
+    }
+    // Parse the schema
+    const schema = parseGraphQLSchema(input);
+    // Convert to full GraphQL collection
+    return convertGraphQLToCollection(schema, name, endpoint, description);
+}
+/**
+ * Parse GraphQL schema without converting to collection
+ * Useful for schema exploration and type information
+ */ export async function parseGraphQL(input) {
+    const validation = validateGraphQLSchema(input);
+    if (!validation.valid) {
+        throw new Error(`${GRAPHQL_INVALID_SCHEMA}: ${validation.error}`);
+    }
+    return parseGraphQLSchema(input);
+}