@brainfish-ai/devdoc 0.1.42 → 0.1.43

package/renderer/components/ui/spinner.js

@@ -0,0 +1,92 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from "@/lib/utils";
+import { CircleNotch } from "@phosphor-icons/react";
+import { useEffect, useState } from "react";
+export function Spinner({ size = "md", className }) {
+    const sizeClasses = {
+        sm: "h-4 w-4",
+        md: "h-6 w-6",
+        lg: "h-8 w-8"
+    };
+    return /*#__PURE__*/ _jsx(CircleNotch, {
+        className: cn("animate-spin text-primary", sizeClasses[size], className)
+    });
+}
+const loadingMessages = [
+    "Loading API documentation...",
+    "Fetching endpoint specifications...",
+    "Preparing interactive documentation...",
+    "Compiling API reference...",
+    "Initializing documentation viewer...",
+    "Loading schema definitions...",
+    "Rendering API endpoints...",
+    "Setting up interactive examples...",
+    "Organizing API methods...",
+    "Building comprehensive docs...",
+    "Configuring API explorer...",
+    "Loading request/response models..."
+];
+export function LoadingSpinner({ message = "Loading...", className, dynamicText = false }) {
+    const [currentMessage, setCurrentMessage] = useState(message);
+    useEffect(()=>{
+        if (!dynamicText) {
+            setCurrentMessage(message);
+            return;
+        }
+        // Initialize with a random message
+        const initialIndex = Math.floor(Math.random() * loadingMessages.length);
+        setCurrentMessage(loadingMessages[initialIndex]);
+        const messageInterval = setInterval(()=>{
+            setCurrentMessage((prevMessage)=>{
+                const currentIndex = loadingMessages.indexOf(prevMessage);
+                const nextIndex = (currentIndex + 1) % loadingMessages.length;
+                return loadingMessages[nextIndex];
+            });
+        }, 2000) // Change message every 2 seconds
+        ;
+        return ()=>{
+            clearInterval(messageInterval);
+        };
+    }, [
+        dynamicText,
+        message
+    ]);
+    return /*#__PURE__*/ _jsxs("div", {
+        className: cn("flex flex-col items-center justify-center space-y-6", className),
+        children: [
+            /*#__PURE__*/ _jsxs("div", {
+                className: "relative",
+                children: [
+                    /*#__PURE__*/ _jsx(Spinner, {
+                        size: "lg",
+                        className: "drop-shadow-sm"
+                    }),
+                    /*#__PURE__*/ _jsx("div", {
+                        className: "absolute inset-0 bg-primary/10 rounded-full blur-lg scale-150 animate-pulse"
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsxs("div", {
+                className: "text-center max-w-xs",
+                children: [
+                    /*#__PURE__*/ _jsx("p", {
+                        className: "text-sm text-muted-foreground animate-in fade-in-0 duration-500 font-medium",
+                        children: currentMessage
+                    }, currentMessage),
+                    dynamicText && /*#__PURE__*/ _jsx("div", {
+                        className: "flex justify-center mt-3 space-x-1",
+                        children: [
+                            ...Array(3)
+                        ].map((_, i)=>/*#__PURE__*/ _jsx("div", {
+                                className: "w-1 h-1 bg-primary/60 rounded-full animate-pulse",
+                                style: {
+                                    animationDelay: `${i * 0.3}s`,
+                                    animationDuration: '1.8s'
+                                }
+                            }, i))
+                    })
+                ]
+            })
+        ]
+    });
+}

package/renderer/components/ui/tabs.js

@@ -0,0 +1,34 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+import * as TabsPrimitive from "@radix-ui/react-tabs";
+import { cn } from "@/lib/utils";
+function Tabs({ className, ...props }) {
+    return /*#__PURE__*/ _jsx(TabsPrimitive.Root, {
+        "data-slot": "tabs",
+        className: cn("flex flex-col gap-2", className),
+        ...props
+    });
+}
+function TabsList({ className, ...props }) {
+    return /*#__PURE__*/ _jsx(TabsPrimitive.List, {
+        "data-slot": "tabs-list",
+        className: cn("bg-muted text-muted-foreground inline-flex h-9 w-fit items-center justify-center rounded-sm p-[3px]", className),
+        ...props
+    });
+}
+function TabsTrigger({ className, ...props }) {
+    return /*#__PURE__*/ _jsx(TabsPrimitive.Trigger, {
+        "data-slot": "tabs-trigger",
+        className: cn("data-[state=active]:bg-background dark:data-[state=active]:text-foreground focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:outline-ring dark:data-[state=active]:border-input dark:data-[state=active]:bg-input/30 text-foreground dark:text-muted-foreground inline-flex h-[calc(100%-1px)] flex-1 items-center justify-center gap-1.5 rounded-sm border border-transparent px-2 py-1 text-sm font-medium whitespace-nowrap transition-[color,box-shadow] focus-visible:ring-[3px] focus-visible:outline-1 disabled:pointer-events-none disabled:opacity-50 data-[state=active]:shadow-sm [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4", className),
+        ...props
+    });
+}
+function TabsContent({ className, ...props }) {
+    return /*#__PURE__*/ _jsx(TabsPrimitive.Content, {
+        "data-slot": "tabs-content",
+        className: cn("flex-1 outline-none", className),
+        ...props
+    });
+}
+export { Tabs, TabsList, TabsTrigger, TabsContent };

package/renderer/components/ui/tooltip.js

@@ -0,0 +1,43 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+import { cn } from "@/lib/utils";
+function TooltipProvider({ delayDuration = 0, ...props }) {
+    return /*#__PURE__*/ _jsx(TooltipPrimitive.Provider, {
+        "data-slot": "tooltip-provider",
+        delayDuration: delayDuration,
+        ...props
+    });
+}
+function Tooltip({ ...props }) {
+    return /*#__PURE__*/ _jsx(TooltipProvider, {
+        children: /*#__PURE__*/ _jsx(TooltipPrimitive.Root, {
+            "data-slot": "tooltip",
+            ...props
+        })
+    });
+}
+function TooltipTrigger({ ...props }) {
+    return /*#__PURE__*/ _jsx(TooltipPrimitive.Trigger, {
+        "data-slot": "tooltip-trigger",
+        ...props
+    });
+}
+function TooltipContent({ className, sideOffset = 0, children, ...props }) {
+    return /*#__PURE__*/ _jsx(TooltipPrimitive.Portal, {
+        children: /*#__PURE__*/ _jsxs(TooltipPrimitive.Content, {
+            "data-slot": "tooltip-content",
+            sideOffset: sideOffset,
+            className: cn("bg-foreground text-background animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 w-fit origin-(--radix-tooltip-content-transform-origin) rounded-sm px-3 py-1.5 text-xs text-balance", className),
+            ...props,
+            children: [
+                children,
+                /*#__PURE__*/ _jsx(TooltipPrimitive.Arrow, {
+                    className: "bg-foreground fill-foreground z-50 size-2.5 translate-y-[calc(-50%_-_2px)] rotate-45 rounded-[2px]"
+                })
+            ]
+        })
+    });
+}
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/renderer/hooks/use-code-copy.js

@@ -0,0 +1,76 @@
+'use client';
+import { useEffect } from 'react';
+/**
+ * Hook to add copy buttons to rehype-pretty-code figures
+ * This enhances static code blocks with interactive copy functionality
+ */ export function useCodeCopy(containerRef, deps = []) {
+    useEffect(()=>{
+        if (!containerRef.current) return;
+        // Small delay to ensure content is rendered
+        const timeoutId = setTimeout(()=>{
+            if (!containerRef.current) return;
+            const figures = containerRef.current.querySelectorAll('[data-rehype-pretty-code-figure]');
+            figures.forEach((figure)=>{
+                // Skip if already has a copy button
+                if (figure.querySelector('.code-copy-button')) return;
+                const title = figure.querySelector('[data-rehype-pretty-code-title]');
+                const pre = figure.querySelector('pre');
+                const code = pre?.querySelector('code');
+                if (!pre || !code) return;
+                // Create copy button
+                const button = document.createElement('button');
+                button.type = 'button';
+                button.className = 'code-copy-button';
+                button.title = 'Copy code';
+                button.innerHTML = `
+          <svg class="copy-icon" xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" viewBox="0 0 256 256">
+            <path d="M216,32H88a8,8,0,0,0-8,8V80H40a8,8,0,0,0-8,8V216a8,8,0,0,0,8,8H168a8,8,0,0,0,8-8V176h40a8,8,0,0,0,8-8V40A8,8,0,0,0,216,32ZM160,208H48V96H160Zm48-48H176V88a8,8,0,0,0-8-8H96V48H208Z"></path>
+          </svg>
+          <svg class="check-icon" xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill="currentColor" viewBox="0 0 256 256" style="display:none;">
+            <path d="M229.66,77.66l-128,128a8,8,0,0,1-11.32,0l-56-56a8,8,0,0,1,11.32-11.32L96,188.69,218.34,66.34a8,8,0,0,1,11.32,11.32Z"></path>
+          </svg>
+        `;
+                button.addEventListener('click', async ()=>{
+                    const text = code.textContent || '';
+                    try {
+                        await navigator.clipboard.writeText(text);
+                        // Show check icon
+                        const copyIcon = button.querySelector('.copy-icon');
+                        const checkIcon = button.querySelector('.check-icon');
+                        if (copyIcon && checkIcon) {
+                            copyIcon.style.display = 'none';
+                            checkIcon.style.display = 'block';
+                            checkIcon.style.color = 'rgb(16, 185, 129)';
+                            setTimeout(()=>{
+                                copyIcon.style.display = 'block';
+                                checkIcon.style.display = 'none';
+                            }, 2000);
+                        }
+                    } catch (err) {
+                        console.error('Failed to copy:', err);
+                    }
+                });
+                // If there's a title, add button to header area
+                if (title) {
+                    // Create a wrapper for the header content
+                    const headerWrapper = document.createElement('div');
+                    headerWrapper.className = 'code-header-wrapper';
+                    // Move title into wrapper
+                    title.parentNode?.insertBefore(headerWrapper, title);
+                    headerWrapper.appendChild(title);
+                    headerWrapper.appendChild(button);
+                } else {
+                    // For code blocks without title, add button to pre
+                    pre.style.position = 'relative';
+                    button.classList.add('code-copy-button-floating');
+                    pre.appendChild(button);
+                }
+            });
+        }, 100);
+        return ()=>clearTimeout(timeoutId);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [
+        containerRef,
+        ...deps
+    ]);
+}

package/renderer/hooks/use-openapi-title.js

@@ -0,0 +1,33 @@
+'use client';
+import { useState, useEffect } from 'react';
+export function useOpenApiTitle() {
+    const [title, setTitle] = useState('API Documentation');
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    useEffect(()=>{
+        async function fetchTitle() {
+            try {
+                setLoading(true);
+                const response = await fetch('/api/openapi-spec');
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch OpenAPI spec: ${response.status}`);
+                }
+                const spec = await response.json();
+                setTitle(spec.info.title || 'API Documentation');
+                setError(null);
+            } catch (err) {
+                console.error('Error fetching OpenAPI title:', err);
+                setError(err instanceof Error ? err.message : 'Unknown error');
+                setTitle('API Documentation'); // Fallback title
+            } finally{
+                setLoading(false);
+            }
+        }
+        fetchTitle();
+    }, []);
+    return {
+        title,
+        loading,
+        error
+    };
+}

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

@@ -0,0 +1,4 @@
+/**
+ * Agent Module Exports
+ */ export * from './types';
+export * from './indexer';

package/renderer/lib/api-docs/agent/indexer.js

@@ -0,0 +1,254 @@
+/**
+ * Collection Indexer
+ * Builds a searchable index of all API endpoints for the AI agent
+ */ /**
+ * Find a request by ID in the collection (recursive)
+ */ export function findRequestById(collection, id) {
+    // Check direct requests
+    const found = collection.requests.find((r)=>r.id === id);
+    if (found) return found;
+    // Check folders recursively
+    for (const folder of collection.folders){
+        const request = findRequestById(folder, id);
+        if (request) return request;
+    }
+    return null;
+}
+/**
+ * Format full request details for AI context
+ * Returns a structured object with all the information the AI needs
+ */ export function formatRequestForAI(request) {
+    // Format parameters
+    const parameters = request.params.map((p)=>({
+            name: p.key,
+            description: p.description || '',
+            required: p.active
+        }));
+    // Format headers
+    const headers = request.headers.filter((h)=>![
+            'Content-Type',
+            'Authorization'
+        ].includes(h.key)) // Filter out auto-managed headers
+    .map((h)=>({
+            name: h.key,
+            description: h.description || '',
+            required: h.active
+        }));
+    // Format auth
+    const auth = {
+        type: request.auth.authType
+    };
+    if (request.auth.authType === 'api-key') {
+        auth.details = {
+            keyName: request.auth.key,
+            location: request.auth.addTo === 'HEADERS' ? 'header' : 'query'
+        };
+    } else if (request.auth.authType === 'bearer') {
+        auth.details = {
+            headerFormat: 'Bearer <token>'
+        };
+    } else if (request.auth.authType === 'basic') {
+        auth.details = {
+            format: 'Basic base64(username:password)'
+        };
+    }
+    // Format body
+    const body = {
+        required: request.body.body !== null,
+        contentType: request.body.contentType,
+        schema: null
+    };
+    if (request.body.body !== null) {
+        if (Array.isArray(request.body.body)) {
+            // Form data
+            body.schema = request.body.body.map((item)=>({
+                    key: item.key,
+                    isFile: item.isFile
+                }));
+        } else if (typeof request.body.body === 'string') {
+            // JSON or raw body - try to parse and extract schema info
+            try {
+                const parsed = JSON.parse(request.body.body);
+                body.example = request.body.body;
+                // Extract field names and types from example
+                body.schema = JSON.stringify(extractSchemaFromExample(parsed), null, 2);
+            } catch  {
+                // Raw string body
+                body.example = request.body.body.slice(0, 500);
+                body.schema = 'raw text';
+            }
+        }
+    }
+    // Format responses
+    const responses = Object.entries(request.responses).map(([name, resp])=>({
+            code: resp.code,
+            status: resp.status,
+            description: name !== resp.status ? name : undefined,
+            example: resp.body ? resp.body.slice(0, 500) : undefined
+        }));
+    return {
+        id: request.id,
+        name: request.name,
+        method: request.method,
+        path: request.endpoint,
+        description: request.description,
+        parameters,
+        headers,
+        auth,
+        body,
+        responses
+    };
+}
+/**
+ * Extract a simple schema from a JSON example
+ */ function extractSchemaFromExample(obj, depth = 0) {
+    if (depth > 3) return '...' // Prevent deep recursion
+    ;
+    if (obj === null) return 'null';
+    if (typeof obj === 'string') return 'string';
+    if (typeof obj === 'number') return 'number';
+    if (typeof obj === 'boolean') return 'boolean';
+    if (Array.isArray(obj)) {
+        if (obj.length === 0) return '[]';
+        return [
+            extractSchemaFromExample(obj[0], depth + 1)
+        ];
+    }
+    if (typeof obj === 'object') {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)){
+            result[key] = extractSchemaFromExample(value, depth + 1);
+        }
+        return result;
+    }
+    return 'unknown';
+}
+/**
+ * Recursively extracts all requests from a collection and its nested folders
+ */ function extractRequests(collection, parentTags = []) {
+    const results = [];
+    // Add requests from this level
+    for (const request of collection.requests){
+        results.push({
+            request,
+            tags: [
+                ...parentTags,
+                collection.name
+            ].filter((t)=>t !== 'root')
+        });
+    }
+    // Recursively process folders
+    for (const folder of collection.folders){
+        const folderResults = extractRequests(folder, [
+            ...parentTags,
+            collection.name
+        ]);
+        results.push(...folderResults);
+    }
+    return results;
+}
+/**
+ * Builds an endpoint index for AI context
+ */ export function buildEndpointIndex(collection) {
+    const allRequests = extractRequests(collection);
+    return allRequests.map(({ request, tags })=>({
+            id: request.id,
+            name: request.name,
+            method: request.method,
+            path: request.endpoint,
+            description: request.description,
+            parameters: request.params.map((p)=>p.key),
+            hasBody: request.body.body !== null,
+            tags: [
+                ...new Set([
+                    ...tags,
+                    ...request.tags
+                ])
+            ].filter(Boolean)
+        }));
+}
+/**
+ * Formats the endpoint index as a string for the AI system prompt
+ */ export function formatEndpointsForContext(endpoints) {
+    return endpoints.map((ep, i)=>{
+        const params = ep.parameters.length > 0 ? `\n   Parameters: ${ep.parameters.join(', ')}` : '';
+        const tags = ep.tags.length > 0 ? `\n   Tags: ${ep.tags.join(', ')}` : '';
+        return `${i + 1}. [${ep.method}] ${ep.path}
+   ID: ${ep.id}
+   Name: ${ep.name}${ep.description ? `\n   Description: ${ep.description.slice(0, 200)}${ep.description.length > 200 ? '...' : ''}` : ''}${params}${tags}`;
+    }).join('\n\n');
+}
+/**
+ * Fuzzy/BM25-like search over endpoints
+ */ export function searchEndpoints(endpoints, query, method) {
+    // Tokenize query
+    const queryTokens = query.toLowerCase().split(/\s+/).filter((t)=>t.length > 1);
+    const queryLower = query.toLowerCase();
+    // Score each endpoint
+    const scoredEndpoints = endpoints.filter((ep)=>!method || ep.method === method).map((ep)=>{
+        let score = 0;
+        const nameLower = ep.name.toLowerCase();
+        const pathLower = ep.path.toLowerCase();
+        const descLower = (ep.description || '').toLowerCase();
+        const tagsLower = ep.tags.map((t)=>t.toLowerCase());
+        const paramsLower = ep.parameters.map((p)=>p.toLowerCase());
+        // Exact phrase match (highest priority)
+        if (nameLower.includes(queryLower)) score += 100;
+        if (pathLower.includes(queryLower)) score += 80;
+        if (descLower.includes(queryLower)) score += 60;
+        // Token matching
+        for (const token of queryTokens){
+            // Name matches (most important)
+            if (nameLower === token) score += 50;
+            else if (nameLower.startsWith(token)) score += 30;
+            else if (nameLower.includes(token)) score += 20;
+            // Path segment matches
+            const pathParts = pathLower.split('/').filter(Boolean);
+            if (pathParts.some((part)=>part === token)) score += 40;
+            if (pathParts.some((part)=>part.startsWith(token))) score += 25;
+            if (pathParts.some((part)=>part.includes(token))) score += 15;
+            // Description matches
+            if (descLower.includes(token)) score += 15;
+            // Tag matches
+            if (tagsLower.some((tag)=>tag === token)) score += 30;
+            if (tagsLower.some((tag)=>tag.includes(token))) score += 15;
+            // Parameter matches
+            if (paramsLower.some((param)=>param === token)) score += 25;
+            if (paramsLower.some((param)=>param.includes(token))) score += 10;
+            // HTTP method relevance
+            if (ep.method.toLowerCase() === token) score += 20;
+            // Fuzzy matching for similar words
+            const allWords = [
+                nameLower,
+                ...pathParts,
+                ...tagsLower,
+                ...paramsLower
+            ];
+            for (const word of allWords){
+                if (word.length > 2 && token.length > 2) {
+                    const minLen = Math.min(word.length, token.length);
+                    let matches = 0;
+                    for(let i = 0; i < minLen; i++){
+                        if (word[i] === token[i]) matches++;
+                    }
+                    if (matches / minLen > 0.7) score += 5;
+                }
+            }
+        }
+        return {
+            ...ep,
+            score
+        };
+    });
+    // Filter and sort by score
+    return scoredEndpoints.filter((ep)=>ep.score > 0).sort((a, b)=>b.score - a.score).slice(0, 10).map((ep)=>({
+            id: ep.id,
+            name: ep.name,
+            method: ep.method,
+            path: ep.path,
+            description: ep.description,
+            parameters: ep.parameters,
+            hasBody: ep.hasBody,
+            tags: ep.tags
+        }));
+}