arcvision 0.2.7 → 0.2.12

package/README.md

@@ -1,6 +1,7 @@
 # ArcVision System Context Artifact
 
-## What This Is
+
+## What This Is [arcvision.context.json](./arcvision.context.json)
 
 This file is the **canonical structural context** of this codebase.
 It represents how the system actually works — not how it is described.
@@ -35,9 +36,9 @@ Use this artifact when:
 
 ## Determinism & Trust
 
-- Generated from commit: b63e62db4aedf6ffb21055dd88d13c8a947a7422
-- Generation timestamp: 2026-01-13T03:50:34.571Z
-- Tool version: 0.2.5
+- Generated from commit: baeeb76e6d823a22126f930b1aa9b4064ed6ab24
+- Generation timestamp: 2026-01-15T03:47:02.411Z
+- Tool version: 0.2.11
 - Deterministic: same input → same output
 - Explicit assumptions listed inside the artifact
 
@@ -47,16 +48,16 @@ If this artifact conflicts with human memory, **trust the artifact**.
 
 The following files have the highest blast radius and represent critical structural hubs in the system:
 
-- **src/lib/utils.ts**
-  - Blast Radius: 62 files (14.73% of codebase)
+- **src/core/scanner.js**
+  - Blast Radius: 3 files (6% of codebase)
   - Risk: Changes here may silently propagate across the system.
 
-- **src/components/ui/button.tsx**
-  - Blast Radius: 49 files (11.64% of codebase)
+- **src/core/tsconfig-utils.js**
+  - Blast Radius: 3 files (6% of codebase)
   - Risk: Acts as a coordination layer between components.
 
-- **src/lib/supabase/client.ts**
-  - Blast Radius: 45 files (10.69% of codebase)
+- **src/core/blastRadius.js**
+  - Blast Radius: 2 files (4% of codebase)
   - Risk: Modifications can cause widespread inconsistencies.
 
 
@@ -82,4 +83,7 @@ arcvision scan --upload
 ## Source of Truth
 
 This artifact is the **source of truth** for system structure.
-All explanations, decisions, and AI reasoning should reference it.
+All explanations, decisions, and AI reasoning should reference it.
+
+Some execution script invocations are dynamically assembled at runtime and may not be statically traceable; such scripts are included 
+as execution boundaries without guaranteed call-site resolution

package/dist/index.js

@@ -56393,6 +56393,7 @@ var require_parser = __commonJS({
     function parseFile(filePath) {
       const content = fs2.readFileSync(filePath, "utf-8");
       let ast;
+      const isDeclarationFile = filePath.endsWith(".d.ts");
       const parserOptions = {
         sourceType: "unambiguous",
         // Auto-detect between script and module
@@ -56432,26 +56433,80 @@ var require_parser = __commonJS({
           "decoratorAutoAccessors"
         ]
       };
+      if (isDeclarationFile) {
+        parserOptions.plugins.push("typescript");
+      }
       try {
         ast = parser.parse(content, parserOptions);
       } catch (error) {
         const fallbackParserOptions = {
           ...parserOptions,
           // Allow more flexible parsing
-          errorRecovery: true
+          errorRecovery: true,
           // Allow parser to continue after errors
+          plugins: [
+            "jsx",
+            "typescript",
+            "decorators-legacy",
+            "classProperties",
+            "exportDefaultFrom",
+            "exportNamespaceFrom",
+            "dynamicImport",
+            "functionBind",
+            "nullishCoalescingOperator",
+            "optionalChaining",
+            "numericSeparator",
+            "bigInt",
+            "importMeta",
+            "asyncGenerators",
+            "optionalCatchBinding",
+            "throwExpressions",
+            "logicalAssignment",
+            "nullishCoalescingOperator",
+            "doExpressions",
+            "pipeOperator",
+            "recordAndTuple",
+            "moduleBlocks",
+            "topLevelAwait",
+            "v8intrinsic",
+            "partialApplication",
+            "regexpUnicodeSets",
+            "destructuringPrivate",
+            "decoratorAutoAccessors",
+            "typescript",
+            "decorators"
+          ]
         };
+        if (isDeclarationFile) {
+          fallbackParserOptions.plugins.push("typescript");
+        }
         try {
           ast = parser.parse(content, fallbackParserOptions);
         } catch (fallbackError) {
-          console.warn(`\u26A0\uFE0F  Failed to parse ${filePath}: ${error.message}`);
-          return {
-            id: filePath,
-            imports: [],
-            exports: [],
-            functions: [],
-            apiCalls: []
+          const ultraFallbackParserOptions = {
+            sourceType: "unambiguous",
+            allowImportExportEverywhere: true,
+            allowReturnOutsideFunction: true,
+            allowSuperOutsideMethod: true,
+            errorRecovery: true,
+            plugins: ["typescript", "jsx", "decorators-legacy", "classProperties"]
           };
+          if (isDeclarationFile) {
+            ultraFallbackParserOptions.plugins.push("typescript");
+          }
+          try {
+            ast = parser.parse(content, ultraFallbackParserOptions);
+          } catch (ultraFallbackError) {
+            console.warn(`\u26A0\uFE0F  Failed to parse ${filePath}: ${error.message}`);
+            return {
+              id: filePath,
+              imports: [],
+              exports: [],
+              functions: [],
+              apiCalls: [],
+              potentialInvocations: extractPotentialLuaInvocations(content)
+            };
+          }
         }
       }
       const metadata = {
@@ -56732,7 +56787,13 @@ var require_parser = __commonJS({
           }
         },
         VariableDeclarator({ node }) {
-          if (node.init && node.init.type === "CallExpression" && node.init.callee.name === "require" && node.init.arguments.length > 0 && node.init.arguments[0].type === "StringLiteral") {
+          if (node.init && node.init.type === "CallExpression" && (node.init.callee.name === "require" || node.init.callee.property && node.init.callee.property.name === "require" || node.init.callee.type === "MemberExpression" && node.init.callee.property.name === "import") && node.init.arguments.length > 0 && (node.init.arguments[0].type === "StringLiteral" || node.init.arguments[0].type === "TemplateLiteral")) {
+            let sourceValue = "";
+            if (node.init.arguments[0].type === "StringLiteral") {
+              sourceValue = node.init.arguments[0].value;
+            } else if (node.init.arguments[0].type === "TemplateLiteral") {
+              sourceValue = node.init.arguments[0].quasis.map((q) => q.value.cooked).join("");
+            }
             const specifiers = [];
             if (node.id.type === "ObjectPattern") {
               node.id.properties.forEach((prop) => {
@@ -56750,9 +56811,18 @@ var require_parser = __commonJS({
                 imported: "default",
                 local: node.id.name
               });
+            } else if (node.id.type === "ArrayPattern") {
+              node.id.elements.forEach((element, index) => {
+                if (element && element.name) {
+                  specifiers.push({
+                    imported: String(index),
+                    local: element.name
+                  });
+                }
+              });
             }
             metadata.imports.push({
-              source: node.init.arguments[0].value,
+              source: sourceValue,
               specifiers,
               type: "require-assignment"
             });
@@ -56763,6 +56833,30 @@ var require_parser = __commonJS({
       });
       return metadata;
     }
+    function extractPotentialLuaInvocations(content) {
+      const invocations = [];
+      const patterns = [
+        /defineCommand\(\s*['"].*?['"]\s*,\s*\{[^}]*lua\s*:[^}]*(?:\.lua)?[^}]*\}/gi,
+        /defineCommand\(\s*[^,)]+\s*,\s*\{[^}]*lua\s*:[^}]*(?:\.lua)?[^}]*\}/gi,
+        /defineCommand\(\s*\{[^}]*lua\s*:[^}]*(?:\.lua)?[^}]*\}/gi,
+        /readFileSync\(['"].*\.lua['"].*\)/gi,
+        /require\(['"].*\.lua['"].*\)/gi,
+        /fs\.readFileSync\(['"].*\.lua['"].*\)/gi,
+        /loadScript\(['"].*\.lua['"].*\)/gi,
+        /loadLua\(['"].*\.lua['"].*\)/gi,
+        /load\(['"].*\.lua['"].*\)/gi
+      ];
+      patterns.forEach((pattern) => {
+        let match;
+        while ((match = pattern.exec(content)) !== null) {
+          invocations.push({
+            pattern: match[0],
+            type: "lua_invocation"
+          });
+        }
+      });
+      return invocations;
+    }
     module2.exports = { parseFile };
   }
 });
@@ -57418,6 +57512,10 @@ var require_parser_enhanced = __commonJS({
       }
       const ast = metadata.ast;
       const fileContent = fs2.readFileSync(filePath, "utf-8");
+      if (filePath.endsWith(".md")) {
+        delete metadata.ast;
+        return metadata;
+      }
       try {
         const diPatterns = detectDependencyInjection(ast);
         metadata.constructorInjections = diPatterns.constructorInjections || [];
@@ -57524,15 +57622,21 @@ var require_pass1_facts = __commonJS({
       if (fs2.existsSync(pluginDir)) {
         pluginManager.loadPluginsFromDirectory(pluginDir);
       }
-      const files = await glob("**/*.{js,jsx,ts,tsx,json,lua}", {
+      const files = await glob("**/*.{js,jsx,ts,tsx,cjs,mjs,json,lua,md}", {
         ...scanOptions,
-        ignore: [...scanOptions.ignore, "**/*.d.ts", "**/.next/**", "**/coverage/**", "**/arcvision.context.json"]
+        ignore: [...scanOptions.ignore, "**/*.d.ts", "**/.next/**", "**/coverage/**", "**/arcvision.context.json", "**/package-lock.json", "**/yarn.lock"]
       });
+      const dtsFiles = await glob("**/*.d.ts", {
+        ...scanOptions,
+        ignore: [...scanOptions.ignore, "**/node_modules/**", "**/.git/**", "**/dist/**", "**/build/**"]
+      });
+      const allFiles = [...files, ...dtsFiles];
+      console.log(`   Identified ${allFiles.length} files for analysis (${files.length} code files, ${dtsFiles.length} declaration files)`);
       const CONCURRENCY = 100;
       const rawNodes = [];
       let totalFacts = 0;
-      for (let i = 0; i < files.length; i += CONCURRENCY) {
-        const batch = files.slice(i, i + CONCURRENCY);
+      for (let i = 0; i < allFiles.length; i += CONCURRENCY) {
+        const batch = allFiles.slice(i, i + CONCURRENCY);
         const promises = batch.map(async (file) => {
           try {
             const relativePath = path2.relative(directory, file);
@@ -57607,7 +57711,7 @@ var require_pass1_facts = __commonJS({
           totalFacts += res.factCount;
         });
         if (i % (CONCURRENCY * 4) === 0 && i > 0) {
-          console.log(`   ... processed ${Math.min(i + CONCURRENCY, files.length)} / ${files.length} files`);
+          console.log(`   ... processed ${Math.min(i + CONCURRENCY, allFiles.length)} / ${allFiles.length} files`);
         }
       }
       console.log(`   \u2713 Scanned ${rawNodes.length} files`);
@@ -57990,6 +58094,21 @@ var require_call_resolver = __commonJS({
                     if (this.symbolIndex.has(candidateId))
                       return candidateId;
                   }
+                  const commonPatterns = [
+                    `${targetFileId}::use${targetSymbolName.charAt(0).toUpperCase() + targetSymbolName.slice(1)}`,
+                    `${targetFileId}::get${targetSymbolName.charAt(0).toUpperCase() + targetSymbolName.slice(1)}`,
+                    `${targetFileId}::create${targetSymbolName.charAt(0).toUpperCase() + targetSymbolName.slice(1)}`,
+                    `${targetFileId}::_${targetSymbolName}`,
+                    // underscore prefix
+                    `${targetFileId}::${targetSymbolName}Impl`,
+                    // implementation suffix
+                    `${targetFileId}::${targetSymbolName}Handler`
+                    // handler suffix
+                  ];
+                  for (const patternId of commonPatterns) {
+                    if (this.symbolIndex.has(patternId))
+                      return patternId;
+                  }
                 }
               }
             }
@@ -57998,6 +58117,21 @@ var require_call_resolver = __commonJS({
           if (this.symbolIndex.has(localId)) {
             return localId;
           }
+          const localPatterns = [
+            `${fileId}::use${symbolName.charAt(0).toUpperCase() + symbolName.slice(1)}`,
+            `${fileId}::get${symbolName.charAt(0).toUpperCase() + symbolName.slice(1)}`,
+            `${fileId}::create${symbolName.charAt(0).toUpperCase() + symbolName.slice(1)}`,
+            `${fileId}::_${symbolName}`,
+            // underscore prefix
+            `${fileId}::${symbolName}Impl`,
+            // implementation suffix
+            `${fileId}::${symbolName}Handler`
+            // handler suffix
+          ];
+          for (const patternId of localPatterns) {
+            if (this.symbolIndex.has(patternId))
+              return patternId;
+          }
           return null;
         };
         if (functionCalls) {
@@ -58207,11 +58341,13 @@ var require_pass2_semantics = __commonJS({
         if (!content)
           continue;
         const luaInvocationPatterns = [
-          /readFileSync\(['"].*\.lua['"].*\)/gi,
-          /defineCommand\(\s*[^,]*,\s*\{[^}]*lua\s*:.+?\}/gi,
+          /defineCommand\(\s*['"].*?['"]\s*,\s*\{[^}]*lua\s*:[^}]*\}/gi,
+          // Matches defineCommand("commandName", { ... lua: ... })
+          /defineCommand\(\s*[^,)]+\s*,\s*\{[^}]*lua\s*:[^}]*\}/gi,
           // Matches defineCommand(commandName, { ... lua: ... })
-          /defineCommand\(\s*\{\s*lua\s*:.*?\}/gi,
+          /defineCommand\(\s*\{[^}]*lua\s*:[^}]*\}/gi,
           // Original pattern
+          /readFileSync\(['"].*\.lua['"].*\)/gi,
           /require\(['"].*\.lua['"].*\)/gi,
           /fs\.readFileSync\(['"].*\.lua['"].*\)/gi,
           /import\s+.*?from\s+['"].*\.lua['"].*\)?/gi,
@@ -58485,8 +58621,44 @@ var require_blastRadius = __commonJS({
         const dependencyStrength = calculateDependencyStrength(reverseGraph, file);
         let criticalityScore = blastRadius;
         criticalityScore += dependencyStrength * 0.5;
-        if (node && node.metadata && node.metadata.functions && node.metadata.functions.length > 0) {
-          criticalityScore += 1;
+        if (node && node.metadata) {
+          if (node.metadata.functions && node.metadata.functions.length > 0) {
+            criticalityScore += 1;
+          }
+          if (node.metadata.classes && node.metadata.classes.length > 0) {
+            criticalityScore += 1.5;
+          }
+          if (node.metadata.types && node.metadata.types.length > 0) {
+            criticalityScore += 0.5;
+          }
+          if (node.metadata.exports && node.metadata.exports.length > 0) {
+            criticalityScore += 0.7;
+          }
+          if (node.metadata.apiCalls && node.metadata.apiCalls.length > 0) {
+            criticalityScore += 1.2;
+          }
+        }
+        if (file.toLowerCase().includes("auth")) {
+          criticalityScore += 2;
+        } else if (file.toLowerCase().includes("core") || file.toLowerCase().includes("util") || file.toLowerCase().includes("utils")) {
+          criticalityScore += 1.5;
+        } else if (file.toLowerCase().includes("config") || file.toLowerCase().includes("index")) {
+          criticalityScore += 0.8;
+        }
+        if (blastRadius > 10) {
+          criticalityScore *= 1.8;
+        } else if (blastRadius > 5) {
+          criticalityScore *= 1.5;
+        } else if (blastRadius > 0) {
+          criticalityScore *= 1.1;
+        }
+        if (node && node.dependencies && node.dependencies.length > 5) {
+          criticalityScore += 2;
+        } else if (node && node.dependencies && node.dependencies.length > 10) {
+          criticalityScore += 5;
+        }
+        if (file.includes("/shared/") || file.includes("/common/") || file.includes("/utils/") || file.includes("/lib/")) {
+          criticalityScore += 1.5;
         }
         criticalityAnalysis.push({
           file,
@@ -58642,6 +58814,18 @@ var require_context_builder = __commonJS({
         if (file.intelligence && file.intelligence.connections) {
           file.intelligence.connections.forEach((c) => addDep(c.target));
         }
+        if (!file.intelligence && file.metadata && file.metadata.imports) {
+          file.metadata.imports.forEach((imp) => {
+            if (imp.source) {
+              let depPath = imp.source;
+              if (depPath.startsWith("./") || depPath.startsWith("../")) {
+                depPath = path2.join(path2.dirname(file.id), depPath);
+                depPath = path2.normalize(depPath);
+              }
+              addDep(depPath);
+            }
+          });
+        }
         const nodeObj = {
           id: stableId(file.id),
           type: "file",
@@ -65849,6 +66033,325 @@ var require_diff_analyzer = __commonJS({
   }
 });
 
+// src/core/chunked-uploader.js
+var require_chunked_uploader = __commonJS({
+  "src/core/chunked-uploader.js"(exports2, module2) {
+    var chalk2 = require_source();
+    var { Buffer: Buffer2 } = require("buffer");
+    var ChunkedUploader2 = class {
+      constructor(chunkSize = 1024 * 1024 * 4) {
+        this.chunkSize = chunkSize;
+      }
+      /**
+       * Calculate approximate byte size of a JSON object
+       */
+      calculateByteSize(obj) {
+        return Buffer2.byteLength(JSON.stringify(obj));
+      }
+      /**
+       * Split a large JSON object into chunks
+       */
+      splitIntoChunks(data, maxChunkSize = this.chunkSize) {
+        const jsonString = JSON.stringify(data);
+        const chunks = [];
+        for (let i = 0; i < jsonString.length; i += maxChunkSize) {
+          const chunk = jsonString.slice(i, i + maxChunkSize);
+          chunks.push({
+            data: chunk,
+            index: Math.floor(i / maxChunkSize),
+            totalChunks: Math.ceil(jsonString.length / maxChunkSize)
+          });
+        }
+        return chunks;
+      }
+      /**
+       * Reconstruct data from chunks
+       */
+      reconstructFromChunks(chunks) {
+        chunks.sort((a, b) => a.index - b.index);
+        const reconstructedString = chunks.map((chunk) => chunk.data).join("");
+        return JSON.parse(reconstructedString);
+      }
+      /**
+       * Upload data in chunks to the server
+       */
+      async uploadInChunks(data, token, apiUrl) {
+        const totalSize = this.calculateByteSize(data);
+        const chunks = this.splitIntoChunks(data);
+        console.log(chalk2.blue(`Preparing to upload ${chunks.length} chunks (${Math.round(totalSize / 1024 / 1024)} MB total)`));
+        const sessionId = await this.initiateSession(chunks.length, token, apiUrl);
+        if (!sessionId) {
+          throw new Error("Failed to initiate upload session");
+        }
+        const uploadPromises = chunks.map(async (chunk, index) => {
+          const progress = (index + 1) / chunks.length * 100;
+          console.log(chalk2.yellow(`Uploading chunk ${index + 1}/${chunks.length} (${Math.round(progress)}%)`));
+          return this.uploadChunk(chunk, sessionId, token, apiUrl);
+        });
+        const results = await Promise.all(uploadPromises);
+        const allSuccessful = results.every((result) => result.success);
+        if (!allSuccessful) {
+          throw new Error("Some chunks failed to upload");
+        }
+        const finalResult = await this.finalizeUpload(sessionId, token, apiUrl);
+        return finalResult;
+      }
+      /**
+       * Initiate a chunked upload session
+       */
+      async initiateSession(totalChunks, token, apiUrl) {
+        try {
+          const response = await fetch(`${apiUrl}/api/upload/initiate`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Authorization": `Bearer ${token}`
+            },
+            body: JSON.stringify({
+              totalChunks,
+              timestamp: Date.now()
+            })
+          });
+          if (!response.ok) {
+            throw new Error(`Session initiation failed: ${response.status}`);
+          }
+          const result = await response.json();
+          return result.sessionId;
+        } catch (error) {
+          console.error(chalk2.red(`Failed to initiate upload session: ${error.message}`));
+          return null;
+        }
+      }
+      /**
+       * Upload a single chunk
+       */
+      async uploadChunk(chunk, sessionId, token, apiUrl) {
+        try {
+          const response = await fetch(`${apiUrl}/api/upload/chunk`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Authorization": `Bearer ${token}`
+            },
+            body: JSON.stringify({
+              sessionId,
+              chunkIndex: chunk.index,
+              chunkData: chunk.data,
+              totalChunks: chunk.totalChunks
+            })
+          });
+          const result = await response.json();
+          if (!response.ok) {
+            console.error(chalk2.red(`Chunk ${chunk.index} upload failed: ${response.status}`));
+            return { success: false, error: result.error || response.statusText };
+          }
+          return { success: true, chunkIndex: chunk.index };
+        } catch (error) {
+          console.error(chalk2.red(`Chunk ${chunk.index} upload error: ${error.message}`));
+          return { success: false, error: error.message };
+        }
+      }
+      /**
+       * Finalize the chunked upload
+       */
+      async finalizeUpload(sessionId, token, apiUrl) {
+        try {
+          console.log(chalk2.yellow("Finalizing upload..."));
+          const response = await fetch(`${apiUrl}/api/upload/finalize`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Authorization": `Bearer ${token}`
+            },
+            body: JSON.stringify({
+              sessionId
+            })
+          });
+          if (!response.ok) {
+            throw new Error(`Finalization failed: ${response.status}`);
+          }
+          const result = await response.json();
+          return result;
+        } catch (error) {
+          console.error(chalk2.red(`Upload finalization failed: ${error.message}`));
+          throw error;
+        }
+      }
+    };
+    module2.exports = {
+      ChunkedUploader: ChunkedUploader2
+    };
+  }
+});
+
+// src/core/compression.js
+var require_compression = __commonJS({
+  "src/core/compression.js"(exports2, module2) {
+    var zlib2 = require("zlib");
+    var { promisify } = require("util");
+    var compressAsync = promisify(zlib2.deflate);
+    var decompressAsync = promisify(zlib2.inflate);
+    var CompressionUtil2 = class {
+      /**
+       * Compress JSON data using zlib deflate
+       */
+      static async compress(data) {
+        try {
+          const jsonString = JSON.stringify(data);
+          const compressedBuffer = await compressAsync(jsonString, {
+            level: 6
+            // Balance between speed and compression ratio
+          });
+          return compressedBuffer.toString("base64");
+        } catch (error) {
+          throw new Error(`Compression failed: ${error.message}`);
+        }
+      }
+      /**
+       * Decompress base64 encoded compressed data
+       */
+      static async decompress(compressedBase64) {
+        try {
+          const compressedBuffer = Buffer.from(compressedBase64, "base64");
+          const decompressedBuffer = await decompressAsync(compressedBuffer);
+          const jsonString = decompressedBuffer.toString();
+          return JSON.parse(jsonString);
+        } catch (error) {
+          throw new Error(`Decompression failed: ${error.message}`);
+        }
+      }
+      /**
+       * Get the compression ratio for data
+       */
+      static async getCompressionRatio(data) {
+        const originalSize = Buffer.byteLength(JSON.stringify(data));
+        const compressedData = await this.compress(data);
+        const compressedSize = Buffer.byteLength(compressedData);
+        return {
+          originalSize,
+          compressedSize,
+          ratio: originalSize / compressedSize,
+          percentage: Math.round((originalSize - compressedSize) / originalSize * 100)
+        };
+      }
+      /**
+       * Check if data needs compression based on size
+       */
+      static needsCompression(data, threshold = 1024 * 1024) {
+        return Buffer.byteLength(JSON.stringify(data)) > threshold;
+      }
+    };
+    module2.exports = CompressionUtil2;
+  }
+});
+
+// src/core/progress-tracker.js
+var require_progress_tracker = __commonJS({
+  "src/core/progress-tracker.js"(exports2, module2) {
+    var chalk2 = require_source();
+    var ProgressTracker2 = class {
+      constructor(totalSteps) {
+        this.totalSteps = totalSteps;
+        this.currentStep = 0;
+        this.startTime = Date.now();
+      }
+      update(step, message) {
+        this.currentStep = step;
+        const progress = this.currentStep / this.totalSteps * 100;
+        const elapsed = Date.now() - this.startTime;
+        const elapsedSeconds = Math.floor(elapsed / 1e3);
+        const minutes = Math.floor(elapsedSeconds / 60);
+        const seconds = elapsedSeconds % 60;
+        const timeString = `${minutes}:${seconds.toString().padStart(2, "0")}`;
+        console.log(
+          chalk2.blue(`[${timeString}] `) + chalk2.yellow(`Progress: ${this.currentStep}/${this.totalSteps} (${Math.round(progress)}%) - ${message}`)
+        );
+      }
+      updateSimple(current, total, message) {
+        const progress = current / total * 100;
+        const elapsed = Date.now() - this.startTime;
+        const elapsedSeconds = Math.floor(elapsed / 1e3);
+        const minutes = Math.floor(elapsedSeconds / 60);
+        const seconds = elapsedSeconds % 60;
+        const timeString = `${minutes}:${seconds.toString().padStart(2, "0")}`;
+        console.log(
+          chalk2.blue(`[${timeString}] `) + chalk2.yellow(`Progress: ${current}/${total} (${Math.round(progress)}%) - ${message}`)
+        );
+      }
+      complete(message = "Operation completed") {
+        const elapsed = Date.now() - this.startTime;
+        const elapsedSeconds = Math.floor(elapsed / 1e3);
+        const minutes = Math.floor(elapsedSeconds / 60);
+        const seconds = elapsedSeconds % 60;
+        const timeString = `${minutes}:${seconds.toString().padStart(2, "0")}`;
+        console.log(
+          chalk2.green(`[${timeString}] \u2713 ${message}`)
+        );
+      }
+      estimateRemaining(current, total) {
+        const elapsed = Date.now() - this.startTime;
+        const progress = current / total;
+        const estimatedTotalTime = elapsed / progress;
+        const remainingTime = estimatedTotalTime - elapsed;
+        const remainingSeconds = Math.floor(remainingTime / 1e3);
+        const minutes = Math.floor(remainingSeconds / 60);
+        const seconds = remainingSeconds % 60;
+        return `${minutes}:${seconds.toString().padStart(2, "0")}`;
+      }
+    };
+    module2.exports = ProgressTracker2;
+  }
+});
+
+// src/core/retry-handler.js
+var require_retry_handler = __commonJS({
+  "src/core/retry-handler.js"(exports2, module2) {
+    var chalk2 = require_source();
+    var RetryHandler2 = class {
+      constructor(maxRetries = 3, baseDelay = 1e3, backoffMultiplier = 2) {
+        this.maxRetries = maxRetries;
+        this.baseDelay = baseDelay;
+        this.backoffMultiplier = backoffMultiplier;
+      }
+      async executeWithRetry(operation, context = "") {
+        let lastError;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+          try {
+            if (attempt > 0) {
+              const delay = this.baseDelay * Math.pow(this.backoffMultiplier, attempt - 1);
+              console.log(chalk2.yellow(`Retry attempt ${attempt}/${this.maxRetries} for ${context} after ${delay}ms delay...`));
+              await this.sleep(delay);
+            }
+            const result = await operation(attempt);
+            return { success: true, result, attempts: attempt + 1 };
+          } catch (error) {
+            lastError = error;
+            if (attempt < this.maxRetries) {
+              console.log(chalk2.red(`Attempt ${attempt + 1} failed for ${context}: ${error.message}`));
+            }
+          }
+        }
+        return { success: false, error: lastError, attempts: this.maxRetries + 1 };
+      }
+      sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+      }
+      // Specific retry for network requests
+      async executeNetworkRequest(url, options, context = "network request") {
+        return this.executeWithRetry(async (attempt) => {
+          const response = await fetch(url, options);
+          if (!response.ok) {
+            const errorText = await response.text().catch(() => "Unknown error");
+            throw new Error(`HTTP ${response.status}: ${errorText}`);
+          }
+          return await response.json();
+        }, context);
+      }
+    };
+    module2.exports = RetryHandler2;
+  }
+});
+
 // src/core/readme-generator.js
 var require_readme_generator = __commonJS({
   "src/core/readme-generator.js"(exports2, module2) {
@@ -65967,7 +66470,10 @@ arcvision scan --upload
 ## Source of Truth
 
 This artifact is the **source of truth** for system structure.
-All explanations, decisions, and AI reasoning should reference it.`;
+All explanations, decisions, and AI reasoning should reference it.
+
+Some execution script invocations are dynamically assembled at runtime and may not be statically traceable; such scripts are included 
+as execution boundaries without guaranteed call-site resolution`;
       return content;
     }
     function generateReadme(outputDir, toolVersion, blastRadiusData = null) {
@@ -65988,8 +66494,13 @@ var chalk = require_source();
 var path = require("path");
 var fs = require("fs");
 var os = require("os");
+var zlib = require("zlib");
 var scanner = require_scanner();
 var { generateDiffSummary } = require_diff_analyzer();
+var { ChunkedUploader } = require_chunked_uploader();
+var CompressionUtil = require_compression();
+var ProgressTracker = require_progress_tracker();
+var RetryHandler = require_retry_handler();
 var version = "1.0.0";
 try {
   const packageJsonPath = path.join(__dirname, "../package.json");
@@ -66071,68 +66582,159 @@ async function uploadToDatabase(jsonData) {
     process.exit(1);
   }
   try {
-    console.log(chalk.blue(`Uploading to ${API_URL}/api/upload...`));
-    const controller = new AbortController();
-    const progress30s = setTimeout(() => {
-      console.log(chalk.yellow("Upload taking longer than expected, please wait while the process continues..."));
-    }, 3e4);
-    const progress60s = setTimeout(() => {
-      console.log(chalk.yellow("File size is large and may take additional time, process still working..."));
-    }, 6e4);
-    const timeoutId = setTimeout(() => {
-      controller.abort();
-      clearTimeout(progress30s);
-      clearTimeout(progress60s);
-    }, 12e4);
-    const response = await fetch(`${API_URL}/api/upload`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${token}`
-      },
-      body: JSON.stringify({
-        graph: jsonData
-      }),
-      signal: controller.signal
-    });
-    clearTimeout(timeoutId);
-    clearTimeout(progress30s);
-    clearTimeout(progress60s);
-    if (response.status === 401) {
-      console.error(chalk.red("\u274C Invalid or revoked token."));
-      console.error(chalk.yellow("The token may be invalid, revoked, or the associated project may have been deleted."));
-      console.log(chalk.yellow("\u{1F4A1} Please create a new project on the dashboard and generate a new token."));
-      process.exit(1);
-    }
-    if (response.status === 404) {
-      console.error(chalk.red("\u274C Project not found."));
-      console.error(chalk.yellow("The project associated with this token may have been deleted."));
-      console.log(chalk.yellow("\u{1F4A1} Please create a new project on the dashboard and generate a new token."));
-      process.exit(1);
-    }
-    if (response.status === 429) {
-      console.error(chalk.red("\u274C Rate limit exceeded. Please wait before trying again."));
-      process.exit(1);
-    }
-    if (!response.ok) {
-      console.error(chalk.red(`\u274C Upload failed: ${response.status} ${response.statusText}`));
-      const text = await response.text();
-      try {
-        const errorJson = JSON.parse(text);
-        if (errorJson.error)
-          console.error(chalk.red(`Server Error: ${errorJson.error}`));
-      } catch (e) {
-        console.error(chalk.red(`Server Error: ${text}`));
+    console.log(chalk.blue(`Starting upload to ${API_URL}/api/upload...`));
+    const originalSize = Buffer.byteLength(JSON.stringify(jsonData));
+    const sizeInMB = Math.round(originalSize / (1024 * 1024));
+    console.log(chalk.yellow(`Data size: ~${sizeInMB} MB`));
+    const needsChunkedUpload = sizeInMB > 3;
+    const needsCompression = CompressionUtil.needsCompression(jsonData, 1024 * 1024 * 2);
+    if (needsCompression) {
+      console.log(chalk.yellow("Compressing data to reduce payload size..."));
+      const compressionRatio = await CompressionUtil.getCompressionRatio(jsonData);
+      console.log(chalk.yellow(`Compression ratio: ${compressionRatio.ratio.toFixed(2)}x (${compressionRatio.percentage}% reduction)`));
+      const compressedData = await CompressionUtil.compress(jsonData);
+      const compressedSize = Buffer.byteLength(compressedData);
+      const compressedSizeInMB = Math.round(compressedSize / (1024 * 1024));
+      console.log(chalk.yellow(`Compressed size: ~${compressedSizeInMB} MB`));
+      if (compressedSizeInMB > 3 || needsChunkedUpload) {
+        console.log(chalk.blue("Using chunked upload for large compressed data..."));
+        const chunkedUploader = new ChunkedUploader();
+        const retryHandler = new RetryHandler(2, 2e3, 2);
+        const result = await retryHandler.executeWithRetry(async () => {
+          return await chunkedUploader.uploadInChunks(
+            { graph: compressedData, compressed: true },
+            token,
+            API_URL
+          );
+        }, "chunked upload");
+        if (result.success) {
+          console.log(chalk.green("\u2705 Graph uploaded successfully using chunked upload!"));
+        } else {
+          console.error(chalk.red("\u274C Chunked upload failed after retries:", result.error.message));
+          process.exit(1);
+        }
+      } else {
+        console.log(chalk.blue("Sending compressed data in single request..."));
+        const retryHandler = new RetryHandler(3, 1e3, 2);
+        const result = await retryHandler.executeWithRetry(async () => {
+          const controller = new AbortController();
+          const progress30s = setTimeout(() => {
+            console.log(chalk.yellow("Upload taking longer than expected, please wait while the process continues..."));
+          }, 3e4);
+          const progress60s = setTimeout(() => {
+            console.log(chalk.yellow("File size is large and may take additional time, process still working..."));
+          }, 6e4);
+          const timeoutId = setTimeout(() => {
+            controller.abort();
+            clearTimeout(progress30s);
+            clearTimeout(progress60s);
+          }, 18e4);
+          const response = await fetch(`${API_URL}/api/upload`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Authorization": `Bearer ${token}`
+            },
+            body: JSON.stringify({
+              graph: compressedData,
+              compressed: true
+            }),
+            signal: controller.signal
+          });
+          clearTimeout(timeoutId);
+          clearTimeout(progress30s);
+          clearTimeout(progress60s);
+          if (response.status === 401) {
+            throw new Error("Invalid or revoked token");
+          }
+          if (response.status === 404) {
+            throw new Error("Project not found");
+          }
+          if (response.status === 429) {
+            throw new Error("Rate limit exceeded");
+          }
+          if (!response.ok) {
+            const text = await response.text().catch(() => "Unknown error");
+            throw new Error(`${response.status} ${response.statusText}: ${text}`);
+          }
+          return await response.json();
+        }, "compressed upload");
+        if (result.success && result.result.success) {
+          console.log(chalk.green("\u2705 Compressed graph uploaded successfully!"));
+        } else {
+          console.error(chalk.red("\u274C Compressed upload failed:", result.error?.message || "Unknown error"));
+          process.exit(1);
+        }
       }
-      process.exit(1);
-    }
-    const result = await response.json();
-    if (result.success) {
-      console.log(chalk.green("\u2705 Graph uploaded successfully!"));
     } else {
-      console.log(chalk.red("\u274C Upload reported failure despite 200 OK."));
-      if (result.error) {
-        console.error(chalk.red(`Error details: ${result.error}`));
+      if (needsChunkedUpload) {
+        console.log(chalk.blue("Using chunked upload for large data..."));
+        const chunkedUploader = new ChunkedUploader();
+        const retryHandler = new RetryHandler(2, 2e3, 2);
+        const result = await retryHandler.executeWithRetry(async () => {
+          return await chunkedUploader.uploadInChunks(
+            { graph: jsonData },
+            token,
+            API_URL
+          );
+        }, "chunked upload");
+        if (result.success) {
+          console.log(chalk.green("\u2705 Graph uploaded successfully using chunked upload!"));
+        } else {
+          console.error(chalk.red("\u274C Chunked upload failed after retries:", result.error.message));
+          process.exit(1);
+        }
+      } else {
+        console.log(chalk.blue("Sending data in single request..."));
+        const retryHandler = new RetryHandler(3, 1e3, 2);
+        const result = await retryHandler.executeWithRetry(async () => {
+          const controller = new AbortController();
+          const progress30s = setTimeout(() => {
+            console.log(chalk.yellow("Upload taking longer than expected, please wait while the process continues..."));
+          }, 3e4);
+          const progress60s = setTimeout(() => {
+            console.log(chalk.yellow("File size is large and may take additional time, process still working..."));
+          }, 6e4);
+          const timeoutId = setTimeout(() => {
+            controller.abort();
+            clearTimeout(progress30s);
+            clearTimeout(progress60s);
+          }, 12e4);
+          const response = await fetch(`${API_URL}/api/upload`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "Authorization": `Bearer ${token}`
+            },
+            body: JSON.stringify({
+              graph: jsonData
+            }),
+            signal: controller.signal
+          });
+          clearTimeout(timeoutId);
+          clearTimeout(progress30s);
+          clearTimeout(progress60s);
+          if (response.status === 401) {
+            throw new Error("Invalid or revoked token");
+          }
+          if (response.status === 404) {
+            throw new Error("Project not found");
+          }
+          if (response.status === 429) {
+            throw new Error("Rate limit exceeded");
+          }
+          if (!response.ok) {
+            const text = await response.text().catch(() => "Unknown error");
+            throw new Error(`${response.status} ${response.statusText}: ${text}`);
+          }
+          return await response.json();
+        }, "standard upload");
+        if (result.success && result.result.success) {
+          console.log(chalk.green("\u2705 Graph uploaded successfully!"));
+        } else {
+          console.error(chalk.red("\u274C Upload failed:", result.error?.message || "Unknown error"));
+          process.exit(1);
+        }
       }
     }
   } catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arcvision",
-  "version": "0.2.7",
+  "version": "0.2.12",
   "description": "Architecture scanner for modern codebases",
   "bin": {
     "arcvision": "./dist/index.js"