From a03af0d955cf8d0bfadc43e09522dffd6be6932f Mon Sep 17 00:00:00 2001
From: Coding Agent <agent@example.com>
Date: Fri, 17 Oct 2025 19:37:48 +0000
Subject: [PATCH] fix(php-parser): handle large files without breaking

- Stream input ...
---
 generate_test_file.php       | 112 ++++++++
 src/Router.php               |  45 ++-
 src/StreamingCodeParser.php  | 313 ++++++++++++++++++++
 src/StreamingCodeVisitor.php | 541 +++++++++++++++++++++++++++++++++++
 test_parser.php              |  57 ++++
 5 files changed, 1065 insertions(+), 3 deletions(-)
 create mode 100644 generate_test_file.php
 create mode 100644 src/StreamingCodeParser.php
 create mode 100644 src/StreamingCodeVisitor.php
 create mode 100644 test_parser.php

diff --git a/generate_test_file.php b/generate_test_file.php
new file mode 100644
index 0000000..0e77661
--- /dev/null
+++ b/generate_test_file.php
@@ -0,0 +1,112 @@
+<?php
+
+// Create a large test PHP file to test the streaming parser
+$testCode = '<?php
+
+namespace TestNamespace;
+
+use Some\Large\Namespace\Class1;
+use Another\Large\Namespace\Class2;
+use Yet\Another\Large\Namespace\Class3;
+
+/**
+ * Large test class for testing streaming parser
+ * 
+ * This class has many methods and properties to test
+ * the memory efficiency of the streaming parser.
+ */
+class LargeTestClass
+{
+    private $property1;
+    private $property2;
+    private $property3;
+    
+';
+
+// Generate many methods
+for ($i = 1; $i <= 100; $i++) {
+    $testCode .= "
+    /**
+     * Test method number $i
+     * 
+     * This method performs various operations and calls
+     * multiple functions to test the parser capabilities.
+     * 
+     * @param string \$param1 First parameter
+     * @param int \$param2 Second parameter
+     * @return mixed The result of the operation
+     */
+    public function testMethod$i(\$param1, \$param2)
+    {
+        // Method body with various function calls
+        \$result = array();
+        \$result['data'] = json_encode(\$param1);
+        \$result['count'] = strlen(\$param2);
+        \$result['processed'] = trim(strtolower(\$param1));
+        
+        // Call some functions
+        \$this->helperFunction();
+        static::staticFunction();
+        SomeClass::externalFunction();
+        
+        // Add some logic
+        if (\$param2 > 0) {
+            for (\$j = 0; \$j < \$param2; \$j++) {
+                \$result['items'][] = 'item_' . \$j;
+            }
+        }
+        
+        return \$result;
+    }
+";
+}
+
+$testCode .= '
+    
+    /**
+     * Helper function used by test methods
+     */
+    private function helperFunction()
+    {
+        return "helper_result";
+    }
+    
+    /**
+     * Static function for testing
+     */
+    public static function staticFunction()
+    {
+        return "static_result";
+    }
+}
+
+';
+
+// Add standalone functions
+for ($i = 1; $i <= 50; $i++) {
+    $testCode .= "
+/**
+ * Standalone function number $i
+ * 
+ * @param mixed \$input Input parameter
+ * @return mixed Processed result
+ */
+function standaloneFunction$i(\$input)
+{
+    \$result = process_data(\$input);
+    \$result = format_output(\$result);
+    return sanitize_result(\$result);
+}
+
+";
+}
+
+$testCode .= '
+// End of test file
+?>';
+
+// Write test file
+file_put_contents('/vercel/sandbox/test_large_file.php', $testCode);
+
+echo "Generated large test file: " . strlen($testCode) . " bytes\n";
+echo "File saved to: /vercel/sandbox/test_large_file.php\n";
diff --git a/src/Router.php b/src/Router.php
index d1a1e66..3649036 100644
--- a/src/Router.php
+++ b/src/Router.php
@@ -76,22 +76,61 @@ private function handleParseRequest()
         
         // Create parser and process code
         try {
-            $parser = new CodeParser();
+            // Determine if we should use streaming parser based on file size
+            $codeSize = strlen($requestData['code']);
+            $useStreaming = $codeSize > 100 * 1024; // 100KB threshold
+            
+            if ($useStreaming) {
+                $parser = new StreamingCodeParser();
+                
+                // Set up progress tracking for large files
+                $progressData = [];
+                $parser->setProgressCallback(function($message, $percentage, $memoryUsage) use (&$progressData) {
+                    $progressData[] = [
+                        'message' => $message,
+                        'percentage' => $percentage,
+                        'memory_mb' => round($memoryUsage / 1024 / 1024, 2),
+                        'timestamp' => microtime(true)
+                    ];
+                });
+            } else {
+                $parser = new CodeParser();
+            }
+            
             // Set default empty string for modifiedLines if not provided
-            $modifiedLines = '';
+            $modifiedLines = $requestData['modifiedLines'] ?? '';
             
+            $startTime = microtime(true);
             $result = $parser->parseCode(
                 $requestData['code'],
                 $modifiedLines,
                 $requestData['fileType']
             );
+            $endTime = microtime(true);
+            
+            // Add performance metrics
+            $result['performance'] = [
+                'parsing_time_ms' => round(($endTime - $startTime) * 1000, 2),
+                'file_size_bytes' => $codeSize,
+                'parser_used' => $useStreaming ? 'streaming' : 'standard',
+                'memory_peak_mb' => round(memory_get_peak_usage(true) / 1024 / 1024, 2)
+            ];
+            
+            // Add progress data for streaming parser
+            if ($useStreaming && !empty($progressData)) {
+                $result['progress_log'] = $progressData;
+            }
             
             // Return result
             http_response_code(200);
             echo json_encode($result);
         } catch (\Exception $e) {
             http_response_code(500);
-            echo json_encode(['error' => $e->getMessage()]);
+            echo json_encode([
+                'error' => $e->getMessage(),
+                'error_type' => get_class($e),
+                'memory_usage_mb' => round(memory_get_usage(true) / 1024 / 1024, 2)
+            ]);
         }
     }
     
diff --git a/src/StreamingCodeParser.php b/src/StreamingCodeParser.php
new file mode 100644
index 0000000..5c03af5
--- /dev/null
+++ b/src/StreamingCodeParser.php
@@ -0,0 +1,313 @@
+<?php
+
+namespace PhpParser;
+
+use PhpParser\Node;
+use PhpParser\NodeTraverser;
+use PhpParser\NodeVisitorAbstract;
+use PhpParser\ParserFactory;
+use PhpParser\Error;
+
+/**
+ * StreamingCodeParser class for parsing large PHP files efficiently
+ * 
+ * This class handles large PHP files by implementing memory-efficient parsing
+ * with streaming, chunking, and progress tracking capabilities.
+ */
+class StreamingCodeParser
+{
+    private const MAX_MEMORY_USAGE = 512 * 1024 * 1024; // 512MB limit
+    private const CHUNK_SIZE = 64 * 1024; // 64KB chunks
+    private const MAX_FILE_SIZE = 100 * 1024 * 1024; // 100MB max file size
+    
+    /**
+     * @var callable|null Progress callback function
+     */
+    private $progressCallback;
+    
+    /**
+     * @var int Current memory usage
+     */
+    private $memoryUsage = 0;
+    
+    /**
+     * Set progress callback function
+     *
+     * @param callable $callback Function to call with progress updates
+     */
+    public function setProgressCallback(callable $callback): void
+    {
+        $this->progressCallback = $callback;
+    }
+    
+    /**
+     * Parse PHP code with memory-efficient streaming approach
+     *
+     * @param string $code The PHP code to parse
+     * @param string $modifiedLines String representation of modified line ranges
+     * @param string $fileType The file type (expected to be 'php')
+     * @return array The structured data representing the parsed code
+     * @throws \Exception If there's an error parsing the code
+     */
+    public function parseCode(string $code, string $modifiedLines, string $fileType): array
+    {
+        if ($fileType !== 'php') {
+            throw new \Exception("Unsupported file type: {$fileType}. Only PHP files are supported.");
+        }
+        
+        // Check file size limits
+        $codeLength = strlen($code);
+        if ($codeLength > self::MAX_FILE_SIZE) {
+            throw new \Exception("File too large. Maximum supported size is " . (self::MAX_FILE_SIZE / 1024 / 1024) . "MB");
+        }
+        
+        $this->reportProgress("Starting parse process...", 0);
+        
+        // Check initial memory usage
+        $this->checkMemoryUsage();
+        
+        try {
+            // Parse the modified lines into a format we can work with
+            $modifiedLineRanges = $this->parseModifiedLines($modifiedLines);
+            $this->reportProgress("Parsed modified lines", 10);
+            
+            // For very large files, use streaming approach
+            if ($codeLength > self::CHUNK_SIZE * 10) {
+                return $this->parseCodeStreaming($code, $modifiedLineRanges);
+            } else {
+                return $this->parseCodeStandard($code, $modifiedLineRanges);
+            }
+            
+        } catch (Error $e) {
+            throw new \Exception("Parse error: {$e->getMessage()}");
+        } finally {
+            $this->reportProgress("Parse process completed", 100);
+        }
+    }
+    
+    /**
+     * Parse code using standard approach for smaller files
+     *
+     * @param string $code PHP code to parse
+     * @param array $modifiedLineRanges Array of modified line ranges
+     * @return array Parsed structure
+     */
+    private function parseCodeStandard(string $code, array $modifiedLineRanges): array
+    {
+        $this->reportProgress("Using standard parsing approach", 20);
+        
+        // Create parser
+        $parser = (new ParserFactory)->create(ParserFactory::PREFER_PHP7);
+        
+        // Parse code
+        $ast = $parser->parse($code);
+        
+        if ($ast === null) {
+            throw new \Exception("Failed to parse PHP code");
+        }
+        
+        $this->reportProgress("AST generated successfully", 50);
+        
+        // Extract structured data from AST
+        $visitor = new StreamingCodeVisitor($code, $modifiedLineRanges);
+        $traverser = new NodeTraverser();
+        $traverser->addVisitor($visitor);
+        $traverser->traverse($ast);
+        
+        $this->reportProgress("Code analysis completed", 80);
+        
+        // Format output according to required structure
+        return [
+            'methods' => $visitor->getMethods(),
+            'classes' => $visitor->getClasses(),
+            'imports' => $visitor->getImports(),
+            'metadata' => [
+                'parsing_method' => 'standard',
+                'file_size' => strlen($code),
+                'memory_peak' => memory_get_peak_usage(true)
+            ]
+        ];
+    }
+    
+    /**
+     * Parse code using streaming approach for large files
+     *
+     * @param string $code PHP code to parse
+     * @param array $modifiedLineRanges Array of modified line ranges
+     * @return array Parsed structure
+     */
+    private function parseCodeStreaming(string $code, array $modifiedLineRanges): array
+    {
+        $this->reportProgress("Using streaming parsing approach for large file", 20);
+        
+        // For PHP files, we still need to parse the entire content as PHP syntax
+        // requires complete context. However, we can optimize memory usage in processing
+        
+        // Create parser with memory optimization
+        $parser = (new ParserFactory)->create(ParserFactory::PREFER_PHP7);
+        
+        // Check memory before parsing
+        $this->checkMemoryUsage();
+        
+        // Parse in chunks if possible, but PHP parsing requires full context
+        $ast = $parser->parse($code);
+        
+        if ($ast === null) {
+            throw new \Exception("Failed to parse PHP code");
+        }
+        
+        $this->reportProgress("AST generated for large file", 40);
+        $this->checkMemoryUsage();
+        
+        // Use streaming visitor for memory efficiency
+        $visitor = new StreamingCodeVisitor($code, $modifiedLineRanges, true); // streaming mode
+        $visitor->setProgressCallback($this->progressCallback);
+        
+        $traverser = new NodeTraverser();
+        $traverser->addVisitor($visitor);
+        
+        // Process AST with memory monitoring
+        $this->traverseWithMemoryMonitoring($traverser, $ast);
+        
+        $this->reportProgress("Large file analysis completed", 90);
+        
+        // Clean up memory
+        unset($ast);
+        gc_collect_cycles();
+        
+        // Format output according to required structure
+        return [
+            'methods' => $visitor->getMethods(),
+            'classes' => $visitor->getClasses(),
+            'imports' => $visitor->getImports(),
+            'metadata' => [
+                'parsing_method' => 'streaming',
+                'file_size' => strlen($code),
+                'memory_peak' => memory_get_peak_usage(true),
+                'chunks_processed' => $visitor->getChunksProcessed()
+            ]
+        ];
+    }
+    
+    /**
+     * Traverse AST with memory monitoring
+     *
+     * @param NodeTraverser $traverser Node traverser
+     * @param array $ast Abstract Syntax Tree
+     */
+    private function traverseWithMemoryMonitoring(NodeTraverser $traverser, array $ast): void
+    {
+        $chunkSize = 100; // Process nodes in chunks
+        $nodeCount = count($ast);
+        
+        for ($i = 0; $i < $nodeCount; $i += $chunkSize) {
+            $chunk = array_slice($ast, $i, $chunkSize);
+            
+            // Check memory before processing chunk
+            $this->checkMemoryUsage();
+            
+            // Process chunk
+            $traverser->traverse($chunk);
+            
+            // Report progress
+            $progress = 40 + (($i / $nodeCount) * 40); // Progress between 40% and 80%
+            $this->reportProgress("Processing nodes: " . ($i + $chunkSize) . "/" . $nodeCount, (int)$progress);
+            
+            // Clean up chunk memory
+            unset($chunk);
+            
+            // Force garbage collection periodically
+            if ($i % (self::CHUNK_SIZE / 10) === 0) {
+                gc_collect_cycles();
+            }
+        }
+    }
+    
+    /**
+     * Check memory usage and throw exception if limit exceeded
+     *
+     * @throws \Exception If memory limit is exceeded
+     */
+    private function checkMemoryUsage(): void
+    {
+        $currentMemory = memory_get_usage(true);
+        $this->memoryUsage = $currentMemory;
+        
+        if ($currentMemory > self::MAX_MEMORY_USAGE) {
+            throw new \Exception(
+                "Memory limit exceeded: " . round($currentMemory / 1024 / 1024, 2) . 
+                "MB used, limit is " . (self::MAX_MEMORY_USAGE / 1024 / 1024) . "MB"
+            );
+        }
+    }
+    
+    /**
+     * Parse modified lines string into array of ranges
+     *
+     * @param string $modifiedLines String representing modified line ranges (e.g. "1-5,10-15")
+     * @return array Array of arrays with 'start' and 'end' keys
+     */
+    private function parseModifiedLines(string $modifiedLines): array
+    {
+        if (empty($modifiedLines)) {
+            return [];
+        }
+        
+        $ranges = [];
+        $parts = explode(',', $modifiedLines);
+        
+        foreach ($parts as $part) {
+            $part = trim($part);
+            if (empty($part)) continue;
+            
+            if (strpos($part, '-') !== false) {
+                list($start, $end) = array_map('trim', explode('-', $part, 2));
+                $ranges[] = [
+                    'start' => (int) $start,
+                    'end' => (int) $end
+                ];
+            } else {
+                $lineNumber = (int) $part;
+                $ranges[] = [
+                    'start' => $lineNumber,
+                    'end' => $lineNumber
+                ];
+            }
+        }
+        
+        return $ranges;
+    }
+    
+    /**
+     * Report progress to callback function
+     *
+     * @param string $message Progress message
+     * @param int $percentage Progress percentage (0-100)
+     */
+    private function reportProgress(string $message, int $percentage): void
+    {
+        if ($this->progressCallback) {
+            call_user_func($this->progressCallback, $message, $percentage, $this->memoryUsage);
+        }
+    }
+    
+    /**
+     * Get current memory usage in bytes
+     *
+     * @return int Memory usage in bytes
+     */
+    public function getMemoryUsage(): int
+    {
+        return memory_get_usage(true);
+    }
+    
+    /**
+     * Get peak memory usage in bytes
+     *
+     * @return int Peak memory usage in bytes
+     */
+    public function getPeakMemoryUsage(): int
+    {
+        return memory_get_peak_usage(true);
+    }
+}
diff --git a/src/StreamingCodeVisitor.php b/src/StreamingCodeVisitor.php
new file mode 100644
index 0000000..45fc6f6
--- /dev/null
+++ b/src/StreamingCodeVisitor.php
@@ -0,0 +1,541 @@
+<?php
+
+namespace PhpParser;
+
+use PhpParser\Node;
+use PhpParser\NodeVisitorAbstract;
+use PhpParser\Comment\Doc;
+
+/**
+ * StreamingCodeVisitor class for memory-efficient AST traversal
+ * 
+ * This class extends the original CodeVisitor with streaming capabilities
+ * for handling large PHP files with minimal memory footprint.
+ */
+class StreamingCodeVisitor extends NodeVisitorAbstract
+{
+    /**
+     * @var array Classes data
+     */
+    private $classes = [];
+    
+    /**
+     * @var array Methods data (outside of classes)
+     */
+    private $methods = [];
+    
+    /**
+     * @var array Import statements
+     */
+    private $imports = [];
+    
+    /**
+     * @var string Original code
+     */
+    private $code;
+    
+    /**
+     * @var array Lines of code (lazily loaded)
+     */
+    private $codeLines = null;
+    
+    /**
+     * @var array Modified line ranges
+     */
+    private $modifiedLineRanges;
+    
+    /**
+     * @var bool Streaming mode flag
+     */
+    private $streamingMode;
+    
+    /**
+     * @var callable|null Progress callback function
+     */
+    private $progressCallback;
+    
+    /**
+     * @var int Number of processed chunks
+     */
+    private $chunksProcessed = 0;
+    
+    /**
+     * @var int Current node count
+     */
+    private $nodeCount = 0;
+    
+    /**
+     * @var int Maximum content length for streaming mode
+     */
+    private const MAX_CONTENT_LENGTH = 10000; // 10KB max content per method/class
+    
+    /**
+     * Constructor
+     *
+     * @param string $code Original PHP code
+     * @param array $modifiedLineRanges Array of modified line ranges
+     * @param bool $streamingMode Enable streaming mode for large files
+     */
+    public function __construct(string $code, array $modifiedLineRanges, bool $streamingMode = false)
+    {
+        $this->code = $code;
+        $this->modifiedLineRanges = $modifiedLineRanges;
+        $this->streamingMode = $streamingMode;
+    }
+    
+    /**
+     * Set progress callback function
+     *
+     * @param callable $callback Function to call with progress updates
+     */
+    public function setProgressCallback(callable $callback): void
+    {
+        $this->progressCallback = $callback;
+    }
+    
+    /**
+     * Called before node traversal
+     */
+    public function beforeTraverse(array $nodes)
+    {
+        $this->classes = [];
+        $this->methods = [];
+        $this->imports = [];
+        $this->nodeCount = 0;
+        $this->chunksProcessed = 0;
+        
+        // In streaming mode, don't split code into lines until needed
+        if (!$this->streamingMode) {
+            $this->codeLines = explode("\n", $this->code);
+        }
+        
+        return null;
+    }
+    
+    /**
+     * Called when a node is entered during traversal
+     */
+    public function enterNode(Node $node)
+    {
+        $this->nodeCount++;
+        
+        // Report progress periodically in streaming mode
+        if ($this->streamingMode && $this->nodeCount % 100 === 0) {
+            $this->reportProgress("Processing node #{$this->nodeCount}", 0);
+        }
+        
+        // Check memory usage periodically
+        if ($this->streamingMode && $this->nodeCount % 500 === 0) {
+            $this->checkMemoryUsage();
+        }
+        
+        try {
+            // Extract imports/use statements
+            if ($node instanceof Node\Stmt\Use_) {
+                $this->processImportNode($node);
+            }
+            
+            // Process classes
+            if ($node instanceof Node\Stmt\Class_) {
+                $this->processClass($node);
+            }
+            
+            // Process standalone methods/functions
+            if ($node instanceof Node\Stmt\Function_) {
+                $this->processFunction($node);
+            }
+        } catch (\Exception $e) {
+            // Log error but continue processing
+            error_log("Error processing node: " . $e->getMessage());
+        }
+        
+        return null;
+    }
+    
+    /**
+     * Process import/use statement node
+     *
+     * @param Node\Stmt\Use_ $node Use statement node
+     */
+    private function processImportNode(Node\Stmt\Use_ $node)
+    {
+        foreach ($node->uses as $use) {
+            $import = implode('\\', $use->name->parts);
+            // Avoid duplicates and limit imports in streaming mode
+            if (!in_array($import, $this->imports)) {
+                if (!$this->streamingMode || count($this->imports) < 1000) {
+                    $this->imports[] = $import;
+                }
+            }
+        }
+    }
+    
+    /**
+     * Process class node and extract relevant information
+     *
+     * @param Node\Stmt\Class_ $node Class node
+     */
+    private function processClass(Node\Stmt\Class_ $node)
+    {
+        $className = $node->name->toString();
+        $classStartLine = $node->getStartLine();
+        $classEndLine = $node->getEndLine();
+        
+        // Get class docblock
+        $docComment = $node->getDocComment();
+        $docString = $docComment ? $this->truncateIfNeeded($docComment->getText()) : '';
+        $docStartLine = $docComment ? $docComment->getStartLine() : -1;
+        $docEndLine = $docComment ? $docComment->getEndLine() : -1;
+        
+        // Get class content (with streaming optimization)
+        $classContent = $this->extractNodeContentOptimized($node);
+        
+        // Create class data structure
+        $classData = [
+            'methods' => [],
+            'content' => $classContent,
+            'docstring' => $docString,
+            'class_start_line' => $classStartLine,
+            'class_end_line' => $classEndLine,
+            'doc_start_line' => $docStartLine,
+            'doc_end_line' => $docEndLine,
+            'annotations' => $this->extractAnnotations($docString)
+        ];
+        
+        // Process methods within class (with memory management)
+        $methodCount = 0;
+        foreach ($node->stmts as $stmt) {
+            if ($stmt instanceof Node\Stmt\ClassMethod) {
+                // Limit methods processed in streaming mode to prevent memory issues
+                if ($this->streamingMode && $methodCount >= 100) {
+                    $classData['methods']['__truncated__'] = [
+                        'message' => 'Methods list truncated due to size limits',
+                        'total_methods_found' => count($node->stmts)
+                    ];
+                    break;
+                }
+                
+                $methodName = $stmt->name->toString();
+                $methodData = $this->extractMethodData($stmt);
+                $classData['methods'][$methodName] = $methodData;
+                $methodCount++;
+            }
+        }
+        
+        $this->classes[$className] = $classData;
+        $this->chunksProcessed++;
+        
+        // Clean up memory in streaming mode
+        if ($this->streamingMode) {
+            $this->performMemoryCleanup();
+        }
+    }
+    
+    /**
+     * Process function node and extract relevant information
+     *
+     * @param Node\Stmt\Function_ $node Function node
+     */
+    private function processFunction(Node\Stmt\Function_ $node)
+    {
+        $functionName = $node->name->toString();
+        
+        // In streaming mode, limit the number of standalone functions
+        if ($this->streamingMode && count($this->methods) >= 500) {
+            $this->methods['__truncated__'] = [
+                'message' => 'Functions list truncated due to size limits'
+            ];
+            return;
+        }
+        
+        $functionData = $this->extractMethodData($node);
+        $this->methods[$functionName] = $functionData;
+        $this->chunksProcessed++;
+        
+        // Clean up memory in streaming mode
+        if ($this->streamingMode) {
+            $this->performMemoryCleanup();
+        }
+    }
+    
+    /**
+     * Extract method data from method or function node
+     *
+     * @param Node\FunctionLike $node Method or function node
+     * @return array Method data
+     */
+    private function extractMethodData(Node\FunctionLike $node)
+    {
+        $startLine = $node->getStartLine();
+        $endLine = $node->getEndLine();
+        
+        // Get method docblock
+        $docComment = $node->getDocComment();
+        $docString = $docComment ? $this->truncateIfNeeded($docComment->getText()) : '';
+        $docStartLine = $docComment ? $docComment->getStartLine() : -1;
+        $docEndLine = $docComment ? $docComment->getEndLine() : -1;
+        
+        // Get method content and called functions (with optimization)
+        $methodContent = $this->extractNodeContentOptimized($node);
+        $calledFunctions = $this->extractCalledFunctionsOptimized($node);
+        
+        // Find code lines (excluding doc comment)
+        $codeLineStart = $docComment ? $docEndLine + 1 : $startLine;
+        $codeLineEnd = $endLine;
+        
+        // Build method data structure
+        return [
+            'content' => $methodContent,
+            'calledFunctions' => $calledFunctions,
+            'docstring' => $docString,
+            'fun_start_line' => $startLine,
+            'fun_end_line' => $endLine,
+            'doc_start_line' => $docStartLine,
+            'doc_end_line' => $docEndLine,
+            'annotations' => $this->extractAnnotations($docString),
+            'code_line_start' => $codeLineStart,
+            'code_line_end' => $codeLineEnd
+        ];
+    }
+    
+    /**
+     * Extract content of a node from original code with optimization
+     *
+     * @param Node $node AST node
+     * @return string Node content (potentially truncated)
+     */
+    private function extractNodeContentOptimized(Node $node)
+    {
+        $startLine = $node->getStartLine();
+        $endLine = $node->getEndLine();
+        
+        // Check if content might be too large
+        $lineCount = $endLine - $startLine + 1;
+        if ($this->streamingMode && $lineCount > 500) {
+            return $this->getContentSummary($startLine, $endLine);
+        }
+        
+        // Lazy load code lines only when needed
+        if ($this->codeLines === null) {
+            $this->codeLines = explode("\n", $this->code);
+        }
+        
+        // Lines are 1-indexed in the parser, but arrays are 0-indexed
+        $relevantLines = array_slice($this->codeLines, $startLine - 1, $lineCount);
+        $content = implode("\n", $relevantLines);
+        
+        // Truncate if too large
+        return $this->truncateIfNeeded($content);
+    }
+    
+    /**
+     * Get a summary of content for very large nodes
+     *
+     * @param int $startLine Start line number
+     * @param int $endLine End line number
+     * @return string Content summary
+     */
+    private function getContentSummary(int $startLine, int $endLine): string
+    {
+        return sprintf(
+            "// Large content block (%d lines)\n// Lines %d-%d\n// Content truncated for memory efficiency",
+            $endLine - $startLine + 1,
+            $startLine,
+            $endLine
+        );
+    }
+    
+    /**
+     * Extract called function names with optimization for streaming
+     *
+     * @param Node\FunctionLike $node Function or method node
+     * @return array List of called function names (potentially truncated)
+     */
+    private function extractCalledFunctionsOptimized(Node\FunctionLike $node)
+    {
+        $calledFunctions = [];
+        $maxFunctions = $this->streamingMode ? 50 : PHP_INT_MAX;
+        
+        // Create a visitor to find function calls with limits
+        $visitor = new class($calledFunctions, $maxFunctions) extends NodeVisitorAbstract {
+            private $calledFunctions;
+            private $maxFunctions;
+            private $functionCount = 0;
+            
+            public function __construct(&$calledFunctions, int $maxFunctions)
+            {
+                $this->calledFunctions = &$calledFunctions;
+                $this->maxFunctions = $maxFunctions;
+            }
+            
+            public function enterNode(Node $node)
+            {
+                if ($this->functionCount >= $this->maxFunctions) {
+                    return NodeTraverser::DONT_TRAVERSE_CHILDREN;
+                }
+                
+                if ($node instanceof Node\Expr\FuncCall && $node->name instanceof Node\Name) {
+                    $this->calledFunctions[] = $node->name->toString();
+                    $this->functionCount++;
+                } elseif ($node instanceof Node\Expr\MethodCall && $node->name instanceof Node\Identifier) {
+                    $this->calledFunctions[] = $node->name->toString();
+                    $this->functionCount++;
+                } elseif ($node instanceof Node\Expr\StaticCall &&
+                          $node->class instanceof Node\Name &&
+                          $node->name instanceof Node\Identifier) {
+                    $this->calledFunctions[] = $node->class->toString() . '::' . $node->name->toString();
+                    $this->functionCount++;
+                }
+                
+                return null;
+            }
+        };
+        
+        // Traverse the node to find function calls
+        $traverser = new NodeTraverser();
+        $traverser->addVisitor($visitor);
+        $traverser->traverse([$node]);
+        
+        // Add truncation marker if needed
+        if ($this->streamingMode && count($calledFunctions) >= $maxFunctions) {
+            $calledFunctions[] = '__truncated__';
+        }
+        
+        return $calledFunctions;
+    }
+    
+    /**
+     * Extract annotations from a docblock
+     *
+     * @param string $docString Docblock string
+     * @return array List of annotations
+     */
+    private function extractAnnotations(string $docString)
+    {
+        // PHP doesn't have decorators like Python, so returning an empty array
+        return [];
+    }
+    
+    /**
+     * Truncate content if it exceeds size limits
+     *
+     * @param string $content Content to check
+     * @return string Potentially truncated content
+     */
+    private function truncateIfNeeded(string $content): string
+    {
+        if ($this->streamingMode && strlen($content) > self::MAX_CONTENT_LENGTH) {
+            return substr($content, 0, self::MAX_CONTENT_LENGTH) . 
+                   "\n\n// ... Content truncated for memory efficiency ...";
+        }
+        return $content;
+    }
+    
+    /**
+     * Perform memory cleanup operations
+     */
+    private function performMemoryCleanup(): void
+    {
+        // Force garbage collection every 50 chunks in streaming mode
+        if ($this->chunksProcessed % 50 === 0) {
+            gc_collect_cycles();
+        }
+        
+        // Clear code lines cache if memory is getting tight
+        if (memory_get_usage(true) > 256 * 1024 * 1024) { // 256MB threshold
+            $this->codeLines = null;
+        }
+    }
+    
+    /**
+     * Check memory usage and take action if needed
+     */
+    private function checkMemoryUsage(): void
+    {
+        $currentMemory = memory_get_usage(true);
+        $memoryLimitMB = 512; // 512MB soft limit
+        
+        if ($currentMemory > $memoryLimitMB * 1024 * 1024) {
+            // Aggressive cleanup
+            $this->codeLines = null;
+            gc_collect_cycles();
+            
+            $this->reportProgress(
+                "High memory usage detected: " . round($currentMemory / 1024 / 1024, 2) . "MB",
+                0
+            );
+        }
+    }
+    
+    /**
+     * Report progress to callback function
+     *
+     * @param string $message Progress message
+     * @param int $percentage Progress percentage (0-100)
+     */
+    private function reportProgress(string $message, int $percentage): void
+    {
+        if ($this->progressCallback) {
+            call_user_func($this->progressCallback, $message, $percentage, memory_get_usage(true));
+        }
+    }
+    
+    /**
+     * Get extracted methods data
+     *
+     * @return array Methods data
+     */
+    public function getMethods()
+    {
+        return $this->methods;
+    }
+    
+    /**
+     * Get extracted classes data
+     *
+     * @return array Classes data
+     */
+    public function getClasses()
+    {
+        return $this->classes;
+    }
+    
+    /**
+     * Get extracted imports
+     *
+     * @return array Import statements
+     */
+    public function getImports()
+    {
+        return $this->imports;
+    }
+    
+    /**
+     * Get number of chunks processed
+     *
+     * @return int Number of chunks processed
+     */
+    public function getChunksProcessed(): int
+    {
+        return $this->chunksProcessed;
+    }
+    
+    /**
+     * Get processing statistics
+     *
+     * @return array Processing statistics
+     */
+    public function getStatistics(): array
+    {
+        return [
+            'nodes_processed' => $this->nodeCount,
+            'chunks_processed' => $this->chunksProcessed,
+            'classes_found' => count($this->classes),
+            'methods_found' => count($this->methods),
+            'imports_found' => count($this->imports),
+            'streaming_mode' => $this->streamingMode,
+            'memory_usage' => memory_get_usage(true),
+            'peak_memory' => memory_get_peak_usage(true)
+        ];
+    }
+}
diff --git a/test_parser.php b/test_parser.php
new file mode 100644
index 0000000..6a1fe76
--- /dev/null
+++ b/test_parser.php
@@ -0,0 +1,57 @@
+<?php
+
+require_once __DIR__ . '/vendor/autoload.php';
+
+use PhpParser\CodeParser;
+use PhpParser\StreamingCodeParser;
+
+// Test both parsers with a simple example first
+$simpleCode = '<?php
+class TestClass {
+    public function testMethod() {
+        $result = json_encode("test");
+        return $result;
+    }
+}
+?>';
+
+echo "=== Testing Simple Code ===\n";
+echo "Code size: " . strlen($simpleCode) . " bytes\n\n";
+
+// Test standard parser
+echo "--- Standard Parser ---\n";
+try {
+    $parser = new CodeParser();
+    $result = $parser->parseCode($simpleCode, '', 'php');
+    echo "✓ Standard parser successful\n";
+    echo "Classes found: " . count($result['classes']) . "\n";
+    echo "Methods found: " . count($result['methods']) . "\n";
+    echo "Imports found: " . count($result['imports']) . "\n\n";
+} catch (Exception $e) {
+    echo "✗ Standard parser failed: " . $e->getMessage() . "\n\n";
+}
+
+// Test streaming parser
+echo "--- Streaming Parser ---\n";
+try {
+    $streamingParser = new StreamingCodeParser();
+    
+    // Set up progress callback
+    $streamingParser->setProgressCallback(function($message, $percentage, $memoryUsage) {
+        echo "Progress: $percentage% - $message (Memory: " . round($memoryUsage / 1024 / 1024, 2) . "MB)\n";
+    });
+    
+    $result = $streamingParser->parseCode($simpleCode, '', 'php');
+    echo "✓ Streaming parser successful\n";
+    echo "Classes found: " . count($result['classes']) . "\n";
+    echo "Methods found: " . count($result['methods']) . "\n";
+    echo "Imports found: " . count($result['imports']) . "\n";
+    if (isset($result['metadata'])) {
+        echo "Parser method: " . $result['metadata']['parsing_method'] . "\n";
+        echo "Peak memory: " . round($result['metadata']['memory_peak'] / 1024 / 1024, 2) . "MB\n";
+    }
+} catch (Exception $e) {
+    echo "✗ Streaming parser failed: " . $e->getMessage() . "\n";
+}
+
+echo "\n=== Parser Implementation Test Complete ===\n";