refactor: Clean up RepoConfig + LocalRepoOperator (#418)

Author: caroljung-cg

.github/workflows/unit-tests.yml

@@ -141,7 +141,7 @@ jobs:
         timeout-minutes: 5
         env:
           GITHUB_WORKSPACE: $GITHUB_WORKSPACE
-          GITHUB_TOKEN: ${{ secrets.GHA_PAT }}
+          CODEGEN_SECRETS__GITHUB_TOKEN: ${{ secrets.GHA_PAT }}
         run: |
           uv run pytest \
             -n auto \

ruff.toml

@@ -47,6 +47,8 @@ ignore = [
 exclude = [
   "*.ipynb",
 ] # disable just linting for notebooks (allow for formatting)
+[lint.per-file-ignores]
+"src/codegen/cli/mcp/resources/system_prompt.py" = ["E501"]
 [lint.pydocstyle]
 convention = "google"
 [lint.pyflakes]

src/codegen/cli/commands/init/main.py

@@ -23,7 +23,7 @@ def init_command(repo_name: str | None = None, organization_name: str | None = N
     """Initialize or update the Codegen folder."""
     # Print a message if not in a git repo
     try:
-        subprocess.run(["git", "rev-parse", "--is-inside-work-tree"], capture_output=True, check=True, text=True)
+        output = subprocess.run(["git", "rev-parse", "--show-toplevel"], capture_output=True, check=True, text=True)
     except (subprocess.CalledProcessError, FileNotFoundError):
         rich.print("\n[bold red]Error:[/bold red] Not in a git repository")
         rich.print("[white]Please run this command from within a git repository.[/white]")

src/codegen/cli/mcp/resources/system_prompt.py

@@ -1421,16 +1421,15 @@ def baz():
 ```python
 from codegen import Codebase
 from codegen.git.repo_operator.local_repo_operator import LocalRepoOperator
-from codegen.git.schemas.repo_config import BaseRepoConfig
+from codegen.git.schemas.repo_config import RepoConfig
 from codegen.sdk.codebase.config import ProjectConfig
 from codegen.sdk.enums import ProgrammingLanguage
 
 codebase = Codebase(
     projects = [
         ProjectConfig(
             repo_operator=LocalRepoOperator(
-                repo_path="/tmp/codegen-sdk",
-                repo_config=BaseRepoConfig(),
+                repo_config=RepoConfig(name="codegen-sdk"),
                 bot_commit=True
             ),
             programming_language=ProgrammingLanguage.TYPESCRIPT,

src/codegen/git/clients/git_repo_client.py

@@ -51,10 +51,6 @@ def repo(self) -> Repository:
     # PROPERTIES
     ####################################################################################################################
 
-    @property
-    def id(self) -> int:
-        return self.repo_config.id
-
     @property
     def default_branch(self) -> str:
         return self.repo.default_branch

src/codegen/git/configs/config.py

@@ -13,7 +13,7 @@
 from codegen.git.clients.git_repo_client import GitRepoClient
 from codegen.git.repo_operator.repo_operator import RepoOperator
 from codegen.git.schemas.enums import FetchResult
-from codegen.git.schemas.repo_config import BaseRepoConfig
+from codegen.git.schemas.repo_config import RepoConfig
 from codegen.git.utils.clone_url import url_to_github
 from codegen.git.utils.file_utils import create_files
 
@@ -31,28 +31,21 @@ class LocalRepoOperator(RepoOperator):
     - Creating "fake" repos from a dictionary of files contents
     """
 
-    _repo_path: str
-    _repo_name: str
     _git_cli: GitCLI
-    repo_config: BaseRepoConfig
     _github_api_key: str | None
     _remote_git_repo: GitRepoClient | None = None
 
     def __init__(
         self,
-        repo_path: str,  # full path to the repo
+        repo_config: RepoConfig,
         github_api_key: str | None = None,
-        repo_config: BaseRepoConfig | None = None,
         bot_commit: bool = False,
     ) -> None:
-        self._repo_path = repo_path
-        self._repo_name = os.path.basename(repo_path)
         self._github_api_key = github_api_key
         self._remote_git_repo = None
+        super().__init__(repo_config, bot_commit)
         os.makedirs(self.repo_path, exist_ok=True)
         GitCLI.init(self.repo_path)
-        repo_config = repo_config or BaseRepoConfig()
-        super().__init__(repo_config, self.repo_path, bot_commit)
 
     ####################################################################################################################
     # PROPERTIES
@@ -86,7 +79,7 @@ def remote_git_repo(self) -> GitRepoClient:
     # CLASS METHODS
     ####################################################################################################################
     @classmethod
-    def create_from_files(cls, repo_path: str, files: dict[str, str], bot_commit: bool = True, repo_config: BaseRepoConfig = BaseRepoConfig()) -> "LocalRepoOperator":
+    def create_from_files(cls, repo_path: str, files: dict[str, str], bot_commit: bool = True) -> "LocalRepoOperator":
         """Used when you want to create a directory from a set of files and then create a LocalRepoOperator that points to that directory.
         Use cases:
         - Unit testing
@@ -96,14 +89,13 @@ def create_from_files(cls, repo_path: str, files: dict[str, str], bot_commit: bo
         Args:
             repo_path (str): The path to the directory to create.
             files (dict[str, str]): A dictionary of file names and contents to create in the directory.
-            repo_config (BaseRepoConfig): The configuration of the repo.
         """
         # Step 1: Create dir (if not exists) + files
         os.makedirs(repo_path, exist_ok=True)
         create_files(base_dir=repo_path, files=files)
 
         # Step 2: Init git repo
-        op = cls(repo_path=repo_path, bot_commit=bot_commit, repo_config=repo_config)
+        op = cls(repo_config=RepoConfig.from_repo_path(repo_path), bot_commit=bot_commit)
         if op.stage_and_commit_all_changes("[Codegen] initial commit"):
             op.checkout_branch(None, create_if_missing=True)
         return op
@@ -118,7 +110,7 @@ def create_from_commit(cls, repo_path: str, commit: str, url: str, github_api_ke
             url (str): Git URL of the repository
             github_api_key (str | None): Optional GitHub API key for operations that need GitHub access
         """
-        op = cls(repo_path=repo_path, bot_commit=False, github_api_key=github_api_key)
+        op = cls(repo_config=RepoConfig.from_repo_path(repo_path), bot_commit=False, github_api_key=github_api_key)
         op.discard_changes()
         if op.get_active_branch_or_commit() != commit:
             op.create_remote("origin", url)
@@ -149,7 +141,7 @@ def create_from_repo(cls, repo_path: str, url: str, github_api_key: str | None =
                     remote_head = git_cli.remotes.origin.refs[git_cli.active_branch.name].commit
                     # If up to date, use existing repo
                     if local_head.hexsha == remote_head.hexsha:
-                        return cls(repo_path=repo_path, bot_commit=False, github_api_key=github_api_key)
+                        return cls(repo_config=RepoConfig.from_repo_path(repo_path), bot_commit=False, github_api_key=github_api_key)
             except Exception:
                 # If any git operations fail, fallback to fresh clone
                 pass
@@ -166,20 +158,12 @@ def create_from_repo(cls, repo_path: str, url: str, github_api_key: str | None =
         # Initialize with the cloned repo
         git_cli = GitCLI(repo_path)
 
-        return cls(repo_path=repo_path, bot_commit=False, github_api_key=github_api_key)
+        return cls(repo_config=RepoConfig.from_repo_path(repo_path), bot_commit=False, github_api_key=github_api_key)
 
     ####################################################################################################################
     # PROPERTIES
     ####################################################################################################################
 
-    @property
-    def repo_name(self) -> str:
-        return self._repo_name
-
-    @property
-    def repo_path(self) -> str:
-        return self._repo_path
-
     @property
     def codeowners_parser(self) -> CodeOwnersParser | None:
         return None

src/codegen/git/repo_operator/local_repo_operator.py

@@ -37,13 +37,12 @@ class RemoteRepoOperator(RepoOperator):
     def __init__(
         self,
         repo_config: RepoConfig,
-        base_dir: str = "/tmp",
         setup_option: SetupOption = SetupOption.PULL_OR_CLONE,
         shallow: bool = True,
         bot_commit: bool = True,
         access_token: str | None = None,
     ) -> None:
-        super().__init__(repo_config=repo_config, base_dir=base_dir, bot_commit=bot_commit)
+        super().__init__(repo_config=repo_config, bot_commit=bot_commit)
         self.access_token = access_token
         self.setup_repo_dir(setup_option=setup_option, shallow=shallow)
 

src/codegen/git/repo_operator/remote_repo_operator.py

@@ -16,7 +16,7 @@
 
 from codegen.git.configs.constants import CODEGEN_BOT_EMAIL, CODEGEN_BOT_NAME
 from codegen.git.schemas.enums import CheckoutResult, FetchResult
-from codegen.git.schemas.repo_config import BaseRepoConfig
+from codegen.git.schemas.repo_config import RepoConfig
 from codegen.shared.performance.stopwatch_utils import stopwatch
 from codegen.shared.performance.time_utils import humanize_duration
 
@@ -26,21 +26,20 @@
 class RepoOperator(ABC):
     """A wrapper around GitPython to make it easier to interact with a repo."""
 
-    repo_config: BaseRepoConfig
+    repo_config: RepoConfig
     base_dir: str
     bot_commit: bool = True
     _codeowners_parser: CodeOwnersParser | None = None
     _default_branch: str | None = None
 
     def __init__(
         self,
-        repo_config: BaseRepoConfig,
-        base_dir: str = "/tmp",
+        repo_config: RepoConfig,
         bot_commit: bool = True,
     ) -> None:
         assert repo_config is not None
         self.repo_config = repo_config
-        self.base_dir = base_dir
+        self.base_dir = repo_config.base_dir
         self.bot_commit = bot_commit
 
     ####################################################################################################################

src/codegen/git/repo_operator/repo_operator.py

@@ -1,5 +1,6 @@
 import base64
 import logging
+import os.path
 
 from pydantic import BaseModel
 
@@ -8,35 +9,36 @@
 logger = logging.getLogger(__name__)
 
 
-class BaseRepoConfig(BaseModel):
-    """Base version of RepoConfig that does not depend on the db."""
-
-    name: str = ""
-    respect_gitignore: bool = True
-
-
 class RepoConfig(BaseModel):
     """All the information about the repo needed to build a codebase"""
 
-    id: int
     name: str
-    full_name: str
+    full_name: str | None = None
+    organization_name: str | None = None
     visibility: RepoVisibility | None = None
 
-    # Org fields
-    organization_id: int
-    organization_name: str
-
     # Codebase fields
-    base_dir: str = "/tmp"
-    base_path: str | None = None
+    base_dir: str = "/tmp"  # parent directory of the git repo
+    base_path: str | None = None  # root directory of the codebase within the repo
     language: str | None = "PYTHON"
     subdirectories: list[str] | None = None
     respect_gitignore: bool = True
 
+    @property
+    def repo_path(self) -> str:
+        return f"{self.base_dir}/{self.name}"
+
+    @classmethod
+    def from_repo_path(cls, repo_path: str, **kwargs) -> "RepoConfig":
+        name = os.path.basename(repo_path)
+        base_dir = os.path.dirname(repo_path)
+        return cls(name=name, base_dir=base_dir, **kwargs)
+
+    # TODO: remove
     def encoded_json(self):
         return base64.b64encode(self.model_dump_json().encode("utf-8")).decode("utf-8")
 
+    # TODO: remove, read from shared config instead
     @staticmethod
     def from_encoded_json(encoded_json: str) -> "RepoConfig":
         decoded = base64.b64decode(encoded_json).decode("utf-8")

src/codegen/git/schemas/repo_config.py

@@ -31,14 +31,14 @@ def create_codeowners_parser_for_repo(py_github_repo: GitRepoClient) -> CodeOwne
                 return codeowners
         except Exception as e:
             continue
-    logger.info(f"Failed to create CODEOWNERS parser for repo: {py_github_repo.repo_config.id}. Returning None.")
+    logger.info(f"Failed to create CODEOWNERS parser for repo: {py_github_repo.repo_config.name}. Returning None.")
     return None
 
 
 def get_codeowners_for_pull(repo: GitRepoClient, pull: PullRequest) -> list[str]:
     codeowners_parser = create_codeowners_parser_for_repo(repo)
     if not codeowners_parser:
-        logger.warning(f"Failed to create codeowners parser for repo: {repo.repo_config.id}. Returning empty list.")
+        logger.warning(f"Failed to create codeowners parser for repo: {repo.repo_config.name}. Returning empty list.")
         return []
     codeowners_for_pull_set = set()
     pull_files = pull.get_files()

src/codegen/git/utils/codeowner_utils.py

@@ -3,7 +3,6 @@
 
 from git import Commit as GitCommit
 
-from codegen.git.configs.config import config
 from codegen.git.repo_operator.remote_repo_operator import RemoteRepoOperator
 from codegen.git.schemas.repo_config import RepoConfig
 from codegen.runner.models.apis import CreateBranchRequest, CreateBranchResponse, GetDiffRequest, GetDiffResponse
@@ -14,6 +13,7 @@
 from codegen.sdk.core.codebase import Codebase
 from codegen.sdk.enums import ProgrammingLanguage
 from codegen.shared.compilation.string_to_code import create_execute_function_from_codeblock
+from codegen.shared.configs.config import config
 from codegen.shared.performance.stopwatch_utils import stopwatch
 
 logger = logging.getLogger(__name__)
@@ -36,12 +36,12 @@ def __init__(
         repo_config: RepoConfig,
     ) -> None:
         self.repo = repo_config
-        self.op = RemoteRepoOperator(repo_config=repo_config, base_dir=repo_config.base_dir, access_token=config.GITHUB_TOKEN)
+        self.op = RemoteRepoOperator(repo_config=repo_config, access_token=config.secrets.github_token)
         self.commit = self.op.git_cli.head.commit
 
     async def warmup(self) -> None:
         """Warms up this runner by cloning the repo and parsing the graph."""
-        logger.info(f"===== Warming runner for {self.repo.full_name} (ID={self.repo.id}) =====")
+        logger.info(f"===== Warming runner for {self.repo.full_name or self.repo.name} =====")
         sys.setrecursionlimit(10000)  # for graph parsing
 
         self.codebase = await self._build_graph()

src/codegen/runner/sandbox/runner.py

@@ -5,7 +5,7 @@
 from typing import TypedDict
 
 from codegen.git.repo_operator.local_repo_operator import LocalRepoOperator
-from codegen.git.schemas.repo_config import BaseRepoConfig
+from codegen.git.schemas.repo_config import RepoConfig
 from codegen.sdk.codebase.config import CodebaseConfig, DefaultConfig, ProjectConfig
 from codegen.sdk.core.codebase import Codebase, CodebaseType
 from codegen.sdk.enums import ProgrammingLanguage
@@ -35,10 +35,14 @@ def get_codegen_codebase_base_path() -> str:
 def get_current_code_codebase(config: CodebaseConfig = DefaultConfig, subdirectories: list[str] | None = None) -> CodebaseType:
     """Returns a Codebase for the code that is *currently running* (i.e. the Codegen repo)"""
     codegen_repo_path = get_graphsitter_repo_path()
-    logger.info(f"Creating codebase from repo at: {codegen_repo_path} with base_path {get_codegen_codebase_base_path()}")
-    op = LocalRepoOperator(repo_path=codegen_repo_path, bot_commit=False, repo_config=BaseRepoConfig(respect_gitignore=False))
-    config = config.model_copy(update={"base_path": get_codegen_codebase_base_path()})
-    projects = [ProjectConfig(repo_operator=op, programming_language=ProgrammingLanguage.PYTHON, subdirectories=subdirectories, base_path=get_codegen_codebase_base_path())]
+    base_dir = get_codegen_codebase_base_path()
+    logger.info(f"Creating codebase from repo at: {codegen_repo_path} with base_path {base_dir}")
+
+    repo_config = RepoConfig.from_repo_path(codegen_repo_path, respect_gitignore=False)
+    op = LocalRepoOperator(repo_config=repo_config, bot_commit=False)
+
+    config = config.model_copy(update={"base_path": base_dir})
+    projects = [ProjectConfig(repo_operator=op, programming_language=ProgrammingLanguage.PYTHON, subdirectories=subdirectories, base_path=base_dir)]
     codebase = Codebase(projects=projects, config=config)
     return codebase