@brainfish-ai/devdoc 0.1.42 → 0.1.44

package/renderer/lib/api-docs/code-editor/mode-context.js

@@ -0,0 +1,126 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import React, { createContext, useContext, useState, useCallback, useEffect, useMemo } from 'react';
+import { switchView } from '@/lib/docs-navigation';
+const ModeContext = /*#__PURE__*/ createContext(null);
+/**
+ * Parse view mode from URL hash
+ */ function parseViewFromHash() {
+    if (typeof window === 'undefined') return 'docs';
+    const hash = window.location.hash.slice(1);
+    if (!hash) return 'docs';
+    // Check for view suffix at the end
+    if (hash.endsWith('/playground')) return 'playground';
+    if (hash.endsWith('/notes')) return 'notes';
+    return 'docs';
+}
+/**
+ * Convert ViewMode to PlaygroundMode
+ */ function viewToPlaygroundMode(view) {
+    switch(view){
+        case 'playground':
+            return 'api_client';
+        case 'notes':
+            return 'notes';
+        default:
+            return 'docs';
+    }
+}
+/**
+ * Convert PlaygroundMode to ViewMode
+ */ function playgroundModeToView(mode) {
+    switch(mode){
+        case 'api_client':
+            return 'playground';
+        case 'notes':
+            return 'notes';
+        default:
+            return 'docs';
+    }
+}
+export function ModeProvider({ children, defaultMode = 'docs' }) {
+    // Track current hash to derive mode
+    const [hash, setHash] = useState(()=>typeof window !== 'undefined' ? window.location.hash : '');
+    // Derive mode from URL hash
+    const mode = useMemo(()=>{
+        const view = parseViewFromHash();
+        return viewToPlaygroundMode(view);
+    }, [
+        hash
+    ]);
+    // Notes-specific state (not URL-based yet)
+    const [activeFilePath, setActiveFilePathState] = useState(null);
+    const [streamingContent, setStreamingContent] = useState(null);
+    const [notesRefreshTrigger, setNotesRefreshTrigger] = useState(0);
+    // Listen for hash changes to update mode
+    useEffect(()=>{
+        const handleHashChange = ()=>{
+            setHash(window.location.hash);
+        };
+        window.addEventListener('hashchange', handleHashChange);
+        window.addEventListener('popstate', handleHashChange);
+        return ()=>{
+            window.removeEventListener('hashchange', handleHashChange);
+            window.removeEventListener('popstate', handleHashChange);
+        };
+    }, []);
+    // Wrapper for setActiveFilePath
+    const setActiveFilePath = useCallback((path)=>{
+        // Handle the ?t= timestamp suffix for forcing reloads
+        const cleanPath = path?.split('?')[0] || null;
+        setActiveFilePathState(cleanPath);
+    }, []);
+    const switchToNotes = useCallback((openFile)=>{
+        if (openFile) {
+            setActiveFilePathState(openFile);
+        }
+        switchView('notes');
+    }, []);
+    const switchToApiClient = useCallback(()=>{
+        switchView('playground');
+    }, []);
+    const switchToDocs = useCallback(()=>{
+        switchView('docs');
+    }, []);
+    const appendStreamingContent = useCallback((delta)=>{
+        setStreamingContent((prev)=>{
+            if (!prev) return prev;
+            return {
+                ...prev,
+                content: prev.content + delta
+            };
+        });
+    }, []);
+    const triggerNotesRefresh = useCallback(()=>{
+        setNotesRefreshTrigger((prev)=>prev + 1);
+    }, []);
+    const value = {
+        mode,
+        activeFilePath,
+        setActiveFilePath,
+        streamingContent,
+        setStreamingContent,
+        appendStreamingContent,
+        switchToDocs,
+        switchToNotes,
+        switchToApiClient,
+        notesRefreshTrigger,
+        triggerNotesRefresh
+    };
+    return /*#__PURE__*/ _jsx(ModeContext.Provider, {
+        value: value,
+        children: children
+    });
+}
+export function useModeContext() {
+    const context = useContext(ModeContext);
+    if (!context) {
+        throw new Error('useModeContext must be used within a ModeProvider');
+    }
+    return context;
+}
+// Hook for checking if we're in notes mode
+export function useIsNotesMode() {
+    const { mode } = useModeContext();
+    return mode === 'notes';
+}

package/renderer/lib/api-docs/code-editor/types.js

@@ -0,0 +1,53 @@
+// Types for the Notes/Scratchpad feature
+// Simplified from full project management to a brainstorming workspace
+// Helper to detect file type from path
+export function getFileType(path) {
+    const ext = path.split('.').pop()?.toLowerCase() || '';
+    const typeMap = {
+        'js': 'javascript',
+        'mjs': 'javascript',
+        'jsx': 'javascript',
+        'ts': 'typescript',
+        'tsx': 'typescript',
+        'py': 'python',
+        'go': 'go',
+        'rb': 'ruby',
+        'php': 'php',
+        'sh': 'shell',
+        'bash': 'shell',
+        'curl': 'shell',
+        'md': 'markdown',
+        'mdx': 'markdown',
+        'mmd': 'mermaid',
+        'mermaid': 'mermaid',
+        'json': 'json',
+        'yaml': 'yaml',
+        'yml': 'yaml',
+        'txt': 'text'
+    };
+    return typeMap[ext] || 'text';
+}
+// Helper to get Monaco language from file type
+export function getMonacoLanguage(path) {
+    const type = getFileType(path);
+    const languageMap = {
+        'javascript': 'javascript',
+        'typescript': 'typescript',
+        'python': 'python',
+        'go': 'go',
+        'ruby': 'ruby',
+        'php': 'php',
+        'shell': 'shell',
+        'markdown': 'markdown',
+        'mermaid': 'markdown',
+        'json': 'json',
+        'yaml': 'yaml',
+        'text': 'plaintext'
+    };
+    return languageMap[type];
+}
+// Check if file type supports preview
+export function supportsPreview(path) {
+    const type = getFileType(path);
+    return type === 'markdown' || type === 'mermaid';
+}

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

@@ -0,0 +1,258 @@
+/**
+ * Code generation definitions for supported languages/libraries
+ * Based on HTTPSnippet supported targets
+ */ export const CodegenDefinitions = [
+    // Shell
+    {
+        name: 'shell-curl',
+        lang: 'shell',
+        client: 'curl',
+        caption: 'cURL',
+        category: 'Shell'
+    },
+    {
+        name: 'shell-httpie',
+        lang: 'shell',
+        client: 'httpie',
+        caption: 'HTTPie',
+        category: 'Shell'
+    },
+    {
+        name: 'shell-wget',
+        lang: 'shell',
+        client: 'wget',
+        caption: 'Wget',
+        category: 'Shell'
+    },
+    // JavaScript
+    {
+        name: 'javascript-fetch',
+        lang: 'javascript',
+        client: 'fetch',
+        caption: 'Fetch',
+        category: 'JavaScript'
+    },
+    {
+        name: 'javascript-axios',
+        lang: 'javascript',
+        client: 'axios',
+        caption: 'Axios',
+        category: 'JavaScript'
+    },
+    {
+        name: 'javascript-jquery',
+        lang: 'javascript',
+        client: 'jquery',
+        caption: 'jQuery',
+        category: 'JavaScript'
+    },
+    {
+        name: 'javascript-xhr',
+        lang: 'javascript',
+        client: 'xhr',
+        caption: 'XMLHttpRequest',
+        category: 'JavaScript'
+    },
+    // Node.js
+    {
+        name: 'node-fetch',
+        lang: 'node',
+        client: 'fetch',
+        caption: 'Node Fetch',
+        category: 'Node.js'
+    },
+    {
+        name: 'node-axios',
+        lang: 'node',
+        client: 'axios',
+        caption: 'Axios',
+        category: 'Node.js'
+    },
+    {
+        name: 'node-native',
+        lang: 'node',
+        client: 'native',
+        caption: 'HTTP',
+        category: 'Node.js'
+    },
+    // Python
+    {
+        name: 'python-requests',
+        lang: 'python',
+        client: 'requests',
+        caption: 'Requests',
+        category: 'Python'
+    },
+    {
+        name: 'python-python3',
+        lang: 'python',
+        client: 'python3',
+        caption: 'http.client',
+        category: 'Python'
+    },
+    // Go
+    {
+        name: 'go-native',
+        lang: 'go',
+        client: 'native',
+        caption: 'Native',
+        category: 'Go'
+    },
+    // Java
+    {
+        name: 'java-okhttp',
+        lang: 'java',
+        client: 'okhttp',
+        caption: 'OkHttp',
+        category: 'Java'
+    },
+    {
+        name: 'java-unirest',
+        lang: 'java',
+        client: 'unirest',
+        caption: 'Unirest',
+        category: 'Java'
+    },
+    // C#
+    {
+        name: 'csharp-httpclient',
+        lang: 'csharp',
+        client: 'httpclient',
+        caption: 'HttpClient',
+        category: 'C#'
+    },
+    {
+        name: 'csharp-restsharp',
+        lang: 'csharp',
+        client: 'restsharp',
+        caption: 'RestSharp',
+        category: 'C#'
+    },
+    // Ruby
+    {
+        name: 'ruby-native',
+        lang: 'ruby',
+        client: 'native',
+        caption: 'Net::HTTP',
+        category: 'Ruby'
+    },
+    // PHP
+    {
+        name: 'php-curl',
+        lang: 'php',
+        client: 'curl',
+        caption: 'cURL',
+        category: 'PHP'
+    },
+    {
+        name: 'php-guzzle',
+        lang: 'php',
+        client: 'guzzle',
+        caption: 'Guzzle',
+        category: 'PHP'
+    },
+    // Swift
+    {
+        name: 'swift-nsurlsession',
+        lang: 'swift',
+        client: 'nsurlsession',
+        caption: 'URLSession',
+        category: 'Swift'
+    },
+    // Kotlin
+    {
+        name: 'kotlin-okhttp',
+        lang: 'kotlin',
+        client: 'okhttp',
+        caption: 'OkHttp',
+        category: 'Kotlin'
+    },
+    // Rust
+    {
+        name: 'rust-reqwest',
+        lang: 'rust',
+        client: 'reqwest',
+        caption: 'Reqwest',
+        category: 'Rust'
+    },
+    // C
+    {
+        name: 'c-libcurl',
+        lang: 'c',
+        client: 'libcurl',
+        caption: 'libcurl',
+        category: 'C'
+    },
+    // PowerShell
+    {
+        name: 'powershell-webrequest',
+        lang: 'powershell',
+        client: 'webrequest',
+        caption: 'Invoke-WebRequest',
+        category: 'PowerShell'
+    },
+    {
+        name: 'powershell-restmethod',
+        lang: 'powershell',
+        client: 'restmethod',
+        caption: 'Invoke-RestMethod',
+        category: 'PowerShell'
+    },
+    // Clojure
+    {
+        name: 'clojure-clj_http',
+        lang: 'clojure',
+        client: 'clj_http',
+        caption: 'clj-http',
+        category: 'Clojure'
+    },
+    // Objective-C
+    {
+        name: 'objc-nsurlsession',
+        lang: 'objc',
+        client: 'nsurlsession',
+        caption: 'NSURLSession',
+        category: 'Objective-C'
+    },
+    // OCaml
+    {
+        name: 'ocaml-cohttp',
+        lang: 'ocaml',
+        client: 'cohttp',
+        caption: 'CoHTTP',
+        category: 'OCaml'
+    },
+    // R
+    {
+        name: 'r-httr',
+        lang: 'r',
+        client: 'httr',
+        caption: 'httr',
+        category: 'R'
+    },
+    // HTTP
+    {
+        name: 'http-http1.1',
+        lang: 'http',
+        client: 'http1.1',
+        caption: 'HTTP 1.1',
+        category: 'Raw'
+    }
+];
+/**
+ * Get codegen definitions grouped by category
+ */ export function getCodegenByCategory() {
+    const grouped = {};
+    for (const def of CodegenDefinitions){
+        if (!grouped[def.category]) {
+            grouped[def.category] = [];
+        }
+        grouped[def.category].push(def);
+    }
+    return grouped;
+}
+/**
+ * Find a codegen definition by name
+ */ export function findCodegenByName(name) {
+    return CodegenDefinitions.find((def)=>def.name === name);
+}

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

@@ -0,0 +1,171 @@
+/**
+ * HAR (HTTP Archive) Request Builder
+ * Converts BrainfishRESTRequest to HAR format for HTTPSnippet
+ */ /**
+ * Build HAR headers from request headers
+ */ function buildHarHeaders(request) {
+    return request.headers.filter((header)=>header.active).map((header)=>({
+            name: header.key,
+            value: header.value
+        }));
+}
+/**
+ * Build HAR query strings from request params
+ */ function buildHarQueryStrings(request) {
+    return request.params.filter((param)=>param.active).map((param)=>({
+            name: param.key,
+            value: param.value
+        }));
+}
+/**
+ * Build HAR post params for form data
+ */ function buildHarPostParams(body) {
+    const result = [];
+    for (const entry of body){
+        if (!entry.active) continue;
+        if (entry.isFile) {
+            // Handle file entries
+            const values = Array.isArray(entry.value) ? entry.value : [
+                entry.value
+            ];
+            for(let i = 0; i < values.length; i++){
+                result.push({
+                    name: entry.key,
+                    fileName: entry.key,
+                    contentType: entry.contentType || 'application/octet-stream'
+                });
+            }
+        } else {
+            result.push({
+                name: entry.key,
+                value: entry.value,
+                contentType: entry.contentType
+            });
+        }
+    }
+    return result;
+}
+/**
+ * Parse URL-encoded body string to params
+ */ function parseUrlEncodedBody(body) {
+    if (!body) return [];
+    return body.split('\n').map((line)=>{
+        const colonIndex = line.indexOf(':');
+        if (colonIndex === -1) {
+            return {
+                name: line.trim(),
+                value: ''
+            };
+        }
+        const key = line.slice(0, colonIndex).trim();
+        const value = line.slice(colonIndex + 1).trim();
+        return {
+            name: key,
+            value
+        };
+    });
+}
+/**
+ * Build HAR post data from request body
+ */ function buildHarPostData(request) {
+    const { contentType, body } = request.body;
+    if (!contentType || !body) return undefined;
+    // Handle form data types
+    if (contentType === 'application/x-www-form-urlencoded') {
+        return {
+            mimeType: contentType,
+            params: typeof body === 'string' ? parseUrlEncodedBody(body) : []
+        };
+    }
+    if (contentType === 'multipart/form-data') {
+        return {
+            mimeType: contentType,
+            params: Array.isArray(body) ? buildHarPostParams(body) : []
+        };
+    }
+    // Handle text-based content types (JSON, XML, HTML, plain text)
+    return {
+        mimeType: contentType,
+        text: typeof body === 'string' ? body : JSON.stringify(body)
+    };
+}
+/**
+ * Add authentication headers to the request
+ */ function addAuthHeaders(request, headers) {
+    const { auth } = request;
+    const result = [
+        ...headers
+    ];
+    if (!auth.authActive) return result;
+    switch(auth.authType){
+        case 'basic':
+            {
+                if (auth.username && auth.password) {
+                    const credentials = btoa(`${auth.username}:${auth.password}`);
+                    result.push({
+                        name: 'Authorization',
+                        value: `Basic ${credentials}`
+                    });
+                }
+                break;
+            }
+        case 'bearer':
+            {
+                if (auth.token) {
+                    result.push({
+                        name: 'Authorization',
+                        value: `Bearer ${auth.token}`
+                    });
+                }
+                break;
+            }
+        case 'api-key':
+            {
+                if (auth.key && auth.value) {
+                    if (auth.addTo === 'HEADERS') {
+                        result.push({
+                            name: auth.key,
+                            value: auth.value
+                        });
+                    }
+                }
+                break;
+            }
+    }
+    return result;
+}
+/**
+ * Build URL with query parameters for API key auth
+ */ function buildUrlWithApiKeyAuth(request) {
+    let url = request.endpoint;
+    // Add API key to query params if configured
+    if (request.auth.authActive && request.auth.authType === 'api-key' && request.auth.addTo === 'QUERY_PARAMS' && request.auth.key && request.auth.value) {
+        const separator = url.includes('?') ? '&' : '?';
+        url = `${url}${separator}${encodeURIComponent(request.auth.key)}=${encodeURIComponent(request.auth.value)}`;
+    }
+    return url;
+}
+/**
+ * Convert BrainfishRESTRequest to HAR Request format
+ */ export function buildHarRequest(request) {
+    const headers = addAuthHeaders(request, buildHarHeaders(request));
+    const url = buildUrlWithApiKeyAuth(request);
+    // Add content-type header if body exists and not already present
+    if (request.body.contentType && !headers.some((h)=>h.name.toLowerCase() === 'content-type')) {
+        headers.push({
+            name: 'Content-Type',
+            value: request.body.contentType
+        });
+    }
+    return {
+        method: request.method,
+        url,
+        httpVersion: 'HTTP/1.1',
+        cookies: [],
+        headers,
+        queryString: buildHarQueryStrings(request),
+        postData: buildHarPostData(request),
+        headersSize: -1,
+        bodySize: -1
+    };
+}