@totalreclaw/totalreclaw 3.3.12 → 3.3.13

package/import-adapters/chatgpt-adapter.ts

@@ -116,15 +116,15 @@ export class ChatGPTAdapter extends BaseImportAdapter {
     let conversations: ChatGPTConversation[];
 
     try {
-      const data = JSON.parse(content);
+      const parsed = JSON.parse(content);
 
-      if (Array.isArray(data)) {
-        conversations = data;
-      } else if (data.conversations && Array.isArray(data.conversations)) {
-        conversations = data.conversations;
-      } else if (data.mapping) {
+      if (Array.isArray(parsed)) {
+        conversations = parsed;
+      } else if (parsed.conversations && Array.isArray(parsed.conversations)) {
+        conversations = parsed.conversations;
+      } else if (parsed.mapping) {
         // Single conversation object
-        conversations = [data];
+        conversations = [parsed];
       } else {
         errors.push(
           'Unrecognized ChatGPT format. Expected an array of conversation objects (conversations.json) ' +

package/import-adapters/gemini-adapter.ts

@@ -87,29 +87,29 @@ export class GeminiAdapter extends BaseImportAdapter {
     }
 
     // Delegate ALL format parsing to the shared core.
-    const result = getWasm().parseGemini(content) as CoreParseResult;
+    const parseResult = getWasm().parseGemini(content) as CoreParseResult;
 
     if (onProgress) {
       onProgress({
-        current: result.chunks.length,
-        total: result.chunks.length,
+        current: parseResult.chunks.length,
+        total: parseResult.chunks.length,
         phase: 'parsing',
-        message: `Parsed ${result.total_messages} messages into ${result.chunks.length} chunks`,
+        message: `Parsed ${parseResult.total_messages} messages into ${parseResult.chunks.length} chunks`,
       });
     }
 
     return {
       facts: [],
-      chunks: result.chunks,
-      totalMessages: result.total_messages,
-      warnings: [...warnings, ...result.warnings],
-      errors: [...errors, ...result.errors],
+      chunks: parseResult.chunks,
+      totalMessages: parseResult.total_messages,
+      warnings: [...warnings, ...parseResult.warnings],
+      errors: [...errors, ...parseResult.errors],
       source_metadata: {
-        format: result.format,
-        chunks_count: result.chunks.length,
-        total_messages: result.total_messages,
-        ...(result.records_count ? { records_count: result.records_count } : {}),
-        ...(result.skipped ? { skipped_non_gemini: result.skipped } : {}),
+        format: parseResult.format,
+        chunks_count: parseResult.chunks.length,
+        total_messages: parseResult.total_messages,
+        ...(parseResult.records_count ? { records_count: parseResult.records_count } : {}),
+        ...(parseResult.skipped ? { skipped_non_gemini: parseResult.skipped } : {}),
       },
     };
   }

package/import-adapters/mem0-adapter.ts

@@ -118,21 +118,21 @@ export class Mem0Adapter extends BaseImportAdapter {
    */
   private parseExportContent(content: string, errors: string[]): Mem0Memory[] {
     try {
-      const data = JSON.parse(content.trim());
+      const parsed = JSON.parse(content.trim());
 
       // Handle export file format: { memories: [...] }
-      if (data.memories && Array.isArray(data.memories)) {
-        return data.memories;
+      if (parsed.memories && Array.isArray(parsed.memories)) {
+        return parsed.memories;
       }
 
       // Handle API response format: { results: [...] }
-      if (data.results && Array.isArray(data.results)) {
-        return data.results;
+      if (parsed.results && Array.isArray(parsed.results)) {
+        return parsed.results;
       }
 
       // Handle bare array
-      if (Array.isArray(data)) {
-        return data;
+      if (Array.isArray(parsed)) {
+        return parsed;
       }
 
       errors.push('Unrecognized Mem0 format. Expected { memories: [...] }, { results: [...] }, or bare array.');
@@ -181,14 +181,14 @@ export class Mem0Adapter extends BaseImportAdapter {
           break;
         }
 
-        const data: Mem0ApiResponse = await response.json();
-        const memories = data.results || [];
+        const apiResponse: Mem0ApiResponse = await response.json();
+        const memories = apiResponse.results || [];
         allMemories.push(...memories);
 
         if (onProgress) {
           onProgress({
             current: allMemories.length,
-            total: data.total || allMemories.length,
+            total: apiResponse.total || allMemories.length,
             phase: 'fetching',
             message: `Fetched ${allMemories.length} memories from Mem0...`,
           });