aligned uploader and agent path

streamlit-client/app.py

@@ -135,15 +135,28 @@ def run_ideation(q):
 
 
 def run_data(path, q):
+    # Ensure path is absolute and exists
+    data_path = Path(path).resolve()
+    if not data_path.exists():
+        return f"Error: Data path does not exist: {data_path}", []
+
+    # Log path for debugging
+    logger = __import__("loguru").logger
+    logger.info(f"Running data analysis on path: {data_path}")
+    logger.info(
+        f"Path exists: {data_path.exists()}, is_dir: {data_path.is_dir()}, is_file: {data_path.is_file()}"
+    )
+
     w = DataWorkflow(
-        data_path=Path(path),
+        data_path=data_path,
         workspace_path=st.session_state.workspace_path,
         recursion_limit=100,
     )
     w.run()
     intermediate_state = getattr(w, "data_agent_intermediate_state", [])
     if w.final_status != "success":
-        return "Data workflow failed", intermediate_state
+        error_msg = w.error_message or "Data workflow failed"
+        return f"Data workflow failed: {error_msg}", intermediate_state
     out = ["## Data Analysis Complete"]
     if w.data_summary:
         out.append(w.data_summary)
@@ -152,10 +165,19 @@ def run_data(path, q):
 
 def run_experiment(q, path):
     if path:
+        # Ensure path is absolute and exists
+        analysis_path = Path(path).resolve()
+        if not analysis_path.exists():
+            return f"Error: Data analysis file does not exist: {analysis_path}", []
+
+        logger = __import__("loguru").logger
+        logger.info(f"Running experiment with analysis file: {analysis_path}")
+        logger.info(f"Path exists: {analysis_path.exists()}, is_file: {analysis_path.is_file()}")
+
         w = ExperimentWorkflow.from_data_analysis_file(
             workspace_path=st.session_state.workspace_path,
             user_query=q,
-            data_analysis_path=path,
+            data_analysis_path=str(analysis_path),
             max_revisions=5,
             recursion_limit=100,
         )
@@ -166,10 +188,23 @@ def run_experiment(q, path):
 
 
 def run_full(cfg):
+    data_path = None
+    if cfg.get("data_path"):
+        data_path = Path(cfg["data_path"]).resolve()
+        if not data_path.exists():
+            return f"Error: Data path does not exist: {data_path}", []
+
+    logger = __import__("loguru").logger
+    if data_path:
+        logger.info(f"Running full workflow with data path: {data_path}")
+        logger.info(
+            f"Path exists: {data_path.exists()}, is_dir: {data_path.is_dir()}, is_file: {data_path.is_file()}"
+        )
+
     w = FullWorkflowWithIdeation(
         user_query=cfg["query"],
         workspace_path=st.session_state.workspace_path,
-        data_path=Path(cfg["data_path"]) if cfg["data_path"] else None,
+        data_path=data_path,
         run_data_workflow=cfg["run_data"],
         run_experiment_workflow=cfg["run_exp"],
         max_revisions=5,
@@ -203,11 +238,12 @@ def save_and_extract_upload(uploaded_file) -> Path | None:
     with open(zip_path, "wb") as f:
         f.write(uploaded_file.getvalue())
     extract_dir = dest_dir / "extracted"
-    extract_dir.mkdir(exist_ok=True)
+    extract_dir.mkdir(parents=True, exist_ok=True)
     with zipfile.ZipFile(zip_path, "r") as zf:
         zf.extractall(extract_dir)
     zip_path.unlink()
-    return extract_dir
+    # Return absolute path to ensure it works in container environments
+    return extract_dir.resolve()
 
 
 def find_data_analysis_file(extract_dir: Path) -> Path | None:
@@ -444,24 +480,33 @@ elif st.session_state.selected_workflow == "data":
             if uploaded_zip:
                 cleanup_uploaded_data()  # Remove previous upload before saving new one
                 extracted = save_and_extract_upload(uploaded_zip)
-                if extracted:
+                if extracted and extracted.exists():
+                    # Use absolute path and verify it exists
+                    extracted = extracted.resolve()
                     st.session_state.uploaded_data_path = str(extracted)
                     st.session_state.workspace_path = extracted.parent
                     path_to_use = str(extracted)
+                    st.success(f"✅ File uploaded and extracted to: {path_to_use}")
                 else:
-                    st.error("Failed to process uploaded zip file.")
+                    st.error(f"Failed to process uploaded zip file. Extracted path: {extracted}")
             elif data_path_manual.strip():
                 path_to_use = data_path_manual.strip()
             elif st.session_state.get("uploaded_data_path"):
-                path = Path(st.session_state.uploaded_data_path)
+                path = Path(st.session_state.uploaded_data_path).resolve()
                 if path.exists():
-                    path_to_use = st.session_state.uploaded_data_path
+                    path_to_use = str(path)
                     st.session_state.workspace_path = path.parent
                 else:
+                    st.warning(f"Previously uploaded path no longer exists: {path}")
                     cleanup_uploaded_data()
             if path_to_use:
-                workflow_config = {"type": "data", "path": path_to_use, "query": query}
-                st.session_state.selected_workflow = None
+                # Verify path exists before creating workflow config
+                verify_path = Path(path_to_use).resolve()
+                if not verify_path.exists():
+                    st.error(f"Path does not exist: {path_to_use}")
+                else:
+                    workflow_config = {"type": "data", "path": str(verify_path), "query": query}
+                    st.session_state.selected_workflow = None
             else:
                 st.error("Please upload a zip file or enter a data path.")
 
@@ -492,22 +537,30 @@ elif st.session_state.selected_workflow == "experiment":
                     if "uploaded_experiment_path" in st.session_state:
                         del st.session_state.uploaded_experiment_path
                 extracted = save_and_extract_upload(uploaded_exp_zip)
-                if extracted:
+                if extracted and extracted.exists():
+                    extracted = extracted.resolve()
                     analysis_file = find_data_analysis_file(extracted)
-                    if analysis_file:
+                    if analysis_file and analysis_file.exists():
+                        analysis_file = analysis_file.resolve()
                         st.session_state.uploaded_experiment_path = str(analysis_file)
                         st.session_state.workspace_path = analysis_file.parent
                         path_to_use = str(analysis_file)
+                        st.success(f"✅ Found analysis file: {path_to_use}")
                     else:
-                        st.error("Zip must contain data_analysis.md or analysis.md")
+                        st.error(
+                            f"Zip must contain data_analysis.md or analysis.md. Searched in: {extracted}"
+                        )
+                else:
+                    st.error(f"Failed to process uploaded zip file. Extracted path: {extracted}")
             elif data_path_manual.strip():
                 path_to_use = data_path_manual.strip()
             elif st.session_state.get("uploaded_experiment_path"):
-                p = Path(st.session_state.uploaded_experiment_path)
+                p = Path(st.session_state.uploaded_experiment_path).resolve()
                 if p.exists():
-                    path_to_use = st.session_state.uploaded_experiment_path
+                    path_to_use = str(p)
                     st.session_state.workspace_path = p.parent
                 else:
+                    st.warning(f"Previously uploaded path no longer exists: {p}")
                     if "uploaded_experiment_path" in st.session_state:
                         del st.session_state.uploaded_experiment_path
             if path_to_use:
@@ -546,18 +599,26 @@ elif st.session_state.selected_workflow == "full":
                         if "uploaded_full_data_path" in st.session_state:
                             del st.session_state.uploaded_full_data_path
                     extracted = save_and_extract_upload(uploaded_full_zip)
-                    if extracted:
+                    if extracted and extracted.exists():
+                        extracted = extracted.resolve()
                         st.session_state.uploaded_full_data_path = str(extracted)
                         st.session_state.workspace_path = extracted.parent
                         data_path_to_use = str(extracted)
+                        st.success(f"✅ File uploaded and extracted to: {data_path_to_use}")
+                    else:
+                        st.error(
+                            f"Failed to process uploaded zip file. Extracted path: {extracted}"
+                        )
+                        data_path_to_use = None
                 elif data_path_manual.strip():
                     data_path_to_use = data_path_manual.strip()
                 elif st.session_state.get("uploaded_full_data_path"):
-                    p = Path(st.session_state.uploaded_full_data_path)
+                    p = Path(st.session_state.uploaded_full_data_path).resolve()
                     if p.exists():
-                        data_path_to_use = st.session_state.uploaded_full_data_path
+                        data_path_to_use = str(p)
                         st.session_state.workspace_path = p.parent
                     else:
+                        st.warning(f"Previously uploaded path no longer exists: {p}")
                         if "uploaded_full_data_path" in st.session_state:
                             del st.session_state.uploaded_full_data_path
                 if not data_path_to_use: