@totalreclaw/totalreclaw 3.3.12 → 3.3.13-rc.1

package/dist/import-adapters/chatgpt-adapter.js

@@ -60,16 +60,16 @@ export class ChatGPTAdapter extends BaseImportAdapter {
     parseConversationsJson(content, warnings, errors, onProgress) {
         let conversations;
         try {
-            const data = JSON.parse(content);
-            if (Array.isArray(data)) {
-                conversations = data;
+            const parsed = JSON.parse(content);
+            if (Array.isArray(parsed)) {
+                conversations = parsed;
             }
-            else if (data.conversations && Array.isArray(data.conversations)) {
-                conversations = data.conversations;
+            else if (parsed.conversations && Array.isArray(parsed.conversations)) {
+                conversations = parsed.conversations;
             }
-            else if (data.mapping) {
+            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/dist/import-adapters/gemini-adapter.js

@@ -58,27 +58,27 @@ export class GeminiAdapter extends BaseImportAdapter {
             onProgress({ current: 0, total: 0, phase: 'parsing', message: 'Parsing Gemini export...' });
         }
         // Delegate ALL format parsing to the shared core.
-        const result = getWasm().parseGemini(content);
+        const parseResult = getWasm().parseGemini(content);
         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/dist/import-adapters/mem0-adapter.js

@@ -65,18 +65,18 @@ export class Mem0Adapter extends BaseImportAdapter {
      */
     parseExportContent(content, errors) {
         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.');
             return [];
@@ -114,13 +114,13 @@ export class Mem0Adapter extends BaseImportAdapter {
                     errors?.push(`Mem0 API error (${response.status}): ${errorText.slice(0, 200)}`);
                     break;
                 }
-                const data = await response.json();
-                const memories = data.results || [];
+                const apiResponse = 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...`,
                     });