cecli-dev 0.98.1__tar.gz → 0.99.0__tar.gz

{cecli_dev-0.98.1 → cecli_dev-0.99.0}/.github/workflows/ubuntu-tests.yml

@@ -56,6 +56,12 @@ jobs:
           -r requirements/requirements-playwright.in \
           ".[help,playwright]"
 
+    - name: Configure Git for tests
+      run: |
+        git config --global user.name "Test User"
+        git config --global user.email "test@example.com"
+        git config --global init.defaultBranch main
+
     - name: Run tests
       run: |
         pytest

{cecli_dev-0.98.1 → cecli_dev-0.99.0}/.github/workflows/windows-tests.yml

@@ -44,6 +44,12 @@ jobs:
         pip install uv
         uv pip install --system pytest pytest-asyncio pytest-mock -r requirements/requirements.in -r requirements/requirements-help.in -r requirements/requirements-playwright.in '.[help,playwright]'
 
+    - name: Configure Git for tests
+      run: |
+        git config --global user.name "Test User"
+        git config --global user.email "test@example.com"
+        git config --global init.defaultBranch main
+
     - name: Run tests
       run: |
         pytest

{cecli_dev-0.98.1 → cecli_dev-0.99.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.98.1
+Version: 0.99.0
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli
@@ -108,6 +108,7 @@ LLMs are a part of our lives from here on out so join us in learning about and c
 * [Skills](https://github.com/dwash96/cecli/blob/main/cecli/website/docs/config/skills.md)
 * [Session Management](https://github.com/dwash96/cecli/blob/main/cecli/website/docs/sessions.md)
 * [Hooks](https://github.com/dwash96/cecli/blob/main/cecli/website/docs/config/hooks.md)
+* [Workspaces](https://github.com/dwash96/cecli/blob/main/cecli/website/docs/config/workspaces.md)
 * [Custom Commands](https://github.com/dwash96/cecli/blob/main/cecli/website/docs/config/custom-commands.md)
 * [Custom System Prompts](https://github.com/dwash96/cecli/blob/main/cecli/website/docs/config/custom-system-prompts.md)
 * [Custom Tools](https://github.com/dwash96/cecli/blob/main/cecli/website/docs/config/agent-mode.md#creating-custom-tools)

{cecli_dev-0.98.1 → cecli_dev-0.99.0}/README.md

@@ -22,6 +22,7 @@ LLMs are a part of our lives from here on out so join us in learning about and c
 * [Skills](https://github.com/dwash96/cecli/blob/main/cecli/website/docs/config/skills.md)
 * [Session Management](https://github.com/dwash96/cecli/blob/main/cecli/website/docs/sessions.md)
 * [Hooks](https://github.com/dwash96/cecli/blob/main/cecli/website/docs/config/hooks.md)
+* [Workspaces](https://github.com/dwash96/cecli/blob/main/cecli/website/docs/config/workspaces.md)
 * [Custom Commands](https://github.com/dwash96/cecli/blob/main/cecli/website/docs/config/custom-commands.md)
 * [Custom System Prompts](https://github.com/dwash96/cecli/blob/main/cecli/website/docs/config/custom-system-prompts.md)
 * [Custom Tools](https://github.com/dwash96/cecli/blob/main/cecli/website/docs/config/agent-mode.md#creating-custom-tools)

{cecli_dev-0.98.1 → cecli_dev-0.99.0}/cecli/__init__.py

@@ -1,6 +1,6 @@
 from packaging import version
 
-__version__ = "0.98.0.dev"
+__version__ = "0.99.0.dev"
 safe_version = __version__
 
 try:

{cecli_dev-0.98.1 → cecli_dev-0.99.0}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.98.1'
-__version_tuple__ = version_tuple = (0, 98, 1)
+__version__ = version = '0.99.0'
+__version_tuple__ = version_tuple = (0, 99, 0)
 
-__commit_id__ = commit_id = 'g05e9595a9'
+__commit_id__ = commit_id = 'g12b89af88'

{cecli_dev-0.98.1 → cecli_dev-0.99.0}/cecli/args.py

@@ -314,6 +314,19 @@ def get_parser(default_config_files, git_root):
         help="Specify TUI Mode configuration as a JSON string",
         default=None,
     )
+    #########
+    group = parser.add_argument_group("Workspace Settings")
+    group.add_argument(
+        "--workspaces",
+        type=str,
+        help="JSON/YAML configuration for workspace initialization",
+    )
+    group.add_argument(
+        "--workspace-name",
+        type=str,
+        help="Specify the workspace name to activate",
+    )
+
     #########
     group = parser.add_argument_group("Agent Settings")
     group.add_argument(

{cecli_dev-0.98.1 → cecli_dev-0.99.0}/cecli/coders/agent_coder.py

@@ -43,6 +43,7 @@ class AgentCoder(Coder):
     def __init__(self, *args, **kwargs):
         self.recently_removed = {}
         self.tool_usage_history = []
+        self.loaded_custom_tools = []
         self.tool_usage_retries = 20
         self.last_round_tools = []
         self.tool_call_vectors = []
@@ -90,6 +91,7 @@ class AgentCoder(Coder):
         self.agent_config = self._get_agent_config()
         self._setup_agent()
         ToolRegistry.build_registry(agent_config=self.agent_config)
+        self.loaded_custom_tools = ToolRegistry.loaded_custom_tools
         super().__init__(*args, **kwargs)
 
     def _setup_agent(self):
@@ -196,6 +198,9 @@ class AgentCoder(Coder):
 
     def show_announcements(self):
         super().show_announcements()
+        if self.loaded_custom_tools:
+            self.io.tool_output(f"Loaded custom tools: {', '.join(self.loaded_custom_tools)}")
+
         skills = self.skills_manager.find_skills()
         if skills:
             skills_list = []
@@ -295,21 +300,6 @@ class AgentCoder(Coder):
                             tasks.append(result)
                         else:
                             tasks.append(asyncio.to_thread(lambda: result))
-                elif self.mcp_tools:
-                    for server_name, server_tools in self.mcp_tools:
-                        if any(
-                            t.get("function", {}).get("name") == norm_tool_name
-                            for t in server_tools
-                        ):
-                            server = self.mcp_manager.get_server(server_name)
-                            if server:
-                                for params in parsed_args_list:
-                                    tasks.append(
-                                        self._execute_mcp_tool(server, norm_tool_name, params)
-                                    )
-                                break
-                    else:
-                        all_results_content.append(f"Error: Unknown tool name '{tool_name}'")
                 else:
                     all_results_content.append(f"Error: Unknown tool name '{tool_name}'")
                 if tasks:
@@ -1047,7 +1037,9 @@ I will proceed based on the tool results and updated context.""")
                     )
                     self.model_kwargs["frequency_penalty"] = min(0, max(freq_penalty - 0.15, 0))
 
-            self.model_kwargs["temperature"] = max(0, min(self.model_kwargs["temperature"], 1))
+            self.model_kwargs["temperature"] = max(
+                0, min(nested.getter(self.model_kwargs, "temperature", 1), 1)
+            )
             # One twentieth of the time, just straight reset the randomness
             if random.random() < 0.05:
                 self.model_kwargs = {}

{cecli_dev-0.98.1 → cecli_dev-0.99.0}/cecli/coders/base_coder.py

@@ -58,6 +58,7 @@ from cecli.reasoning_tags import (
 )
 from cecli.repo import ANY_GIT_ERROR, GitRepo
 from cecli.repomap import RepoMap
+from cecli.report import update_error_prefix
 from cecli.run_cmd import run_cmd
 from cecli.sessions import SessionManager
 from cecli.tools.utils.output import print_tool_response
@@ -531,6 +532,11 @@ class Coder:
         has_map_prompt = nested.getter(self, "gpt_prompts.repo_content_prefix")
 
         if use_repo_map and self.repo and has_map_prompt:
+            repo_root = (
+                self.repo.workspace_path
+                if (self.repo and getattr(self.repo, "workspace_path", None))
+                else self.root
+            )
             self.repo_map = RepoMap(
                 map_tokens,
                 self.map_cache_dir,
@@ -542,9 +548,9 @@ class Coder:
                 map_mul_no_files=map_mul_no_files,
                 refresh=map_refresh,
                 max_code_line_length=map_max_line_length,
-                repo_root=self.root,
+                repo_root=repo_root,
                 use_memory_cache=repomap_in_memory,
-                use_enhanced_map=False if not self.args or self.args.use_enhanced_map else True,
+                use_enhanced_map=getattr(self.args, "use_enhanced_map", False),
             )
 
         self.summarizer = summarizer or ChatSummary(
@@ -1508,6 +1514,9 @@ class Coder:
             except (SwitchCoderSignal, SystemExit):
                 raise
             except Exception as e:
+                traceback_str = traceback.format_exc()
+                update_error_prefix(traceback_str)
+
                 if self.verbose or self.args.debug:
                     print(e)
 
@@ -3221,12 +3230,13 @@ class Coder:
                 try:
                     func = chunk.choices[0].delta.function_call
                     # dump(func)
-                    for k, v in func.items():
-                        self.tool_reflection = True
-                        self.io.update_spinner_suffix(v)
+                    if func:
+                        for k, v in func.items():
+                            self.tool_reflection = True
+                            self.io.update_spinner_suffix(v)
 
-                    received_content = True
-                    self.token_profiler.on_token()
+                        received_content = True
+                        self.token_profiler.on_token()
                 except AttributeError:
                     pass
 
@@ -3650,13 +3660,14 @@ class Coder:
                 # Continue to get tracked files normally
 
         if self.repo:
-            if not self.repo.cecli_ignore_file or not self.repo.cecli_ignore_file.is_file():
+            if hasattr(self.repo, "workspace_path") and self.repo.workspace_path:
+                files = self.repo.get_workspace_files()
+            elif not self.repo.cecli_ignore_file or not self.repo.cecli_ignore_file.is_file():
                 files = self.repo.get_tracked_files()
             else:
                 files = self.repo.get_non_ignored_files_from_root()
         else:
             files = self.get_inchat_relative_files()
-
         # This is quite slow in large repos
         # files = [fname for fname in files if self.is_file_safe(fname)]
 
@@ -3918,6 +3929,13 @@ class Coder:
         if not self.repo or not self.auto_commits or self.dry_run:
             return
 
+        # Workspace-aware commit logic
+        if hasattr(self.args, "workspace") and self.args.workspace:
+            # We are in a workspace context.
+            # The GitRepo instance (self.repo) should already be pointing to the correct worktree/repo
+            # within the workspace because of the os.chdir in main.py and detection in repo.py.
+            pass
+
         if not context:
             context = self.get_context_from_history(
                 ConversationService.get_manager(self).get_messages_dict(MessageTag.CUR)

{cecli_dev-0.98.1 → cecli_dev-0.99.0}/cecli/commands/__init__.py

@@ -79,6 +79,7 @@ from .utils.registry import CommandRegistry
 from .voice import VoiceCommand
 from .weak_model import WeakModelCommand
 from .web import WebCommand
+from .workspace import WorkspaceCommand
 
 # Register commands
 CommandRegistry.register(AddCommand)
@@ -143,6 +144,7 @@ CommandRegistry.register(UndoCommand)
 CommandRegistry.register(VoiceCommand)
 CommandRegistry.register(WeakModelCommand)
 CommandRegistry.register(WebCommand)
+CommandRegistry.register(WorkspaceCommand)
 
 
 __all__ = [
@@ -220,4 +222,5 @@ __all__ = [
     "VoiceCommand",
     "WeakModelCommand",
     "WebCommand",
+    "WorkspaceCommand",
 ]

cecli_dev-0.99.0/cecli/commands/workspace.py

@@ -0,0 +1,72 @@
+import subprocess
+
+from cecli.commands.utils.base_command import BaseCommand
+
+
+class WorkspaceCommand(BaseCommand):
+    NORM_NAME = "workspace"
+    DESCRIPTION = "Print information about the current workspace"
+
+    @classmethod
+    async def execute(cls, io, coder, args, **kwargs):
+        """Execute the workspace command."""
+        if not coder or not coder.repo:
+            io.tool_output("No repository or workspace active.")
+            return
+
+        workspace_path = getattr(coder.repo, "workspace_path", None)
+        if not workspace_path:
+            io.tool_output("Not currently working within a cecli workspace.")
+            return
+
+        import json
+
+        metadata_path = workspace_path / ".cecli-workspace.json"
+        config = {}
+        if metadata_path.exists():
+            try:
+                with open(metadata_path, "r") as f:
+                    config = json.load(f)
+            except Exception:
+                pass
+
+        ws_name = config.get("name", workspace_path.name)
+        is_active = config.get("active", False)
+
+        io.print(f"Current Workspace: {ws_name}{' (Active)' if is_active else ''}")
+        io.print(f"Root Directory:    {workspace_path}")
+        io.print("-" * 40)
+        io.print("Projects:")
+
+        projects = config.get("projects", [])
+        for proj in projects:
+            proj_name = proj.get("name")
+            if not proj_name:
+                continue
+
+            proj_root = workspace_path / proj_name / "main"
+            branch_info = "Unknown"
+            if proj_root.exists():
+                try:
+                    branch_info = subprocess.check_output(
+                        ["git", "-C", str(proj_root), "rev-parse", "--abbrev-ref", "HEAD"],
+                        stderr=subprocess.DEVNULL,
+                        encoding="utf-8",
+                    ).strip()
+                except Exception:
+                    branch_info = "Error retrieving branch"
+
+            repo_url = proj.get("repo", "N/A")
+            io.print(f"  - {proj_name}:")
+            io.print(f"    Branch: {branch_info}")
+            io.print(f"    Remote: {repo_url}")
+            io.print(f"    Path:   {proj_root}")
+            io.print("")
+
+    @classmethod
+    def get_help(cls) -> str:
+        """Get help text for the workspace command."""
+        help_text = super().get_help()
+        help_text += "\nUsage:\n"
+        help_text += "  /workspace  # Show details of the active monorepo workspace\n"
+        return help_text

cecli_dev-0.99.0/cecli/helpers/monorepo/config.py

@@ -0,0 +1,149 @@
+import json
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import yaml
+
+
+def resolve_workspace_config(config_arg: Optional[str] = None) -> Optional[Any]:
+    """
+    Common logic to resolve workspace configuration from hierarchy:
+    1. config_arg (JSON string)
+    2. Local .cecli.workspaces.yml/yaml
+    3. Global ~/.cecli/workspaces.yml/yaml
+    4. Fallback to .cecli.conf.yml
+    """
+    workspace_conf = None
+
+    # 1. Try config_arg (JSON string from main.py)
+    if config_arg:
+        try:
+            loaded = json.loads(config_arg)
+            if isinstance(loaded, dict):
+                workspace_conf = loaded.get("workspaces") or loaded.get("workspace") or loaded
+            elif isinstance(loaded, list):
+                workspace_conf = loaded
+        except json.JSONDecodeError:
+            try:
+                loaded = yaml.safe_load(config_arg)
+                if isinstance(loaded, dict):
+                    workspace_conf = loaded.get("workspaces") or loaded.get("workspace") or loaded
+                elif isinstance(loaded, list):
+                    workspace_conf = loaded
+            except yaml.YAMLError:
+                pass
+
+    # 2. Look for local .cecli.workspaces.yml/yaml
+    if not workspace_conf:
+        for local_name in [".cecli.workspaces.yml", ".cecli.workspaces.yaml"]:
+            local_path = Path(local_name)
+            if local_path.exists():
+                try:
+                    with open(local_path, "r") as f:
+                        loaded = yaml.safe_load(f)
+                        if loaded:
+                            workspace_conf = (
+                                loaded.get("workspaces") or loaded.get("workspace") or loaded
+                            )
+                            if workspace_conf:
+                                break
+                except Exception:
+                    pass
+
+    # 3. Look for global ~/.cecli/workspaces.yml/yaml
+    if not workspace_conf:
+        for global_name in ["workspaces.yml", "workspaces.yaml"]:
+            global_path = Path.home() / ".cecli" / global_name
+            if global_path.exists():
+                try:
+                    with open(global_path, "r") as f:
+                        loaded = yaml.safe_load(f)
+                        if loaded:
+                            workspace_conf = (
+                                loaded.get("workspaces") or loaded.get("workspace") or loaded
+                            )
+                            if workspace_conf:
+                                break
+                except Exception:
+                    pass
+
+    return workspace_conf
+
+
+def load_workspace_config(
+    config_arg: Optional[str] = None, name: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    Load workspace configuration from hierarchy.
+    If name is provided, select that specific workspace from a list.
+    """
+    workspace_conf = resolve_workspace_config(config_arg)
+
+    config = {}
+    # Handle list of workspaces or single dict
+    if isinstance(workspace_conf, list):
+        if name:
+            selected_ws = next((ws for ws in workspace_conf if ws.get("name") == name), None)
+            if not selected_ws:
+                raise ValueError(f"Workspace '{name}' not found in configuration")
+            config = selected_ws
+        else:
+            active_workspaces = [ws for ws in workspace_conf if ws.get("active")]
+            if len(active_workspaces) > 1:
+                active_names = [ws.get("name", "unknown") for ws in active_workspaces]
+                raise ValueError(f"Multiple workspaces marked as active: {', '.join(active_names)}")
+
+            active_ws = active_workspaces[0] if active_workspaces else None
+
+            # If no workspace is explicitly marked active, but there is only one, use it
+            if not active_ws and len(workspace_conf) == 1:
+                active_ws = workspace_conf[0]
+            config = active_ws if active_ws else {}
+    elif isinstance(workspace_conf, dict):
+        config = workspace_conf
+
+    validate_config(config)
+    return config
+
+
+def validate_config(config: Dict[str, Any]) -> None:
+    """
+    Minimal validation of required fields.
+    """
+    if not config:
+        return
+
+    if "name" not in config:
+        raise ValueError("Workspace configuration must include a 'name'")
+
+    if "projects" not in config:
+        config["projects"] = []
+
+    project_names = set()
+    for project in config["projects"]:
+        if "name" not in project or "repo" not in project:
+            raise ValueError("Each project must have a 'name' and 'repo' URL")
+        if project["name"] in project_names:
+            raise ValueError(f"Duplicate project name: {project['name']}")
+        project_names.add(project["name"])
+
+
+def find_active_workspace_name(config_arg: Optional[str] = None) -> Optional[str]:
+    """
+    Find the name of the active workspace from the config without resolving it fully.
+    Used in main.py to automatically activate a workspace.
+    """
+    workspace_conf = resolve_workspace_config(config_arg)
+
+    if isinstance(workspace_conf, list):
+        active_ws = next((ws for ws in workspace_conf if ws.get("active")), None)
+        if active_ws:
+            return active_ws.get("name")
+        # If there's only one workspace, it's considered active
+        if len(workspace_conf) == 1:
+            return workspace_conf[0].get("name")
+    elif isinstance(workspace_conf, dict):
+        # If it's a single dict, it's considered active by default
+        return workspace_conf.get("name")
+
+    return None

cecli_dev-0.99.0/cecli/helpers/monorepo/project.py

@@ -0,0 +1,89 @@
+import subprocess
+from pathlib import Path
+from typing import Any, Dict
+
+from cecli.helpers.monorepo.worktree import WorktreeManager
+
+
+class Project:
+    def __init__(self, workspace_path: Path, config: Dict[str, Any]):
+        self.workspace_path = workspace_path
+        self.config = config
+        self.name = config["name"]
+        self.repo_url = config["repo"]
+        self.base_path = workspace_path / self.name
+        self.main_path = self.base_path / "main"
+
+    def initialize(self) -> None:
+        """Clone the repository and setup worktrees."""
+        if not self.main_path.exists():
+            self.main_path.mkdir(parents=True, exist_ok=True)
+
+            target_branch = self.config.get("branch")
+            use_current = self.config.get("use_current_branch", True)
+
+            clone_cmd = ["git", "clone", "--depth", "1"]
+            if target_branch and not use_current:
+                clone_cmd += ["--branch", target_branch]
+
+            clone_cmd += [self.repo_url, str(self.main_path)]
+
+            subprocess.run(clone_cmd, check=True)
+
+        # Ensure correct branch is checked out
+        target_branch = self.config.get("branch")
+        use_current = self.config.get("use_current_branch", True)
+
+        if target_branch and not use_current:
+            try:
+                # Check current branch
+                current_branch = subprocess.check_output(
+                    ["git", "-C", str(self.main_path), "rev-parse", "--abbrev-ref", "HEAD"],
+                    encoding="utf-8",
+                ).strip()
+
+                if current_branch != target_branch:
+                    # Try to checkout directly
+                    res = subprocess.run(
+                        ["git", "-C", str(self.main_path), "checkout", target_branch],
+                        check=False,
+                        capture_output=True,
+                    )
+
+                    if res.returncode != 0:
+                        # If checkout fails, check if it exists on origin
+                        subprocess.run(
+                            ["git", "-C", str(self.main_path), "fetch", "origin", target_branch],
+                            check=False,
+                        )
+
+                        # Try checking out the remote branch
+                        res = subprocess.run(
+                            [
+                                "git",
+                                "-C",
+                                str(self.main_path),
+                                "checkout",
+                                "-b",
+                                target_branch,
+                                f"origin/{target_branch}",
+                            ],
+                            check=False,
+                            capture_output=True,
+                        )
+
+                        if res.returncode != 0:
+                            # If it still fails, it doesn't exist on origin, so create it locally
+                            subprocess.run(
+                                ["git", "-C", str(self.main_path), "checkout", "-b", target_branch],
+                                check=True,
+                            )
+            except Exception:
+                # Fallback for unexpected errors
+                pass
+        # Handle worktrees
+        worktrees_config = self.config.get("worktrees", [])
+        if worktrees_config:
+            wt_manager = WorktreeManager(self.main_path)
+            for wt_cfg in worktrees_config:
+                wt_manager.create(wt_cfg["name"], wt_cfg["branch"])

cecli_dev-0.99.0/cecli/helpers/monorepo/workspace.py

@@ -0,0 +1,36 @@
+import os
+from pathlib import Path
+from typing import Any, Dict
+
+from cecli.helpers.monorepo.project import Project
+
+
+class WorkspaceManager:
+    def __init__(self, workspace_name: str, config: Dict[str, Any]):
+        self.name = workspace_name
+        self.config = config
+        self.path = Path(os.path.expanduser(f"~/.cecli/workspaces/{workspace_name}"))
+
+    def exists(self) -> bool:
+        """Check if workspace directory exists"""
+        return self.path.exists()
+
+    def initialize(self) -> None:
+        """Create workspace structure and clone repositories"""
+        self.path.mkdir(parents=True, exist_ok=True)
+
+        projects_config = self.config.get("projects", [])
+        for proj_cfg in projects_config:
+            project = Project(self.path, proj_cfg)
+            project.initialize()
+
+        # Write metadata
+        import json
+
+        metadata_path = self.path / ".cecli-workspace.json"
+        with open(metadata_path, "w") as f:
+            json.dump(self.config, f, indent=2)
+
+    def get_working_directory(self) -> Path:
+        """Return workspace root path for cd"""
+        return self.path

cecli_dev-0.99.0/cecli/helpers/monorepo/worktree.py

@@ -0,0 +1,21 @@
+import subprocess
+from pathlib import Path
+
+
+class WorktreeManager:
+    def __init__(self, main_repo_path: Path):
+        self.main_repo_path = main_repo_path
+        self.worktrees_dir = main_repo_path.parent / "worktrees"
+
+    def create(self, name: str, branch: str) -> None:
+        """Create a git worktree."""
+        wt_path = self.worktrees_dir / name
+        if wt_path.exists():
+            return
+
+        self.worktrees_dir.mkdir(parents=True, exist_ok=True)
+
+        subprocess.run(
+            ["git", "-C", str(self.main_repo_path), "worktree", "add", str(wt_path), branch],
+            check=True,
+        )

{cecli_dev-0.98.1 → cecli_dev-0.99.0}/cecli/helpers/plugin_manager.py

@@ -37,6 +37,8 @@ def normalize_filename(filename: str) -> str:
     :param filename: Original filename
     :return: Normalized module name
     """
+    if not filename:
+        return ""
     # Remove extension
     name = Path(filename).stem
 
@@ -58,6 +60,8 @@ def load_module(source, module_name=None, reload=False):
     :param module_name: name of module to register in sys.modules
     :return: loaded module
     """
+    if not source:
+        return None
     # Convert to absolute path for cache key
     source_path = Path(source).resolve()