ctxsync 0.8.0__py3-none-any.whl

ctxsync/cli/submodule.py

@@ -0,0 +1,148 @@
+import json
+import os
+
+import click
+from ctxsync.exceptions import ProviderError
+from ..utils import (
+    handle_errors,
+    validate_and_get_provider,
+    detect_submodules,
+)
+
+
+@click.group()
+def submodule():
+    """Manage submodules within the current project."""
+    pass
+
+
+@submodule.command()
+@click.pass_obj
+@handle_errors
+def ls(config):
+    """List all detected submodules in the current project."""
+    local_path = config.get_local_path()
+    if not local_path:
+        click.echo(
+            "No local project path found. Please select an existing project or create a new one using "
+            "'ctxsync project select' or 'ctxsync project create'."
+        )
+        return
+
+    submodule_detect_filenames = config.get("submodule_detect_filenames", [])
+    submodules = detect_submodules(local_path, submodule_detect_filenames)
+
+    if not submodules:
+        click.echo("No submodules detected in the current project.")
+    else:
+        click.echo("Detected submodules:")
+        for submodule, detected_file in submodules:
+            click.echo(f"  - {submodule} [{detected_file}]")
+
+
+@submodule.command()
+@click.pass_obj
+@handle_errors
+def create(config):
+    """Creates new projects for each detected submodule that doesn't already exist remotely."""
+    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")
+    local_path = config.get_local_path()
+
+    if not local_path:
+        click.echo(
+            "No local project path found. Please select an existing project or create a new one using "
+            "'ctxsync project select' or 'ctxsync project create'."
+        )
+        return
+
+    submodule_detect_filenames = config.get("submodule_detect_filenames", [])
+    submodules_with_files = detect_submodules(local_path, submodule_detect_filenames)
+
+    if not submodules_with_files:
+        click.echo("No submodules detected in the current project.")
+        return
+
+    # Fetch all remote projects
+    all_remote_projects = provider.get_projects(
+        active_organization_id, include_archived=False
+    )
+
+    click.echo(
+        f"Detected {len(submodules_with_files)} submodule(s). Checking for existing remote projects:"
+    )
+
+    # Load existing local config (the project may still use a legacy .claudesync dir)
+    local_config_path = os.path.join(local_path, ".ctxsync", "config.local.json")
+    if not os.path.exists(local_config_path):
+        legacy_path = os.path.join(local_path, ".claudesync", "config.local.json")
+        if os.path.exists(legacy_path):
+            local_config_path = legacy_path
+    with open(local_config_path, "r") as f:
+        local_config = json.load(f)
+
+    # Initialize submodules list if it doesn't exist
+    if "submodules" not in local_config:
+        local_config["submodules"] = []
+
+    for i, (submodule, detected_file) in enumerate(submodules_with_files, 1):
+        submodule_name = os.path.basename(submodule)
+        new_project_name = f"{active_project_name}-SubModule-{submodule_name}"
+
+        # Check if the submodule project already exists
+        existing_project = next(
+            (p for p in all_remote_projects if p["name"] == new_project_name), None
+        )
+
+        if existing_project:
+            click.echo(
+                f"{i}. Submodule '{submodule_name}' already exists as project "
+                f"'{new_project_name}' (ID: {existing_project['id']}). Updating local config."
+            )
+            project_id = existing_project["id"]
+        else:
+            description = f"Submodule '{submodule_name}' for project '{active_project_name}' (ID: {active_project_id})"
+            try:
+                new_project = provider.create_project(
+                    active_organization_id, new_project_name, description
+                )
+                project_id = new_project["uuid"]
+                click.echo(
+                    f"{i}. Created project '{new_project_name}' (ID: {project_id}) for submodule '{submodule_name}'"
+                )
+            except ProviderError as e:
+                click.echo(
+                    f"Failed to create project for submodule '{submodule_name}': {str(e)}"
+                )
+                continue
+
+        # Update or add submodule information in local config
+        submodule_config = {
+            "active_provider": config.get("active_provider"),
+            "active_organization_id": active_organization_id,
+            "active_project_id": project_id,
+            "active_project_name": new_project_name,
+            "relative_path": submodule,
+        }
+
+        # Check if submodule already exists in config and update it, or append new entry
+        submodule_index = next(
+            (
+                index
+                for (index, d) in enumerate(local_config["submodules"])
+                if d["relative_path"] == submodule
+            ),
+            None,
+        )
+        if submodule_index is not None:
+            local_config["submodules"][submodule_index] = submodule_config
+        else:
+            local_config["submodules"].append(submodule_config)
+
+    # Save updated local config
+    with open(local_config_path, "w") as f:
+        json.dump(local_config, f, indent=2)
+
+    click.echo("\nSubmodule project creation and configuration update completed.")

ctxsync/cli/sync.py

@@ -0,0 +1,79 @@
+import os
+import shutil
+import sys
+import click
+from crontab import CronTab
+
+from ..utils import handle_errors, validate_and_get_provider
+
+
+@click.command()
+@click.pass_obj
+@handle_errors
+def ls(config):
+    """List files in the active remote project."""
+    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")
+    files = provider.list_files(active_organization_id, active_project_id)
+    if not files:
+        click.echo("No files found in the active project.")
+    else:
+        click.echo(
+            f"Files in project '{config.get('active_project_name')}' (ID: {active_project_id}):"
+        )
+        for file in files:
+            click.echo(
+                f"  - {file['file_name']} (ID: {file['uuid']}, Created: {file['created_at']})"
+            )
+
+
+def validate_local_path(local_path):
+    if not local_path:
+        click.echo(
+            "No local path set. Please select or create a project to set the local path."
+        )
+        sys.exit(1)
+    if not os.path.exists(local_path):
+        click.echo(f"The configured local path does not exist: {local_path}")
+        click.echo("Please update the local path by selecting or creating a project.")
+        sys.exit(1)
+
+
+@click.command()
+@click.pass_obj
+@click.option(
+    "--interval", type=int, default=5, prompt="Enter sync interval in minutes"
+)
+@handle_errors
+def schedule(config, interval):
+    """Set up automated synchronization at regular intervals."""
+    ctxsync_path = shutil.which("ctxsync")
+    if not ctxsync_path:
+        click.echo(
+            "Error: ctxsync not found in PATH. Please ensure it's installed correctly."
+        )
+        sys.exit(1)
+
+    if sys.platform.startswith("win"):
+        setup_windows_task(ctxsync_path, interval)
+    else:
+        setup_unix_cron(ctxsync_path, interval)
+
+
+def setup_windows_task(ctxsync_path, interval):
+    click.echo("Windows Task Scheduler setup:")
+    command = f'schtasks /create /tn "ctxsync" /tr "{ctxsync_path} sync" /sc minute /mo {interval}'
+    click.echo(f"Run this command to create the task:\n{command}")
+    click.echo('\nTo remove the task, run: schtasks /delete /tn "ctxsync" /f')
+
+
+def setup_unix_cron(ctxsync_path, interval):
+    cron = CronTab(user=True)
+    job = cron.new(command=f"{ctxsync_path} sync")
+    job.minute.every(interval)
+    cron.write()
+    click.echo(f"Cron job created successfully! It will run every {interval} minutes.")
+    click.echo(
+        "\nTo remove the cron job, run: crontab -e and remove the line for ctxsync"
+    )

ctxsync/compression.py

@@ -0,0 +1,302 @@
+import json
+import zlib
+import bz2
+import lzma
+import base64
+import brotli
+from collections import Counter
+import os
+import io
+import heapq
+
+
+def compress_files(local_path, local_files, algorithm):
+    packed_content = _pack_files(local_path, local_files)
+    return compress_content(packed_content, algorithm)
+
+
+def decompress_files(local_path, compressed_content, algorithm):
+    decompressed_content = decompress_content(compressed_content, algorithm)
+    _unpack_files(local_path, decompressed_content)
+
+
+def _pack_files(local_path, local_files):
+    packed_content = io.StringIO()
+    for file_path, file_hash in local_files.items():
+        full_path = os.path.join(local_path, file_path)
+        with open(full_path, "r", encoding="utf-8") as f:
+            content = f.read()
+        packed_content.write(f"--- BEGIN FILE: {file_path} ---\n")
+        packed_content.write(content)
+        packed_content.write(f"\n--- END FILE: {file_path} ---\n")
+    return packed_content.getvalue()
+
+
+def _unpack_files(local_path, decompressed_content):
+    current_file = None
+    current_content = io.StringIO()
+
+    for line in decompressed_content.splitlines():
+        if line.startswith("--- BEGIN FILE:"):
+            if current_file:
+                _write_file(local_path, current_file, current_content.getvalue())
+                current_content = io.StringIO()
+            current_file = line.split("--- BEGIN FILE:")[1].strip()
+        elif line.startswith("--- END FILE:"):
+            if current_file:
+                _write_file(local_path, current_file, current_content.getvalue())
+                current_file = None
+                current_content = io.StringIO()
+        else:
+            current_content.write(line + "\n")
+
+    if current_file:
+        _write_file(local_path, current_file, current_content.getvalue())
+
+
+def _write_file(local_path, file_path, content):
+    full_path = os.path.join(local_path, file_path)
+    os.makedirs(os.path.dirname(full_path), exist_ok=True)
+    with open(full_path, "w", encoding="utf-8") as f:
+        f.write(content)
+
+
+def compress_content(content, algorithm):
+    compressors = {
+        "zlib": zlib_compress,
+        "bz2": bz2_compress,
+        "lzma": lzma_compress,
+        "brotli": brotli_compress,  # Add Brotli to compressors
+        "dictionary": dictionary_compress,
+        "rle": rle_compress,
+        "huffman": huffman_compress,
+        "lzw": lzw_compress,
+        "pack": no_compress,
+    }
+    if algorithm in compressors:
+        return compressors[algorithm](content)
+    else:
+        return content  # No compression
+
+
+def decompress_content(compressed_content, algorithm):
+    decompressors = {
+        "zlib": zlib_decompress,
+        "bz2": bz2_decompress,
+        "lzma": lzma_decompress,
+        "brotli": brotli_decompress,  # Add Brotli to decompressors
+        "dictionary": dictionary_decompress,
+        "rle": rle_decompress,
+        "huffman": huffman_decompress,
+        "lzw": lzw_decompress,
+        "pack": no_decompress,
+    }
+    if algorithm in decompressors:
+        return decompressors[algorithm](compressed_content)
+    else:
+        return compressed_content  # No decompression
+
+
+# Pack compression
+def no_compress(text):
+    return text
+
+
+def no_decompress(compressed_text):
+    return compressed_text
+
+
+# Brotli compression
+def brotli_compress(text):
+    compressed = brotli.compress(text.encode("utf-8"))
+    return base64.b64encode(compressed).decode("ascii")
+
+
+def brotli_decompress(compressed_text):
+    decoded = base64.b64decode(compressed_text.encode("ascii"))
+    return brotli.decompress(decoded).decode("utf-8")
+
+
+# Zlib compression
+def zlib_compress(text):
+    compressed = zlib.compress(text.encode("utf-8"))
+    return base64.b64encode(compressed).decode("ascii")
+
+
+def zlib_decompress(compressed_text):
+    decoded = base64.b64decode(compressed_text.encode("ascii"))
+    return zlib.decompress(decoded).decode("utf-8")
+
+
+# BZ2 compression
+def bz2_compress(text):
+    compressed = bz2.compress(text.encode("utf-8"))
+    return base64.b64encode(compressed).decode("ascii")
+
+
+def bz2_decompress(compressed_text):
+    decoded = base64.b64decode(compressed_text.encode("ascii"))
+    return bz2.decompress(decoded).decode("utf-8")
+
+
+# LZMA compression
+def lzma_compress(text):
+    compressed = lzma.compress(text.encode("utf-8"))
+    return base64.b64encode(compressed).decode("ascii")
+
+
+def lzma_decompress(compressed_text):
+    decoded = base64.b64decode(compressed_text.encode("ascii"))
+    return lzma.decompress(decoded).decode("utf-8")
+
+
+# Dictionary-based compression
+def dictionary_compress(text):
+    words = text.split()
+    dictionary = {}
+    compressed = []
+
+    for word in words:
+        if word not in dictionary:
+            dictionary[word] = str(len(dictionary))
+        compressed.append(dictionary[word])
+
+    return json.dumps({"dict": dictionary, "compressed": " ".join(compressed)})
+
+
+def dictionary_decompress(compressed_text):
+    data = json.loads(compressed_text)
+    dictionary = {v: k for k, v in data["dict"].items()}
+    return " ".join(dictionary[token] for token in data["compressed"].split())
+
+
+# Run-length encoding (RLE)
+def rle_compress(text):
+    compressed = []
+    count = 1
+    for i in range(1, len(text)):
+        if text[i] == text[i - 1]:
+            count += 1
+        else:
+            compressed.append((text[i - 1], count))
+            count = 1
+    compressed.append((text[-1], count))
+    return json.dumps(compressed)
+
+
+def rle_decompress(compressed_text):
+    compressed = json.loads(compressed_text)
+    return "".join(char * count for char, count in compressed)
+
+
+# Huffman coding
+class HuffmanNode:
+    def __init__(self, char, freq):
+        self.char = char
+        self.freq = freq
+        self.left = None
+        self.right = None
+
+    def __lt__(self, other):
+        return self.freq < other.freq
+
+
+def huffman_compress(text):
+    freq = Counter(text)
+    heap = [HuffmanNode(char, freq) for char, freq in freq.items()]
+    heapq.heapify(heap)
+
+    while len(heap) > 1:
+        left = heapq.heappop(heap)
+        right = heapq.heappop(heap)
+        merged = HuffmanNode(None, left.freq + right.freq)
+        merged.left = left
+        merged.right = right
+        heapq.heappush(heap, merged)
+
+    root = heap[0]
+    codes = {}
+
+    def generate_codes(node, code):
+        if node.char:
+            codes[node.char] = code
+            return
+        generate_codes(node.left, code + "0")
+        generate_codes(node.right, code + "1")
+
+    generate_codes(root, "")
+
+    encoded = "".join(codes[char] for char in text)
+    padding = 8 - len(encoded) % 8
+    encoded += "0" * padding
+
+    compressed = bytearray()
+    for i in range(0, len(encoded), 8):
+        byte = encoded[i : i + 8]
+        compressed.append(int(byte, 2))
+
+    return json.dumps(
+        {
+            "tree": {char: code for char, code in codes.items()},
+            "padding": padding,
+            "data": base64.b64encode(compressed).decode("ascii"),
+        }
+    )
+
+
+def huffman_decompress(compressed_text):
+    data = json.loads(compressed_text)
+    tree = {code: char for char, code in data["tree"].items()}
+    padding = data["padding"]
+    compressed = base64.b64decode(data["data"].encode("ascii"))
+
+    binary = "".join(f"{byte:08b}" for byte in compressed)
+    binary = binary[:-padding] if padding else binary
+
+    decoded = ""
+    code = ""
+    for bit in binary:
+        code += bit
+        if code in tree:
+            decoded += tree[code]
+            code = ""
+
+    return decoded
+
+
+# LZW compression
+def lzw_compress(text):
+    dictionary = {chr(i): i for i in range(256)}
+    result = []
+    w = ""
+    for c in text:
+        wc = w + c
+        if wc in dictionary:
+            w = wc
+        else:
+            result.append(dictionary[w])
+            dictionary[wc] = len(dictionary)
+            w = c
+    if w:
+        result.append(dictionary[w])
+    return base64.b64encode(bytes(result)).decode("ascii")
+
+
+def lzw_decompress(compressed_text):
+    compressed = base64.b64decode(compressed_text.encode("ascii"))
+    dictionary = {i: chr(i) for i in range(256)}
+    result = []
+    w = chr(compressed[0])
+    result.append(w)
+    for i in range(1, len(compressed)):
+        k = compressed[i]
+        if k in dictionary:
+            entry = dictionary[k]
+        elif k == len(dictionary):
+            entry = w + w[0]
+        else:
+            raise ValueError("Bad compressed k: %s" % k)
+        result.append(entry)
+        dictionary[len(dictionary)] = w + entry[0]
+        w = entry
+    return "".join(result)

ctxsync/configmanager/__init__.py

@@ -0,0 +1,5 @@
+from .base_config_manager import BaseConfigManager
+from .file_config_manager import FileConfigManager
+from .inmemory_config_manager import InMemoryConfigManager
+
+__all__ = ["BaseConfigManager", "FileConfigManager", "InMemoryConfigManager"]