Update build_logic.py

build_logic.py

@@ -13,7 +13,6 @@ from huggingface_hub import (
     hf_hub_download,
     delete_file as hf_delete_file,
     HfApi,
-    duplicate_repo as hf_duplicate_repo,
     list_repos as hf_list_repos
 )
 from huggingface_hub.hf_api import CommitOperationDelete, CommitOperationAdd, CommitOperation
@@ -296,12 +295,16 @@ def get_space_file_content(ui_api_token_from_textbox, space_name_ui, owner_ui, f
         logger.exception(f"Error fetching file content for {file_path_in_repo} from {repo_id_for_error_logging or 'unknown repo'}:")
         return None, f"Error fetching file content: {str(e)}"
 
-def apply_staged_changes(ui_api_token_from_textbox, owner_ui, space_name_ui, changeset):
+# Renamed and modified to only handle file changes (CREATE, UPDATE, DELETE)
+def apply_staged_file_changes(ui_api_token_from_textbox, owner_ui, space_name_ui, file_changeset):
     repo_id_for_error_logging = f"{owner_ui}/{space_name_ui}" if owner_ui else space_name_ui
     repo_id = None
     status_messages = []
 
-    logger.info(f"Attempting to apply {len(changeset)} staged changes to {repo_id_for_error_logging}")
+    logger.info(f"Attempting to apply {len(file_changeset)} staged file changes to {repo_id_for_error_logging}")
+
+    if not owner_ui or not space_name_ui:
+        return "Error: Cannot apply file changes. Owner and Space Name must be provided."
 
     try:
         resolved_api_token, token_err = _get_api_token(ui_api_token_from_textbox)
@@ -313,60 +316,6 @@ def apply_staged_changes(ui_api_token_from_textbox, owner_ui, space_name_ui, cha
 
         api = HfApi(token=resolved_api_token)
 
-        # --- Handle Exclusive Actions First ---
-        exclusive_action = next((c for c in changeset if c['type'] in ['DUPLICATE_SPACE', 'DELETE_SPACE']), None)
-
-        if exclusive_action:
-             if exclusive_action['type'] == 'DUPLICATE_SPACE':
-                  # This should be handled in the confirm_changes handler to trigger a space load
-                  # Reaching here means the logic in confirm_changes failed to intercept it
-                  status_messages.append("Internal Error: DUPLICATE_SPACE action should have been handled exclusively.")
-                  logger.error("Internal Error: DUPLICATE_SPACE action was passed to apply_staged_changes unexpectedly.")
-             elif exclusive_action['type'] == 'DELETE_SPACE':
-                  # This should also ideally be handled by confirm_changes for UI state reset, but we can execute it here too
-                  delete_owner = exclusive_action.get('owner') or owner_ui
-                  delete_space = exclusive_action.get('space_name') or space_name_ui
-                  delete_repo_id_target = f"{delete_owner}/{delete_space}" if delete_owner and delete_space else repo_id
-
-                  if not delete_repo_id_target:
-                       status_messages.append("DELETE_SPACE Error: Target repo_id not specified.")
-                  elif delete_repo_id_target != repo_id:
-                       status_messages.append(f"DELETE_SPACE Error: AI requested deletion of '{delete_repo_id_target}', but this action is only permitted for the currently loaded space '{repo_id}'. Action blocked.")
-                       logger.warning(f"Blocked DELETE_SPACE action in apply_staged_changes: requested '{delete_repo_id_target}', current '{repo_id}'.")
-                  else:
-                       logger.warning(f"Attempting DESTRUCTIVE DELETE_SPACE action for {delete_repo_id_target}")
-                       try:
-                            api.delete_repo(repo_id=delete_repo_id_target, repo_type='space')
-                            status_messages.append(f"DELETE_SPACE: Successfully deleted space `{delete_repo_id_target}`.")
-                            logger.warning(f"Successfully deleted space {delete_repo_id_target}.")
-                       except HfHubHTTPError as e_http:
-                            status_messages.append(f"DELETE_SPACE HTTP Error ({e_http.response.status_code if e_http.response else 'N/A'}): {e_http.response.text if e_http.response else str(e_http)}. Check token/permissions.")
-                            logger.error(f"HTTP error deleting space {delete_repo_id_target}: {e_http}")
-                       except Exception as e:
-                            status_messages.append(f"DELETE_SPACE Error: {str(e)}. Check logs.")
-                            logger.exception(f"Error deleting space {delete_repo_id_target}:")
-             # If an exclusive action was found and potentially processed, stop here
-             final_status = " | ".join(status_messages) if status_messages else "Exclusive operation attempted."
-             logger.info(f"Exclusive action processed. Final status: {final_status}")
-             return final_status
-
-
-        # --- Handle Non-Exclusive Actions and File Changes ---
-        # This block is only reached if no exclusive action was found
-
-        create_space_op = next((c for c in changeset if c['type'] == 'CREATE_SPACE'), None)
-        if create_space_op:
-            try:
-                 api.create_repo(repo_id=repo_id, repo_type="space", space_sdk=create_space_op.get('sdk', 'gradio'), private=create_space_op.get('private', False), exist_ok=True)
-                 status_messages.append(f"CREATE_SPACE: Successfully created or ensured space [{repo_id}](https://huggingface.co/spaces/{repo_id}) exists.")
-                 logger.info(f"Successfully created or ensured space {repo_id} exists.")
-            except HfHubHTTPError as e_http:
-                 status_messages.append(f"CREATE_SPACE HTTP Error ({e_http.response.status_code if e_http.response else 'N/A'}): {e_http.response.text if e_http.response else str(e_http)}. Check logs.")
-                 logger.error(f"HTTP error creating space {repo_id}: {e_http}")
-            except Exception as e:
-                 status_messages.append(f"CREATE_SPACE Error: {e}")
-                 logger.error(f"Error creating space {repo_id}: {e}")
-
         temp_dir = None
         paths_to_upload = {}
         delete_operations = []
@@ -386,7 +335,7 @@ def apply_staged_changes(ui_api_token_from_textbox, owner_ui, space_name_ui, cha
                 logger.warning(f"Could not stage .gitattributes: {e}")
 
 
-            for change in changeset:
+            for change in file_changeset: # Iterate only through file changes
                 if change['type'] == 'UPDATE_FILE' or change['type'] == 'CREATE_FILE':
                     file_path_in_repo = change['path'].lstrip('/').replace(os.sep, '/')
                     if not file_path_in_repo:
@@ -429,7 +378,8 @@ def apply_staged_changes(ui_api_token_from_textbox, owner_ui, space_name_ui, cha
                          repo_id=repo_id,
                          repo_type="space",
                          operations=delete_operations,
-                         commit_message=commit_message_delete
+                         commit_message=commit_message_delete,
+                         timeout=30
                       )
                       status_messages.append(f"File Deletions: Successfully committed {len(delete_operations)} deletions.")
                       logger.info("Delete commit successful.")
@@ -453,6 +403,7 @@ def apply_staged_changes(ui_api_token_from_textbox, owner_ui, space_name_ui, cha
                          repo_type="space",
                          commit_message=commit_message_upload,
                          allow_patterns=["*"],
+                         timeout=120 # Increased timeout for uploads
                       )
                       status_messages.append(f"File Uploads/Updates: Successfully uploaded/updated {len(paths_to_upload)} files.")
                       logger.info("Upload/Update commit successful.")
@@ -476,34 +427,15 @@ def apply_staged_changes(ui_api_token_from_textbox, owner_ui, space_name_ui, cha
                 except Exception as e:
                     logger.error(f"Error cleaning up temp dir: {e}")
 
-        for change in changeset:
-            if change['type'] == 'SET_PRIVACY':
-                 try:
-                      target_repo_id = change.get('repo_id', repo_id)
-                      if not target_repo_id:
-                           status_messages.append("SET_PRIVACY Error: Target repo_id not specified.")
-                           continue
-                      api.update_repo_visibility(repo_id=target_repo_id, private=change['private'], repo_type='space')
-                      status_messages.append(f"SET_PRIVACY: Successfully set `{target_repo_id}` to `private={change['private']}`.")
-                      logger.info(f"Successfully set privacy for {target_repo_id} to {change['private']}.")
-                 except HfHubHTTPError as e_http:
-                      status_messages.append(f"SET_PRIVACY HTTP Error ({e_http.response.status_code if e_http.response else 'N/A'}): {e_http.response.text if e_http.response else str(e_http)}. Check token/permissions.")
-                      logger.error(f"HTTP error setting privacy for {target_repo_id}: {e_http}")
-                 except Exception as e:
-                      status_messages.append(f"SET_PRIVACY Error: {str(e)}. Check logs.")
-                      logger.exception(f"Error setting privacy for {target_repo_id}:")
-
-            # Note: DELETE_SPACE and DUPLICATE_SPACE are handled as exclusive actions at the top
-
     except HfHubHTTPError as e_http:
-        logger.error(f"Top-level HTTP error during apply_staged_changes for {repo_id_for_error_logging or 'unknown repo'}: {e_http}")
+        logger.error(f"Top-level HTTP error during apply_staged_file_changes for {repo_id_for_error_logging or 'unknown repo'}: {e_http}")
         status_messages.append(f"API HTTP Error ({e_http.response.status_code if e_http.response else 'N/A'}): {e_http.response.text if e_http.response else str(e_http)}")
     except Exception as e:
-        logger.exception(f"Top-level error during apply_staged_changes for {repo_id_for_error_logging or 'unknown repo'}:")
-        status_messages.append(f"An unexpected error occurred during apply staged changes: {str(e)}")
+        logger.exception(f"Top-level error during apply_staged_file_changes for {repo_id_for_error_logging or 'unknown repo'}:")
+        status_messages.append(f"An unexpected error occurred during apply file changes: {str(e)}")
 
-    final_status = " | ".join(status_messages) if status_messages else "No operations were applied."
-    logger.info(f"Finished applying staged changes. Final status: {final_status}")
+    final_status = " | ".join(status_messages) if status_messages else "No file operations were applied."
+    logger.info(f"Finished applying staged file changes. Final status: {final_status}")
     return final_status
 
 def delete_space_file(ui_api_token_from_textbox, space_name_ui, owner_ui, file_path_in_repo, commit_message_ui=None):
@@ -700,6 +632,172 @@ def build_logic_delete_space(hf_api_key, owner, space_name):
         logger.exception(f"Error deleting space {repo_id}:")
         return f"Error deleting space `{repo_id}`: {e}"
 
+def build_logic_create_pull_request(hf_api_key, source_repo_id, target_repo_id, title, body=""):
+    logger.info(f"Attempting to create PR from '{source_repo_id}' to '{target_repo_id}'. Title: '{title}'")
+    try:
+        token, err = _get_api_token(hf_api_key)
+        if err or not token:
+             logger.error(f"Token error creating PR: {err or 'Token not found'}")
+             return f"Error getting token: {err or 'Token not found.'}"
+
+        api = HfApi(token=token)
+
+        # Assuming the source repo is a Space and the target can be any repo type
+        # Assuming PR is from source_repo_id main branch to target_repo_id main branch
+        # This might need refinement based on actual use cases (e.g., PR from space branch to model repo main)
+        # For simplicity now, assume PR from source_repo_id (space) 'main' to target_repo_id 'main'
+        # Need to check if the token has write access to target_repo_id.
+
+        # A PR is created on the *target* repository
+        # We need to check if the token can write to the target.
+        # There isn't a direct "check write permission" API, so we rely on create_pull_request errors.
+
+        pr_url = api.create_pull_request(
+             repo_id=target_repo_id, # PR is created ON the target repo
+             title=title,
+             description=body,
+             # Source branch is the branch *in the source repo* (the space)
+             # Target branch is the branch *in the target repo*
+             # By default, create_pull_request assumes 'main' for both,
+             # but source is interpreted as 'main' in the *source_repo_id*
+             # and target as 'main' in the *repo_id* parameter (target_repo_id).
+             # The API docs mention `repo_id` is the target and `base_repo` is the source for cross-repo PRs.
+             # Let's use `repo_id` as target and `base_repo` as source (the space).
+             base_repo=source_repo_id, # The Space repo is the source
+             base="main", # Source branch in the Space (source_repo_id)
+             head="main", # Target branch in the target_repo_id
+             token=token,
+             timeout=30
+        )
+
+        logger.info(f"Successfully created PR: {pr_url}")
+        return f"Successfully created Pull Request: {pr_url}"
+
+    except HfHubHTTPError as e_http:
+        logger.error(f"HTTP error creating PR from {source_repo_id} to {target_repo_id}: {e_http}")
+        status_code = e_http.response.status_code if e_http.response else 'N/A'
+        # Check for common errors like permission denied or target not found
+        if status_code in (401, 403):
+             return f"PR Error ({status_code}): Access denied or authentication required to create PR on '{target_repo_id}'. Check token permissions."
+        if status_code == 404:
+             return f"PR Error ({status_code}): Target repository '{target_repo_id}' not found."
+        # Add more specific error checks if needed (e.g., PR already exists, invalid branches)
+        if e_http.response and 'already exists' in e_http.response.text:
+             return f"PR Error: Pull Request already exists."
+        return f"PR HTTP Error ({status_code}): {e_http.response.text if e_http.response else str(e_http)}"
+
+    except Exception as e:
+        logger.exception(f"Error creating PR from {source_repo_id} to {target_repo_id}:")
+        return f"PR Error: {e}"
+
+
+def build_logic_add_comment(hf_api_key, repo_id, comment_text):
+    logger.info(f"Attempting to add comment to '{repo_id}'. Text: '{comment_text[:50]}...'")
+    try:
+        token, err = _get_api_token(hf_api_key)
+        if err or not token:
+             logger.error(f"Token error adding comment: {err or 'Token not found'}")
+             return f"Error getting token: {err or 'Token not found.'}"
+
+        api = HfApi(token=token)
+        # The create_discussion method can be used for comments on the repo itself
+        api.create_discussion(
+             repo_id=repo_id,
+             title=f"Comment from AI Space Commander [{time.strftime('%Y-%m-%d %H:%M')}]", # Title required, use timestamp
+             description=comment_text,
+             token=token,
+             timeout=20
+        )
+        # Note: This creates a *discussion* rather than a direct comment stream entry.
+        # A more direct comment API might exist or could be simulated via other means,
+        # but create_discussion is the closest public API method for adding arbitrary text.
+        # Let's clarify this limitation or use a different method if available (e.g., adding a commit comment).
+        # HfApi does not seem to expose a simple "add comment to repo page" API.
+        # create_discussion is the most reasonable public function.
+        # Re-reading the API docs... maybe there's no public API for the little comment boxes?
+        # The Discussions API is the closest. Let's use that, but inform the user it's a discussion.
+        # Or, maybe the AI should be suggesting adding a comment via a COMMIT message?
+        # The prompt asks for "send comment", which implies a direct comment stream.
+        # This might require an internal API or simulating via another method.
+        # Let's stick to the most direct public API for now: Discussions.
+        # Or, better, tell the AI this action is not supported via public API or needs clarification.
+        # Let's return an error message for now, as `create_discussion` isn't what the user likely means by "add comment".
+        # Okay, let's re-read the original codebase. There *was* no comment/like function. The user is *requesting* them.
+        # The simplest interpretation of "add comment" is adding to the discussions tab or commit comments.
+        # Let's add `create_discussion` for now as it's a public API and the closest fit.
+        # We should clarify the AI prompt/action description to mention it creates a *discussion*.
+        # Reverted: create_discussion requires a *title*. The prompt just says "comment text".
+        # This reinforces that the requested action might not map directly to a public API.
+        # Let's implement it using `create_discussion` and add a default title.
+
+        api.create_discussion(
+            repo_id=repo_id,
+            title=f"AI Space Commander Comment: {comment_text[:50]}{'...' if len(comment_text) > 50 else ''} [{time.strftime('%Y-%m-%d %H:%M')}]", # Use part of comment + timestamp as title
+            description=comment_text, # Full comment in description
+            token=token,
+            timeout=20
+        )
+
+        logger.info(f"Successfully added comment (as discussion) to {repo_id}.")
+        return f"Successfully added comment (as a discussion) to `{repo_id}`."
+
+    except HfHubHTTPError as e_http:
+        logger.error(f"HTTP error adding comment to {repo_id}: {e_http}")
+        status_code = e_http.response.status_code if e_http.response else 'N/A'
+        if status_code in (401, 403):
+             return f"Comment Error ({status_code}): Access denied or authentication required to add comment on '{repo_id}'. Check token permissions."
+        if status_code == 404:
+             return f"Comment Error ({status_code}): Repository '{repo_id}' not found."
+        return f"Comment HTTP Error ({status_code}): {e_http.response.text if e_http.response else str(e_http)}"
+
+    except Exception as e:
+        logger.exception(f"Error adding comment to {repo_id}:")
+        return f"Comment Error: {e}"
+
+
+def build_logic_like_space(hf_api_key, repo_id):
+    logger.info(f"Attempting to like space '{repo_id}'.")
+    try:
+        token, err = _get_api_token(hf_api_key)
+        if err or not token:
+             logger.error(f"Token error liking space: {err or 'Token not found'}")
+             return f"Error getting token: {err or 'Token not found.'}"
+
+        api = HfApi(token=token)
+        # HfApi does not have a direct 'like' method.
+        # This action might also require an internal API or not be publicly exposed.
+        # Let's return an error for now, or note it's not directly supported.
+        # Given the request "add... like", it implies it *should* be possible.
+        # A manual approach might involve an authenticated API call not wrapped by hf_hub.
+        # For now, let's return an informative error.
+        # Reverted: There *is* an internal endpoint used by the UI. It's not in the public `HfApi`.
+        # Implementing this reliably without internal API knowledge is difficult and fragile.
+        # Let's return an error message stating it's not supported via the public API.
+
+        return f"Like Error: Liking spaces is not directly supported via the public Hugging Face Hub API used by this tool."
+
+        # Example (likely unstable/unsupported) attempt using requests if we knew the endpoint:
+        # like_url = f"https://huggingface.co/api/v1/repos/{repo_id}/like"
+        # headers = {"Authorization": f"Bearer {token}"}
+        # response = requests.post(like_url, headers=headers, timeout=10)
+        # response.raise_for_status()
+        # logger.info(f"Successfully liked space: {repo_id}")
+        # return f"Successfully liked space: `{repo_id}`."
+        # except requests.exceptions.HTTPError as e:
+        #      # Handle 409 Conflict (already liked) or other errors
+        #      status_code = e.response.status_code if e.response else 'N/A'
+        #      if status_code == 409: return f"Like Error: Space '{repo_id}' already liked."
+        #      return f"Like HTTP Error ({status_code}): {e.response.text if e.response else str(e)}"
+        # except Exception as e:
+        #      logger.exception(f"Error liking space {repo_id}:")
+        #      return f"Like Error: {e}"
+
+
+    except Exception as e: # Catch potential errors even in the error path above
+        logger.exception(f"Unexpected error in build_logic_like_space for {repo_id}:")
+        return f"Like Error: An unexpected error occurred: {e}"
+
+
 def duplicate_space(hf_api_key, source_repo_id, target_repo_id, private: bool = False):
     """Duplicates a Hugging Face Space."""
     logger.info(f"Attempting to duplicate '{source_repo_id}' to '{target_repo_id}' (private={private}).")
@@ -709,33 +807,29 @@ def duplicate_space(hf_api_key, source_repo_id, target_repo_id, private: bool =
             logger.error(f"Token error duplicating space: {err or 'Token not found'}")
             return f"Error getting token: {err or 'Token not found.'}"
 
-        # Validate target_repo_id format if it includes owner, extract owner/name
         if '/' in target_repo_id:
              target_owner, target_space_name = target_repo_id.split('/', 1)
              if not target_owner or not target_space_name or '/' in target_space_name:
                   return f"Error: Invalid target repository ID format '{target_repo_id}'. Must be '<owner>/<space_name>'."
         else:
-             # If only space name is provided, try to use the token's user as owner
              target_space_name = target_repo_id
              try:
                  user_info = whoami(token=token)
                  target_owner = user_info.get('name')
                  if not target_owner: raise Exception("Could not determine owner from token.")
-                 target_repo_id = f"{target_owner}/{target_space_name}" # Update target_repo_id
+                 target_repo_id = f"{target_owner}/{target_space_name}"
              except Exception as e:
                  logger.error(f"Could not determine target owner from token: {e}")
                  return f"Error: Target repository ID '{target_repo_id}' is missing owner, and owner could not be determined from token ({e}). Use '<owner>/<space_name>' format or set the Owner field."
 
-
-        hf_duplicate_repo(
+        api = HfApi(token=token) # Use HfApi object to call duplicate_repo
+        api.duplicate_repo(
             from_repo=source_repo_id,
             to_repo=target_repo_id,
             repo_type="space",
             token=token,
             private=private,
-            # Use exist_ok=True? The UI should probably warn, but the backend can handle overwrite
-            # For now, let's assume overwrite is intended if triggered by AI/manual button after warning
-            exist_ok=True # Allow overwriting existing target space
+            exist_ok=True
         )
         logger.info(f"Successfully duplicated space from {source_repo_id} to {target_repo_id}.")
         return f"Successfully duplicated space from `{source_repo_id}` to `{target_repo_id}`."
@@ -756,8 +850,6 @@ def list_user_spaces(hf_api_key, owner=None):
             logger.error(f"Token error listing spaces: {err or 'Token not found'}")
             return None, f"Error getting token: {err or 'Token not found.'}"
 
-        # If owner is not provided, list spaces for the authenticated user
-        # We need the username for list_repos filter if owner is None in UI
         effective_owner = owner
         if not effective_owner:
              try:
@@ -767,14 +859,10 @@ def list_user_spaces(hf_api_key, owner=None):
                  logger.info(f"Listing spaces for auto-detected owner: {effective_owner}")
              except Exception as e:
                  logger.error(f"Could not determine owner from token for listing: {e}")
-                 # Continue trying list_repos without username filter? No, list_repos
-                 # typically needs user or org specified for filtering unless it's public repos.
-                 # Let's require owner or a valid token for user listing.
                  return None, f"Error auto-detecting owner for listing: {e}. Please specify Owner field."
 
-
         api = HfApi(token=token)
-        spaces = hf_list_repos(author=effective_owner, type="space", token=token, timeout=20)
+        spaces = api.list_repos(author=effective_owner, type="space", token=token, timeout=20)
         space_ids = [f"{r.author}/{r.id}" for r in spaces]
 
         logger.info(f"Successfully listed {len(space_ids)} spaces for {effective_owner}.")
@@ -784,7 +872,6 @@ def list_user_spaces(hf_api_key, owner=None):
         logger.error(f"HTTP error listing spaces for {owner or 'authenticated user'}: {e_http}")
         status_code = e_http.response.status_code if e_http.response else 'N/A'
         if status_code == 404:
-             # 404 could mean the owner doesn't exist or has no public spaces and token doesn't give access
              return [], f"HTTP Error ({status_code}): Owner '{owner}' not found or has no accessible spaces."
         if status_code in (401, 403):
              return [], f"HTTP Error ({status_code}): Access denied or authentication required for listing spaces for '{owner}'. Check token permissions."