ctxsync 0.8.0__py3-none-any.whl

ctxsync/chat_sync.py

@@ -0,0 +1,186 @@
+import json
+import logging
+import os
+import re
+
+from tqdm import tqdm
+
+from .exceptions import ConfigurationError
+
+logger = logging.getLogger(__name__)
+
+
+def sync_chats(provider, config, sync_all=False):
+    """
+    Synchronize chats and their artifacts from the remote source.
+
+    This function fetches all chats for the active organization, saves their metadata,
+    messages, and extracts any artifacts found in the assistant's messages.
+
+    Args:
+        provider: The API provider instance.
+        config: The configuration manager instance.
+        sync_all (bool): If True, sync all chats regardless of project. If False, only sync chats for the active project.
+
+    Raises:
+        ConfigurationError: If required configuration settings are missing.
+    """
+    # Get the local_path for chats
+    local_path = config.get("local_path")
+    if not local_path:
+        raise ConfigurationError(
+            "Local path not set. Use 'ctxsync project set' or 'ctxsync project create' to set it."
+        )
+
+    # Create chats directory within local_path
+    chat_destination = os.path.join(local_path, "claude_chats")
+    os.makedirs(chat_destination, exist_ok=True)
+
+    # Get the active organization ID
+    organization_id = config.get("active_organization_id")
+    if not organization_id:
+        raise ConfigurationError(
+            "No active organization set. Please set an organization."
+        )
+
+    # Get the active project ID
+    active_project_id = config.get("active_project_id")
+    if not active_project_id and not sync_all:
+        raise ConfigurationError(
+            "No active project set. Please set a project or use the -a flag to sync all chats."
+        )
+
+    # Fetch all chats for the organization
+    logger.debug(f"Fetching chats for organization {organization_id}")
+    chats = provider.get_chat_conversations(organization_id)
+    logger.debug(f"Found {len(chats)} chats")
+
+    # Process each chat
+    for chat in tqdm(chats, desc="Chats"):
+        sync_chat(
+            active_project_id,
+            chat,
+            chat_destination,
+            organization_id,
+            provider,
+            sync_all,
+        )
+
+    logger.debug(f"Chats and artifacts synchronized to {chat_destination}")
+
+
+def sync_chat(
+    active_project_id, chat, chat_destination, organization_id, provider, sync_all
+):
+    # Check if the chat belongs to the active project or if we're syncing all chats
+    if sync_all or (
+        chat.get("project") and chat["project"].get("uuid") == active_project_id
+    ):
+        logger.debug(f"Processing chat {chat['uuid']}")
+        chat_folder = os.path.join(chat_destination, chat["uuid"])
+        os.makedirs(chat_folder, exist_ok=True)
+
+        # Save chat metadata
+        metadata_file = os.path.join(chat_folder, "metadata.json")
+        if not os.path.exists(metadata_file):
+            with open(metadata_file, "w") as f:
+                json.dump(chat, f, indent=2)
+
+        # Fetch full chat conversation
+        logger.debug(f"Fetching full conversation for chat {chat['uuid']}")
+        full_chat = provider.get_chat_conversation(organization_id, chat["uuid"])
+
+        # Process each message in the chat
+        for message in full_chat["chat_messages"]:
+            message_file = os.path.join(chat_folder, f"{message['uuid']}.json")
+
+            # Skip processing if the message file already exists
+            if os.path.exists(message_file):
+                logger.debug(f"Skipping existing message {message['uuid']}")
+                continue
+
+            # Save the message
+            with open(message_file, "w") as f:
+                json.dump(message, f, indent=2)
+
+            # Handle artifacts in assistant messages
+            if message["sender"] == "assistant":
+                artifacts = extract_artifacts(message["text"])
+                if artifacts:
+                    save_artifacts(artifacts, chat_folder, message)
+    else:
+        logger.debug(
+            f"Skipping chat {chat['uuid']} as it doesn't belong to the active project"
+        )
+
+
+def save_artifacts(artifacts, chat_folder, message):
+    logger.info(f"Found {len(artifacts)} artifacts in message {message['uuid']}")
+    artifact_folder = os.path.join(chat_folder, "artifacts")
+    os.makedirs(artifact_folder, exist_ok=True)
+    for artifact in artifacts:
+        # Save each artifact
+        artifact_file = os.path.join(
+            artifact_folder,
+            f"{artifact['identifier']}.{get_file_extension(artifact['type'])}",
+        )
+        if not os.path.exists(artifact_file):
+            with open(artifact_file, "w") as f:
+                f.write(artifact["content"])
+
+
+def get_file_extension(artifact_type):
+    """
+    Get the appropriate file extension for a given artifact type.
+
+    Args:
+        artifact_type (str): The MIME type of the artifact.
+
+    Returns:
+        str: The corresponding file extension.
+    """
+    type_to_extension = {
+        "text/html": "html",
+        "application/vnd.ant.code": "txt",
+        "image/svg+xml": "svg",
+        "application/vnd.ant.mermaid": "mmd",
+        "application/vnd.ant.react": "jsx",
+    }
+    return type_to_extension.get(artifact_type, "txt")
+
+
+def extract_artifacts(text):
+    """
+    Extract artifacts from the given text.
+
+    This function searches for antArtifact tags in the text and extracts
+    the artifact information, including identifier, type, and content.
+
+    Args:
+        text (str): The text to search for artifacts.
+
+    Returns:
+        list: A list of dictionaries containing artifact information.
+    """
+    artifacts = []
+
+    # Regular expression to match the <antArtifact> tags and extract their attributes and content
+    pattern = re.compile(
+        r'<antArtifact\s+identifier="([^"]+)"\s+type="([^"]+)"\s+title="([^"]+)">([\s\S]*?)</antArtifact>',
+        re.MULTILINE,
+    )
+
+    # Find all matches in the text
+    matches = pattern.findall(text)
+
+    for match in matches:
+        identifier, artifact_type, title, content = match
+        artifacts.append(
+            {
+                "identifier": identifier,
+                "type": artifact_type,
+                "content": content.strip(),
+            }
+        )
+
+    return artifacts

ctxsync/cli/__init__.py

@@ -0,0 +1,3 @@
+from .main import cli
+
+__all__ = ["cli"]

ctxsync/cli/auth.py

@@ -0,0 +1,77 @@
+import click
+
+from ctxsync.provider_factory import get_provider
+from ..exceptions import ProviderError
+from ..utils import handle_errors
+
+
+@click.group()
+def auth():
+    """Manage authentication."""
+    pass
+
+
+@auth.command()
+@click.option(
+    "--provider",
+    prompt="Choose provider",
+    type=click.Choice(["claude.ai"], case_sensitive=False),
+    default="claude.ai",
+    help="The provider to use for this project",
+)
+@click.option(
+    "--session-key",
+    help="Directly provide the Claude.ai session key",
+    envvar="CLAUDE_SESSION_KEY",
+)
+@click.option(
+    "--auto-approve",
+    is_flag=True,
+    help="Automatically approve the suggested expiry time",
+)
+@click.pass_context
+@handle_errors
+def login(ctx, provider, session_key, auto_approve):
+    """Authenticate with an AI provider."""
+    config = ctx.obj
+    provider_instance = get_provider(config, provider)
+
+    try:
+        if session_key:
+            # If session key is provided, bypass the interactive prompt
+            if not session_key.startswith("sk-ant"):
+                raise ProviderError(
+                    "Invalid sessionKey format. Must start with 'sk-ant'"
+                )
+            # Set auto_approve to True when session key is provided
+            provider_instance._auto_approve_expiry = auto_approve
+            provider_instance._provided_session_key = session_key
+
+        session_key, expiry = provider_instance.login()
+        config.set_session_key(provider, session_key, expiry)
+        click.echo(
+            f"Successfully authenticated with {provider}. Session key stored globally."
+        )
+    except ProviderError as e:
+        click.echo(f"Authentication failed: {str(e)}")
+
+
+@auth.command()
+@click.pass_obj
+def logout(config):
+    """Log out from all AI providers."""
+    config.clear_all_session_keys()
+    click.echo("Logged out from all providers successfully.")
+
+
+@auth.command()
+@click.pass_obj
+def ls(config):
+    """List all authenticated providers."""
+    authenticated_providers = config.get_providers_with_session_keys()
+    if authenticated_providers:
+        click.echo("Authenticated providers:")
+        for provider in authenticated_providers:
+            click.echo(f"  - {provider}")
+    else:
+        click.echo("No authenticated providers found.")

ctxsync/cli/category.py

@@ -0,0 +1,71 @@
+import click
+from ..utils import handle_errors
+
+
+@click.group()
+def category():
+    """Manage file categories."""
+    pass
+
+
+@category.command()
+@click.argument("name")
+@click.option("--description", required=True, help="Description of the category")
+@click.option(
+    "--patterns", required=True, multiple=True, help="File patterns for the category"
+)
+@click.pass_obj
+@handle_errors
+def add(config, name, description, patterns):
+    """Add a new file category."""
+    config.add_file_category(name, description, list(patterns))
+    click.echo(f"File category '{name}' added successfully.")
+
+
+@category.command()
+@click.argument("name")
+@click.pass_obj
+@handle_errors
+def rm(config, name):
+    """Remove a file category."""
+    config.remove_file_category(name)
+    click.echo(f"File category '{name}' removed successfully.")
+
+
+@category.command()
+@click.argument("name")
+@click.option("--description", help="New description for the category")
+@click.option("--patterns", multiple=True, help="New file patterns for the category")
+@click.pass_obj
+@handle_errors
+def update(config, name, description, patterns):
+    """Update an existing file category."""
+    config.update_file_category(name, description, list(patterns) if patterns else None)
+    click.echo(f"File category '{name}' updated successfully.")
+
+
+@category.command()
+@click.pass_obj
+@handle_errors
+def ls(config):
+    """List all file categories."""
+    categories = config.get("file_categories", {})
+    if not categories:
+        click.echo("No file categories defined.")
+    else:
+        for name, data in categories.items():
+            click.echo(f"\nCategory: {name}")
+            click.echo(f"Description: {data['description']}")
+            click.echo("Patterns:")
+            for pattern in data["patterns"]:
+                click.echo(f"  - {pattern}")
+
+
+@category.command()
+@click.argument("category", required=True)
+@click.pass_obj
+@handle_errors
+def set_default(config, category):
+    """Set the default category for synchronization."""
+    config.set_default_category(category)
+    click.echo(f"Default sync category set to: {category}")

ctxsync/cli/chat.py

@@ -0,0 +1,357 @@
+import os
+
+import click
+import logging
+from ..exceptions import ProviderError
+from ..utils import handle_errors, validate_and_get_provider
+from ..chat_sync import sync_chats
+
+logger = logging.getLogger(__name__)
+
+
+@click.group()
+def chat():
+    """Manage and synchronize chats."""
+    pass
+
+
+@chat.command()
+@click.pass_obj
+@handle_errors
+def pull(config):
+    """Synchronize chats and their artifacts from the remote source."""
+    provider = validate_and_get_provider(config, require_project=True)
+    sync_chats(provider, config)
+
+
+@chat.command()
+@click.pass_obj
+@handle_errors
+def ls(config):
+    """List all chats."""
+    provider = validate_and_get_provider(config)
+    organization_id = config.get("active_organization_id")
+    chats = provider.get_chat_conversations(organization_id)
+
+    for chat in chats:
+        project = chat.get("project")
+        project_name = project.get("name") if project else ""
+        click.echo(
+            f"UUID: {chat.get('uuid', 'Unknown')}, "
+            f"Name: {chat.get('name', 'Unnamed')}, "
+            f"Project: {project_name}, "
+            f"Updated: {chat.get('updated_at', 'Unknown')}"
+        )
+
+
+@chat.command()
+@click.option("-a", "--all", "delete_all", is_flag=True, help="Delete all chats")
+@click.pass_obj
+@handle_errors
+def rm(config, delete_all):
+    """Delete chat conversations. Use -a to delete all chats, or run without -a to select specific chats to delete."""
+    provider = validate_and_get_provider(config)
+    organization_id = config.get("active_organization_id")
+
+    if delete_all:
+        delete_all_chats(provider, organization_id)
+    else:
+        delete_single_chat(provider, organization_id)
+
+
+def delete_chats(provider, organization_id, uuids):
+    """Delete a list of chats by their UUIDs."""
+    try:
+        result = provider.delete_chat(organization_id, uuids)
+        return len(result), 0
+    except ProviderError as e:
+        logger.error(f"Error deleting chats: {str(e)}")
+        click.echo(f"Error occurred while deleting chats: {str(e)}")
+        return 0, len(uuids)
+
+
+def delete_all_chats(provider, organization_id):
+    """Delete all chats for the given organization."""
+    if click.confirm("Are you sure you want to delete all chats?"):
+        total_deleted = 0
+        with click.progressbar(length=100, label="Deleting chats") as bar:
+            while True:
+                chats = provider.get_chat_conversations(organization_id)
+                if not chats:
+                    break
+                uuids_to_delete = [chat["uuid"] for chat in chats[:50]]
+                deleted, _ = delete_chats(provider, organization_id, uuids_to_delete)
+                total_deleted += deleted
+                bar.update(len(uuids_to_delete))
+        click.echo(f"Chat deletion complete. Total chats deleted: {total_deleted}")
+
+
+def delete_single_chat(provider, organization_id):
+    """Delete a single chat selected by the user."""
+    chats = provider.get_chat_conversations(organization_id)
+    if not chats:
+        click.echo("No chats found.")
+        return
+
+    display_chat_list(chats)
+    selected_chat = get_chat_selection(chats)
+    if selected_chat:
+        confirm_and_delete_chat(provider, organization_id, selected_chat)
+
+
+def display_chat_list(chats):
+    """Display a list of chats to the user."""
+    click.echo("Available chats:")
+    for idx, chat in enumerate(chats, 1):
+        project = chat.get("project")
+        project_name = project.get("name") if project else ""
+        click.echo(
+            f"{idx}. Name: {chat.get('name', 'Unnamed')}, "
+            f"Project: {project_name}, Updated: {chat.get('updated_at', 'Unknown')}"
+        )
+
+
+def get_chat_selection(chats):
+    """Get a valid chat selection from the user."""
+    while True:
+        selection = click.prompt(
+            "Enter the number of the chat to delete (or 'q' to quit)", type=str
+        )
+        if selection.lower() == "q":
+            return None
+        try:
+            selection = int(selection)
+            if 1 <= selection <= len(chats):
+                return chats[selection - 1]
+            click.echo("Invalid selection. Please try again.")
+        except ValueError:
+            click.echo("Invalid input. Please enter a number or 'q' to quit.")
+
+
+def confirm_and_delete_chat(provider, organization_id, chat):
+    """Confirm deletion with the user and delete the selected chat."""
+    if click.confirm(
+        f"Are you sure you want to delete the chat '{chat.get('name', 'Unnamed')}'?"
+    ):
+        deleted, _ = delete_chats(provider, organization_id, [chat["uuid"]])
+        if deleted:
+            click.echo(f"Successfully deleted chat: {chat.get('name', 'Unnamed')}")
+        else:
+            click.echo(f"Failed to delete chat: {chat.get('name', 'Unnamed')}")
+
+
+@chat.command()
+@click.option("--name", default="", help="Name of the chat conversation")
+@click.option("--project", help="UUID of the project to associate the chat with")
+@click.pass_obj
+@handle_errors
+def init(config, name, project):
+    """Initializes a new chat conversation on the active provider."""
+    provider = validate_and_get_provider(config)
+    organization_id = config.get("active_organization_id")
+    active_project_id = config.get("active_project_id")
+    active_project_name = config.get("active_project_name")
+    local_path = config.get("local_path")
+
+    if not organization_id:
+        click.echo("No active organization set.")
+        return
+
+    if not project:
+        project = select_project(
+            active_project_id,
+            active_project_name,
+            local_path,
+            organization_id,
+            provider,
+        )
+        if project is None:
+            return
+
+    try:
+        new_chat = provider.create_chat(
+            organization_id, chat_name=name, project_uuid=project
+        )
+        click.echo(f"Created new chat conversation: {new_chat['uuid']}")
+        if name:
+            click.echo(f"Chat name: {name}")
+        click.echo(f"Associated project: {project}")
+    except Exception as e:
+        click.echo(f"Failed to create chat conversation: {str(e)}")
+
+
+def process_message_event(event):
+    """Process a single streaming event from the message response."""
+    # Handle new API format (content_block_delta with text_delta)
+    if event.get("type") == "content_block_delta":
+        delta = event.get("delta", {})
+        if delta.get("type") == "text_delta":
+            click.echo(delta.get("text", ""), nl=False)
+    # Handle legacy format (for backward compatibility)
+    elif "completion" in event:
+        click.echo(event["completion"], nl=False)
+    elif "content" in event:
+        click.echo(event["content"], nl=False)
+    elif "error" in event:
+        click.echo(f"\nError: {event['error']}")
+    elif "message_limit" in event:
+        click.echo(f"\nRemaining messages: {event['message_limit']['remaining']}")
+
+
+@chat.command()
+@click.argument("message", nargs=-1, required=True)
+@click.option("--chat", help="UUID of the chat to send the message to")
+@click.option("--timezone", default="UTC", help="Timezone for the message")
+@click.option(
+    "--model",
+    help="Model to use for the conversation. Available options:\n"
+    + "- claude-3-5-haiku-20241022\n"
+    + "- claude-3-opus-20240229\n"
+    + "Or any custom model string. If not specified, uses the default model.",
+)
+@click.pass_obj
+@handle_errors
+def message(config, message, chat, timezone, model):
+    """Send a message to a specified chat or create a new chat and send the message."""
+    provider = validate_and_get_provider(config, require_project=True)
+    active_organization_id = config.get("active_organization_id")
+    active_project_id = config.get("active_project_id")
+    active_project_name = config.get("active_project_name")
+
+    message = " ".join(message)  # Join all message parts into a single string
+
+    try:
+        chat = create_chat(
+            config,
+            active_project_id,
+            active_project_name,
+            chat,
+            active_organization_id,
+            provider,
+            model,
+        )
+        if chat is None:
+            return
+
+        # Send message and process the streaming response
+        for event in provider.send_message(
+            active_organization_id, chat, message, timezone, model
+        ):
+            process_message_event(event)
+
+        click.echo()  # Print a newline at the end of the response
+
+    except Exception as e:
+        click.echo(f"Failed to send message: {str(e)}")
+
+
+def create_chat(
+    config,
+    active_project_id,
+    active_project_name,
+    chat,
+    active_organization_id,
+    provider,
+    model,
+):
+    if not chat:
+        if not active_project_name:
+            active_project_id = select_project(
+                config,
+                active_project_id,
+                active_project_name,
+                active_organization_id,
+                provider,
+            )
+        if active_project_id is None:
+            return None
+
+        # Create a new chat with the selected project
+        new_chat = provider.create_chat(
+            active_organization_id, project_uuid=active_project_id, model=model
+        )
+        chat = new_chat["uuid"]
+        click.echo(f"New chat created with ID: {chat}")
+    return chat
+
+
+def select_project(
+    config, active_project_id, active_project_name, active_organization_id, provider
+):
+    all_projects = provider.get_projects(active_organization_id)
+    if not all_projects:
+        click.echo("No projects found in the active organization.")
+        return None
+
+    # Filter projects to include only the active project and its submodules
+    filtered_projects = [
+        p
+        for p in all_projects
+        if p["id"] == active_project_id
+        or (
+            p["name"].startswith(f"{active_project_name}-SubModule-")
+            and not p.get("archived_at")
+        )
+    ]
+
+    if not filtered_projects:
+        click.echo("No active project or related submodules found.")
+        return None
+
+    # Determine the current working directory
+    current_dir = os.path.abspath(os.getcwd())
+
+    default_project = get_default_project(
+        config, active_project_id, active_project_name, current_dir, filtered_projects
+    )
+
+    click.echo("Available projects:")
+    for idx, proj in enumerate(filtered_projects, 1):
+        project_type = (
+            "Active Project" if proj["id"] == active_project_id else "Submodule"
+        )
+        default_marker = " (default)" if idx - 1 == default_project else ""
+        click.echo(
+            f"{idx}. {proj['name']} (ID: {proj['id']}) - {project_type}{default_marker}"
+        )
+
+    while True:
+        prompt = "Enter the number of the project to associate with the chat"
+        if default_project is not None:
+            default_project_name = filtered_projects[default_project]["name"]
+            prompt += f" (default: {default_project + 1} - {default_project_name})"
+        selection = click.prompt(
+            prompt,
+            type=int,
+            default=default_project + 1 if default_project is not None else None,
+        )
+        if 1 <= selection <= len(filtered_projects):
+            project = filtered_projects[selection - 1]["id"]
+            break
+        click.echo("Invalid selection. Please try again.")
+    return project
+
+
+def get_default_project(
+    config, active_project_id, active_project_name, current_dir, filtered_projects
+):
+    local_path = config.get("local_path")
+    if not local_path:
+        return None
+
+    # Find the project that matches the current directory
+    default_project = None
+    for idx, proj in enumerate(filtered_projects):
+        if proj["id"] == active_project_id:
+            project_path = os.path.abspath(local_path)
+        else:
+            submodule_name = proj["name"].replace(
+                f"{active_project_name}-SubModule-", ""
+            )
+            project_path = os.path.abspath(
+                os.path.join(local_path, "services", submodule_name)
+            )
+        if current_dir.startswith(project_path):
+            default_project = idx
+            break
+    return default_project