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

{cecli_dev-0.98.2 → 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.2 → 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.2 → cecli_dev-0.99.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 0.98.2
+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.2 → 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.2 → cecli_dev-0.99.0}/cecli/__init__.py

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

{cecli_dev-0.98.2 → 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.2'
-__version_tuple__ = version_tuple = (0, 98, 2)
+__version__ = version = '0.99.0'
+__version_tuple__ = version_tuple = (0, 99, 0)
 
-__commit_id__ = commit_id = 'g1fefb15aa'
+__commit_id__ = commit_id = 'g12b89af88'

{cecli_dev-0.98.2 → 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.2 → cecli_dev-0.99.0}/cecli/coders/agent_coder.py

@@ -1037,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.2 → 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,7 +548,7 @@ 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=getattr(self.args, "use_enhanced_map", False),
             )
@@ -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)
 
@@ -3651,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)]
 
@@ -3919,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.2 → 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.2 → cecli_dev-0.99.0}/cecli/main.py

@@ -542,36 +542,56 @@ async def main_async(argv=None, input=None, output=None, force_git_root=None, re
     else:
         git_root = get_git_root()
     conf_fname = handle_core_files(Path(".cecli.conf.yml"))
-    default_config_files = []
-    try:
-        default_config_files += [conf_fname.resolve()]
-    except OSError:
-        pass
+    default_config_files = [
+        str(Path.home() / ".cecli.conf.yml"),
+        str(Path(".cecli.conf.yml")),
+    ]
     if git_root:
-        git_conf = Path(git_root) / conf_fname
-        if git_conf not in default_config_files:
-            default_config_files.append(git_conf)
-    default_config_files.append(Path.home() / conf_fname)
-    default_config_files = list(map(str, default_config_files))
-    parser = get_parser(default_config_files, git_root)
-    try:
-        args, unknown = parser.parse_known_args(argv)
-    except AttributeError as e:
-        if all(word in str(e) for word in ["bool", "object", "has", "no", "attribute", "strip"]):
-            if check_config_files_for_yes(default_config_files):
-                return await graceful_exit(None, 1)
-        raise e
-    if args.verbose:
-        print("Config files search order, if no --config:")
-        for file in default_config_files:
-            exists = "(exists)" if Path(file).exists() else ""
-            print(f"  - {file} {exists}")
-    default_config_files.reverse()
+        default_config_files.append(str(Path(git_root) / ".cecli.conf.yml"))
     parser = get_parser(default_config_files, git_root)
     args, unknown = parser.parse_known_args(argv)
+
+    # Load dotenv files and re-parse args before workspace logic
+    # to allow environment variables to be used in workspace config
     loaded_dotenvs = load_dotenv_files(git_root, args.env_file, args.encoding)
     args, unknown = parser.parse_known_args(argv)
+
+    uses_workspace = False
+    if args.workspaces or args.workspace_name:
+        from cecli.helpers.monorepo.config import (
+            find_active_workspace_name,
+            load_workspace_config,
+        )
+        from cecli.helpers.monorepo.workspace import WorkspaceManager
+
+        # Interpolate environment variables in the workspaces argument
+        if args.workspaces:
+            args.workspaces = interpolate_env_vars(args.workspaces)
+
+        ws_config_arg = convert_yaml_to_json_string(args.workspaces) if args.workspaces else None
+        ws_name = args.workspace_name or find_active_workspace_name(ws_config_arg)
+        if ws_name:
+            config = load_workspace_config(ws_config_arg, name=ws_name)
+            workspace_manager = WorkspaceManager(ws_name, config)
+
+            if not workspace_manager.exists():
+                workspace_manager.initialize()
+
+            os.chdir(workspace_manager.get_working_directory())
+            git_root = get_git_root()
+            uses_workspace = True
+
+    if git_root:
+        git_conf = Path(git_root) / conf_fname
+        if git_conf not in default_config_files:
+            default_config_files.append(str(git_conf))
+
+    if uses_workspace:
+        parser = get_parser(default_config_files, git_root)
+        args, unknown = parser.parse_known_args(argv)
+
     set_args_error_data(args)
+
     if len(unknown):
         print("Unknown Args: ", unknown)
 
@@ -589,6 +609,8 @@ async def main_async(argv=None, input=None, output=None, force_git_root=None, re
         args.retries = convert_yaml_to_json_string(args.retries)
     if hasattr(args, "hooks") and args.hooks is not None:
         args.hooks = convert_yaml_to_json_string(args.hooks)
+    if hasattr(args, "workspaces") and args.workspaces is not None:
+        args.hooks = convert_yaml_to_json_string(args.workspaces)
 
     # Interpolate environment variables in all string arguments
     for key, value in vars(args).items():
@@ -1152,7 +1174,7 @@ async def main_async(argv=None, input=None, output=None, force_git_root=None, re
                     pre_init_io.tool_output()
                 except KeyboardInterrupt:
                     return await graceful_exit(coder, 1)
-        if args.git and not suppress_pre_init:
+        if args.git and not (suppress_pre_init or args.workspaces or args.workspace_name):
             git_root = await setup_git(git_root, pre_init_io)
             if args.gitignore:
                 await check_gitignore(git_root, pre_init_io)