lam-cli 0.1.0__py3-none-any.whl → 0.1.3__py3-none-any.whl

lam/lam.py

@@ -22,9 +22,10 @@ from posthog import Posthog
 posthog = Posthog(project_api_key='phc_wfeHFG0p5yZIdBpjVYy00o5x1HbEpggdMzIuFYgNPSK', 
                   host='https://app.posthog.com')
 
-logging.basicConfig(level=logging.INFO, 
+logging.basicConfig(level=logging.DEBUG, 
                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
+logging.getLogger('urllib3').setLevel(logging.WARNING)  # Suppress urllib3 logs
 
 handler = LogtailHandler(source_token="TYz3WrrvC8ehYjXdAEGGyiDp")
 logger.addHandler(handler)
@@ -47,20 +48,20 @@ class ResourceLimitError(LAMError):
 
 def check_resource_limits(modules_dir: Optional[Path] = None) -> None:
     """Check system resource availability"""
-    # Check disk space
+    logger.debug("Checking system resource limits")
     disk = shutil.disk_usage(tempfile.gettempdir())
     if disk.free < 100 * 1024 * 1024:  # 100MB minimum
+        logger.critical("Insufficient disk space: %dMB free", disk.free // (1024*1024))
         raise ResourceLimitError("Insufficient disk space")
     
-    # Check shared modules size if provided
     if modules_dir and modules_dir.exists():
         modules_size = sum(
             os.path.getsize(os.path.join(dirpath, filename))
             for dirpath, _, filenames in os.walk(modules_dir)
             for filename in filenames
         )
-        if modules_size > 500 * 1024 * 1024:  # 500MB limit
-            logger.warning("Shared modules exceeding size limit, cleaning up")
+        if modules_size > 500 * 1024 * 1024:
+            logger.warning("Cleaning oversized modules directory (%dMB)", modules_size//(1024*1024))
             shutil.rmtree(modules_dir)
             modules_dir.mkdir(exist_ok=True)
 
@@ -71,7 +72,6 @@ class Stats:
         self.memory_start = self.get_memory_usage()
     
     def get_memory_usage(self):
-        import psutil
         process = psutil.Process()
         return process.memory_info().rss
     
@@ -120,17 +120,17 @@ class Engine:
 class JQEngine(Engine):
     """JQ execution engine"""
     def validate_environment(self) -> bool:
+        logger.debug("Validating JQ environment")
         return shutil.which("jq") is not None
 
     def execute(self, program_file: str, input_data: str) -> Tuple[Union[Dict, str], Optional[str]]:
         logger.info(f"Executing JQ script: {program_file}")
         
         try:
-            # Parse JQ program
             with open(program_file, 'r') as file:
                 jq_script = ''.join(line for line in file if not line.strip().startswith('#'))
+                logger.debug("Loaded JQ script: %d characters", len(jq_script))
 
-            # Run JQ
             process = subprocess.Popen(
                 ["jq", "-c", jq_script],
                 stdin=subprocess.PIPE,
@@ -139,59 +139,82 @@ class JQEngine(Engine):
                 text=True
             )
             
+            logger.debug("Starting JQ process PID %d", process.pid)
             output, error = process.communicate(input=input_data)
             
             if error:
+                logger.error("JQ error output: %s", error.strip())
                 raise ProcessingError(error)
                 
             # Handle output
             try:
-                return json.loads(output), None
-            except json.JSONDecodeError:
+                output_lines = [line.strip() for line in output.splitlines() if line.strip()]
+                logger.debug(f"Found {len(output_lines)} JSON objects in output")
+                
+                if len(output_lines) > 1:
+                    parsed = [json.loads(line) for line in output_lines]
+                    logger.info(f"Processed {len(parsed)} JSON objects")
+                    return {"lam.result": parsed}, None
+                elif len(output_lines) == 1:
+                    result = json.loads(output_lines[0])
+                    logger.info("Processed single JSON object")
+                    return result, None
+                else:
+                    logger.info("No JSON objects in output")
+                    return {"lam.error": "No JSON objects in output"}, "No JSON objects in output"
+                    
+            except json.JSONDecodeError as e:
                 return {"lam.result": output}, None
                 
         except Exception as e:
+            logger.exception("JQ execution failed")
             self.track_event('lam.jq.error', {'error': str(e)})
             return {"lam.error": str(e)}, str(e)
 
 class BunEngine(Engine):
-    """Bun JavaScript execution engine"""
+    """Bun JavaScript execution engine with enhanced logging"""
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        # Create a persistent temp directory for node_modules
         self.modules_dir = Path(tempfile.gettempdir()) / "lam_modules"
         self.modules_dir.mkdir(exist_ok=True)
         self._setup_shared_modules()
         
         self.runtime_template = '''
-        // Secure runtime environment
-        globalThis.process = undefined;
-        globalThis.Deno = undefined;
-        globalThis.fetch = undefined;
+        const logs = [];
+        const originalLog = console.log;
+        const originalError = console.error;
+        const originalWarn = console.warn;
         
-        import _ from 'lodash';
-        import { format, parseISO } from 'date-fns';
+        console.log = (...args) => logs.push({ type: 'log', message: args.map(String).join(' ') });
+        console.error = (...args) => {
+            originalError(...args);  // Keep error output for debugging
+            logs.push({ type: 'error', message: args.map(String).join(' ') });
+        };
+        console.warn = (...args) => logs.push({ type: 'warn', message: args.map(String).join(' ') });
         
-        // Safe console methods
-        const secureConsole = {
-            log: console.log,
-            error: console.error,
-            warn: console.warn
+        // Keep original stdout for result output
+        const writeResult = (obj) => {
+            console.error("Writing result:", JSON.stringify(obj, null, 2));
+            originalLog(JSON.stringify(obj));
         };
-        globalThis.console = secureConsole;
         
-        // Expose safe utilities
-        globalThis._ = _;
-        globalThis.format = format;
-        globalThis.parseISO = parseISO;
+        const _ = require('lodash');
+        const { format, parseISO } = require('date-fns');
+        
+        module.exports = {
+            _,
+            format,
+            parseISO,
+            logs,
+            writeResult
+        };
         '''
-    
+
     def _setup_shared_modules(self):
         """Setup shared node_modules once"""
         if not (self.modules_dir / "node_modules").exists():
-            # Create package.json
+            logger.info("Initializing shared modules directory")
             package_json = {
-                "type": "module",
                 "dependencies": {
                     "lodash": "^4.17.21",
                     "date-fns": "^2.30.0"
@@ -200,26 +223,25 @@ class BunEngine(Engine):
             with open(self.modules_dir / "package.json", "w") as f:
                 json.dump(package_json, f, indent=2)
 
-            # Install dependencies once
             try:
-                subprocess.run(
+                logger.debug("Installing shared dependencies")
+                result = subprocess.run(
                     [self.get_bun_path(), "install"],
                     cwd=self.modules_dir,
                     check=True,
                     capture_output=True,
                     text=True,
-                    timeout=30  # Reasonable timeout for installation
+                    timeout=30
                 )
+                logger.debug("Dependency install output: %s", result.stdout)
             except subprocess.CalledProcessError as e:
-                logger.error(f"Failed to install shared dependencies: {e.stderr}")
-                raise ProcessingError(
-                    f"Failed to set up JavaScript environment: {e.stderr}"
-                ) from e
+                logger.error("Dependency install failed: %s", e.stderr)
+                raise ProcessingError(f"Environment setup failed: {e.stderr}") from e
 
     def create_wrapper(self, input_data: str, user_script: str) -> str:
         """Create the wrapper script with proper escaping"""
         return f'''
-        import './runtime.js';
+        const {{ _, format, parseISO, logs, writeResult }} = require('./runtime.js');
 
         // Utility function to handle circular references in JSON.stringify
         function safeStringify(obj) {{
@@ -250,7 +272,7 @@ class BunEngine(Engine):
             // Parse input safely
             let input;
             try {{
-                input = {input_data};
+                input = JSON.parse({json.dumps(input_data)});
             }} catch (e) {{
                 throw new Error(`Failed to parse input data: ${{e.message}}`);
             }}
@@ -269,17 +291,15 @@ class BunEngine(Engine):
             // Execute transform
             const result = transform(input);
 
-            // Validate result is serializable
-            try {{
-                const serialized = safeStringify(result);
-                console.log(serialized);
-            }} catch (e) {{
-                throw new Error(`Result is not JSON serializable: ${{e.message}}`);
-            }}
+            // Output result after transform
+            writeResult({{
+                result,
+                logs
+            }});
         }} catch (error) {{
             console.error(JSON.stringify({{
                 error: error.message,
-                stack: error.stack,
+                stack: error.stack?.split('\\n') || [],
                 type: error.constructor.name
             }}));
             process.exit(1);
@@ -292,10 +312,11 @@ class BunEngine(Engine):
         runtime_path = temp_dir / "runtime.js"
         with open(runtime_path, "w") as f:
             f.write(self.runtime_template)
+        logger.debug("Runtime file written to: %s", runtime_path)
         
         # Symlink node_modules from shared directory
         os.symlink(self.modules_dir / "node_modules", temp_dir / "node_modules")
-
+        logger.debug("node_modules symlinked from: %s", self.modules_dir / "node_modules")
 
     def validate_environment(self) -> bool:
         # Check multiple locations for bun
@@ -335,22 +356,23 @@ class BunEngine(Engine):
                 # Read user script
                 with open(program_file, 'r') as f:
                     user_script = f.read()
+                    logger.debug("Loaded user script: %d characters", len(user_script))
 
                 # Create wrapper script
                 wrapper = self.create_wrapper(input_data, user_script)
-
                 script_path = temp_dir / "script.js"
-                with open(script_path, "w") as f:
+                with open(script_path, 'w') as f:
                     f.write(wrapper)
+                logger.debug("Generated wrapper script: %s", script_path)
 
                 # Execute with Bun
                 process = subprocess.Popen(
                     [
                         self.get_bun_path(),
                         "run",
-                        "--no-fetch",    # Disable network
-                        "--smol",        # Reduced memory
-                        "--silent",      # Reduce Bun's own error noise
+                        "--no-fetch",
+                        "--smol",
+                        "--silent",
                         str(script_path)
                     ],
                     stdout=subprocess.PIPE,
@@ -358,36 +380,64 @@ class BunEngine(Engine):
                     text=True,
                     cwd=temp_dir
                 )
+                logger.info("Started Bun process PID %d", process.pid)
 
                 try:
-                    output, error = process.communicate(timeout=5)  # 5 second timeout
+                    output, error = process.communicate(timeout=5)
+                    logger.debug("Process completed with code %d", process.returncode)
                 except subprocess.TimeoutExpired as e:
+                    logger.warning("Process timeout after 5 seconds")
                     process.kill()
-                    raise ProcessingError("Script execution timed out") from e
+                    return {"lam.error": "Script execution timed out"}, "Execution timed out after 5 seconds"
 
-                if error:
+                # Handle process errors
+                if process.returncode != 0:
                     try:
-                        error_data = json.loads(error)
+                        # Try to parse structured error from stderr
+                        error_data = json.loads(error.strip())
                         error_msg = error_data.get('error', 'Unknown error')
-                        if error_data.get('stack'):
-                            error_msg = f"{error_msg}\nStack trace:\n{error_data['stack']}"
+                        stack = error_data.get('stack', [])
+                        
+                        # Format error message
+                        error_details = {
+                            "lam.error": error_msg,
+                            "stack_trace": stack
+                        }
+                        return error_details, error_msg
+                        
                     except json.JSONDecodeError:
-                        error_msg = error.split('\n')[0]  # Just take the first line if not JSON
-                    raise ProcessingError(error_msg)
+                        # Fallback to raw error output
+                        error_msg = error.strip() or "Unknown error"
+                        return {"lam.error": error_msg}, error_msg
 
+                # Handle successful output
                 try:
-                    return json.loads(output), None
-                except json.JSONDecodeError:
-                    return {"lam.result": output}, None
+                    output_data = json.loads(output)
+                    
+                    # Process JavaScript logs (if any)
+                    if 'logs' in output_data:
+                        for log_entry in output_data.get('logs', []):
+                            if log_entry['type'] == 'error':
+                                logger.error("[JS] %s", log_entry['message'])
+                            else:
+                                logger.debug("[JS] %s", log_entry['message'])
+                    
+                    result = output_data.get('result', {})
+                    return result, None
+
+                except json.JSONDecodeError as e:
+                    logger.error("Failed to parse output: %s", str(e))
+                    return {
+                        "lam.error": "Invalid JSON output",
+                        "raw_output": output.strip()
+                    }, "Output format error"
 
         except Exception as e:
-            stats_data = stats.finalize()
-            self.track_event('lam.bun.error', {
-                'error': str(e),
-                'error_type': e.__class__.__name__,
-                **stats_data
-            })
-            return {"lam.error": str(e)}, str(e)
+            logger.exception("Execution failed")
+            return {
+                "lam.error": str(e),
+                "type": e.__class__.__name__
+            }, str(e)
 
 def get_engine(engine_type: str, workspace_id: str, flow_id: str, execution_id: str) -> Engine:
     """Factory function to get the appropriate execution engine"""
@@ -409,13 +459,16 @@ def get_engine(engine_type: str, workspace_id: str, flow_id: str, execution_id:
 def process_input(input: str) -> Tuple[str, Optional[str]]:
     """Process and validate input data"""
     if os.path.isfile(input):
+        logger.debug("Loading input from file: %s", input)
         with open(input, 'r') as file:
             return file.read(), None
             
     try:
         json.loads(input)
+        logger.debug("Validated inline JSON input")
         return input, None
     except json.JSONDecodeError as e:
+        logger.error("Invalid JSON input: %s", str(e))
         return None, str(e)
 
 @click.group()
@@ -435,16 +488,14 @@ def lam():
 def run(program_file: str, input: str, language: str, workspace_id: str, 
         flow_id: str, execution_id: str, as_json: bool):
     """Execute a LAM transformation script"""
-    stats = Stats()  # Start tracking stats at the top level
+    stats = Stats()
     
-    # Initialize engine
     try:
         engine = get_engine(language, workspace_id, flow_id, execution_id)
     except (ValueError, EnvironmentError) as e:
         click.echo({"lam.error": str(e)}, err=True)
         return
 
-    # Setup logging
     log_file = engine.get_log_file()
     result_file = engine.get_result_file()
     
@@ -452,25 +503,22 @@ def run(program_file: str, input: str, language: str, workspace_id: str,
     file_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
     logger.addHandler(file_handler)
     
-    logger.info(f"Starting LAM execution with {language} engine")
+    logger.info("Starting LAM execution with %s engine", language)
     engine.track_event('lam.run.start', {
         'language': language,
         'program_file': program_file
     })
 
     try:
-        # Process input
         input_data, error = process_input(input)
         if error:
             raise ProcessingError(f"Invalid input: {error}")
 
-        # Execute transformation
         result, error = engine.execute(program_file, input_data)
         
-        # Get final stats
         stats_data = stats.finalize()
-        logger.info(f"Execution stats: duration={stats_data['duration_ms']:.2f}ms, "
-                   f"memory_used={stats_data['memory_used_mb']:.2f}MB")
+        logger.info("Execution stats: duration=%.2fms, memory=%.2fMB",
+                   stats_data['duration_ms'], stats_data['memory_used_mb'])
         
         if error:
             click.echo({"lam.error": error}, err=True)
@@ -480,20 +528,17 @@ def run(program_file: str, input: str, language: str, workspace_id: str,
             click.echo(output)
             engine.track_event('lam.run.success', stats_data)
             
-        # Save result with stats
-        result_with_stats = {
-            'result': result,
-            'stats': stats_data,
-            'error': error or None
-        }
+        if isinstance(result, list):
+            result = {"lam.result": result}
+        
         with open(result_file, 'w') as f:
-            json.dump(result_with_stats, f, indent=4)
+            json.dump(result, f, indent=4)
             
     except Exception as e:
         stats_data = stats.finalize()
-        logger.error(f"Execution failed: {e}")
-        logger.error(f"Final stats: duration={stats_data['duration_ms']:.2f}ms, "
-                    f"memory_used={stats_data['memory_used_mb']:.2f}MB")
+        logger.error("Execution failed: %s", str(e))
+        logger.error("Final stats: duration=%.2fms, memory=%.2fMB",
+                    stats_data['duration_ms'], stats_data['memory_used_mb'])
         click.echo({"lam.error": str(e)}, err=True)
         engine.track_event('lam.run.error', {'error': str(e), **stats_data})
         

lam_cli-0.1.3.dist-info/METADATA

@@ -0,0 +1,52 @@
+Metadata-Version: 2.2
+Name: lam-cli
+Version: 0.1.3
+Summary: Secure data transformation tool supporting JQ and JavaScript (Bun)
+Home-page: https://github.com/laminar-run/lam
+Author: Laminar Run, Inc.
+Author-email: connect@laminar.run
+License: GPLv3
+Project-URL: Documentation, https://docs.laminar.run
+Project-URL: Source, https://github.com/laminar-run/lam
+Project-URL: Issue Tracker, https://github.com/laminar-run/lam/issues
+Keywords: laminar,api,integration,transformation,json,jq,javascript,bun
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: backoff>=2.2.1
+Requires-Dist: certifi>=2024.12.14
+Requires-Dist: charset-normalizer>=3.3.2
+Requires-Dist: click>=8.1.7
+Requires-Dist: idna>=3.7
+Requires-Dist: logtail-python>=0.2.2
+Requires-Dist: monotonic>=1.6
+Requires-Dist: msgpack>=1.0.8
+Requires-Dist: posthog>=3.4.0
+Requires-Dist: psutil>=5.9.0
+Requires-Dist: python-dateutil>=2.8.2
+Requires-Dist: requests>=2.32.3
+Requires-Dist: six>=1.16.0
+Requires-Dist: urllib3>=2.2.2
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

lam_cli-0.1.3.dist-info/RECORD

@@ -0,0 +1,8 @@
+lam/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lam/lam.py,sha256=MrJKA_tFVEEvnhKJkMtrDbdL50bX27aJ0WUbP2dUJiU,20981
+lam_cli-0.1.3.dist-info/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+lam_cli-0.1.3.dist-info/METADATA,sha256=urxYh-mNjUh3v-ggzB_gDIdp5JOa1aQPVKx9kPQGSio,1895
+lam_cli-0.1.3.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+lam_cli-0.1.3.dist-info/entry_points.txt,sha256=iJSsJitcGMikKJ3Q9KNWxEy911oTrSxGSO1HiwcBrKE,40
+lam_cli-0.1.3.dist-info/top_level.txt,sha256=WyM7-Ig60qQH9meqS293pEd83jrMtbvGJM8ALZOQCtA,4
+lam_cli-0.1.3.dist-info/RECORD,,

lam_cli-0.1.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+laminar = lam.lam:lam

lam_cli-0.1.0.dist-info/METADATA

@@ -1,196 +0,0 @@
-Metadata-Version: 2.2
-Name: lam-cli
-Version: 0.1.0
-Summary: Secure data transformation tool supporting JQ and JavaScript (Bun)
-Home-page: https://github.com/laminar-run/lam
-Author: Laminar Run, Inc.
-Author-email: connect@laminar.run
-License: GPLv3
-Project-URL: Documentation, https://docs.laminar.run
-Project-URL: Source, https://github.com/laminar-run/lam
-Project-URL: Issue Tracker, https://github.com/laminar-run/lam/issues
-Keywords: laminar,api,integration,transformation,json,jq,javascript,bun
-Classifier: Development Status :: 4 - Beta
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
-Classifier: Topic :: Software Development :: Build Tools
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: backoff>=2.2.1
-Requires-Dist: certifi>=2024.12.14
-Requires-Dist: charset-normalizer>=3.3.2
-Requires-Dist: click>=8.1.7
-Requires-Dist: idna>=3.7
-Requires-Dist: logtail-python>=0.2.2
-Requires-Dist: monotonic>=1.6
-Requires-Dist: msgpack>=1.0.8
-Requires-Dist: posthog>=3.4.0
-Requires-Dist: psutil>=5.9.0
-Requires-Dist: python-dateutil>=2.8.2
-Requires-Dist: requests>=2.32.3
-Requires-Dist: six>=1.16.0
-Requires-Dist: urllib3>=2.2.2
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: keywords
-Dynamic: license
-Dynamic: project-url
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# lam
-Lam is a data transformation tool for Laminar that supports both `jq` and JavaScript transformations using Bun.
-
-## Quickstart
-Install the dependencies:
-```bash
-# For JQ support
-brew install jq  # or sudo apt-get install jq
-
-# For JavaScript support
-curl -fsSL https://bun.sh/install | bash
-
-make setup
-```
-
-Run the CLI tool:
-```bash
-make cli ARGS="run <program> <input> [--language jq|js]"
-```
-
-## Features
-- JQ transformations (default)
-- JavaScript transformations with Bun runtime
-- Built-in utilities (lodash, date-fns)
-- Resource monitoring and limits
-- Detailed execution statistics
-- Secure execution environment
-
-## Examples
-
-### JQ Transform
-```bash
-make cli ARGS="run examples/transform.jq data.json"
-```
-
-### JavaScript Transform
-```bash
-make cli ARGS="run examples/transform.js data.json --language js"
-```
-
-Example JavaScript transform:
-```javascript
-(input) => {
-    // Lodash available as _
-    return _.map(input.data, item => ({
-        value: item.value * 2
-    }));
-}
-```
-
-## Installation
-
-### Docker Installation
-```dockerfile
-# Install lam-cli
-RUN pip3 install git+https://${GITHUB_USER}:${GITHUB_TOKEN}@github.com/user/project.git@{version}
-
-# Install dependencies
-RUN apt-get update && apt-get install -y jq
-RUN curl -fsSL https://bun.sh/install | bash
-```
-
-### Manual Setup
-Create a virtual environment and install dependencies:
-```bash
-python3 -m venv ./venv
-source ./venv/bin/activate
-pip install -r requirements.txt
-```
-
-## Usage
-```bash
-# Basic usage
-python3 ./lam/lam.py run <program> <input>
-
-# With JavaScript
-python3 ./lam/lam.py run script.js data.json --language js
-
-# Full options
-python3 ./lam/lam.py run <program> <input> \
-    --language [jq|js] \
-    --workspace_id <id> \
-    --flow_id <id> \
-    --execution_id <id> \
-    [--as-json]
-```
-
-## Resource Limits
-- Maximum input size: 10MB
-- Execution timeout: 5 seconds
-- Memory limits enabled
-- Disk space monitoring
-
-## Security
-- Sandboxed JavaScript execution
-- Network access disabled
-- Limited global scope
-- Resource monitoring
-- Secure dependency management
-
-## Logging and Monitoring
-- Execution statistics (duration, memory usage)
-- Detailed error tracking
-- PostHog analytics integration
-- Log file generation
-
-## Development
-```bash
-# Run all tests
-make test
-
-# Run specific test suite
-make test-jq
-make test-js
-make test-js-edge-cases
-
-# Run single test
-make test-single TEST=test/js/example.js DATA=test/data/input.json
-```
-
-## Releases
-Update version in `setup.py`:
-```python
-setup(
-    name="lam-cli",
-    version="0.0.<x>",
-    ...
-)
-```
-
-Create and push tag:
-```bash
-git tag v<version>-<increment>
-git push origin v<version>-<increment>
-```
-
-## Dependencies
-Update dependencies:
-```bash
-pip3 install <package>
-pip3 freeze > requirements.txt
-```

lam_cli-0.1.0.dist-info/RECORD

@@ -1,8 +0,0 @@
-lam/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lam/lam.py,sha256=22zXRw3pz0yQvsORvpWIdUjmvaFhP_6_DMkw02_CG1o,17939
-lam_cli-0.1.0.dist-info/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
-lam_cli-0.1.0.dist-info/METADATA,sha256=z2GeyYTNb3x8gM4Px8XUlldd8UpC86ZyUunGeO6SeQM,4674
-lam_cli-0.1.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-lam_cli-0.1.0.dist-info/entry_points.txt,sha256=ph7QV6H2VWqf9fU5rtoAgEabDgZ4f85ZImdLXeBmdfA,36
-lam_cli-0.1.0.dist-info/top_level.txt,sha256=WyM7-Ig60qQH9meqS293pEd83jrMtbvGJM8ALZOQCtA,4
-lam_cli-0.1.0.dist-info/RECORD,,

lam_cli-0.1.0.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-lam = lam.lam:lam