claudesync 0.3.2__tar.gz → 0.3.3__tar.gz

{claudesync-0.3.2/src/claudesync.egg-info → claudesync-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: claudesync
-Version: 0.3.2
+Version: 0.3.3
 Summary: A tool to synchronize local files with Claude.ai projects
 Author-email: Jahziah Wagner <jahziah.wagner+pypi@gmail.com>
 License: MIT License

{claudesync-0.3.2 → claudesync-0.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claudesync"
-version = "0.3.2"
+version = "0.3.3"
 authors = [
     {name = "Jahziah Wagner", email = "jahziah.wagner+pypi@gmail.com"},
 ]
@@ -43,4 +43,4 @@ include = ["claudesync*"]
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 python_files = "test_*.py"
-addopts = "-v --cov=claudesync --cov-report=term-missing"
+addopts = "-v --cov=claudesync --cov-report=term-missing"

{claudesync-0.3.2 → claudesync-0.3.3}/src/claudesync/cli/api.py

@@ -1,4 +1,5 @@
 import click
+
 from claudesync.provider_factory import get_provider
 from ..utils import handle_errors
 

{claudesync-0.3.2 → claudesync-0.3.3}/src/claudesync/cli/organization.py

@@ -1,4 +1,5 @@
 import click
+
 from ..utils import handle_errors, validate_and_get_provider
 
 

{claudesync-0.3.2 → claudesync-0.3.3}/src/claudesync/cli/project.py

@@ -1,4 +1,5 @@
 import click
+
 from claudesync.exceptions import ProviderError
 from ..utils import (
     handle_errors,
@@ -62,7 +63,7 @@ def archive(config):
     if 1 <= selection <= len(projects):
         selected_project = projects[selection - 1]
         if click.confirm(
-            f"Are you sure you want to archive '{selected_project['name']}'?"
+                f"Are you sure you want to archive '{selected_project['name']}'?"
         ):
             provider.archive_project(active_organization_id, selected_project["id"])
             click.echo(f"Project '{selected_project['name']}' has been archived.")

{claudesync-0.3.2 → claudesync-0.3.3}/src/claudesync/cli/sync.py

@@ -1,10 +1,12 @@
-import click
-import sys
 import os
-import time
 import shutil
+import sys
+import time
+
+import click
 from crontab import CronTab
-from claudesync.utils import calculate_checksum, get_local_files
+
+from claudesync.utils import compute_md5_hash, get_local_files
 from ..utils import handle_errors, validate_and_get_provider
 
 
@@ -62,14 +64,14 @@ def sync(config):
             (rf for rf in remote_files if rf["file_name"] == local_file), None
         )
         if remote_file:
-            remote_checksum = calculate_checksum(remote_file["content"])
+            remote_checksum = compute_md5_hash(remote_file["content"])
             if local_checksum != remote_checksum:
                 click.echo(f"Updating {local_file} on remote...")
                 provider.delete_file(
                     active_organization_id, active_project_id, remote_file["uuid"]
                 )
                 with open(
-                    os.path.join(local_path, local_file), "r", encoding="utf-8"
+                        os.path.join(local_path, local_file), "r", encoding="utf-8"
                 ) as file:
                     content = file.read()
                 provider.upload_file(
@@ -80,7 +82,7 @@ def sync(config):
         else:
             click.echo(f"Uploading new file {local_file} to remote...")
             with open(
-                os.path.join(local_path, local_file), "r", encoding="utf-8"
+                    os.path.join(local_path, local_file), "r", encoding="utf-8"
             ) as file:
                 content = file.read()
             provider.upload_file(

claudesync-0.3.3/src/claudesync/config_manager.py

@@ -0,0 +1,89 @@
+import json
+from pathlib import Path
+
+
+class ConfigManager:
+    """
+    A class to manage configuration settings for the application.
+
+    This class handles loading, saving, and accessing configuration settings from a JSON file.
+    It ensures that default values are set for certain keys if they are not present in the configuration file.
+
+    Attributes:
+        config_dir (Path): The directory where the configuration file is stored.
+        config_file (Path): The path to the configuration file.
+        config (dict): The current configuration loaded into memory.
+    """
+
+    def __init__(self):
+        """
+        Initializes the ConfigManager instance by setting up the configuration directory and file paths,
+        and loading the current configuration from the file, applying default values as necessary.
+        """
+        self.config_dir = Path.home() / ".claudesync"
+        self.config_file = self.config_dir / "config.json"
+        self.config = self._load_config()
+
+    def _load_config(self):
+        """
+        Loads the configuration from the JSON file, applying default values for missing keys.
+
+        If the configuration file does not exist, it creates the directory (if necessary) and returns a dictionary
+        with default values.
+
+        Returns:
+            dict: The loaded configuration with default values for missing keys.
+        """
+        if not self.config_file.exists():
+            self.config_dir.mkdir(parents=True, exist_ok=True)
+            return {
+                "log_level": "INFO",
+                "upload_delay": 0.5,
+                "max_file_size": 32 * 1024,  # Default 32 KB
+            }
+        with open(self.config_file, "r") as f:
+            config = json.load(f)
+            if "log_level" not in config:
+                config["log_level"] = "INFO"
+            if "upload_delay" not in config:
+                config["upload_delay"] = 0.5
+            if "max_file_size" not in config:
+                config["max_file_size"] = 32 * 1024  # Default 32 KB
+            return config
+
+    def _save_config(self):
+        """
+        Saves the current configuration to the JSON file.
+
+        This method writes the current state of the `config` attribute to the configuration file,
+        pretty-printing the JSON for readability.
+        """
+        with open(self.config_file, "w") as f:
+            json.dump(self.config, f, indent=2)
+
+    def get(self, key, default=None):
+        """
+        Retrieves a configuration value.
+
+        Args:
+            key (str): The key for the configuration setting to retrieve.
+            default (any, optional): The default value to return if the key is not found. Defaults to None.
+
+        Returns:
+            The value of the configuration setting if found, otherwise the default value.
+        """
+        return self.config.get(key, default)
+
+    def set(self, key, value):
+        """
+        Sets a configuration value and saves the configuration.
+
+        Args:
+            key (str): The key for the configuration setting to set.
+            value (any): The value to set for the given key.
+
+        This method updates the configuration with the provided key-value pair and then saves the configuration
+        to the file.
+        """
+        self.config[key] = value
+        self._save_config()

claudesync-0.3.3/src/claudesync/exceptions.py

@@ -0,0 +1,22 @@
+class ConfigurationError(Exception):
+    """
+    Exception raised when there's an issue with the application's configuration.
+
+    This exception should be raised to indicate problems such as missing required configuration options,
+    invalid values, or issues loading configuration files. It helps in distinguishing configuration-related
+    errors from other types of exceptions.
+    """
+
+    pass
+
+
+class ProviderError(Exception):
+    """
+    Exception raised when there's an issue with a provider operation.
+
+    This exception is used to signal failures in operations related to external service providers,
+    such as authentication failures, data retrieval errors, or actions that cannot be completed as requested.
+    It allows for more granular error handling that is specific to provider interactions.
+    """
+
+    pass

claudesync-0.3.3/src/claudesync/provider_factory.py

@@ -0,0 +1,38 @@
+from .providers.claude_ai import ClaudeAIProvider
+
+
+# Import other providers here as they are added
+
+def get_provider(provider_name=None, session_key=None):
+    """
+    Retrieve an instance of a provider class based on the provider name and session key.
+
+    This function serves as a factory to instantiate provider classes. It maintains a registry of available
+    providers. If a provider name is not specified, it returns a list of available provider names. If a provider
+    name is specified but not found in the registry, it raises a ValueError. If a session key is provided, it
+    is passed to the provider class constructor.
+
+    Args:
+        provider_name (str, optional): The name of the provider to retrieve. If None, returns a list of available provider names.
+        session_key (str, optional): The session key to be used by the provider for authentication. Defaults to None.
+
+    Returns:
+        object: An instance of the requested provider class if both provider_name and session_key are provided.
+        list: A list of available provider names if provider_name is None.
+
+    Raises:
+        ValueError: If the specified provider_name is not found in the registry of providers.
+    """
+    providers = {
+        "claude.ai": ClaudeAIProvider,
+        # Add other providers here as they are implemented
+    }
+
+    if provider_name is None:
+        return list(providers.keys())
+
+    provider_class = providers.get(provider_name)
+    if provider_class is None:
+        raise ValueError(f"Unsupported provider: {provider_name}")
+
+    return provider_class(session_key) if session_key else provider_class()

claudesync-0.3.3/src/claudesync/providers/claude_ai.py

@@ -0,0 +1,333 @@
+import json
+import logging
+
+import click
+import requests
+
+from ..config_manager import ConfigManager
+from ..exceptions import ProviderError
+
+logger = logging.getLogger(__name__)
+
+
+class ClaudeAIProvider:
+    """
+    A provider class for interacting with the Claude AI API.
+
+    This class encapsulates methods for performing API operations such as logging in, retrieving organizations,
+    projects, and files, as well as uploading and deleting files. It uses a session key for authentication,
+    which can be obtained through the login method.
+
+    Attributes:
+        BASE_URL (str): The base URL for the Claude AI API.
+        session_key (str, optional): The session key used for authentication with the API.
+        config (ConfigManager): An instance of ConfigManager to manage application configuration.
+    """
+
+    BASE_URL = "https://claude.ai/api"
+
+    def __init__(self, session_key=None):
+        """
+        Initializes the ClaudeAIProvider instance.
+
+        Sets up the session key if provided, initializes the configuration manager, and configures logging
+        based on the configuration.
+
+        Args:
+            session_key (str, optional): The session key used for authentication. Defaults to None.
+        """
+        self.session_key = session_key
+        self.config = ConfigManager()
+        self._configure_logging()
+
+    def _configure_logging(self):
+        """
+            Configures the logging level for the application based on the configuration.
+            This method sets the global logging configuration to the level specified in the application's configuration.
+            If the log level is not specified in the configuration, it defaults to "INFO".
+            It ensures that all log messages across the application are handled at the configured log level.
+            """
+
+        log_level = self.config.get("log_level", "INFO")  # Retrieve log level from config, default to "INFO"
+        logging.basicConfig(level=getattr(logging, log_level))  # Set global logging configuration
+        logger.setLevel(getattr(logging, log_level))  # Set logger instance to the specified log level
+
+    def login(self):
+        """
+        Guides the user through obtaining a session key from the Claude AI website.
+
+        This method provides step-by-step instructions for the user to log in to the Claude AI website,
+        access the developer tools of their browser, navigate to the cookies section, and retrieve the
+        'sessionKey' cookie value. It then prompts the user to enter this session key, which is stored
+        in the instance for future requests.
+
+        Returns:
+            str: The session key entered by the user.
+        """
+        click.echo("To obtain your session key, please follow these steps:")
+        click.echo("1. Open your web browser and go to https://claude.ai")
+        click.echo("2. Log in to your Claude account if you haven't already")
+        click.echo("3. Once logged in, open your browser's developer tools:")
+        click.echo("   - Chrome/Edge: Press F12 or Ctrl+Shift+I (Cmd+Option+I on Mac)")
+        click.echo("   - Firefox: Press F12 or Ctrl+Shift+I (Cmd+Option+I on Mac)")
+        click.echo(
+            "   - Safari: Enable developer tools in Preferences > Advanced, then press Cmd+Option+I"
+        )
+        click.echo(
+            "4. In the developer tools, go to the 'Application' tab (Chrome/Edge) or 'Storage' tab (Firefox)"
+        )
+        click.echo(
+            "5. In the left sidebar, expand 'Cookies' and select 'https://claude.ai'"
+        )
+        click.echo("6. Find the cookie named 'sessionKey' and copy its value")
+        self.session_key = click.prompt("Please enter your sessionKey", type=str)
+        return self.session_key
+
+    def get_organizations(self):
+        """
+        Retrieves a list of organizations the user is a member of.
+
+        This method sends a GET request to the '/bootstrap' endpoint to fetch account information,
+        including memberships in organizations. It parses the response to extract and return
+        organization IDs and names.
+
+        Raises:
+            ProviderError: If the account information does not contain 'account' or 'memberships' keys,
+                            indicating an issue with retrieving organization information.
+
+        Returns:
+            list of dict: A list of dictionaries, each containing the 'id' and 'name' of an organization.
+        """
+        account_info = self._make_request("GET", "/bootstrap")
+        if (
+                "account" not in account_info
+                or "memberships" not in account_info["account"]
+        ):
+            raise ProviderError("Unable to retrieve organization information")
+
+        return [
+            {
+                "id": membership["organization"]["uuid"],
+                "name": membership["organization"]["name"],
+            }
+            for membership in account_info["account"]["memberships"]
+        ]
+
+    def get_projects(self, organization_id, include_archived=False):
+        """
+        Retrieves a list of projects for a specified organization.
+
+        This method sends a GET request to fetch all projects associated with a given organization ID.
+        It then filters these projects based on the `include_archived` parameter. If `include_archived`
+        is False (default), only active projects are returned. If True, both active and archived projects
+        are returned.
+
+        Args:
+            organization_id (str): The unique identifier for the organization.
+            include_archived (bool, optional): Flag to include archived projects in the result. Defaults to False.
+
+        Returns:
+            list of dict: A list of dictionaries, each representing a project with its ID, name, and archival status.
+        """
+        projects = self._make_request(
+            "GET", f"/organizations/{organization_id}/projects"
+        )
+        filtered_projects = [
+            {
+                "id": project["uuid"],
+                "name": project["name"],
+                "archived_at": project.get("archived_at"),
+            }
+            for project in projects
+            if include_archived or project.get("archived_at") is None
+        ]
+        return filtered_projects
+
+    def list_files(self, organization_id, project_id):
+        """
+        Lists all files within a specified project and organization.
+
+        This method sends a GET request to the Claude AI API to retrieve all documents associated with a given project
+        within an organization. It then formats the response into a list of dictionaries, each representing a file with
+        its unique identifier, file name, content, and creation date.
+
+        Args:
+            organization_id (str): The unique identifier for the organization.
+            project_id (str): The unique identifier for the project within the organization.
+
+        Returns:
+            list of dict: A list of dictionaries, each containing details of a file such as its UUID, file name,
+                          content, and the date it was created.
+        """
+        files = self._make_request(
+            "GET", f"/organizations/{organization_id}/projects/{project_id}/docs"
+        )
+        return [
+            {
+                "uuid": file["uuid"],
+                "file_name": file["file_name"],
+                "content": file["content"],
+                "created_at": file["created_at"],
+            }
+            for file in files
+        ]
+
+    def upload_file(self, organization_id, project_id, file_name, content):
+        """
+        Uploads a file to a specified project within an organization.
+
+        This method sends a POST request to the Claude AI API to upload a file with the given name and content
+        to a specified project within an organization. The file's metadata, including its name and content,
+        is sent as JSON in the request body.
+
+        Args:
+            organization_id (str): The unique identifier for the organization.
+            project_id (str): The unique identifier for the project within the organization.
+            file_name (str): The name of the file to be uploaded.
+            content (str): The content of the file to be uploaded.
+
+        Returns:
+            dict: The response from the server after the file upload operation, typically including details
+                  about the uploaded file such as its ID, name, and a confirmation of the upload status.
+        """
+        return self._make_request(
+            "POST",
+            f"/organizations/{organization_id}/projects/{project_id}/docs",
+            json={"file_name": file_name, "content": content},
+        )
+
+    def delete_file(self, organization_id, project_id, file_uuid):
+        """
+        Deletes a file from a specified project within an organization.
+
+        This method sends a DELETE request to the Claude AI API to remove a file, identified by its UUID,
+        from a specified project within an organization. The organization and project are identified by their
+        respective unique identifiers.
+
+        Args:
+            organization_id (str): The unique identifier for the organization.
+            project_id (str): The unique identifier for the project within the organization.
+            file_uuid (str): The unique identifier (UUID) of the file to be deleted.
+
+        Returns:
+            dict: The response from the server after the file deletion operation, typically confirming the deletion.
+        """
+        return self._make_request(
+            "DELETE",
+            f"/organizations/{organization_id}/projects/{project_id}/docs/{file_uuid}",
+        )
+
+    def _make_request(self, method, endpoint, **kwargs):
+        """
+        Sends a request to the specified endpoint using the given HTTP method.
+
+        This method constructs a request to the Claude AI API, appending the specified endpoint to the base URL.
+        It sets up common headers and cookies for the request, including a session key for authentication.
+        Additional headers can be provided through `kwargs`. The method logs the request and response details
+        and handles common HTTP errors and JSON parsing errors.
+
+        Args:
+            method (str): The HTTP method to use for the request (e.g., 'GET', 'POST').
+            endpoint (str): The API endpoint to which the request is sent.
+            **kwargs: Arbitrary keyword arguments. Can include 'headers' to add or override default headers,
+                      and any other request parameters.
+
+        Returns:
+            dict or None: The parsed JSON response from the API if the response contains content; otherwise, None.
+
+        Raises:
+            ProviderError: If the request fails, if the response status code indicates an error,
+                           or if the response cannot be parsed as JSON.
+        """
+        url = f"{self.BASE_URL}{endpoint}"
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:128.0) Gecko/20100101 Firefox/128.0",
+            "Accept": "*/*",
+            "Accept-Language": "en-US,en;q=0.5",
+            "Referer": "https://claude.ai/",
+            "Origin": "https://claude.ai",
+            "Connection": "keep-alive",
+        }
+        cookies = {"sessionKey": self.session_key}
+
+        if "headers" in kwargs:
+            headers.update(kwargs.pop("headers"))
+
+        try:
+            logger.debug(f"Making {method} request to {url}")
+            logger.debug(f"Headers: {headers}")
+            logger.debug(f"Cookies: {cookies}")
+            if "data" in kwargs:
+                logger.debug(f"Request data: {kwargs['data']}")
+
+            response = requests.request(
+                method, url, headers=headers, cookies=cookies, **kwargs
+            )
+
+            logger.debug(f"Response status code: {response.status_code}")
+            logger.debug(f"Response headers: {response.headers}")
+            logger.debug(
+                f"Response content: {response.text[:1000]}..."
+            )  # Log first 1000 characters of response
+
+            response.raise_for_status()
+
+            if not response.content:
+                return None
+
+            try:
+                return response.json()
+            except json.JSONDecodeError as json_err:
+                logger.error(f"Failed to parse JSON response: {str(json_err)}")
+                logger.error(f"Response content: {response.text}")
+                raise ProviderError(f"Invalid JSON response from API: {str(json_err)}")
+
+        except requests.RequestException as e:
+            logger.error(f"Request failed: {str(e)}")
+            if hasattr(e, "response") and e.response is not None:
+                logger.error(f"Response status code: {e.response.status_code}")
+                logger.error(f"Response headers: {e.response.headers}")
+                logger.error(f"Response content: {e.response.text}")
+            raise ProviderError(f"API request failed: {str(e)}")
+
+    def archive_project(self, organization_id, project_id):
+        """
+        Archives a specified project within an organization.
+
+        This method sends a PUT request to the Claude AI API to change the archival status of a specified project
+        to archive. The project and organization are identified by their respective unique identifiers.
+
+        Args:
+            organization_id (str): The unique identifier for the organization.
+            project_id (str): The unique identifier for the project within the organization.
+
+        Returns:
+            dict: The response from the server after the archival operation, typically confirming the archival status.
+        """
+        return self._make_request(
+            "PUT",
+            f"/organizations/{organization_id}/projects/{project_id}",
+            json={"is_archived": True},
+        )
+
+    def create_project(self, organization_id, name, description=""):
+        """
+        Creates a new project within a specified organization.
+
+        This method sends a POST request to the Claude AI API to create a new project with the given name,
+        description, and sets it as private within the specified organization. The project's name, description,
+        and privacy status are sent as JSON in the request body.
+
+        Args:
+            organization_id (str): The unique identifier for the organization.
+            name (str): The name of the project to be created.
+            description (str, optional): A description of the project. Defaults to an empty string.
+
+        Returns:
+            dict: The response from the server after the project creation operation, typically including details
+                  about the created project such as its ID, name, and a confirmation of the creation status.
+        """
+        data = {"name": name, "description": description, "is_private": True}
+        return self._make_request(
+            "POST", f"/organizations/{organization_id}/projects", json=data
+        )

claudesync-0.3.3/src/claudesync/utils.py

@@ -0,0 +1,264 @@
+import os
+import hashlib
+from functools import wraps
+
+import click
+import pathspec
+import logging
+
+from claudesync.exceptions import ConfigurationError, ProviderError
+from claudesync.provider_factory import get_provider
+from claudesync.config_manager import ConfigManager
+
+logger = logging.getLogger(__name__)
+
+config_manager = ConfigManager()
+
+
+def normalize_and_calculate_md5(content):
+    """
+    Calculate the MD5 checksum of the given content after normalizing line endings.
+
+    This function normalizes the line endings of the input content to Unix-style (\n),
+    strips leading and trailing whitespace, and then calculates the MD5 checksum of the
+    normalized content. This is useful for ensuring consistent checksums across different
+    operating systems and environments where line ending styles may vary.
+
+    Args:
+        content (str): The content for which to calculate the checksum.
+
+    Returns:
+        str: The hexadecimal MD5 checksum of the normalized content.
+    """
+    normalized_content = content.replace("\r\n", "\n").replace("\r", "\n").strip()
+    return hashlib.md5(normalized_content.encode("utf-8")).hexdigest()
+
+
+def load_gitignore(base_path):
+    """
+    Loads and parses the .gitignore file from the specified base path.
+
+    This function attempts to find a .gitignore file in the given base path. If found,
+    it reads the file and creates a PathSpec object that can be used to match paths
+    against the patterns defined in the .gitignore file. This is useful for filtering
+    out files that should be ignored based on the project's .gitignore settings.
+
+    Args:
+        base_path (str): The base directory path where the .gitignore file is located.
+
+    Returns:
+        pathspec.PathSpec or None: A PathSpec object containing the patterns from the .gitignore file
+                                    if the file exists; otherwise, None.
+    """
+    gitignore_path = os.path.join(base_path, ".gitignore")
+    if os.path.exists(gitignore_path):
+        with open(gitignore_path, "r") as f:
+            return pathspec.PathSpec.from_lines("gitwildmatch", f)
+    return None
+
+
+def is_text_file(file_path, sample_size=8192):
+    """
+    Determines if a file is a text file by checking for the absence of null bytes.
+
+    This function reads a sample of the file (default 8192 bytes) and checks if it contains
+    any null byte (\x00). The presence of a null byte is often indicative of a binary file.
+    This is a heuristic method and may not be 100% accurate for all file types.
+
+    Args:
+        file_path (str): The path to the file to be checked.
+        sample_size (int, optional): The number of bytes to read from the file for checking.
+                                     Defaults to 8192.
+
+    Returns:
+        bool: True if the file is likely a text file, False if it is likely binary or an error occurred.
+    """
+    try:
+        with open(file_path, "rb") as file:
+            return b"\x00" not in file.read(sample_size)
+    except IOError:
+        return False
+
+
+def compute_md5_hash(content):
+    """
+    Computes the MD5 hash of the given content.
+
+    This function takes a string as input, encodes it into UTF-8, and then computes the MD5 hash of the encoded string.
+    The result is a hexadecimal representation of the hash, which is commonly used for creating a quick and simple
+    fingerprint of a piece of data.
+
+    Args:
+        content (str): The content for which to compute the MD5 hash.
+
+    Returns:
+        str: The hexadecimal MD5 hash of the input content.
+    """
+    return hashlib.md5(content.encode("utf-8")).hexdigest()
+
+
+def get_local_files(local_path):
+    """
+    Retrieves a dictionary of local files within a specified path, applying various filters.
+
+    This function walks through the directory specified by `local_path`, applying several filters to each file:
+    - Excludes files in directories like .git, .svn, etc.
+    - Skips files larger than a specified maximum size (default 200KB, configurable).
+    - Ignores temporary editor files (ending with '~').
+    - Applies .gitignore rules if a .gitignore file is present in the `local_path`.
+    - Checks if the file is a text file before processing.
+    Each file that passes these filters is read, and its content is hashed using MD5. The function returns a dictionary
+    where each key is the relative path of a file from `local_path`, and its value is the MD5 hash of the file's content.
+
+    Args:
+        local_path (str): The base directory path to search for files.
+
+    Returns:
+        dict: A dictionary where keys are relative file paths, and values are MD5 hashes of the file contents.
+    """
+    gitignore = load_gitignore(local_path)
+    files = {}
+
+    # List of directories to exclude
+    exclude_dirs = {".git", ".svn", ".hg", ".bzr", "_darcs", "CVS"}
+
+    for root, dirs, filenames in os.walk(local_path):
+        # Remove excluded directories
+        dirs[:] = [d for d in dirs if d not in exclude_dirs]
+
+        rel_root = os.path.relpath(root, local_path)
+        if rel_root == ".":
+            rel_root = ""
+
+        for filename in filenames:
+            rel_path = os.path.join(rel_root, filename)
+            full_path = os.path.join(root, filename)
+
+            # Skip files larger than 200KB
+            max_file_size = config_manager.get("max_file_size", 32 * 1024)
+            if os.path.getsize(full_path) > max_file_size:
+                continue
+
+            # Skip temporary editor files
+            if filename.endswith("~"):
+                continue
+
+            # Use gitignore rules if available
+            if gitignore and gitignore.match_file(rel_path):
+                continue
+
+            # Check if it's a text file
+            if not is_text_file(full_path):
+                continue
+
+            try:
+                with open(full_path, "r", encoding="utf-8") as file:
+                    content = file.read()
+                    files[rel_path] = compute_md5_hash(content)
+            except UnicodeDecodeError:
+                # If UTF-8 decoding fails, it's likely not a text file we can handle
+                logger.debug(f"Unable to read {full_path} as UTF-8 text. Skipping.")
+                continue
+            except Exception as e:
+                logger.error(f"Error reading file {full_path}: {str(e)}")
+
+    return files
+
+
+def handle_errors(func):
+    """
+    A decorator that wraps a function to catch and handle specific exceptions.
+
+    This decorator catches exceptions of type ConfigurationError and ProviderError
+    that are raised within the decorated function. When such an exception is caught,
+    it prints an error message to the console using click's echo function. This is
+    useful for CLI applications where a friendly error message is preferred over a
+    full traceback for known error conditions.
+
+    Args:
+        func (Callable): The function to be decorated.
+
+    Returns:
+        Callable: The wrapper function that includes exception handling.
+    """
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except (ConfigurationError, ProviderError) as e:
+            click.echo(f"Error: {str(e)}")
+
+    return wrapper
+
+
+def validate_and_get_provider(config, require_org=True):
+    """
+    Validates the configuration for the presence of an active provider and session key,
+    and optionally checks for an active organization ID. If validation passes, it retrieves
+    the provider instance based on the active provider name.
+
+    This function ensures that the necessary configuration settings are present before
+    attempting to interact with a provider. It raises a ConfigurationError if the required
+    settings are missing, guiding the user to perform necessary setup steps.
+
+    Args:
+        config (ConfigManager): The configuration manager instance containing settings.
+        require_org (bool, optional): Flag to indicate whether an active organization ID
+                                      is required. Defaults to True.
+
+    Returns:
+        object: An instance of the provider specified in the configuration.
+
+    Raises:
+        ConfigurationError: If the active provider or session key is missing, or if
+                            require_org is True and no active organization ID is set.
+    """
+    active_provider = config.get("active_provider")
+    session_key = config.get("session_key")
+    if not active_provider or not session_key:
+        raise ConfigurationError(
+            "No active provider or session key. Please login first."
+        )
+    if require_org and not config.get("active_organization_id"):
+        raise ConfigurationError(
+            "No active organization set. Please select an organization."
+        )
+    return get_provider(active_provider, session_key)
+
+
+def validate_and_store_local_path(config):
+    """
+    Prompts the user for the absolute path to their local project directory and stores it in the configuration.
+
+    This function repeatedly prompts the user to enter the absolute path to their local project directory until
+    a valid absolute path is provided. The path is validated to ensure it exists, is a directory, and is an absolute path.
+    Once a valid path is provided, it is stored in the configuration using the `set` method of the `ConfigManager` object.
+
+    Args:
+        config (ConfigManager): The configuration manager instance to store the local path setting.
+
+    Note:
+        This function uses `click.prompt` to interact with the user, providing a default path (the current working directory)
+        and validating the user's input to ensure it meets the criteria for an absolute path to a directory.
+    """
+    def get_default_path():
+        return os.getcwd()
+
+    while True:
+        default_path = get_default_path()
+        local_path = click.prompt(
+            "Enter the absolute path to your local project directory",
+            type=click.Path(
+                exists=True, file_okay=False, dir_okay=True, resolve_path=True
+            ),
+            default=default_path,
+            show_default=True,
+        )
+
+        if os.path.isabs(local_path):
+            config.set("local_path", local_path)
+            click.echo(f"Local path set to: {local_path}")
+            break
+        else:
+            click.echo("Please enter an absolute path.")

{claudesync-0.3.2 → claudesync-0.3.3/src/claudesync.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: claudesync
-Version: 0.3.2
+Version: 0.3.3
 Summary: A tool to synchronize local files with Claude.ai projects
 Author-email: Jahziah Wagner <jahziah.wagner+pypi@gmail.com>
 License: MIT License

{claudesync-0.3.2 → claudesync-0.3.3}/tests/test_utils.py

@@ -3,7 +3,7 @@ import os
 import tempfile
 
 from claudesync.utils import (
-    calculate_checksum,
+    compute_md5_hash,
     load_gitignore,
     get_local_files,
 )
@@ -14,7 +14,7 @@ class TestUtils(unittest.TestCase):
     def test_calculate_checksum(self):
         content = "Hello, World!"
         expected_checksum = "65a8e27d8879283831b664bd8b7f0ad4"
-        self.assertEqual(calculate_checksum(content), expected_checksum)
+        self.assertEqual(compute_md5_hash(content), expected_checksum)
 
     def test_load_gitignore(self):
         with tempfile.TemporaryDirectory() as tmpdir:

claudesync-0.3.2/src/claudesync/config_manager.py

@@ -1,38 +0,0 @@
-import json
-from pathlib import Path
-
-
-class ConfigManager:
-    def __init__(self):
-        self.config_dir = Path.home() / ".claudesync"
-        self.config_file = self.config_dir / "config.json"
-        self.config = self._load_config()
-
-    def _load_config(self):
-        if not self.config_file.exists():
-            self.config_dir.mkdir(parents=True, exist_ok=True)
-            return {
-                "log_level": "INFO",
-                "upload_delay": 0.5,
-                "max_file_size": 32 * 1024,  # Default 32 KB
-            }
-        with open(self.config_file, "r") as f:
-            config = json.load(f)
-            if "log_level" not in config:
-                config["log_level"] = "INFO"
-            if "upload_delay" not in config:
-                config["upload_delay"] = 0.5
-            if "max_file_size" not in config:
-                config["max_file_size"] = 32 * 1024  # Default 32 KB
-            return config
-
-    def _save_config(self):
-        with open(self.config_file, "w") as f:
-            json.dump(self.config, f, indent=2)
-
-    def get(self, key, default=None):
-        return self.config.get(key, default)
-
-    def set(self, key, value):
-        self.config[key] = value
-        self._save_config()

claudesync-0.3.2/src/claudesync/exceptions.py

@@ -1,10 +0,0 @@
-class ConfigurationError(Exception):
-    """Raised when there's an issue with the configuration."""
-
-    pass
-
-
-class ProviderError(Exception):
-    """Raised when there's an issue with a provider operation."""
-
-    pass

claudesync-0.3.2/src/claudesync/provider_factory.py

@@ -1,19 +0,0 @@
-from .providers.claude_ai import ClaudeAIProvider
-
-# Import other providers here as they are added
-
-
-def get_provider(provider_name=None, session_key=None):
-    providers = {
-        "claude.ai": ClaudeAIProvider,
-        # Add other providers here as they are implemented
-    }
-
-    if provider_name is None:
-        return list(providers.keys())
-
-    provider_class = providers.get(provider_name)
-    if provider_class is None:
-        raise ValueError(f"Unsupported provider: {provider_name}")
-
-    return provider_class(session_key) if session_key else provider_class()

claudesync-0.3.2/src/claudesync/providers/claude_ai.py

@@ -1,166 +0,0 @@
-import requests
-import json
-import click
-import logging
-from ..exceptions import ProviderError
-from ..config_manager import ConfigManager
-
-logger = logging.getLogger(__name__)
-
-
-class ClaudeAIProvider:
-    BASE_URL = "https://claude.ai/api"
-
-    def __init__(self, session_key=None):
-        self.session_key = session_key
-        self.config = ConfigManager()
-        self._configure_logging()
-
-    def _configure_logging(self):
-        log_level = self.config.get("log_level", "INFO")
-        logging.basicConfig(level=getattr(logging, log_level))
-        logger.setLevel(getattr(logging, log_level))
-
-    def login(self):
-        click.echo("To obtain your session key, please follow these steps:")
-        click.echo("1. Open your web browser and go to https://claude.ai")
-        click.echo("2. Log in to your Claude account if you haven't already")
-        click.echo("3. Once logged in, open your browser's developer tools:")
-        click.echo("   - Chrome/Edge: Press F12 or Ctrl+Shift+I (Cmd+Option+I on Mac)")
-        click.echo("   - Firefox: Press F12 or Ctrl+Shift+I (Cmd+Option+I on Mac)")
-        click.echo(
-            "   - Safari: Enable developer tools in Preferences > Advanced, then press Cmd+Option+I"
-        )
-        click.echo(
-            "4. In the developer tools, go to the 'Application' tab (Chrome/Edge) or 'Storage' tab (Firefox)"
-        )
-        click.echo(
-            "5. In the left sidebar, expand 'Cookies' and select 'https://claude.ai'"
-        )
-        click.echo("6. Find the cookie named 'sessionKey' and copy its value")
-
-        self.session_key = click.prompt("Please enter your sessionKey", type=str)
-        return self.session_key
-
-    def get_organizations(self):
-        account_info = self._make_request("GET", "/bootstrap")
-        if (
-            "account" not in account_info
-            or "memberships" not in account_info["account"]
-        ):
-            raise ProviderError("Unable to retrieve organization information")
-
-        return [
-            {
-                "id": membership["organization"]["uuid"],
-                "name": membership["organization"]["name"],
-            }
-            for membership in account_info["account"]["memberships"]
-        ]
-
-    def get_projects(self, organization_id, include_archived=False):
-        projects = self._make_request(
-            "GET", f"/organizations/{organization_id}/projects"
-        )
-        filtered_projects = [
-            {
-                "id": project["uuid"],
-                "name": project["name"],
-                "archived_at": project.get("archived_at"),
-            }
-            for project in projects
-            if include_archived or project.get("archived_at") is None
-        ]
-        return filtered_projects
-
-    def list_files(self, organization_id, project_id):
-        files = self._make_request(
-            "GET", f"/organizations/{organization_id}/projects/{project_id}/docs"
-        )
-        return [
-            {
-                "uuid": file["uuid"],
-                "file_name": file["file_name"],
-                "content": file["content"],
-                "created_at": file["created_at"],
-            }
-            for file in files
-        ]
-
-    def upload_file(self, organization_id, project_id, file_name, content):
-        return self._make_request(
-            "POST",
-            f"/organizations/{organization_id}/projects/{project_id}/docs",
-            json={"file_name": file_name, "content": content},
-        )
-
-    def delete_file(self, organization_id, project_id, file_uuid):
-        return self._make_request(
-            "DELETE",
-            f"/organizations/{organization_id}/projects/{project_id}/docs/{file_uuid}",
-        )
-
-    def _make_request(self, method, endpoint, **kwargs):
-        url = f"{self.BASE_URL}{endpoint}"
-        headers = {
-            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:128.0) Gecko/20100101 Firefox/128.0",
-            "Accept": "*/*",
-            "Accept-Language": "en-US,en;q=0.5",
-            "Referer": "https://claude.ai/",
-            "Origin": "https://claude.ai",
-            "Connection": "keep-alive",
-        }
-        cookies = {"sessionKey": self.session_key}
-
-        if "headers" in kwargs:
-            headers.update(kwargs.pop("headers"))
-
-        try:
-            logger.debug(f"Making {method} request to {url}")
-            logger.debug(f"Headers: {headers}")
-            logger.debug(f"Cookies: {cookies}")
-            if "data" in kwargs:
-                logger.debug(f"Request data: {kwargs['data']}")
-
-            response = requests.request(
-                method, url, headers=headers, cookies=cookies, **kwargs
-            )
-
-            logger.debug(f"Response status code: {response.status_code}")
-            logger.debug(f"Response headers: {response.headers}")
-            logger.debug(
-                f"Response content: {response.text[:1000]}..."
-            )  # Log first 1000 characters of response
-
-            response.raise_for_status()
-
-            if not response.content:
-                return None
-
-            try:
-                return response.json()
-            except json.JSONDecodeError as json_err:
-                logger.error(f"Failed to parse JSON response: {str(json_err)}")
-                logger.error(f"Response content: {response.text}")
-                raise ProviderError(f"Invalid JSON response from API: {str(json_err)}")
-
-        except requests.RequestException as e:
-            logger.error(f"Request failed: {str(e)}")
-            if hasattr(e, "response") and e.response is not None:
-                logger.error(f"Response status code: {e.response.status_code}")
-                logger.error(f"Response headers: {e.response.headers}")
-                logger.error(f"Response content: {e.response.text}")
-            raise ProviderError(f"API request failed: {str(e)}")
-
-    def archive_project(self, organization_id, project_id):
-        return self._make_request(
-            "PUT",
-            f"/organizations/{organization_id}/projects/{project_id}",
-            json={"is_archived": True},
-        )
-
-    def create_project(self, organization_id, name, description=""):
-        data = {"name": name, "description": description, "is_private": True}
-        return self._make_request(
-            "POST", f"/organizations/{organization_id}/projects", json=data
-        )

claudesync-0.3.2/src/claudesync/utils.py

@@ -1,138 +0,0 @@
-import os
-import hashlib
-from functools import wraps
-
-import click
-import pathspec
-import logging
-
-from claudesync.exceptions import ConfigurationError, ProviderError
-from claudesync.provider_factory import get_provider
-from claudesync.config_manager import ConfigManager
-
-logger = logging.getLogger(__name__)
-
-config_manager = ConfigManager()
-
-
-def calculate_checksum(content):
-    normalized_content = content.replace("\r\n", "\n").replace("\r", "\n").strip()
-    return hashlib.md5(normalized_content.encode("utf-8")).hexdigest()
-
-
-def load_gitignore(base_path):
-    gitignore_path = os.path.join(base_path, ".gitignore")
-    if os.path.exists(gitignore_path):
-        with open(gitignore_path, "r") as f:
-            return pathspec.PathSpec.from_lines("gitwildmatch", f)
-    return None
-
-
-def is_text_file(file_path, sample_size=8192):
-    try:
-        with open(file_path, "rb") as file:
-            return b"\x00" not in file.read(sample_size)
-    except IOError:
-        return False
-
-
-def calculate_checksum(content):
-    return hashlib.md5(content.encode("utf-8")).hexdigest()
-
-
-def get_local_files(local_path):
-    gitignore = load_gitignore(local_path)
-    files = {}
-
-    # List of directories to exclude
-    exclude_dirs = {".git", ".svn", ".hg", ".bzr", "_darcs", "CVS"}
-
-    for root, dirs, filenames in os.walk(local_path):
-        # Remove excluded directories
-        dirs[:] = [d for d in dirs if d not in exclude_dirs]
-
-        rel_root = os.path.relpath(root, local_path)
-        if rel_root == ".":
-            rel_root = ""
-
-        for filename in filenames:
-            rel_path = os.path.join(rel_root, filename)
-            full_path = os.path.join(root, filename)
-
-            # Skip files larger than 200KB
-            max_file_size = config_manager.get("max_file_size", 32 * 1024)
-            if os.path.getsize(full_path) > max_file_size:
-                continue
-
-            # Skip temporary editor files
-            if filename.endswith("~"):
-                continue
-
-            # Use gitignore rules if available
-            if gitignore and gitignore.match_file(rel_path):
-                continue
-
-            # Check if it's a text file
-            if not is_text_file(full_path):
-                continue
-
-            try:
-                with open(full_path, "r", encoding="utf-8") as file:
-                    content = file.read()
-                    files[rel_path] = calculate_checksum(content)
-            except UnicodeDecodeError:
-                # If UTF-8 decoding fails, it's likely not a text file we can handle
-                logger.debug(f"Unable to read {full_path} as UTF-8 text. Skipping.")
-                continue
-            except Exception as e:
-                logger.error(f"Error reading file {full_path}: {str(e)}")
-
-    return files
-
-
-def handle_errors(func):
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        try:
-            return func(*args, **kwargs)
-        except (ConfigurationError, ProviderError) as e:
-            click.echo(f"Error: {str(e)}")
-
-    return wrapper
-
-
-def validate_and_get_provider(config, require_org=True):
-    active_provider = config.get("active_provider")
-    session_key = config.get("session_key")
-    if not active_provider or not session_key:
-        raise ConfigurationError(
-            "No active provider or session key. Please login first."
-        )
-    if require_org and not config.get("active_organization_id"):
-        raise ConfigurationError(
-            "No active organization set. Please select an organization."
-        )
-    return get_provider(active_provider, session_key)
-
-
-def validate_and_store_local_path(config):
-    def get_default_path():
-        return os.getcwd()
-
-    while True:
-        default_path = get_default_path()
-        local_path = click.prompt(
-            "Enter the absolute path to your local project directory",
-            type=click.Path(
-                exists=True, file_okay=False, dir_okay=True, resolve_path=True
-            ),
-            default=default_path,
-            show_default=True,
-        )
-
-        if os.path.isabs(local_path):
-            config.set("local_path", local_path)
-            click.echo(f"Local path set to: {local_path}")
-            break
-        else:
-            click.echo("Please enter an absolute path.")

{claudesync-0.3.2 → claudesync-0.3.3}/src/claudesync/cli/main.py

@@ -1,8 +1,8 @@
 import click
-from claudesync.config_manager import ConfigManager
 import click_completion
 import click_completion.core
 
+from claudesync.config_manager import ConfigManager
 from .api import api
 from .organization import organization
 from .project import project