codedthemes-cli 0.1.0__py3-none-any.whl

codedthemes/__init__.py

@@ -0,0 +1,4 @@
+from .config import load_config, save_config
+from .mcp_client import MCPClient
+from .repo_utils import detect_repo_root, zip_repo
+from .patch_utils import apply_patch

codedthemes/cli.py

@@ -0,0 +1,372 @@
+import argparse
+import sys
+import os
+import jwt
+import requests
+import json
+import shutil
+from getpass import getpass
+
+from .config import save_config, load_config
+from .mcp_client import MCPClient
+from .repo_utils import detect_repo_root, zip_repo
+from .patch_utils import apply_patch
+from .sync_manager import SyncManager
+
+
+def handle_login(server_url: str = None):
+    email = input("Email: ").strip()
+    license_key = input("License key: ").strip()
+    
+    client = MCPClient()
+    if server_url:
+        client.server_url = server_url
+
+    try:
+        result = client.call("login", {
+            "email": email,
+            "license_key": license_key
+        })
+        
+
+        if isinstance(result, dict):
+            # The server might have returned {"status": "error", "message": ...}
+            if result.get("status") == "error":
+                print(f"✖ Login failed: {result.get('message', 'Unknown error')}")
+                sys.exit(1)
+            # The app.py bridge wraps string returns in {"message": "..."}
+            elif "message" in result and "Login failed" in result["message"]:
+                print(f"✖ {result['message']}")
+                sys.exit(1)
+
+        # 1. Try to get token directly from API response (if server returns JSON)
+        token = result.get("access_token") if isinstance(result, dict) else None
+        
+        # 2. Fallback: Try to read from local file (because server now returns plain text string)
+        if not token:
+            token_file = os.path.expanduser("~/.mcp_token")
+            if os.path.exists(token_file):
+                with open(token_file, 'r') as f:
+                    token = f.read().strip()
+                    
+        # 3. Final Verification: Throw error if we STILL don't have a token
+        if not token:
+            print("✖ Login failed: No access token returned. Please check your credentials.")
+            sys.exit(1)
+
+        # Write the .mcp_token file natively for the user so it acts just like local MCP
+        token_file = os.path.expanduser("~/.mcp_token")
+        try:
+            with open(token_file, 'w') as f:
+                f.write(token)
+        except Exception as e:
+            print(f"Warning: Could not write {token_file}: {e}")
+
+        save_config({
+            "server_url": client.server_url,
+            "access_token": token
+        })
+
+        print("✔ Login successful.")
+    except Exception as e:
+        err_msg = str(e)
+        if "timed out" in err_msg.lower():
+            print(f"✖ Login failed: License server connection timed out. Please try again.")
+        else:
+            print(f"✖ Login failed: {err_msg}")
+        sys.exit(1)
+
+
+def handle_init():
+    try:
+        repo_root = detect_repo_root()
+        print(f"🔍 Found repository at {repo_root}")
+        
+        client = MCPClient()
+        if not client.token:
+            print("✖ Not logged in. Please run 'codedthemes login' first.")
+            sys.exit(1)
+
+        # 0. Get user email from token for registry profiling
+        user_email = "unknown_user"
+        try:
+            decoded = jwt.decode(client.token, options={"verify_signature": False})
+            user_email = decoded.get("email", "unknown_user")
+        except:
+            pass
+
+        repo_abs_path = str(repo_root)
+        print("📦 Zipping and uploading repository (this may take a moment)...")
+        upload_result = client.upload_workspace(repo_abs_path, user_email)
+        workspace_id = upload_result.get("workspace_id")
+        
+        if not workspace_id:
+            print("✖ Upload failed: No workspace ID returned.")
+            sys.exit(1)
+
+        # 1. Save workspace mapping in config.json
+        config = load_config()
+        last_workspaces = config.get("workspaces", {})
+        last_workspaces[repo_abs_path] = workspace_id
+        config["workspaces"] = last_workspaces
+        save_config(config)
+
+        # 2. Initialize sync state (HASHES) in workspace.json
+        sync_manager = SyncManager()
+        sync_manager.update_sync_state(repo_abs_path, workspace_id, user_email)
+
+        print(f"✔ Workspace initialized successfully.")
+        print(f"✔ Workspace ID: {workspace_id}")
+        print("\nYour repository is now synced to the cloud. You can now use the IDE to plan and apply changes.")
+        
+    except Exception as e:
+        print(f"✖ Error during initialization: {e}")
+        sys.exit(1)
+
+
+def handle_apply(query: str):
+    try:
+        repo_root = detect_repo_root()
+        print(f"🔍 Found repository at {repo_root}")
+        
+        # Note: zipping logic is there but we are calling tools sequentially as per requirements
+        # zip_path = zip_repo(repo_root)
+
+        client = MCPClient()
+        
+        # 0. Get user email from token for registry profiling
+        user_email = "unknown_user"
+        if client.token:
+            try:
+                decoded = jwt.decode(client.token, options={"verify_signature": False})
+                user_email = decoded.get("email", "unknown_user")
+            except:
+                pass
+
+        sync_manager = SyncManager()
+
+        config = load_config()
+        last_workspaces = config.get("workspaces", {})
+        repo_abs_path = str(repo_root)
+        workspace_id = last_workspaces.get(repo_abs_path)
+        
+        # 1. Zip and Upload Repository (Only if not already initialized or expired)
+        if workspace_id:
+            logger_debug = False # toggle for debug
+            try:
+                # Quick check if workspace is still on server
+                check = client.call("check_workspace", {"workspace_id": workspace_id})
+                if isinstance(check, dict) and check.get("status") == "ok":
+                    print(f"✔ Using active workspace: {workspace_id}")
+                else:
+                    workspace_id = None
+            except:
+                workspace_id = None
+
+        if not workspace_id:
+            print("📦 Zipping and uploading repository (this may take a moment)...")
+            upload_result = client.upload_workspace(repo_abs_path, user_email)
+            workspace_id = upload_result.get("workspace_id")
+            
+            # Save workspace_id for future reuse
+            last_workspaces[repo_abs_path] = workspace_id
+            config["workspaces"] = last_workspaces
+            save_config(config)
+
+            # Init sync state locally
+            sync_manager.update_sync_state(repo_abs_path, workspace_id, user_email)
+
+        # Step 1: repo analyzer
+        print("🚀 Analyzing repository...")
+        analysis = client.call("repo_analyzer", {
+            "repo_path": repo_abs_path,
+            "workspace_id": workspace_id
+        })
+
+        if isinstance(analysis, dict) and analysis.get("status") == "error":
+            print(f"✖ Analysis failed: {analysis.get('message', 'Unknown error')}")
+            return
+        
+        if isinstance(analysis, str):
+            # The tool might return a string message shown in CLI
+            if "Analysis Skipped" in analysis:
+                print("✔ Repository is up-to-date. Skipping upload.")
+            else:
+                print(f"✔ {analysis}")
+
+        # Step 2: plan changes
+        print("🔍 Detecting local changes...")
+        local_changes = sync_manager.get_changed_files(repo_abs_path, user_email)
+        if local_changes:
+            print(f"   Detected {len(local_changes)} files changed locally since last apply.")
+
+        print("🧠 Planning changes...")
+        plan = client.call("plan_changes", {
+            "query": query,
+            "workspace_id": workspace_id,
+            "repo_path": str(repo_root),
+            "changes_from_cli": local_changes
+        })
+
+        if plan.get("status") == "error":
+            print(f"✖ Planning failed: {plan.get('message', 'Unknown error')}")
+            return
+
+        target_files = plan.get("files_to_modify", [])
+        plan_instructions = plan.get("plan_instructions", [])
+        files_to_create = plan.get("files_to_create", [])
+        files_to_delete = plan.get("files_to_delete", [])
+
+        if not target_files and not files_to_create and not files_to_delete and not plan_instructions:
+            print("Information: No changes planned.")
+            return
+
+        print("\n📝 Execution Plan:")
+        if plan_instructions:
+            print("Instructions:")
+            for idx, inst in enumerate(plan_instructions, 1):
+                print(f"  {idx}. {inst}")
+        
+        if files_to_create:
+            print("\nFiles to create:")
+            for f in files_to_create:
+                print(f"  + {f}")
+                
+            print("\nFiles to modify:")
+            for f in target_files:
+                print(f"  ~ {f}")
+                
+        if files_to_delete:
+            print("\nFiles to delete:")
+            for f in files_to_delete:
+                print(f"  - {f}")
+
+        while True:
+            choice = input("\nDo you want to proceed with this plan? (y/n): ").strip().lower()
+            if choice in ['y', 'yes']:
+                break
+            elif choice in ['n', 'no']:
+                print("✖ Pipeline terminated by user. Please provide a new query.")
+                return
+            else:
+                print("Please enter 'y' for yes or 'n' for no.")
+
+        # Step 3: execute plan
+        print("⚙ Executing plan...")
+        result = client.call("execute_plan", {
+            "query": query,
+            "plan_instructions": plan_instructions,
+            "files_to_modify": target_files,
+            "files_to_create": files_to_create,
+            "files_to_delete": files_to_delete,
+            "workspace_id": workspace_id,
+            "repo_path": str(repo_root)
+        })
+
+        if not result or (isinstance(result, dict) and (result.get("status") == "error" or "detail" in result)):
+             error_msg = result.get("message") or result.get("detail") if isinstance(result, dict) else "Unknown execution error"
+             print(f"✖ Execution failed: {error_msg}")
+             return
+
+        # --- LOCAL PATCHING LOGIC (WINDOWS) ---
+        # Ensure we are looking at a dictionary
+        res_data = result
+        if isinstance(result, str):
+            try: res_data = json.loads(result)
+            except: res_data = {}
+
+        updates = res_data.get("updates_for_local", [])
+        deletes = res_data.get("deleted_files", [])
+        
+        if not updates:
+            print("  (!) No file updates received in the response payload.")
+        
+        if updates or deletes:
+            # 1. Update/Create files
+            for item in updates:
+                rel_path, code = item.get("path"), item.get("code")
+                if not rel_path or code is None: continue
+                
+                # Normalize path for Windows
+                clean_rel_path = rel_path.replace('/', os.sep)
+                abs_path = os.path.abspath(os.path.join(str(repo_root), clean_rel_path))
+                
+                try:
+                    os.makedirs(os.path.dirname(abs_path), exist_ok=True)
+                    with open(abs_path, 'w', encoding='utf-8') as f:
+                        f.write(code)
+                    print(f"✔ Updated local file: {rel_path}")
+                except Exception as write_err:
+                    print(f"✖ Error writing {rel_path}: {write_err}")
+                    
+            # 2. Delete files
+            for rel_path in (deletes or []):
+                clean_rel_path = rel_path.replace('/', os.sep)
+                abs_path = os.path.normpath(os.path.join(str(repo_root), clean_rel_path))
+                if os.path.exists(abs_path) and abs_path.startswith(os.path.abspath(str(repo_root))):
+                    try:
+                        if os.path.isfile(abs_path): os.remove(abs_path)
+                        elif os.path.isdir(abs_path): shutil.rmtree(abs_path)
+                        print(f"✔ Deleted local file/folder: {rel_path}")
+                    except: pass
+            
+            # Finally, update the sync state so these aren't treated as local user changes next time
+            sync_manager.update_sync_state(repo_abs_path, workspace_id, user_email)
+            print("✔ Local sync state updated.")
+
+            # Display granular report details if available
+            _details_raw = res_data.get("details", [])
+            details_list = _details_raw.get("report", []) if isinstance(_details_raw, dict) else (_details_raw if isinstance(_details_raw, list) else [])
+            if details_list:
+                print("\n📊 Integration Report:")
+                for item in details_list:
+                    status_icon = "✔" if item.get("success") else "✖"
+                    f_name = item.get("file_path")
+                    msg = item.get("message", "")
+                    print(f"  [{status_icon}] {f_name}: {msg}")
+        else:
+            # Fallback for display
+            msg = res_data.get("message", "Changes applied successfully (no local updates needed).")
+            print(f"✔ {msg}")
+            
+            # If there was a report but no updates (already up to date), display why
+            _details_raw = res_data.get("details", [])
+            details_list = _details_raw.get("report", []) if isinstance(_details_raw, dict) else (_details_raw if isinstance(_details_raw, list) else [])
+            if details_list:
+                print("\n📊 Integration Report (Files already up-to-date):")
+                for item in details_list:
+                    status_icon = "✔" if item.get("success") else "✖"
+                    f_name = item.get("file_path")
+                    msg = item.get("message", "")
+                    print(f"  [{status_icon}] {f_name}: {msg}")
+    except Exception as e:
+        print(f"✖ Error: {e}")
+        sys.exit(1)
+
+
+def main():
+    parser = argparse.ArgumentParser(prog="codedthemes", description="CodedThemes CLI client")
+    subparsers = parser.add_subparsers(dest="command")
+
+    login_parser = subparsers.add_parser("login", help="Login to MCP server")
+    login_parser.add_argument("--server", help="MCP server URL")
+
+    apply_parser = subparsers.add_parser("apply", help="Apply changes based on a query")
+    apply_parser.add_argument("query", help="The description of changes you want to make")
+
+    init_parser = subparsers.add_parser("init", help="Initialize and upload repository to the cloud")
+
+    args = parser.parse_args()
+
+    if args.command == "login":
+        handle_login(args.server)
+    elif args.command == "init":
+        handle_init()
+    elif args.command == "apply":
+        handle_apply(args.query)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

codedthemes/config.py

@@ -0,0 +1,26 @@
+import json
+from pathlib import Path
+
+# Stores token at ~/.codedthemes/config.json
+CONFIG_DIR = Path.home() / ".codedthemes"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+
+def ensure_config_dir():
+    CONFIG_DIR.mkdir(exist_ok=True)
+
+
+def save_config(data: dict):
+    ensure_config_dir()
+    with open(CONFIG_FILE, "w") as f:
+        json.dump(data, f, indent=2)
+
+
+def load_config():
+    if not CONFIG_FILE.exists():
+        return {}
+    with open(CONFIG_FILE, "r") as f:
+        try:
+            return json.load(f)
+        except json.JSONDecodeError:
+            return {}

codedthemes/mcp_client.py

@@ -0,0 +1,64 @@
+import os
+import requests
+from .config import load_config
+
+class MCPClient:
+    def __init__(self):
+        config = load_config()
+        self.server_url = (
+            os.getenv("CODEDTHEMES_SERVER")
+            or config.get("server_url")
+            or "https://mcp.codedthemes.com/"
+        )
+        self.token = config.get("access_token")
+
+    def upload_workspace(self, repo_path: str, user_id: str):
+        from .repo_utils import zip_repo
+        
+        zip_path = zip_repo(repo_path)
+        repo_name = os.path.basename(repo_path)
+        
+        headers = {}
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+
+        try:
+            with open(zip_path, 'rb') as f:
+                files = {'file': (f"{repo_name}.zip", f, 'application/zip')}
+                data = {'user_id': user_id, 'repo_name': repo_name}
+                
+                response = requests.post(
+                    f"{self.server_url}/workspaces",
+                    data=data,
+                    files=files,
+                    headers=headers,
+                    timeout=300
+                )
+                
+                if response.status_code != 200:
+                    raise Exception(f"Upload failed: {response.status_code} - {response.text}")
+                
+                return response.json()
+        finally:
+            if os.path.exists(zip_path):
+                os.remove(zip_path)
+
+    def call(self, tool_name: str, payload: dict):
+        headers = {}
+        if self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+
+        response = requests.post(
+            f"{self.server_url}/tools/{tool_name}",
+            json=payload,
+            headers=headers,
+            timeout=300
+        )
+
+        if response.status_code == 401:
+            raise Exception("Unauthorized. Please run 'codedthemes login'.")
+
+        if response.status_code != 200:
+            raise Exception(f"Server error: {response.status_code} - {response.text}")
+
+        return response.json()

codedthemes/patch_utils.py

@@ -0,0 +1,18 @@
+import subprocess
+
+
+def apply_patch(patch_text: str):
+    # Using 'git apply -' to apply from stdin
+    process = subprocess.Popen(
+        ["git", "apply", "-"],
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True
+    )
+    stdout, stderr = process.communicate(input=patch_text)
+
+    if process.returncode != 0:
+        raise Exception(f"Patch failed to apply.\nStdout: {stdout}\nStderr: {stderr}")
+
+    print("✔ Patch applied successfully.")

codedthemes/repo_utils.py

@@ -0,0 +1,40 @@
+import os
+import zipfile
+from pathlib import Path
+import tempfile
+
+
+def detect_repo_root(start_path=None):
+    if not start_path:
+        start_path = os.getcwd()
+
+    current = Path(start_path).resolve()
+
+    while current != current.parent:
+        if (current / "package.json").exists() or (current / "pyproject.toml").exists() or (current / "ai.json").exists() or (current / ".git").exists():
+            return current
+        current = current.parent
+
+    raise Exception("No repository root found.")
+
+
+def zip_repo(repo_root):
+    temp_zip = tempfile.NamedTemporaryFile(delete=False, suffix=".zip")
+    temp_zip.close() # Close so zipfile can open it
+
+    with zipfile.ZipFile(temp_zip.name, "w", zipfile.ZIP_DEFLATED) as z:
+        for root, dirs, files in os.walk(repo_root):
+            # Exclude heavy/build directories
+            exclude_dirs = {
+                "node_modules", ".git", "venv", ".next", "build", "dist", 
+                "out", ".cache", "target", ".idea", ".vscode", "__pycache__"
+            }
+            dirs[:] = [d for d in dirs if d not in exclude_dirs]
+
+            for file in files:
+                full_path = os.path.join(root, file)
+                # FORCE FORWARD SLASHES for zip entry names to ensure Linux compatibility
+                rel_path = os.path.relpath(full_path, repo_root).replace(os.sep, '/')
+                z.write(full_path, rel_path)
+
+    return temp_zip.name

codedthemes/sync_manager.py

@@ -0,0 +1,73 @@
+import os
+import json
+import hashlib
+from datetime import datetime
+
+class SyncManager:
+    """
+    Manages local file hashes to identify what files the user changed manually.
+    Ensures `.codedthemes/workspace.json` is accurately tracked across CLI runs.
+    """
+    def __init__(self):
+        self.config_dir = os.path.expanduser("~/.codedthemes")
+        self.config_file = os.path.join(self.config_dir, "workspace.json")
+        os.makedirs(self.config_dir, exist_ok=True)
+        self.workspaces = self.load()
+        
+    def load(self):
+        if os.path.exists(self.config_file):
+            try:
+                with open(self.config_file, 'r') as f: return json.load(f)
+            except: pass
+        return {}
+        
+    def save(self):
+        with open(self.config_file, 'w') as f:
+            json.dump(self.workspaces, f, indent=2)
+
+    def compute_hashes(self, repo_path):
+        hashes = {}
+        for root, dirs, files in os.walk(repo_path):
+            dirs[:] = [d for d in dirs if d not in {'.git', 'node_modules', '__pycache__', 'venv', '.next', 'build', 'dist', 'out', '.cache', 'target', '.idea', '.vscode'}]
+            for file in files:
+                abs_path = os.path.join(root, file)
+                try:
+                    hasher = hashlib.md5()
+                    with open(abs_path, 'rb') as f:
+                        while chunk := f.read(8192): hasher.update(chunk)
+                    hashes[os.path.relpath(abs_path, repo_path)] = hasher.hexdigest()
+                except Exception:
+                    pass
+        return hashes
+
+    def update_sync_state(self, repo_path, workspace_id, user_id):
+        repo_key = f"{user_id}:{os.path.abspath(repo_path)}"
+        self.workspaces[repo_key] = {
+            "workspace_id": workspace_id,
+            "repo_path": os.path.abspath(repo_path),
+            "last_sync": datetime.utcnow().isoformat(),
+            "file_hashes": self.compute_hashes(repo_path)
+        }
+        self.save()
+
+    def get_changed_files(self, repo_path, user_id):
+        repo_key = f"{user_id}:{os.path.abspath(repo_path)}"
+        if repo_key not in self.workspaces: return []
+        
+        current_hashes = self.compute_hashes(repo_path)
+        last_hashes = self.workspaces[repo_key].get("file_hashes", {})
+        changes = []
+        
+        for rel_path, fhash in current_hashes.items():
+            if rel_path not in last_hashes or last_hashes[rel_path] != fhash:
+                try:
+                    with open(os.path.join(repo_path, rel_path), 'r', encoding='utf-8', errors='ignore') as f:
+                        changes.append({"path": rel_path, "content": f.read()})
+                except Exception:
+                    pass
+                    
+        for rel_path in last_hashes:
+            if rel_path not in current_hashes:
+                changes.append({"path": rel_path, "deleted": True})
+                
+        return changes

codedthemes_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: codedthemes-cli
+Version: 0.1.0
+Summary: CLI tool for Code Theme and Integration
+Author: codedthemes
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+Requires-Dist: pyjwt
+
+# CodedThemes CLI
+
+The `codedthemes` CLI is a powerful command-line interface that allows you to interact with the CodeThemeMCP server. It enables you to analyze and modify your repositories using AI, with a focus on theme and style management.
+
+## Installation
+
+Install the CLI globally using pip:
+
+```bash
+pip install code-theme-mcp-cli
+```
+
+## Getting Started
+
+### 1. Login
+
+Before applying any changes, you must authenticate your session with the MCP Server.
+
+```bash
+codedthemes login
+```
+*You will be prompted to enter your Email and License key.*
+
+### 2. Apply Changes
+
+Navigate to your target project repository and run the `apply` command with your desired changes in quotes:
+
+```bash
+codedthemes apply "Update the theme branding from Mantis to Berry"
+```
+
+The CLI will automatically:
+1. Package and securely send your repository to the remote server for analysis.
+2. Plan the necessary code modifications using AI.
+3. Automatically apply the patches back to your local files.
+
+## Support
+
+For issues or feature requests, please contact the CodedThemes support team.

codedthemes_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+codedthemes/__init__.py,sha256=Ht0XM-dU2-qaLlJ5fPdYEPT1MazvLjbLrdhaM3MSg3k,171
+codedthemes/cli.py,sha256=n0apwHfD8YFEM7NsUYdr4l5U3Yk7jJKxREId-lQPGTw,15134
+codedthemes/config.py,sha256=HWPNq36a2CLsKCBOJdVDzbv5p4bkqPMUW0ESUIqQZPU,599
+codedthemes/mcp_client.py,sha256=kd3Lg6uDDzpYTzkuYTsER4WB29puHH-PUIRz33YP5nA,2115
+codedthemes/patch_utils.py,sha256=fDHMH4HOjqXyA48B2gJ84dxlmXw5rT9uFpOPDy902J0,525
+codedthemes/repo_utils.py,sha256=MrWd5SMZ2tbbsngbxYhRlk8Gp5HA3gIv3HN0IKyZ30s,1463
+codedthemes/sync_manager.py,sha256=S8bFhvTLyLrC5c3FATtObmQxPO-Uyj-ToXaG7w962aw,3012
+codedthemes_cli-0.1.0.dist-info/METADATA,sha256=5LGID9iggnPj99ZxTZ9Yp04VX6lGNytpgrL-pu6a_Oc,1363
+codedthemes_cli-0.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+codedthemes_cli-0.1.0.dist-info/entry_points.txt,sha256=HufkjM_3xdzJ9qOFVi3MgHz6ixTYQzZFduqSlowHbuw,53
+codedthemes_cli-0.1.0.dist-info/top_level.txt,sha256=up4mYBnkWC1EGPSzOIsG8vNRGXqU8gJCLkgd6Ua4D2k,12
+codedthemes_cli-0.1.0.dist-info/RECORD,,

codedthemes_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

codedthemes_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+codedthemes = codedthemes.cli:main

codedthemes_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+codedthemes