Merge pull request #24 from VectorlyApp/unboundlocalerr_fix

Resolve `UnboundLocalError` in `agent.py`

Author: alex-w-99

.pylintrc

@@ -1,7 +1,7 @@
 [MAIN]
 
 # minimum score (out of 10) required to pass
-fail-under=0.00
+fail-under=5.00
 
 # files or directories to be skipped
 ignore=*.ipynb

scripts/browser_monitor.py

@@ -1,12 +1,24 @@
 """
+src/scripts/browser_monitor.py
+
 CDP-based web scraper that blocks trackers and captures network requests.
 """
 
-import os, json, time, shutil, sys, argparse
+import argparse
+import logging
+import os
+import json
+import time
+import shutil
+import sys
+
 from src.cdp.cdp_session import CDPSession
 from src.data_models.network import ResourceType
 from src.cdp.tab_managements import cdp_new_tab, dispose_context
 
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
 # ---- Configuration ----
 
 BLOCK_PATTERNS = [
@@ -264,7 +276,7 @@ def save_session_summary(paths, summary, args, start_time, end_time, created_tab
         }
     }
 
-    with open(paths['summary_path'], 'w', encoding='utf-8') as f:
+    with open(paths['summary_path'], mode='w', encoding='utf-8') as f:
         json.dump(session_summary, f, indent=2, ensure_ascii=False)
 
     return session_summary
@@ -286,30 +298,30 @@ def main():
     remote_debugging_address = f"http://{args.host}:{args.port}"
 
     if not tab_id:
-        print("No tab ID provided, creating new tab...")
+        logger.info("No tab ID provided, creating new tab...")
         try:
             tab_id, context_id = cdp_new_tab(
                 remote_debugging_address=remote_debugging_address,
                 incognito=args.incognito,
                 url=args.url if not args.no_navigate else "about:blank"
             )
             created_tab = True
-            print(f"Created new tab: {tab_id}")
+            logger.info(f"Created new tab: {tab_id}")
             if context_id:
-                print(f"Browser context: {context_id}")
+                logger.info(f"Browser context: {context_id}")
         except Exception as e:
-            print(f"Error creating new tab: {e}")
+            logger.info(f"Error creating new tab: {e}")
             sys.exit(1)
 
     # Build WebSocket URL
     ws_url = f"ws://{args.host}:{args.port}/devtools/page/{tab_id}"
     navigate_to = None if args.no_navigate else args.url
 
-    print(f"Starting CDP monitoring session...")
-    print(f"Output directory: {args.output_dir}")
-    print(f"Target URL: {navigate_to or 'No navigation (attach only)'}")
-    print(f"Tab ID: {tab_id}")
-    
+    logger.info(f"Starting CDP monitoring session...")
+    logger.info(f"Output directory: {args.output_dir}")
+    logger.info(f"Target URL: {navigate_to or 'No navigation (attach only)'}")
+    logger.info(f"Tab ID: {tab_id}")
+
     # Create and run CDP session
     try:
         session = CDPSession(
@@ -323,58 +335,58 @@ def main():
         )
         session.setup_cdp(navigate_to)
         session.run()
-        
+
     except KeyboardInterrupt:
-        print("\nSession stopped by user")
+        logger.info("\nSession stopped by user")
     except Exception as e:
-        print(f"Error: {e}")
+        logger.info(f"Error: {e}")
         sys.exit(1)
     finally:
         # Cleanup: dispose context if we created a tab
         if created_tab and context_id:
             try:
-                print("Cleaning up created browser context...")
+                logger.info("Cleaning up created browser context...")
                 dispose_context(remote_debugging_address, context_id)
             except Exception as e:
-                print(f"Warning: Could not dispose browser context: {e}")
-        
+                logger.info(f"Warning: Could not dispose browser context: {e}")
+
         end_time = time.time()
-        
+
         # Get final summary and save it
         try:
             summary = session.get_monitoring_summary()
             save_session_summary(paths, summary, args, start_time, end_time, created_tab, context_id)
-            
+
             # Print organized summary
-            print("\n" + "="*60)
-            print("SESSION SUMMARY")
-            print("="*60)
-            print(f"Duration: {end_time - start_time:.1f} seconds")
-            print(f"Tab created: {'Yes' if created_tab else 'No'}")
+            logger.info("\n" + "="*60)
+            logger.info("SESSION SUMMARY")
+            logger.info("="*60)
+            logger.info(f"Duration: {end_time - start_time:.1f} seconds")
+            logger.info(f"Tab created: {'Yes' if created_tab else 'No'}")
             if created_tab and context_id:
-                print(f"Browser context: {context_id}")
-            print(f"Network requests tracked: {summary['network']['requests_tracked']}")
-            print(f"Cookies tracked: {summary['storage']['cookies_count']}")
-            print(f"LocalStorage origins: {len(summary['storage']['local_storage_origins'])}")
-            print(f"SessionStorage origins: {len(summary['storage']['session_storage_origins'])}")
-            print("OUTPUT STRUCTURE:")
-            print(f"├── session_summary.json")
-            print(f"├── network/")
-            print(f"│   ├── consolidated_transactions.json")
-            print(f"│   ├── network.har")
-            print(f"│   └── transactions/")
-            print(f"│       └── [timestamp_url_id]/")
-            print(f"│           ├── request.json")
-            print(f"│           ├── response.json")
-            print(f"│           └── response_body.[ext]")
-            print(f"└── storage/")
-            print(f"    └── events.jsonl")
-            print()
-            print(f"Session complete! Check {args.output_dir} for all outputs.")
-            
+                logger.info(f"Browser context: {context_id}")
+            logger.info(f"Network requests tracked: {summary['network']['requests_tracked']}")
+            logger.info(f"Cookies tracked: {summary['storage']['cookies_count']}")
+            logger.info(f"LocalStorage origins: {len(summary['storage']['local_storage_origins'])}")
+            logger.info(f"SessionStorage origins: {len(summary['storage']['session_storage_origins'])}")
+            logger.info("OUTPUT STRUCTURE:")
+            logger.info(f"├── session_summary.json")
+            logger.info(f"├── network/")
+            logger.info(f"│   ├── consolidated_transactions.json")
+            logger.info(f"│   ├── network.har")
+            logger.info(f"│   └── transactions/")
+            logger.info(f"│       └── [timestamp_url_id]/")
+            logger.info(f"│           ├── request.json")
+            logger.info(f"│           ├── response.json")
+            logger.info(f"│           └── response_body.[ext]")
+            logger.info(f"└── storage/")
+            logger.info(f"    └── events.jsonl")
+            logger.info()
+            logger.info(f"Session complete! Check {args.output_dir} for all outputs.")
+
         except Exception as e:
-            print(f"Warning: Could not generate summary: {e}")
+            logger.info("Warning: Could not generate summary: %s", e)
 
 
 if __name__ == "__main__":
-    main() 
+    main()

scripts/discover_routines.py

@@ -6,9 +6,10 @@
 import logging
 import os
 
-from dotenv import load_dotenv
 from openai import OpenAI
 
+from src.config import Config
+from src.utils.exceptions import ApiKeyNotFoundError
 from src.routine_discovery.agent import RoutineDiscoveryAgent
 from src.routine_discovery.context_manager import ContextManager
 
@@ -17,32 +18,29 @@
 
 
 def main() -> None:
-    
     # parse arguments
     parser = ArgumentParser(description="Discover routines from the network transactions.")
     parser.add_argument("--task", type=str, required=True, help="The description of the task to discover routines for.")
     parser.add_argument("--cdp-captures-dir", type=str, default="./cdp_captures", help="The directory containing the CDP captures.")
     parser.add_argument("--output-dir", type=str, default="./routine_discovery_output", help="The directory to save the output to.")
     parser.add_argument("--llm-model", type=str, default="gpt-5", help="The LLM model to use.")
     args = parser.parse_args()
-    
-    # load environment variables
-    load_dotenv()
-    
+
     # ensure OpenAI API key is set
-    if os.getenv("OPENAI_API_KEY") is None:
-        raise ValueError("OPENAI_API_KEY is not set")
-    
+    if Config.OPENAI_API_KEY is None:
+        logger.error("OPENAI_API_KEY is not set")
+        raise ApiKeyNotFoundError("OPENAI_API_KEY is not set")
+
     logger.info(f"\n{'-' * 100}")
-    logger.info(f"Starting routine discovery for task:\n{args.task}")
+    logger.info("Starting routine discovery for task:\n%s", args.task)
     logger.info(f"{'-' * 100}\n")
-    
+
     # initialize OpenAI client
-    openai_client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
-    
+    openai_client = OpenAI(api_key=Config.OPENAI_API_KEY)
+
     # create the output directory
     os.makedirs(args.output_dir, exist_ok=True)
-    
+
     # initialize context manager
     context_manager = ContextManager(
         client=openai_client,
@@ -51,13 +49,12 @@ def main() -> None:
         consolidated_transactions_path=os.path.join(args.cdp_captures_dir, "network/consolidated_transactions.json"),
         storage_jsonl_path=os.path.join(args.cdp_captures_dir, "storage/events.jsonl")
     )
-    
-    logger.info(f"Context manager initialized.")
-    
+    logger.info("Context manager initialized.")
+
     # make the vectorstore
     context_manager.make_vectorstore()
-    logger.info(f"Vectorstore created: {context_manager.vectorstore_id}")
-    
+    logger.info("Vectorstore created: %s", context_manager.vectorstore_id)
+
     # initialize routine discovery agent
     routine_discovery_agent = RoutineDiscoveryAgent(
         client=openai_client,
@@ -66,15 +63,15 @@ def main() -> None:
         llm_model=args.llm_model,
         output_dir=args.output_dir,
     )
-    logger.info(f"Routine discovery agent initialized.")
-    
+    logger.info("Routine discovery agent initialized.")
+
     logger.info(f"\n{'-' * 100}")
-    logger.info(f"Running routine discovery agent.")
+    logger.info("Running routine discovery agent.")
     logger.info(f"{'-' * 100}\n")
-    
+
     # run the routine discovery agent
     routine_discovery_agent.run()
-    logger.info(f"Routine discovery agent run complete")
+    logger.info("Routine discovery agent run complete.")
 
 
 if __name__ == "__main__":

scripts/execute_routine.py

@@ -14,11 +14,15 @@
         --parameters-dict "{'origin': 'boston', 'destination': 'new york', 'departureDate': '2026-03-22'}"
 """
 
-import json
 import argparse
+import json
+import logging
+
 from src.cdp.routine_execution import execute_routine
 from src.data_models.production_routine import Routine
 
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 
 def main(routine_path: str, parameters_path: str | None = None, parameters_dict: dict | None = None):
@@ -49,10 +53,10 @@ def main(routine_path: str, parameters_path: str | None = None, parameters_dict:
             close_tab_when_done=False,
             incognito=True,
         )
-        print(f"Result: {result}")
+        logger.info(f"Result: {result}")
 
     except Exception as e:
-        print("Error executing routine: %s", e)
+        logger.error("Error executing routine: %s", e)
 
 
 if __name__ == "__main__":

src/cdp/cdp_session.py

@@ -1,18 +1,26 @@
-#!/usr/bin/env python3
 """
+src/cdp/cdp_session.py
+
 CDP Session management for web scraping with Chrome DevTools Protocol.
 """
 
 import json
+import logging
 import websocket
 import threading
 import time
+
 from src.cdp.network_monitor import NetworkMonitor
 from src.cdp.storage_monitor import StorageMonitor
 
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
 
 class CDPSession:
-    """Manages CDP WebSocket connection and coordinates monitoring components."""
+    """
+    "Manages CDP WebSocket connection and coordinates monitoring components.
+    """
 
     def __init__(
         self, 
@@ -91,7 +99,7 @@ def setup_cdp(self, navigate_to=None):
 
         # Clear cookies if requested
         if self.clear_cookies:
-            print("Clearing all browser cookies...")
+            logger.info("Clearing all browser cookies...")
             self.send("Network.clearBrowserCookies")
 
             # Also clear cookie store
@@ -102,7 +110,7 @@ def setup_cdp(self, navigate_to=None):
 
         # Clear storage if requested
         if self.clear_storage:
-            print("Clearing localStorage and sessionStorage...")
+            logger.info("Clearing localStorage and sessionStorage...")
             try:
                 # Clear all storage for all origins
                 self.send("Storage.clearDataForOrigin", {
@@ -119,7 +127,7 @@ def setup_cdp(self, navigate_to=None):
                         "includeCommandLineAPI": True
                     })
                 except:
-                    print("Warning: Could not clear storage automatically")
+                    logger.info("Warning: Could not clear storage automatically")
 
         # Setup monitoring components
         self.network_monitor.setup_network_monitoring(self)
@@ -179,14 +187,14 @@ def _handle_command_reply(self, msg):
 
     def run(self):
         """Main message processing loop."""
-        print("Blocking trackers & capturing network/storage… Press Ctrl+C to stop.")
+        logger.info("Blocking trackers & capturing network/storage… Press Ctrl+C to stop.")
 
         try:
             while True:
                 msg = json.loads(self.ws.recv())
                 self.handle_message(msg)
         except KeyboardInterrupt:
-            print("\nStopped.")
+            logger.info("\nStopped.")
             # Final cookie sync using native CDP (no delay needed)
             self.storage_monitor.monitor_cookie_changes(self)
 

src/cdp/routine_execution.py

@@ -701,9 +701,9 @@ def recv_until(predicate, deadline):
         result = None
         current_url = None
 
-        print(f"Executing routine with {len(routine.operations)} operations")
+        logger.info(f"Executing routine with {len(routine.operations)} operations")
         for i, operation in enumerate(routine.operations):
-            print(
+            logger.info(
                 f"Executing operation {i+1}/{len(routine.operations)}: {type(operation).__name__}"
             )
             if isinstance(operation, RoutineNavigateOperation):
@@ -787,4 +787,4 @@ def recv_until(predicate, deadline):
         try:
             ws.close()
         except Exception:
-            pass
+            pass