@robosystems/core 0.3.0

package/components/search/SearchContent.js

@@ -0,0 +1,168 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as SDK from '@robosystems/client';
+import { Alert, Badge, Button, Card, Select, Spinner, TextInput, ToggleSwitch, } from 'flowbite-react';
+import { useCallback, useEffect, useState } from 'react';
+import { HiChevronDown, HiChevronUp, HiSearch } from 'react-icons/hi';
+import ReactMarkdown from 'react-markdown';
+import remarkGfm from 'remark-gfm';
+import { useIsRepository } from '../../components/RepositoryGuard';
+import { useGraphContext } from '../../contexts';
+import { PageLayout } from '../PageLayout';
+const PAGE_SIZE = 20;
+export function SearchContent({ config }) {
+    var _a, _b, _c;
+    const { state: graphState } = useGraphContext();
+    const graphId = graphState.currentGraphId;
+    const { isRepository } = useIsRepository();
+    // Search state
+    const [query, setQuery] = useState('');
+    const [sourceType, setSourceType] = useState((_a = config.defaultSourceType) !== null && _a !== void 0 ? _a : '');
+    const [entity, setEntity] = useState('');
+    const [formType, setFormType] = useState('');
+    const [fiscalYear, setFiscalYear] = useState('');
+    const [semantic, setSemantic] = useState(false);
+    // Results state
+    const [results, setResults] = useState([]);
+    const [total, setTotal] = useState(0);
+    const [offset, setOffset] = useState(0);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [searchedQuery, setSearchedQuery] = useState('');
+    // Document stats
+    const [docCount, setDocCount] = useState(null);
+    // Expanded section
+    const [expandedDocId, setExpandedDocId] = useState(null);
+    const [sectionContent, setSectionContent] = useState(null);
+    const [sectionLoading, setSectionLoading] = useState(false);
+    // Filters visibility
+    const [showFilters, setShowFilters] = useState((_b = config.showFilters) !== null && _b !== void 0 ? _b : false);
+    const filters = (_c = config.filters) !== null && _c !== void 0 ? _c : { sourceType: true };
+    // Load document stats when graph changes (skip for shared repositories)
+    useEffect(() => {
+        if (!graphId || isRepository) {
+            setDocCount(null);
+            return;
+        }
+        SDK.listDocuments({ path: { graph_id: graphId } })
+            .then((res) => {
+            if (res.data) {
+                setDocCount(res.data.total);
+            }
+        })
+            .catch(() => { });
+    }, [graphId, isRepository]);
+    // Reset when graph changes
+    useEffect(() => {
+        setResults([]);
+        setTotal(0);
+        setOffset(0);
+        setSearchedQuery('');
+        setError(null);
+        setExpandedDocId(null);
+        setSectionContent(null);
+    }, [graphId]);
+    const handleSearch = useCallback(async (newOffset = 0) => {
+        if (!graphId || !query.trim())
+            return;
+        setLoading(true);
+        setError(null);
+        setExpandedDocId(null);
+        setSectionContent(null);
+        try {
+            const body = {
+                query: query.trim(),
+                size: PAGE_SIZE,
+                offset: newOffset,
+            };
+            if (sourceType)
+                body.source_type = sourceType;
+            if (entity)
+                body.entity = entity;
+            if (formType)
+                body.form_type = formType;
+            if (fiscalYear) {
+                const parsed = parseInt(fiscalYear, 10);
+                if (Number.isFinite(parsed))
+                    body.fiscal_year = parsed;
+            }
+            if (semantic)
+                body.semantic = true;
+            const res = await SDK.searchDocuments({
+                path: { graph_id: graphId },
+                body: body,
+            });
+            if (res.data) {
+                const data = res.data;
+                setResults(data.hits);
+                setTotal(data.total);
+                setOffset(newOffset);
+                setSearchedQuery(data.query);
+            }
+            else {
+                setError('Search failed. Please try again.');
+            }
+        }
+        catch (_a) {
+            setError('An error occurred while searching.');
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [graphId, query, sourceType, entity, formType, fiscalYear, semantic]);
+    const handleKeyDown = (e) => {
+        if (e.key === 'Enter') {
+            handleSearch(0);
+        }
+    };
+    const handleExpand = async (docId) => {
+        if (expandedDocId === docId) {
+            setExpandedDocId(null);
+            setSectionContent(null);
+            return;
+        }
+        if (!graphId)
+            return;
+        setExpandedDocId(docId);
+        setSectionContent(null);
+        setSectionLoading(true);
+        try {
+            const res = await SDK.getDocumentSection({
+                path: { graph_id: graphId, document_id: docId },
+            });
+            if (res.data) {
+                setSectionContent(res.data);
+            }
+        }
+        catch (_a) {
+            setSectionContent(null);
+        }
+        finally {
+            setSectionLoading(false);
+        }
+    };
+    const hasFilters = filters.entity ||
+        filters.formType ||
+        filters.fiscalYear ||
+        filters.sourceType ||
+        filters.semantic;
+    if (!graphId) {
+        return (_jsx(PageLayout, { children: _jsxs("div", { className: "py-12 text-center", children: [_jsx("div", { className: "from-primary-500 to-secondary-600 mx-auto mb-4 w-fit rounded-lg bg-gradient-to-br p-3", children: _jsx(HiSearch, { className: "h-8 w-8 text-white" }) }), _jsx("h2", { className: "font-heading text-lg font-semibold text-gray-700 dark:text-gray-300", children: config.title }), _jsx("p", { className: "mt-2 text-gray-500 dark:text-gray-400", children: "Select a graph to search documents." })] }) }));
+    }
+    return (_jsxs(PageLayout, { children: [_jsxs("div", { className: "flex items-center gap-4", children: [_jsx("div", { className: "from-primary-500 to-secondary-600 rounded-lg bg-gradient-to-br p-3", children: _jsx(HiSearch, { className: "h-8 w-8 text-white" }) }), _jsxs("div", { children: [_jsx("h1", { className: "font-heading text-3xl font-bold text-gray-900 dark:text-white", children: config.title }), _jsxs("p", { className: "mt-1 text-sm text-gray-500 dark:text-gray-400", children: [config.description, docCount !== null && docCount > 0 && (_jsxs("span", { className: "ml-2 text-gray-400 dark:text-gray-500", children: ["(", docCount, " document", docCount !== 1 ? 's' : '', " indexed)"] }))] })] })] }), _jsx(Card, { children: _jsxs("div", { className: "space-y-4", children: [_jsxs("div", { className: "flex gap-2", children: [_jsx(TextInput, { className: "flex-1", placeholder: config.placeholder, value: query, onChange: (e) => setQuery(e.target.value), onKeyDown: handleKeyDown, icon: HiSearch }), _jsx(Button, { color: "purple", onClick: () => handleSearch(0), disabled: loading || !query.trim(), children: loading ? (_jsx(Spinner, { size: "sm", className: "text-white" })) : ('Search') })] }), _jsxs("div", { className: "flex flex-wrap items-center gap-4", children: [hasFilters && (_jsxs("button", { type: "button", onClick: () => setShowFilters(!showFilters), className: "flex items-center gap-1 text-sm text-gray-500 hover:text-gray-700 dark:text-gray-400 dark:hover:text-gray-200", children: ["Filters", showFilters ? (_jsx(HiChevronUp, { className: "h-4 w-4" })) : (_jsx(HiChevronDown, { className: "h-4 w-4" }))] })), filters.semantic && (_jsx(ToggleSwitch, { checked: semantic, onChange: setSemantic, label: "Semantic search" }))] }), showFilters && hasFilters && (_jsxs("div", { className: "grid grid-cols-1 gap-3 border-t border-gray-200 pt-4 sm:grid-cols-2 lg:grid-cols-4 dark:border-gray-700", children: [filters.sourceType && (_jsxs("div", { children: [_jsx("label", { htmlFor: "search-source-type", className: "mb-1 block text-xs font-medium text-gray-500 dark:text-gray-400", children: "Source Type" }), _jsxs(Select, { id: "search-source-type", value: sourceType, onChange: (e) => setSourceType(e.target.value), children: [_jsx("option", { value: "", children: "All types" }), _jsx("option", { value: "uploaded_doc", children: "Uploaded Documents" }), _jsx("option", { value: "memory", children: "AI Memories" }), _jsx("option", { value: "narrative_section", children: "Narrative Sections" }), _jsx("option", { value: "xbrl_textblock", children: "XBRL Text Blocks" }), _jsx("option", { value: "ixbrl_disclosure", children: "iXBRL Disclosures" })] })] })), filters.entity && (_jsxs("div", { children: [_jsx("label", { htmlFor: "search-entity", className: "mb-1 block text-xs font-medium text-gray-500 dark:text-gray-400", children: "Entity / Ticker" }), _jsx(TextInput, { id: "search-entity", placeholder: "e.g. NVDA", value: entity, onChange: (e) => setEntity(e.target.value) })] })), filters.formType && (_jsxs("div", { children: [_jsx("label", { htmlFor: "search-form-type", className: "mb-1 block text-xs font-medium text-gray-500 dark:text-gray-400", children: "Form Type" }), _jsxs(Select, { id: "search-form-type", value: formType, onChange: (e) => setFormType(e.target.value), children: [_jsx("option", { value: "", children: "All forms" }), _jsx("option", { value: "10-K", children: "10-K (Annual)" }), _jsx("option", { value: "10-Q", children: "10-Q (Quarterly)" }), _jsx("option", { value: "8-K", children: "8-K (Current)" }), _jsx("option", { value: "20-F", children: "20-F (Foreign Annual)" })] })] })), filters.fiscalYear && (_jsxs("div", { children: [_jsx("label", { htmlFor: "search-fiscal-year", className: "mb-1 block text-xs font-medium text-gray-500 dark:text-gray-400", children: "Fiscal Year" }), _jsx(TextInput, { id: "search-fiscal-year", type: "number", placeholder: "e.g. 2024", min: 1900, max: 2100, value: fiscalYear, onChange: (e) => setFiscalYear(e.target.value) })] }))] }))] }) }), error && (_jsx(Alert, { color: "failure", children: _jsx("span", { children: error }) })), results.length > 0 && (_jsxs("div", { className: "space-y-4", children: [_jsx("div", { className: "flex items-center justify-between", children: _jsxs("p", { className: "text-sm text-gray-500 dark:text-gray-400", children: ["Showing ", offset + 1, "\u2013", Math.min(offset + PAGE_SIZE, total), " of", ' ', total, " results for \"", searchedQuery, "\""] }) }), results.map((hit) => {
+                        var _a;
+                        return (_jsxs(Card, { children: [_jsx("button", { type: "button", className: "w-full cursor-pointer text-left", onClick: () => handleExpand(hit.document_id), "aria-expanded": expandedDocId === hit.document_id, children: _jsxs("div", { className: "flex items-start justify-between", children: [_jsxs("div", { className: "min-w-0 flex-1", children: [_jsxs("div", { className: "flex flex-wrap items-center gap-2", children: [_jsx("h3", { className: "text-base font-semibold text-gray-900 dark:text-white", children: hit.document_title || hit.section_label || 'Untitled' }), hit.section_label && hit.document_title && (_jsxs("span", { className: "text-sm text-gray-500 dark:text-gray-400", children: ["/ ", hit.section_label] }))] }), _jsxs("div", { className: "mt-2 flex flex-wrap items-center gap-2", children: [_jsx(Badge, { color: "info", size: "xs", children: hit.score.toFixed(2) }), _jsx(Badge, { color: "gray", size: "xs", children: hit.source_type }), hit.entity_ticker && (_jsx(Badge, { color: "purple", size: "xs", children: hit.entity_ticker })), hit.form_type && (_jsx(Badge, { color: "warning", size: "xs", children: hit.form_type })), hit.fiscal_year && (_jsxs(Badge, { color: "gray", size: "xs", children: ["FY", hit.fiscal_year] })), (_a = hit.tags) === null || _a === void 0 ? void 0 : _a.map((tag) => (_jsx(Badge, { color: "purple", size: "xs", children: tag }, tag)))] }), hit.snippet && (_jsx("p", { className: "mt-3 line-clamp-2 text-sm text-gray-500 dark:text-gray-400", children: hit.snippet }))] }), _jsx("div", { className: "ml-3 shrink-0 pt-1", children: expandedDocId === hit.document_id ? (_jsx(HiChevronUp, { className: "h-5 w-5 text-gray-400" })) : (_jsx(HiChevronDown, { className: "h-5 w-5 text-gray-400" })) })] }) }), expandedDocId === hit.document_id && (_jsx("div", { className: "border-t border-gray-200 pt-4 dark:border-gray-700", children: sectionLoading ? (_jsxs("div", { className: "flex items-center gap-2 text-sm text-gray-500", children: [_jsx(Spinner, { size: "sm" }), "Loading full content..."] })) : sectionContent ? (_jsxs("div", { children: [_jsx("div", { className: "prose prose-sm prose-gray max-h-96 max-w-none overflow-auto rounded-lg border border-gray-200 bg-gray-50 p-4 dark:border-gray-600 dark:bg-gray-800", children: _jsx(ReactMarkdown, { remarkPlugins: [remarkGfm], components: {
+                                                        h1: ({ children }) => (_jsx("h1", { className: "text-gray-900 dark:text-white", children: children })),
+                                                        h2: ({ children }) => (_jsx("h2", { className: "text-gray-900 dark:text-white", children: children })),
+                                                        h3: ({ children }) => (_jsx("h3", { className: "text-gray-900 dark:text-white", children: children })),
+                                                        h4: ({ children }) => (_jsx("h4", { className: "text-gray-900 dark:text-white", children: children })),
+                                                        p: ({ children }) => (_jsx("p", { className: "text-gray-700 dark:text-gray-200", children: children })),
+                                                        li: ({ children }) => (_jsx("li", { className: "text-gray-700 dark:text-gray-200", children: children })),
+                                                        strong: ({ children }) => (_jsx("strong", { className: "text-gray-900 dark:text-white", children: children })),
+                                                        table: ({ children }) => (_jsx("div", { className: "overflow-x-auto", children: _jsx("table", { className: "min-w-full border-collapse text-sm", children: children }) })),
+                                                        thead: ({ children }) => (_jsx("thead", { className: "border-b-2 border-gray-300 dark:border-gray-600", children: children })),
+                                                        th: ({ children }) => (_jsx("th", { className: "px-3 py-2 text-left font-semibold text-gray-900 dark:text-white", children: children })),
+                                                        td: ({ children }) => (_jsx("td", { className: "border-t border-gray-200 px-3 py-2 text-gray-700 dark:border-gray-700 dark:text-gray-200", children: children })),
+                                                    }, children: sectionContent.content }) }), sectionContent.content_length && (_jsxs("p", { className: "mt-2 text-xs text-gray-400 dark:text-gray-500", children: [sectionContent.content_length.toLocaleString(), ' ', "characters"] }))] })) : (_jsx("p", { className: "text-sm text-gray-500", children: "Could not load section content." })) }))] }, hit.document_id));
+                    }), total > PAGE_SIZE && (_jsxs("div", { className: "flex items-center justify-between pt-2", children: [_jsx(Button, { color: "gray", size: "sm", disabled: offset === 0 || loading, onClick: () => handleSearch(Math.max(0, offset - PAGE_SIZE)), children: "Previous" }), _jsxs("span", { className: "text-sm text-gray-500 dark:text-gray-400", children: ["Page ", Math.floor(offset / PAGE_SIZE) + 1, " of", ' ', Math.ceil(total / PAGE_SIZE)] }), _jsx(Button, { color: "gray", size: "sm", disabled: offset + PAGE_SIZE >= total || loading, onClick: () => handleSearch(offset + PAGE_SIZE), children: "Next" })] }))] })), !loading && searchedQuery && results.length === 0 && (_jsxs("div", { className: "py-8 text-center", children: [_jsxs("p", { className: "text-gray-500 dark:text-gray-400", children: ["No results found for \"", searchedQuery, "\"."] }), _jsx("p", { className: "mt-1 text-sm text-gray-400 dark:text-gray-500", children: "Try a different query or adjust your filters." })] }))] }));
+}

package/components/search/index.d.ts

@@ -0,0 +1,2 @@
+export { SearchContent } from './SearchContent';
+export type { SearchConfig, SearchFilterConfig } from './types';

package/components/search/index.js

@@ -0,0 +1 @@
+export { SearchContent } from './SearchContent';

package/components/search/types.d.ts

@@ -0,0 +1,15 @@
+export interface SearchFilterConfig {
+    sourceType?: boolean;
+    entity?: boolean;
+    formType?: boolean;
+    fiscalYear?: boolean;
+    semantic?: boolean;
+}
+export interface SearchConfig {
+    title: string;
+    description: string;
+    placeholder: string;
+    showFilters?: boolean;
+    defaultSourceType?: string;
+    filters?: SearchFilterConfig;
+}

package/components/search/types.js

@@ -0,0 +1 @@
+export {};

package/contexts/entity-context.d.ts

@@ -0,0 +1,28 @@
+import { type PropsWithChildren } from 'react';
+import type { Entity } from '../types';
+export interface EntityContextValue {
+    currentEntity: Entity | null;
+    setCurrentEntity: (entity: Entity | null) => void;
+    clearEntity: () => void;
+}
+export interface EntityProviderProps extends PropsWithChildren {
+    initialEntityCookie?: {
+        identifier: string;
+        name: string;
+        graphId: string;
+    } | null;
+}
+/**
+ * EntityProvider - Manages entity selection for entity-based graphs
+ *
+ * This provider wraps GraphProvider and adds entity-specific state management.
+ * Entity selection persists across page refreshes using cookies.
+ *
+ * Use this for apps that work with entity-based graphs (RoboLedger, RoboInvestor, etc.)
+ */
+export declare function EntityProvider({ children, initialEntityCookie, }: EntityProviderProps): import("react").JSX.Element;
+/**
+ * Hook to access entity context
+ * Must be used within an EntityProvider
+ */
+export declare function useEntity(): EntityContextValue;

package/contexts/entity-context.js

@@ -0,0 +1,89 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useEffect, useState, } from 'react';
+import { clearEntitySelection, persistEntitySelection, } from '../actions/entity-actions';
+import { useGraphContext } from './graph-context';
+const EntityContext = createContext(null);
+/**
+ * EntityProvider - Manages entity selection for entity-based graphs
+ *
+ * This provider wraps GraphProvider and adds entity-specific state management.
+ * Entity selection persists across page refreshes using cookies.
+ *
+ * Use this for apps that work with entity-based graphs (RoboLedger, RoboInvestor, etc.)
+ */
+export function EntityProvider({ children, initialEntityCookie, }) {
+    const { state: graphState } = useGraphContext();
+    const [currentEntity, setCurrentEntityState] = useState(() => {
+        // Initialize from cookie if available
+        if (initialEntityCookie) {
+            return {
+                identifier: initialEntityCookie.identifier,
+                name: initialEntityCookie.name,
+            };
+        }
+        return null;
+    });
+    const setCurrentEntity = useCallback(async (entity) => {
+        setCurrentEntityState(entity);
+        // Persist to cookie
+        try {
+            if (entity && graphState.currentGraphId) {
+                await persistEntitySelection(entity, graphState.currentGraphId);
+            }
+            else {
+                await clearEntitySelection();
+            }
+        }
+        catch (error) {
+            console.error('Failed to persist entity selection:', error);
+            // Don't throw - we don't want to break the UI if cookie persistence fails
+            // The entity state is still updated in memory
+        }
+    }, [graphState.currentGraphId]);
+    // Validate entity cookie against user's actual graphs on load
+    // If the cookie's graphId doesn't belong to the current user, clear it
+    useEffect(() => {
+        if (currentEntity &&
+            (initialEntityCookie === null || initialEntityCookie === void 0 ? void 0 : initialEntityCookie.graphId) &&
+            !graphState.isLoading &&
+            graphState.graphs.length > 0) {
+            const graphExists = graphState.graphs.some((g) => g.graphId === initialEntityCookie.graphId);
+            if (!graphExists) {
+                setCurrentEntityState(null);
+                clearEntitySelection().catch((error) => {
+                    console.error('Failed to clear stale entity selection:', error);
+                });
+            }
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- intentionally omit currentEntity to avoid re-triggering after clearing
+    }, [graphState.isLoading, graphState.graphs, initialEntityCookie]);
+    const clearEntity = useCallback(async () => {
+        setCurrentEntityState(null);
+        try {
+            await clearEntitySelection();
+        }
+        catch (error) {
+            console.error('Failed to clear entity selection:', error);
+            // Don't throw - we don't want to break the UI if cookie clearing fails
+            // The entity state is still cleared in memory
+        }
+    }, []);
+    const value = {
+        currentEntity,
+        setCurrentEntity,
+        clearEntity,
+    };
+    return (_jsx(EntityContext.Provider, { value: value, children: children }));
+}
+/**
+ * Hook to access entity context
+ * Must be used within an EntityProvider
+ */
+export function useEntity() {
+    const context = useContext(EntityContext);
+    if (!context) {
+        throw new Error('useEntity must be used within an EntityProvider');
+    }
+    return context;
+}

package/contexts/graph-context.d.ts

@@ -0,0 +1,27 @@
+import type { GraphInfo } from '@robosystems/client';
+import React from 'react';
+export interface GraphState {
+    graphs: GraphInfo[];
+    currentGraphId: string | null;
+    isLoading: boolean;
+    error: string | null;
+}
+export interface GraphContextValue<T extends GraphState = GraphState> {
+    state: T;
+    loadGraphs: () => Promise<void>;
+    setCurrentGraph: (graphId: string) => Promise<void>;
+    refreshGraphs: () => Promise<void>;
+}
+export declare function createGraphContext<T extends GraphState = GraphState>(): React.Context<GraphContextValue<T>>;
+export interface GraphProviderProps<T extends GraphState = GraphState> {
+    children: React.ReactNode;
+    initialGraphId?: string | null;
+    graphFilter?: (graph: GraphInfo) => boolean;
+    transformState?: (baseState: GraphState) => T;
+    persistGraphSelection: (graphId: string) => Promise<void>;
+}
+export declare function createGraphProvider<T extends GraphState = GraphState>(Context: React.Context<GraphContextValue<T> | null>): ({ children, initialGraphId, graphFilter, transformState, persistGraphSelection, }: GraphProviderProps<T>) => React.JSX.Element;
+export declare function createUseGraphContext<T extends GraphState = GraphState>(Context: React.Context<GraphContextValue<T> | null>): () => GraphContextValue<T>;
+export declare const GraphContext: React.Context<GraphContextValue<GraphState>>;
+export declare const GraphProvider: ({ children, initialGraphId, graphFilter, transformState, persistGraphSelection, }: GraphProviderProps<GraphState>) => React.JSX.Element;
+export declare const useGraphContext: () => GraphContextValue<GraphState>;

package/contexts/graph-context.js

@@ -0,0 +1,128 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as SDK from '@robosystems/client';
+import { createContext, useCallback, useContext, useEffect, useState, } from 'react';
+// Factory function to create a typed graph context
+export function createGraphContext() {
+    return createContext(null);
+}
+// Helper to check if error is 403 Forbidden
+function is403Error(error) {
+    var _a;
+    return ((error === null || error === void 0 ? void 0 : error.status) === 403 ||
+        ((_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.status) === 403 ||
+        (typeof error === 'object' && 'status' in error && error.status === 403));
+}
+// Generic provider factory
+export function createGraphProvider(Context) {
+    return function GraphProvider({ children, initialGraphId, graphFilter, transformState, persistGraphSelection, }) {
+        const [baseState, setBaseState] = useState({
+            graphs: [],
+            currentGraphId: initialGraphId !== null && initialGraphId !== void 0 ? initialGraphId : null,
+            isLoading: false,
+            error: null,
+        });
+        // Transform state if needed
+        const state = transformState ? transformState(baseState) : baseState;
+        // Load all user graphs
+        const loadGraphs = useCallback(async () => {
+            setBaseState((prev) => (Object.assign(Object.assign({}, prev), { isLoading: true, error: null })));
+            try {
+                const response = await SDK.getGraphs();
+                if (response.data) {
+                    const graphsData = response.data;
+                    let graphs = graphsData.graphs || [];
+                    // Apply optional filter
+                    if (graphFilter) {
+                        graphs = graphs.filter(graphFilter);
+                    }
+                    const selectedGraphId = graphsData.selectedGraphId || initialGraphId;
+                    // Validate that selectedGraphId exists in graphs array
+                    const graphIds = graphs.map((g) => g.graphId);
+                    const validSelectedId = selectedGraphId && graphIds.includes(selectedGraphId)
+                        ? selectedGraphId
+                        : null;
+                    setBaseState((prev) => {
+                        // Determine which graph should be selected
+                        let newCurrentGraphId = validSelectedId || (graphs.length > 0 ? graphs[0].graphId : null);
+                        // IMPORTANT: If we currently have a repository selected, preserve it
+                        // The API's selectedGraphId only tracks user graphs, not repositories
+                        if (prev.currentGraphId) {
+                            const currentGraph = graphs.find((g) => g.graphId === prev.currentGraphId);
+                            // If current selection is still in the graph list, keep it
+                            // This prevents loadGraphs from overwriting repository selections
+                            if (currentGraph) {
+                                newCurrentGraphId = prev.currentGraphId;
+                            }
+                        }
+                        return Object.assign(Object.assign({}, prev), { graphs, currentGraphId: newCurrentGraphId, isLoading: false });
+                    });
+                }
+            }
+            catch (error) {
+                console.error('Failed to load graphs:', error);
+                setBaseState((prev) => (Object.assign(Object.assign({}, prev), { isLoading: false, error: 'Failed to load graphs' })));
+            }
+        }, [initialGraphId, graphFilter]);
+        // Set current graph with persistence
+        const setCurrentGraph = useCallback(async (graphId) => {
+            try {
+                // Use functional setState to access current graphs and determine if repository
+                let isUserGraph = false;
+                setBaseState((prev) => {
+                    const graph = prev.graphs.find((g) => g.graphId === graphId);
+                    // Only treat as a user graph if found and NOT a repository
+                    isUserGraph = graph ? !graph.isRepository : false;
+                    return Object.assign(Object.assign({}, prev), { currentGraphId: graphId });
+                });
+                // Only call selectGraph API for user graphs, not repositories
+                // Repositories can be accessed but not "selected" in the backend
+                // If graph is not found in local state, skip the API call (likely a repository)
+                if (isUserGraph) {
+                    await SDK.selectGraph({
+                        path: { graph_id: graphId },
+                    });
+                }
+            }
+            catch (error) {
+                console.error('Failed to select graph via API:', error);
+                // Don't throw - state is already updated, navigation should continue
+            }
+            // Persist to cookies via server action - fire and forget
+            // This can fail in production (e.g. server action issues behind CDN)
+            // but shouldn't block graph selection since React state is already set
+            persistGraphSelection(graphId).catch((error) => {
+                console.warn('Failed to persist graph selection to cookie:', error);
+            });
+        }, [persistGraphSelection]);
+        // Refresh graphs
+        const refreshGraphs = useCallback(async () => {
+            await loadGraphs();
+        }, [loadGraphs]);
+        // Initialize on mount
+        useEffect(() => {
+            loadGraphs();
+        }, [loadGraphs]);
+        const value = {
+            state,
+            loadGraphs,
+            setCurrentGraph,
+            refreshGraphs,
+        };
+        return _jsx(Context.Provider, { value: value, children: children });
+    };
+}
+// Factory for creating a typed hook
+export function createUseGraphContext(Context) {
+    return function useGraphContext() {
+        const context = useContext(Context);
+        if (!context) {
+            throw new Error('useGraphContext must be used within a GraphProvider');
+        }
+        return context;
+    };
+}
+// Default implementation for simple use cases
+export const GraphContext = createGraphContext();
+export const GraphProvider = createGraphProvider(GraphContext);
+export const useGraphContext = createUseGraphContext(GraphContext);

package/contexts/index.d.ts

@@ -0,0 +1,5 @@
+export { EntityProvider, useEntity, type EntityContextValue, type EntityProviderProps, } from './entity-context';
+export { GraphContext, GraphProvider, createGraphContext, createGraphProvider, createUseGraphContext, useGraphContext, type GraphContextValue, type GraphProviderProps, type GraphState, } from './graph-context';
+export { OrgProvider, useOrg, type OrgContextState, type OrgContextValue, type OrgProviderProps, } from './org-context';
+export { ServiceOfferingsProvider, useServiceOfferings, type ServiceOfferings, } from './service-offerings-context';
+export { SidebarProvider, useSidebarContext } from './sidebar-context';

package/contexts/index.js

@@ -0,0 +1,5 @@
+export { EntityProvider, useEntity, } from './entity-context';
+export { GraphContext, GraphProvider, createGraphContext, createGraphProvider, createUseGraphContext, useGraphContext, } from './graph-context';
+export { OrgProvider, useOrg, } from './org-context';
+export { ServiceOfferingsProvider, useServiceOfferings, } from './service-offerings-context';
+export { SidebarProvider, useSidebarContext } from './sidebar-context';

package/contexts/org-context.d.ts

@@ -0,0 +1,25 @@
+import * as SDK from '@robosystems/client';
+import React from 'react';
+export interface OrgContextState {
+    currentOrg: SDK.OrgResponse | null;
+    orgs: SDK.OrgResponse[];
+    loading: boolean;
+    error: string | null;
+}
+export interface OrgContextValue extends OrgContextState {
+    refreshOrgs: () => Promise<void>;
+    setCurrentOrg: (org: SDK.OrgResponse) => void;
+}
+export interface OrgProviderProps {
+    children: React.ReactNode;
+}
+/**
+ * Organization context provider
+ * Manages the current organization and provides org-related state
+ */
+export declare function OrgProvider({ children }: OrgProviderProps): React.JSX.Element;
+/**
+ * Hook to access organization context
+ * @throws {Error} If used outside of OrgProvider
+ */
+export declare function useOrg(): OrgContextValue;

package/contexts/org-context.js

@@ -0,0 +1,64 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as SDK from '@robosystems/client';
+import { createContext, useCallback, useContext, useEffect, useState, } from 'react';
+const OrgContext = createContext(undefined);
+/**
+ * Organization context provider
+ * Manages the current organization and provides org-related state
+ */
+export function OrgProvider({ children }) {
+    const [state, setState] = useState({
+        currentOrg: null,
+        orgs: [],
+        loading: true,
+        error: null,
+    });
+    const refreshOrgs = useCallback(async () => {
+        try {
+            setState((prev) => (Object.assign(Object.assign({}, prev), { loading: true, error: null })));
+            const response = await SDK.listUserOrgs();
+            if (response.error) {
+                const errorMsg = typeof response.error === 'object' && 'detail' in response.error
+                    ? String(response.error.detail)
+                    : 'Failed to load organizations';
+                throw new Error(errorMsg);
+            }
+            if (response.data) {
+                const orgs = response.data.orgs || [];
+                // Since users can only be in one org, set it as current
+                const currentOrg = orgs.length > 0 ? orgs[0] : null;
+                setState({
+                    currentOrg,
+                    orgs,
+                    loading: false,
+                    error: null,
+                });
+            }
+        }
+        catch (error) {
+            console.error('Failed to load organizations:', error);
+            setState((prev) => (Object.assign(Object.assign({}, prev), { loading: false, error: error instanceof Error ? error.message : 'Unknown error' })));
+        }
+    }, []);
+    const setCurrentOrg = useCallback((org) => {
+        setState((prev) => (Object.assign(Object.assign({}, prev), { currentOrg: org })));
+    }, []);
+    useEffect(() => {
+        refreshOrgs();
+    }, [refreshOrgs]);
+    const value = Object.assign(Object.assign({}, state), { refreshOrgs,
+        setCurrentOrg });
+    return _jsx(OrgContext.Provider, { value: value, children: children });
+}
+/**
+ * Hook to access organization context
+ * @throws {Error} If used outside of OrgProvider
+ */
+export function useOrg() {
+    const context = useContext(OrgContext);
+    if (context === undefined) {
+        throw new Error('useOrg must be used within an OrgProvider');
+    }
+    return context;
+}

package/contexts/service-offerings-context.d.ts

@@ -0,0 +1,45 @@
+import type { ServiceOfferingsResponse } from '@robosystems/client';
+import React from 'react';
+export type { ServiceOfferingsResponse };
+export interface ServiceOfferings {
+    billingEnabled: boolean;
+    graphPlans?: {
+        [key: string]: {
+            name: string;
+            displayName: string;
+            monthlyPrice: number;
+            monthlyCredits: number;
+            features: string[];
+            instanceStorageLimitGb?: number;
+            creditMultiplier: number;
+        };
+    };
+    repositoryPlans?: {
+        [repositoryType: string]: {
+            name: string;
+            description: string;
+            enabled: boolean;
+            comingSoon?: boolean;
+            plans: Array<{
+                plan: string;
+                name: string;
+                monthlyPrice: number;
+                monthlyCredits: number;
+                features?: string[];
+            }>;
+        };
+    };
+    features?: {
+        [key: string]: any;
+    };
+}
+interface ServiceOfferingsContextValue {
+    offerings: ServiceOfferings | null;
+    isLoading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+}
+export declare function ServiceOfferingsProvider({ children, }: {
+    children: React.ReactNode;
+}): React.JSX.Element;
+export declare function useServiceOfferings(): ServiceOfferingsContextValue;