feat: CG-10824: simplify config into .env + autoload (#567)

Author: caroljung-cg

.codegen/.gitignore

@@ -4,16 +4,16 @@ examples/
 prompts/
 jupyter/
 .venv/
+.env
 codegen-system-prompt.txt
-*.txt
-*.pyc
 
 # Python cache files
 __pycache__/
 *.py[cod]
 *$py.class
+*.txt
+*.pyc
 
-# Keep config.toml and codemods
-!config.toml
+# Keep codemods
 !codemods/
 !codemods/**

.codegen/config.toml

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

.github/workflows/unit-tests.yml

@@ -2,9 +2,8 @@
 
 import codegen
 from codegen import Codebase
-from codegen.sdk.codebase.config import CodebaseConfig
-from codegen.sdk.secrets import Secrets
-from codegen.shared.configs.models.feature_flags import CodebaseFeatureFlags
+from codegen.shared.configs.models.codebase import CodebaseConfig
+from codegen.shared.configs.models.secrets import SecretsConfig
 
 github_token = "Your github token"
 open_ai_key = "your open ai key"
@@ -77,12 +76,8 @@ def run(codebase: Codebase):
         "getsentry/sentry",
         shallow=False,
         language="python",
-        config=CodebaseConfig(
-            secrets=Secrets(openai_key=open_ai_key, github_api_key=github_token),
-            feature_flags=CodebaseFeatureFlags(
-                sync_enabled=True,
-            ),
-        ),
+        config=CodebaseConfig(sync_enabled=True),
+        secrets=SecretsConfig(openai_api_key=open_ai_key, github_token=github_token),
     )
     review = run(codebase)
     print(review)

codegen-examples/examples/pr_review_bot/run.py

@@ -127,7 +127,7 @@ This codemod includes support for running without the graph feature enabled. Thi
 To run in no-graph mode:
 
 ```python
-codebase = Codebase(str(repo_path), language="python", config=CodebaseConfig(feature_flags=GSFeatureFlags(disable_graph=True)))
+codebase = Codebase(str(repo_path), language="python", config=CodebaseConfig(disable_graph=True))
 ```
 
 ## Running the Conversion

codegen-examples/examples/sqlalchemy_soft_delete/README.md

@@ -3,9 +3,7 @@
 from pathlib import Path
 
 import codegen
-from codegen import Codebase
 from codegen.sdk.core.detached_symbols.function_call import FunctionCall
-from codegen.shared.configs.models.feature_flags import CodebaseFeatureFlags
 
 
 def should_process_join_call(call, soft_delete_models, join_methods):
@@ -93,15 +91,15 @@ def process_soft_deletes(codebase):
 
 if __name__ == "__main__":
     from codegen import Codebase
-    from codegen.sdk.codebase.config import CodebaseConfig
+    from codegen.shared.configs.models.codebase import CodebaseConfig
 
     repo_path = Path("/tmp/core")
     repo_url = "https://github.com/hasgeek/funnel.git"
 
     try:
         clone_repo(repo_url, repo_path)
         subprocess.run(["git", "-C", str(repo_path), "checkout", "8454e15"], check=True)
-        codebase = Codebase(str(repo_path), language="python", config=CodebaseConfig(feature_flags=CodebaseFeatureFlags(disable_graph=True)))
+        codebase = Codebase(str(repo_path), language="python", config=CodebaseConfig(disable_graph=True))
         process_soft_deletes(codebase)
     finally:
         shutil.rmtree(repo_path)

codegen-examples/examples/sqlalchemy_soft_delete/run.py

@@ -46,12 +46,12 @@ The environment is created during `codegen init` and used by commands like `code
 
 ### Configuration
 
-The `config.toml` file stores your project settings:
+The `.env` file stores your project settings:
 
-```toml
-organization_name = "your-org"
-repo_name = "your-repo"
-programming_language = "python"  # or other supported language
+```env
+REPOSITORY_OWNER = "your-org"
+REPOSITORY_PATH = "/root/git/your-repo"
+REPOSITORY_LANGUAGE = "python"  # or other supported language
 ```
 
 This configuration is used by Codegen to provide language-specific features and proper repository context.

docs/building-with-codegen/dot-codegen.mdx

@@ -69,21 +69,19 @@ You can customize the behavior of your Codebase instance by passing a `CodebaseC
 
 ```python
 from codegen import Codebase
-from codegen.sdk.codebase.config import CodebaseConfig, Secrets
+from codegen.shared.configs.models.codebase import CodebaseConfig
+from codegen.shared.configs.models.secrets import SecretsConfig
 
 codebase = Codebase(
     "path/to/repository",
-    config=CodebaseConfig(
-        secrets=Secrets(
-            openai_key="your-openai-key"  # For AI-powered features
-        ),
-    )
+    config=CodebaseConfig(debug=True),
+    secrets=SecretsConfig(openai_api_key="your-openai-key")   # For AI-powered features
 )
 ```
 
-The `CodebaseConfig` allows you to configure:
-- `secrets`: API keys and other sensitive information needed by the codebase
-- `feature_flags`: Toggle specific features like language engines, dependency management, and graph synchronization
+- `CodebaseConfig` and `SecretsConfig` allow you to configure
+  - `config`: Toggle specific features like language engines, dependency management, and graph synchronization
+  - `secrets`: API keys and other sensitive information needed by the codebase
 
 For a complete list of available feature flags and configuration options, see the [source code on GitHub](https://github.com/codegen-sh/codegen-sdk/blob/develop/src/codegen/sdk/codebase/config.py).
 

docs/building-with-codegen/parsing-codebases.mdx

@@ -50,7 +50,6 @@ dependencies = [
   "pygit2>=1.16.0",
   "unidiff>=0.7.5",
   "datamodel-code-generator>=0.26.5",
-  "toml>=0.10.2",
   "PyGithub==2.6.0",
   "GitPython==3.1.44",
   "psutil>=5.8.0",
@@ -141,7 +140,6 @@ dev-dependencies = [
   "pre-commit-uv>=4.1.4",
   "austin-dist>=3.7.0",
   "uv>=0.4.25",
-  "cython>=3.0.11",
   "deptry>=0.22.0",
   "cibuildwheel[uv]>=2.22.0",
   "sybil[pytest]>=9.0.0",
@@ -158,6 +156,7 @@ dev-dependencies = [
   "jupyterlab>=4.3.5",
   "modal>=0.73.25",
   "pytest-lsp>=1.0.0b1",
+  "cython>=3.0.11",
 ]
 
 [tool.uv.workspace]

pyproject.toml

@@ -8,9 +8,9 @@
 from codegen.cli.git.repo import get_git_repo
 from codegen.cli.rich.codeblocks import format_command
 from codegen.git.repo_operator.local_git_repo import LocalGitRepo
-from codegen.shared.configs.constants import CODEGEN_DIR_NAME, CONFIG_FILENAME
-from codegen.shared.configs.models.session import SessionConfig
-from codegen.shared.configs.session_configs import global_config, load_session_config
+from codegen.shared.configs.constants import CODEGEN_DIR_NAME, ENV_FILENAME
+from codegen.shared.configs.session_manager import session_manager
+from codegen.shared.configs.user_config import UserConfig
 
 
 class CodegenSession:
@@ -19,7 +19,7 @@ class CodegenSession:
     repo_path: Path
     local_git: LocalGitRepo
     codegen_dir: Path
-    config: SessionConfig
+    config: UserConfig
     existing: bool
 
     def __init__(self, repo_path: Path, git_token: str | None = None) -> None:
@@ -30,16 +30,16 @@ def __init__(self, repo_path: Path, git_token: str | None = None) -> None:
         self.repo_path = repo_path
         self.local_git = LocalGitRepo(repo_path=repo_path)
         self.codegen_dir = repo_path / CODEGEN_DIR_NAME
-        self.config = load_session_config(self.codegen_dir / CONFIG_FILENAME)
+        self.config = UserConfig(env_filepath=self.codegen_dir / ENV_FILENAME)
         self.config.secrets.github_token = git_token or self.config.secrets.github_token
-        self.existing = global_config.get_session(repo_path) is not None
+        self.existing = session_manager.get_session(repo_path) is not None
 
         self._initialize()
-        global_config.set_active_session(repo_path)
+        session_manager.set_active_session(repo_path)
 
     @classmethod
     def from_active_session(cls) -> "CodegenSession | None":
-        active_session = global_config.get_active_session()
+        active_session = session_manager.get_active_session()
         if not active_session:
             return None
 
@@ -49,9 +49,8 @@ def _initialize(self) -> None:
         """Initialize the codegen session"""
         self._validate()
 
-        self.config.repository.repo_path = self.config.repository.repo_path or str(self.local_git.repo_path)
-        self.config.repository.repo_name = self.config.repository.repo_name or self.local_git.name
-        self.config.repository.full_name = self.config.repository.full_name or self.local_git.full_name
+        self.config.repository.path = self.config.repository.path or str(self.local_git.repo_path)
+        self.config.repository.owner = self.config.repository.owner or self.local_git.owner
         self.config.repository.user_name = self.config.repository.user_name or self.local_git.user_name
         self.config.repository.user_email = self.config.repository.user_email or self.local_git.user_email
         self.config.repository.language = self.config.repository.language or self.local_git.get_language(access_token=self.config.secrets.github_token).upper()
@@ -60,20 +59,13 @@ def _initialize(self) -> None:
     def _validate(self) -> None:
         """Validates that the session configuration is correct, otherwise raises an error"""
         if not self.codegen_dir.exists():
-            rich.print(f"\n[bold red]Error:[/bold red] Codegen folder is missing at {self.codegen_dir}")
-            raise click.Abort()
-
-        if not Path(self.config.file_path).exists():
-            rich.print(f"\n[bold red]Error:[/bold red] Missing config.toml at {self.codegen_dir}")
-            rich.print("[white]Please remove the codegen folder and reinitialize.[/white]")
-            rich.print(format_command(f"rm -rf {self.codegen_dir} && codegen init"))
-            raise click.Abort()
+            self.codegen_dir.mkdir(parents=True, exist_ok=True)
 
         git_token = self.config.secrets.github_token
         if git_token is None:
             rich.print("\n[bold yellow]Warning:[/bold yellow] GitHub token not found")
             rich.print("To enable full functionality, please set your GitHub token:")
-            rich.print(format_command("export CODEGEN_SECRETS__GITHUB_TOKEN=<your-token>"))
+            rich.print(format_command("export SECRETS_GITHUB_TOKEN=<your-token>"))
             rich.print("Or pass in as a parameter:")
             rich.print(format_command("codegen init --token <your-token>"))
 

src/codegen/cli/auth/session.py

@@ -5,9 +5,9 @@
 import rich_click as click
 from rich.table import Table
 
-from codegen.cli.auth.session import CodegenSession
-from codegen.cli.workspace.decorators import requires_init
-from codegen.shared.configs.session_configs import global_config
+from codegen.shared.configs.constants import CODEGEN_DIR_NAME, ENV_FILENAME, GLOBAL_ENV_FILE
+from codegen.shared.configs.session_manager import session_manager
+from codegen.shared.configs.user_config import UserConfig
 
 
 @click.group(name="config")
@@ -17,13 +17,9 @@ def config_command():
 
 
 @config_command.command(name="list")
-@requires_init
 @click.option("--global", "is_global", is_flag=True, help="Lists the global configuration values")
-def list_command(session: CodegenSession, is_global: bool):
+def list_command(is_global: bool):
     """List current configuration values."""
-    table = Table(title="Configuration Values", border_style="blue", show_header=True)
-    table.add_column("Key", style="cyan", no_wrap=True)
-    table.add_column("Value", style="magenta")
 
     def flatten_dict(data: dict, prefix: str = "") -> dict:
         items = {}
@@ -38,60 +34,70 @@ def flatten_dict(data: dict, prefix: str = "") -> dict:
                 items[full_key] = value
         return items
 
-    # Get flattened config and sort by keys
-    config = global_config.global_session if is_global else session.config
-    flat_config = flatten_dict(config.model_dump())
+    config = _get_user_config(is_global)
+    flat_config = flatten_dict(config.to_dict())
     sorted_items = sorted(flat_config.items(), key=lambda x: x[0])
 
-    # Group by top-level prefix
+    # Create table
+    table = Table(title="Configuration Values", border_style="blue", show_header=True, title_justify="center")
+    table.add_column("Key", style="cyan", no_wrap=True)
+    table.add_column("Value", style="magenta")
+
+    # Group by prefix (before underscore)
     def get_prefix(item):
-        return item[0].split(".")[0]
+        return item[0].split("_")[0]
 
     for prefix, group in groupby(sorted_items, key=get_prefix):
         table.add_section()
-        table.add_row(f"[bold yellow]{prefix}[/bold yellow]", "")
+        table.add_row(f"[bold yellow]{prefix.title()}[/bold yellow]", "")
         for key, value in group:
-            # Remove the prefix from the displayed key
-            display_key = key[len(prefix) + 1 :] if "." in key else key
-            table.add_row(f"  {display_key}", str(value))
+            table.add_row(f"  {key}", str(value))
 
     rich.print(table)
 
 
 @config_command.command(name="get")
-@requires_init
 @click.argument("key")
 @click.option("--global", "is_global", is_flag=True, help="Get the global configuration value")
-def get_command(session: CodegenSession, key: str, is_global: bool):
+def get_command(key: str, is_global: bool):
     """Get a configuration value."""
-    config = global_config.global_session if is_global else session.config
-    value = config.get(key)
-    if value is None:
+    config = _get_user_config(is_global)
+    if not config.has_key(key):
         rich.print(f"[red]Error: Configuration key '{key}' not found[/red]")
         return
 
-    rich.print(f"[cyan]{key}[/cyan] = [magenta]{value}[/magenta]")
+    value = config.get(key)
+
+    rich.print(f"[cyan]{key}[/cyan]=[magenta]{value}[/magenta]")
 
 
 @config_command.command(name="set")
-@requires_init
 @click.argument("key")
 @click.argument("value")
 @click.option("--global", "is_global", is_flag=True, help="Sets the global configuration value")
-def set_command(session: CodegenSession, key: str, value: str, is_global: bool):
-    """Set a configuration value and write to config.toml."""
-    config = global_config.global_session if is_global else session.config
-    cur_value = config.get(key)
-    if cur_value is None:
+def set_command(key: str, value: str, is_global: bool):
+    """Set a configuration value and write to .env"""
+    config = _get_user_config(is_global)
+    if not config.has_key(key):
         rich.print(f"[red]Error: Configuration key '{key}' not found[/red]")
         return
 
-    if cur_value.lower() != value.lower():
+    cur_value = config.get(key)
+    if cur_value is None or cur_value.lower() != value.lower():
         try:
             config.set(key, value)
         except Exception as e:
             logging.exception(e)
             rich.print(f"[red]{e}[/red]")
             return
 
-    rich.print(f"[green]Successfully set {key}=[magenta]{value}[/magenta] and saved to config.toml[/green]")
+    rich.print(f"[green]Successfully set {key}=[magenta]{value}[/magenta] and saved to .env[/green]")
+
+
+def _get_user_config(is_global: bool) -> UserConfig:
+    if is_global or (active_session_path := session_manager.get_active_session()) is None:
+        env_filepath = GLOBAL_ENV_FILE
+    else:
+        env_filepath = active_session_path / CODEGEN_DIR_NAME / ENV_FILENAME
+
+    return UserConfig(env_filepath)