@cmdoss/memwal-sdk 0.6.0

package/dist/hooks.wip/index.js

@@ -0,0 +1,58 @@
+/**
+ * React Hooks for Personal Data Wallet SDK
+ *
+ * High-level hooks for React dApps:
+ * - useMemoryManager: Initialize ClientMemoryManager
+ * - useCreateMemory: Create memories with progress tracking
+ * - useCreateMemoryBatch: Create multiple memories in a single Quilt (~90% gas savings)
+ * - useSearchMemories: Search memories with caching
+ * - useWalletMemories: Fetch and manage all user memories
+ * - useMemoryChat: Memory-aware chat with AI integration
+ *
+ * LangChain integration hooks:
+ * - usePDWVectorStore: Initialize PDWVectorStore for LangChain
+ * - usePDWRAG: Build RAG applications with LangChain + PDW
+ *
+ * Browser-compatible hooks for client-side operations:
+ * - useMemorySearch: Vector search with HNSW
+ * - useMemoryIndex: Memory indexing
+ * - useKnowledgeGraph: Knowledge graph operations
+ * - useMemoryServices: Low-level service management
+ *
+ * Vector embedding hooks (for RAG workflows):
+ * - useStoreEmbedding: Generate and store vector embeddings
+ * - useRetrieveEmbedding: Retrieve stored embeddings
+ *
+ * @example
+ * ```tsx
+ * import { useCreateMemory, useSearchMemories } from 'personal-data-wallet-sdk/hooks';
+ * import { useCurrentAccount } from '@mysten/dapp-kit';
+ *
+ * function MyComponent() {
+ *   const account = useCurrentAccount();
+ *   const { mutate: createMemory, isPending } = useCreateMemory();
+ *   const { data: results } = useSearchMemories(account?.address, query);
+ *
+ *   // Use the hooks...
+ * }
+ * ```
+ */
+// ==================== High-Level Hooks ====================
+export { useMemoryManager } from './useMemoryManager.js';
+export { useCreateMemory } from './useCreateMemory.js';
+export { useCreateMemoryBatch } from './useCreateMemoryBatch.js';
+export { useSearchMemories } from './useSearchMemories.js';
+export { useWalletMemories } from './useWalletMemories.js';
+export { useMemoryChat } from './useMemoryChat.js';
+// ==================== Browser-Compatible Hooks ====================
+export { useMemoryServices, clearMemoryServices, getMemoryServicesStats } from './useMemoryServices.js';
+export { useMemorySearch } from './useMemorySearch.js';
+export { useMemoryIndex } from './useMemoryIndex.js';
+export { useKnowledgeGraph } from './useKnowledgeGraph.js';
+// ==================== Vector Embedding Hooks ====================
+export { useStoreEmbedding } from './useStoreEmbedding.js';
+export { useRetrieveEmbedding } from './useRetrieveEmbedding.js';
+// ==================== LangChain Integration Hooks ====================
+export { usePDWVectorStore } from './usePDWVectorStore.js';
+export { usePDWRAG } from './usePDWRAG.js';
+//# sourceMappingURL=index.js.map

package/dist/hooks.wip/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/hooks.wip/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,6DAA6D;AAE7D,OAAO,EACL,gBAAgB,EAEjB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,eAAe,EAGhB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,oBAAoB,EAGrB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,iBAAiB,EAGlB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,iBAAiB,EAGlB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,aAAa,EAGd,MAAM,iBAAiB,CAAC;AAEzB,qEAAqE;AAErE,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,sBAAsB,EAGvB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,eAAe,EAGhB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,cAAc,EAIf,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,iBAAiB,EAClB,MAAM,qBAAqB,CAAC;AAE7B,mEAAmE;AAEnE,OAAO,EACL,iBAAiB,EAKlB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,oBAAoB,EAIrB,MAAM,wBAAwB,CAAC;AAEhC,wEAAwE;AAExE,OAAO,EACL,iBAAiB,EAGlB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,SAAS,EAGV,MAAM,aAAa,CAAC"}

package/dist/hooks.wip/useCreateMemory.d.ts

@@ -0,0 +1,111 @@
+/**
+ * useCreateMemory - Hook for creating memories with automatic state management
+ *
+ * Simplifies memory creation with loading states, error handling, and progress tracking.
+ *
+ * @example
+ * ```tsx
+ * import { useCreateMemory } from 'personal-data-wallet-sdk/hooks';
+ * import { useCurrentAccount, useSignAndExecuteTransaction, useSuiClient } from '@mysten/dapp-kit';
+ *
+ * function MemoryCreator() {
+ *   const account = useCurrentAccount();
+ *   const { mutate: signAndExecute } = useSignAndExecuteTransaction();
+ *   const client = useSuiClient();
+ *
+ *   const { mutate: createMemory, isPending, data, error, progress } = useCreateMemory({
+ *     onSuccess: (blobId) => {
+ *       console.log('Memory created:', blobId);
+ *     },
+ *     onError: (error) => {
+ *       console.error('Failed:', error);
+ *     }
+ *   });
+ *
+ *   const handleCreate = () => {
+ *     createMemory({
+ *       content: 'I love TypeScript',
+ *       category: 'personal'
+ *     });
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={handleCreate} disabled={isPending}>
+ *         {isPending ? 'Creating...' : 'Create Memory'}
+ *       </button>
+ *       {progress && <div>{progress.message}</div>}
+ *       {error && <div>Error: {error.message}</div>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+import type { CreateMemoryInput, CreateMemoryProgress, CreateMemoryResult, MemoryManagerConfig } from './utils/types';
+export interface UseCreateMemoryOptions {
+    /**
+     * Callback when memory creation succeeds
+     */
+    onSuccess?: (result: CreateMemoryResult) => void;
+    /**
+     * Callback when memory creation fails
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Callback for progress updates
+     */
+    onProgress?: (progress: CreateMemoryProgress) => void;
+    /**
+     * Optional memory manager config override
+     */
+    config?: MemoryManagerConfig;
+    /**
+     * Whether to automatically invalidate memory queries on success
+     * @default true
+     */
+    invalidateQueries?: boolean;
+}
+export interface UseCreateMemoryReturn {
+    /**
+     * Mutation function to create a memory
+     */
+    mutate: (input: CreateMemoryInput) => void;
+    /**
+     * Async mutation function (returns promise)
+     */
+    mutateAsync: (input: CreateMemoryInput) => Promise<CreateMemoryResult>;
+    /**
+     * Whether the mutation is currently loading
+     */
+    isPending: boolean;
+    /**
+     * Whether the mutation succeeded
+     */
+    isSuccess: boolean;
+    /**
+     * Whether the mutation failed
+     */
+    isError: boolean;
+    /**
+     * The result data (blobId) if successful
+     */
+    data?: CreateMemoryResult;
+    /**
+     * The error if failed
+     */
+    error: Error | null;
+    /**
+     * Current progress status
+     */
+    progress?: CreateMemoryProgress;
+    /**
+     * Reset mutation state
+     */
+    reset: () => void;
+}
+/**
+ * Hook for creating memories with automatic state management
+ */
+export declare function useCreateMemory(options?: UseCreateMemoryOptions): UseCreateMemoryReturn;
+export default useCreateMemory;
+//# sourceMappingURL=useCreateMemory.d.ts.map

package/dist/hooks.wip/useCreateMemory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCreateMemory.d.ts","sourceRoot":"","sources":["../../src/hooks.wip/useCreateMemory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAOH,OAAO,KAAK,EACV,iBAAiB,EACjB,oBAAoB,EACpB,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,eAAe,CAAC;AAEvB,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,kBAAkB,KAAK,IAAI,CAAC;IAEjD;;OAEG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAEjC;;OAEG;IACH,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,oBAAoB,KAAK,IAAI,CAAC;IAEtD;;OAEG;IACH,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAE7B;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,qBAAqB;IACpC;;OAEG;IACH,MAAM,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;IAE3C;;OAEG;IACH,WAAW,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAEvE;;OAEG;IACH,SAAS,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,SAAS,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;OAEG;IACH,IAAI,CAAC,EAAE,kBAAkB,CAAC;IAE1B;;OAEG;IACH,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IAEpB;;OAEG;IACH,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAEhC;;OAEG;IACH,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,GAAE,sBAA2B,GAAG,qBAAqB,CAgH3F;AAED,eAAe,eAAe,CAAC"}

package/dist/hooks.wip/useCreateMemory.js

@@ -0,0 +1,149 @@
+/**
+ * useCreateMemory - Hook for creating memories with automatic state management
+ *
+ * Simplifies memory creation with loading states, error handling, and progress tracking.
+ *
+ * @example
+ * ```tsx
+ * import { useCreateMemory } from 'personal-data-wallet-sdk/hooks';
+ * import { useCurrentAccount, useSignAndExecuteTransaction, useSuiClient } from '@mysten/dapp-kit';
+ *
+ * function MemoryCreator() {
+ *   const account = useCurrentAccount();
+ *   const { mutate: signAndExecute } = useSignAndExecuteTransaction();
+ *   const client = useSuiClient();
+ *
+ *   const { mutate: createMemory, isPending, data, error, progress } = useCreateMemory({
+ *     onSuccess: (blobId) => {
+ *       console.log('Memory created:', blobId);
+ *     },
+ *     onError: (error) => {
+ *       console.error('Failed:', error);
+ *     }
+ *   });
+ *
+ *   const handleCreate = () => {
+ *     createMemory({
+ *       content: 'I love TypeScript',
+ *       category: 'personal'
+ *     });
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={handleCreate} disabled={isPending}>
+ *         {isPending ? 'Creating...' : 'Create Memory'}
+ *       </button>
+ *       {progress && <div>{progress.message}</div>}
+ *       {error && <div>Error: {error.message}</div>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { useState, useCallback } from 'react';
+import { useSuiClient, useCurrentAccount, useSignAndExecuteTransaction } from '@mysten/dapp-kit';
+import { useMemoryManager } from './useMemoryManager.js';
+import { cacheKeys } from './utils/cache.js';
+/**
+ * Hook for creating memories with automatic state management
+ */
+export function useCreateMemory(options = {}) {
+    const { onSuccess, onError, onProgress, config, invalidateQueries = true, } = options;
+    const queryClient = useQueryClient();
+    const client = useSuiClient();
+    const account = useCurrentAccount();
+    const { mutate: signAndExecute } = useSignAndExecuteTransaction();
+    const manager = useMemoryManager(config);
+    const [progress, setProgress] = useState();
+    // Progress handler
+    const handleProgress = useCallback((status) => {
+        let stage = 'analyzing';
+        if (status.includes('Analyzing')) {
+            stage = 'analyzing';
+        }
+        else if (status.includes('embedding')) {
+            stage = 'embedding';
+        }
+        else if (status.includes('Encrypting')) {
+            stage = 'encrypting';
+        }
+        else if (status.includes('Uploading')) {
+            stage = 'uploading';
+        }
+        else if (status.includes('Registering')) {
+            stage = 'registering';
+        }
+        else if (status.includes('successfully')) {
+            stage = 'success';
+        }
+        const progressUpdate = {
+            stage,
+            message: status,
+        };
+        setProgress(progressUpdate);
+        onProgress?.(progressUpdate);
+    }, [onProgress]);
+    // Create memory mutation
+    const mutation = useMutation({
+        mutationFn: async (input) => {
+            if (!manager) {
+                throw new Error('Memory manager not initialized. Check your configuration.');
+            }
+            if (!account) {
+                throw new Error('No wallet connected. Please connect your wallet.');
+            }
+            if (!client) {
+                throw new Error('Sui client not available.');
+            }
+            // Create memory
+            const blobId = await manager.createMemory({
+                content: input.content,
+                category: input.category,
+                account,
+                signAndExecute: signAndExecute, // Type compatibility workaround
+                client: client, // Type compatibility workaround
+                onProgress: handleProgress,
+            });
+            return {
+                blobId,
+            };
+        },
+        onSuccess: (data) => {
+            // Invalidate relevant queries
+            if (invalidateQueries && account) {
+                queryClient.invalidateQueries({
+                    queryKey: cacheKeys.walletMemories(account.address),
+                });
+                queryClient.invalidateQueries({
+                    queryKey: cacheKeys.memoryStats(account.address),
+                });
+            }
+            onSuccess?.(data);
+        },
+        onError: (error) => {
+            setProgress({
+                stage: 'error',
+                message: error.message,
+            });
+            onError?.(error);
+        },
+    });
+    return {
+        mutate: mutation.mutate,
+        mutateAsync: mutation.mutateAsync,
+        isPending: mutation.isPending,
+        isSuccess: mutation.isSuccess,
+        isError: mutation.isError,
+        data: mutation.data,
+        error: mutation.error,
+        progress,
+        reset: () => {
+            mutation.reset();
+            setProgress(undefined);
+        },
+    };
+}
+export default useCreateMemory;
+//# sourceMappingURL=useCreateMemory.js.map

package/dist/hooks.wip/useCreateMemory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCreateMemory.js","sourceRoot":"","sources":["../../src/hooks.wip/useCreateMemory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACpE,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,4BAA4B,EAAE,MAAM,kBAAkB,CAAC;AACjG,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAmF1C;;GAEG;AACH,MAAM,UAAU,eAAe,CAAC,UAAkC,EAAE;IAClE,MAAM,EACJ,SAAS,EACT,OAAO,EACP,UAAU,EACV,MAAM,EACN,iBAAiB,GAAG,IAAI,GACzB,GAAG,OAAO,CAAC;IAEZ,MAAM,WAAW,GAAG,cAAc,EAAE,CAAC;IACrC,MAAM,MAAM,GAAG,YAAY,EAAE,CAAC;IAC9B,MAAM,OAAO,GAAG,iBAAiB,EAAE,CAAC;IACpC,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,GAAG,4BAA4B,EAAE,CAAC;IAClE,MAAM,OAAO,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC;IAEzC,MAAM,CAAC,QAAQ,EAAE,WAAW,CAAC,GAAG,QAAQ,EAAoC,CAAC;IAE7E,mBAAmB;IACnB,MAAM,cAAc,GAAG,WAAW,CAChC,CAAC,MAAc,EAAE,EAAE;QACjB,IAAI,KAAK,GAAkC,WAAW,CAAC;QAEvD,IAAI,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC;YACjC,KAAK,GAAG,WAAW,CAAC;QACtB,CAAC;aAAM,IAAI,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC;YACxC,KAAK,GAAG,WAAW,CAAC;QACtB,CAAC;aAAM,IAAI,MAAM,CAAC,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC;YACzC,KAAK,GAAG,YAAY,CAAC;QACvB,CAAC;aAAM,IAAI,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC;YACxC,KAAK,GAAG,WAAW,CAAC;QACtB,CAAC;aAAM,IAAI,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC;YAC1C,KAAK,GAAG,aAAa,CAAC;QACxB,CAAC;aAAM,IAAI,MAAM,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC;YAC3C,KAAK,GAAG,SAAS,CAAC;QACpB,CAAC;QAED,MAAM,cAAc,GAAyB;YAC3C,KAAK;YACL,OAAO,EAAE,MAAM;SAChB,CAAC;QAEF,WAAW,CAAC,cAAc,CAAC,CAAC;QAC5B,UAAU,EAAE,CAAC,cAAc,CAAC,CAAC;IAC/B,CAAC,EACD,CAAC,UAAU,CAAC,CACb,CAAC;IAEF,yBAAyB;IACzB,MAAM,QAAQ,GAAG,WAAW,CAAC;QAC3B,UAAU,EAAE,KAAK,EAAE,KAAwB,EAA+B,EAAE;YAC1E,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,MAAM,IAAI,KAAK,CAAC,2DAA2D,CAAC,CAAC;YAC/E,CAAC;YAED,IAAI,CAAC,OAAO,EAAE,CAAC;gBACb,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;YACtE,CAAC;YAED,IAAI,CAAC,MAAM,EAAE,CAAC;gBACZ,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;YAC/C,CAAC;YAED,gBAAgB;YAChB,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,YAAY,CAAC;gBACxC,OAAO,EAAE,KAAK,CAAC,OAAO;gBACtB,QAAQ,EAAE,KAAK,CAAC,QAAQ;gBACxB,OAAO;gBACP,cAAc,EAAE,cAAqB,EAAE,gCAAgC;gBACvE,MAAM,EAAE,MAAa,EAAE,gCAAgC;gBACvD,UAAU,EAAE,cAAc;aAC3B,CAAC,CAAC;YAEH,OAAO;gBACL,MAAM;aACP,CAAC;QACJ,CAAC;QACD,SAAS,EAAE,CAAC,IAAI,EAAE,EAAE;YAClB,8BAA8B;YAC9B,IAAI,iBAAiB,IAAI,OAAO,EAAE,CAAC;gBACjC,WAAW,CAAC,iBAAiB,CAAC;oBAC5B,QAAQ,EAAE,SAAS,CAAC,cAAc,CAAC,OAAO,CAAC,OAAO,CAAC;iBACpD,CAAC,CAAC;gBACH,WAAW,CAAC,iBAAiB,CAAC;oBAC5B,QAAQ,EAAE,SAAS,CAAC,WAAW,CAAC,OAAO,CAAC,OAAO,CAAC;iBACjD,CAAC,CAAC;YACL,CAAC;YAED,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC;QACpB,CAAC;QACD,OAAO,EAAE,CAAC,KAAY,EAAE,EAAE;YACxB,WAAW,CAAC;gBACV,KAAK,EAAE,OAAO;gBACd,OAAO,EAAE,KAAK,CAAC,OAAO;aACvB,CAAC,CAAC;YACH,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;QACnB,CAAC;KACF,CAAC,CAAC;IAEH,OAAO;QACL,MAAM,EAAE,QAAQ,CAAC,MAAM;QACvB,WAAW,EAAE,QAAQ,CAAC,WAAW;QACjC,SAAS,EAAE,QAAQ,CAAC,SAAS;QAC7B,SAAS,EAAE,QAAQ,CAAC,SAAS;QAC7B,OAAO,EAAE,QAAQ,CAAC,OAAO;QACzB,IAAI,EAAE,QAAQ,CAAC,IAAI;QACnB,KAAK,EAAE,QAAQ,CAAC,KAAK;QACrB,QAAQ;QACR,KAAK,EAAE,GAAG,EAAE;YACV,QAAQ,CAAC,KAAK,EAAE,CAAC;YACjB,WAAW,CAAC,SAAS,CAAC,CAAC;QACzB,CAAC;KACF,CAAC;AACJ,CAAC;AAED,eAAe,eAAe,CAAC"}

package/dist/hooks.wip/useCreateMemoryBatch.d.ts

@@ -0,0 +1,122 @@
+/**
+ * useCreateMemoryBatch - Hook for creating multiple memories in a single Quilt
+ *
+ * Batch memory creation with ~90% gas savings by using Walrus Quilts.
+ * All memories in a batch are stored in a single Quilt with per-file metadata tags.
+ *
+ * @example
+ * ```tsx
+ * import { useCreateMemoryBatch } from 'personal-data-wallet-sdk/hooks';
+ * import { useCurrentAccount, useSignAndExecuteTransaction, useSuiClient } from '@mysten/dapp-kit';
+ *
+ * function BatchMemoryCreator() {
+ *   const account = useCurrentAccount();
+ *   const { mutate: signAndExecute } = useSignAndExecuteTransaction();
+ *   const client = useSuiClient();
+ *
+ *   const { mutate: createBatch, isPending, data, error, progress } = useCreateMemoryBatch({
+ *     geminiApiKey: process.env.NEXT_PUBLIC_GEMINI_API_KEY!,
+ *     onSuccess: (result) => {
+ *       console.log(`Created ${result.memoriesCreated} memories in Quilt ${result.quiltId}`);
+ *       console.log(`Upload time: ${result.uploadTimeMs}ms`);
+ *     },
+ *     onProgress: (progress) => {
+ *       console.log(`${progress.message} (${progress.percent}%)`);
+ *     }
+ *   });
+ *
+ *   const handleBatchCreate = () => {
+ *     createBatch({
+ *       memories: [
+ *         { content: 'First memory', category: 'personal' },
+ *         { content: 'Second memory', category: 'personal' },
+ *         { content: 'Third memory', category: 'work' },
+ *       ]
+ *     });
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={handleBatchCreate} disabled={isPending}>
+ *         {isPending ? `Creating... ${progress?.percent || 0}%` : 'Create Batch'}
+ *       </button>
+ *       {progress && <div>{progress.message}</div>}
+ *       {error && <div>Error: {error.message}</div>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+import type { CreateMemoryBatchInput, CreateMemoryBatchProgress, CreateMemoryBatchResult, MemoryManagerConfig } from './utils/types';
+export interface UseCreateMemoryBatchOptions {
+    /**
+     * Callback when batch creation succeeds
+     */
+    onSuccess?: (result: CreateMemoryBatchResult) => void;
+    /**
+     * Callback when batch creation fails
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Callback for progress updates
+     */
+    onProgress?: (progress: CreateMemoryBatchProgress) => void;
+    /**
+     * Gemini API key for embedding generation
+     * @required
+     */
+    geminiApiKey: string;
+    /**
+     * Optional memory manager config override
+     */
+    config?: MemoryManagerConfig;
+    /**
+     * Whether to automatically invalidate memory queries on success
+     * @default true
+     */
+    invalidateQueries?: boolean;
+}
+export interface UseCreateMemoryBatchReturn {
+    /**
+     * Mutation function to create a batch of memories
+     */
+    mutate: (input: CreateMemoryBatchInput) => void;
+    /**
+     * Async mutation function (returns promise)
+     */
+    mutateAsync: (input: CreateMemoryBatchInput) => Promise<CreateMemoryBatchResult>;
+    /**
+     * Whether the mutation is currently loading
+     */
+    isPending: boolean;
+    /**
+     * Whether the mutation succeeded
+     */
+    isSuccess: boolean;
+    /**
+     * Whether the mutation failed
+     */
+    isError: boolean;
+    /**
+     * The result data (Quilt ID and file list) if successful
+     */
+    data?: CreateMemoryBatchResult;
+    /**
+     * The error if failed
+     */
+    error: Error | null;
+    /**
+     * Current progress status
+     */
+    progress?: CreateMemoryBatchProgress;
+    /**
+     * Reset mutation state
+     */
+    reset: () => void;
+}
+/**
+ * Hook for creating multiple memories in a single Quilt
+ */
+export declare function useCreateMemoryBatch(options: UseCreateMemoryBatchOptions): UseCreateMemoryBatchReturn;
+export default useCreateMemoryBatch;
+//# sourceMappingURL=useCreateMemoryBatch.d.ts.map

package/dist/hooks.wip/useCreateMemoryBatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCreateMemoryBatch.d.ts","sourceRoot":"","sources":["../../src/hooks.wip/useCreateMemoryBatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAOH,OAAO,KAAK,EACV,sBAAsB,EACtB,yBAAyB,EACzB,uBAAuB,EACvB,mBAAmB,EACpB,MAAM,eAAe,CAAC;AAEvB,MAAM,WAAW,2BAA2B;IAC1C;;OAEG;IACH,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,uBAAuB,KAAK,IAAI,CAAC;IAEtD;;OAEG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAEjC;;OAEG;IACH,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,yBAAyB,KAAK,IAAI,CAAC;IAE3D;;;OAGG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAE7B;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,0BAA0B;IACzC;;OAEG;IACH,MAAM,EAAE,CAAC,KAAK,EAAE,sBAAsB,KAAK,IAAI,CAAC;IAEhD;;OAEG;IACH,WAAW,EAAE,CAAC,KAAK,EAAE,sBAAsB,KAAK,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAEjF;;OAEG;IACH,SAAS,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,SAAS,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;OAEG;IACH,IAAI,CAAC,EAAE,uBAAuB,CAAC;IAE/B;;OAEG;IACH,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IAEpB;;OAEG;IACH,QAAQ,CAAC,EAAE,yBAAyB,CAAC;IAErC;;OAEG;IACH,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,2BAA2B,GACnC,0BAA0B,CAwO5B;AAED,eAAe,oBAAoB,CAAC"}

package/dist/hooks.wip/useCreateMemoryBatch.js

@@ -0,0 +1,221 @@
+/**
+ * useCreateMemoryBatch - Hook for creating multiple memories in a single Quilt
+ *
+ * Batch memory creation with ~90% gas savings by using Walrus Quilts.
+ * All memories in a batch are stored in a single Quilt with per-file metadata tags.
+ *
+ * @example
+ * ```tsx
+ * import { useCreateMemoryBatch } from 'personal-data-wallet-sdk/hooks';
+ * import { useCurrentAccount, useSignAndExecuteTransaction, useSuiClient } from '@mysten/dapp-kit';
+ *
+ * function BatchMemoryCreator() {
+ *   const account = useCurrentAccount();
+ *   const { mutate: signAndExecute } = useSignAndExecuteTransaction();
+ *   const client = useSuiClient();
+ *
+ *   const { mutate: createBatch, isPending, data, error, progress } = useCreateMemoryBatch({
+ *     geminiApiKey: process.env.NEXT_PUBLIC_GEMINI_API_KEY!,
+ *     onSuccess: (result) => {
+ *       console.log(`Created ${result.memoriesCreated} memories in Quilt ${result.quiltId}`);
+ *       console.log(`Upload time: ${result.uploadTimeMs}ms`);
+ *     },
+ *     onProgress: (progress) => {
+ *       console.log(`${progress.message} (${progress.percent}%)`);
+ *     }
+ *   });
+ *
+ *   const handleBatchCreate = () => {
+ *     createBatch({
+ *       memories: [
+ *         { content: 'First memory', category: 'personal' },
+ *         { content: 'Second memory', category: 'personal' },
+ *         { content: 'Third memory', category: 'work' },
+ *       ]
+ *     });
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={handleBatchCreate} disabled={isPending}>
+ *         {isPending ? `Creating... ${progress?.percent || 0}%` : 'Create Batch'}
+ *       </button>
+ *       {progress && <div>{progress.message}</div>}
+ *       {error && <div>Error: {error.message}</div>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { useState, useCallback } from 'react';
+import { useSuiClient, useCurrentAccount, useSignAndExecuteTransaction } from '@mysten/dapp-kit';
+import { useMemoryServices } from './useMemoryServices.js';
+import { cacheKeys } from './utils/cache.js';
+/**
+ * Hook for creating multiple memories in a single Quilt
+ */
+export function useCreateMemoryBatch(options) {
+    const { onSuccess, onError, onProgress, geminiApiKey, config, invalidateQueries = true, } = options;
+    const queryClient = useQueryClient();
+    const client = useSuiClient();
+    const account = useCurrentAccount();
+    const { mutate: signAndExecute } = useSignAndExecuteTransaction();
+    // Get services with Gemini API key
+    const { storageService, embeddingService, encryptionService, geminiAIService, isReady } = useMemoryServices(account?.address, { geminiApiKey, ...config });
+    const [progress, setProgress] = useState();
+    // Progress helper
+    const updateProgress = useCallback((stage, message, current, total) => {
+        const percent = Math.round((current / total) * 100);
+        const progressUpdate = {
+            stage,
+            message,
+            current,
+            total,
+            percent,
+        };
+        setProgress(progressUpdate);
+        onProgress?.(progressUpdate);
+    }, [onProgress]);
+    // Create batch mutation
+    const mutation = useMutation({
+        mutationFn: async (input) => {
+            if (!isReady) {
+                throw new Error('Services not initialized. Please wait...');
+            }
+            if (!account) {
+                throw new Error('No wallet connected. Please connect your wallet.');
+            }
+            if (!client) {
+                throw new Error('Sui client not available.');
+            }
+            if (!storageService || !embeddingService || !encryptionService) {
+                throw new Error('Required services not available.');
+            }
+            if (!signAndExecute) {
+                throw new Error('Sign and execute function not available.');
+            }
+            const total = input.memories.length;
+            if (total === 0) {
+                throw new Error('No memories provided.');
+            }
+            updateProgress('preparing', 'Preparing batch operation...', 0, total);
+            // Step 1: Extract AI metadata for all memories in batch (if AI service available)
+            let metadataArray = [];
+            if (geminiAIService) {
+                updateProgress('preparing', 'Analyzing content with AI...', 0, total);
+                try {
+                    metadataArray = await geminiAIService.extractRichMetadataBatch(input.memories.map(m => ({ content: m.content, category: m.category })));
+                    console.log('✅ AI metadata extracted for all memories');
+                }
+                catch (error) {
+                    console.warn('⚠️ AI metadata extraction failed, using fallbacks:', error);
+                    // Fallback to simple extraction
+                    metadataArray = input.memories.map(m => ({
+                        importance: 5,
+                        topic: m.category || 'uncategorized',
+                        summary: m.content.substring(0, 100),
+                        category: m.category || 'uncategorized'
+                    }));
+                }
+            }
+            else {
+                console.warn('⚠️ No AI service available, using simple metadata extraction');
+                metadataArray = input.memories.map(m => ({
+                    importance: 5,
+                    topic: m.category || 'uncategorized',
+                    summary: m.content.substring(0, 100),
+                    category: m.category || 'uncategorized'
+                }));
+            }
+            // Step 2: Process each memory: generate embeddings and encrypt
+            const processedMemories = [];
+            for (let i = 0; i < total; i++) {
+                const memory = input.memories[i];
+                const metadata = metadataArray[i];
+                const current = i + 1;
+                // Generate embedding
+                updateProgress('processing', `Generating embedding for memory ${current}/${total}...`, current, total);
+                const embeddingResult = await embeddingService.embedText({
+                    text: memory.content,
+                    taskType: 'RETRIEVAL_DOCUMENT',
+                });
+                // Encrypt content
+                updateProgress('encrypting', `Encrypting memory ${current}/${total}...`, current, total);
+                const encryptionResult = await encryptionService.encrypt(new TextEncoder().encode(memory.content), account.address);
+                processedMemories.push({
+                    content: memory.content,
+                    category: metadata.category,
+                    importance: metadata.importance,
+                    topic: metadata.topic,
+                    embedding: embeddingResult.vector,
+                    encryptedContent: encryptionResult.encryptedObject,
+                    summary: metadata.summary,
+                });
+            }
+            // Upload batch to Walrus Quilt
+            updateProgress('uploading', 'Uploading batch to Walrus Quilt...', total, total);
+            // Create a simple signer wrapper from signAndExecute
+            const signer = {
+                async signAndSend(txb) {
+                    return new Promise((resolve, reject) => {
+                        signAndExecute({ transaction: txb }, {
+                            onSuccess: (result) => resolve(result),
+                            onError: (error) => reject(error),
+                        });
+                    });
+                },
+            };
+            const result = await storageService.uploadMemoryBatch(processedMemories, {
+                signer: signer,
+                epochs: 5,
+                userAddress: account.address,
+            });
+            updateProgress('success', 'Batch created successfully!', total, total);
+            return {
+                quiltId: result.quiltId,
+                files: result.files,
+                uploadTimeMs: result.uploadTimeMs,
+                memoriesCreated: total,
+            };
+        },
+        onSuccess: (data) => {
+            // Invalidate relevant queries
+            if (invalidateQueries && account) {
+                queryClient.invalidateQueries({
+                    queryKey: cacheKeys.walletMemories(account.address),
+                });
+                queryClient.invalidateQueries({
+                    queryKey: cacheKeys.memoryStats(account.address),
+                });
+            }
+            onSuccess?.(data);
+        },
+        onError: (error) => {
+            setProgress({
+                stage: 'error',
+                message: error.message,
+                current: 0,
+                total: 0,
+                percent: 0,
+            });
+            onError?.(error);
+        },
+    });
+    return {
+        mutate: mutation.mutate,
+        mutateAsync: mutation.mutateAsync,
+        isPending: mutation.isPending,
+        isSuccess: mutation.isSuccess,
+        isError: mutation.isError,
+        data: mutation.data,
+        error: mutation.error,
+        progress,
+        reset: () => {
+            mutation.reset();
+            setProgress(undefined);
+        },
+    };
+}
+export default useCreateMemoryBatch;
+//# sourceMappingURL=useCreateMemoryBatch.js.map