feat(cli): add --no-venv to skip virtualenv creation and use the ambient env

Closes #46

Add a --no-venv flag (AnalysisOptions.no_venv) that skips virtualenv creation and
dependency installation and resolves imports against the ambient interpreter
(self.virtualenv stays None, so Jedi uses the default environment). Useful in CI /
containers where the project's dependencies are already installed, for sandboxed
runs where network installs are disallowed, and for speed. Tradeoff: import /
call-resolution quality then depends on what is installed in the ambient env.

Regenerates the README --help block; adds a CLI regression test (no virtualenv is
created and analysis.json is still produced).

Author: rahlk

README.md

@@ -185,6 +185,11 @@ $ canpy --help
 │                                                               [default: lazy]                    │
 │ --skip-tests          --include-tests                         Skip test files in analysis.       │
 │                                                               [default: skip-tests]              │
+│ --no-venv             --venv                                  Skip virtualenv creation and       │
+│                                                               dependency installation; resolve   │
+│                                                               imports against the ambient Python │
+│                                                               environment instead.               │
+│                                                               [default: venv]                    │
 │ --file-name                              PATH                 Analyze only the specified file    │
 │                                                               (relative to input directory).     │
 │ --cache-dir       -c                     PATH                 Directory to store analysis cache. │

codeanalyzer/__main__.py

@@ -104,6 +104,14 @@ def main(
             help="Skip test files in analysis.",
         ),
     ] = True,
+    no_venv: Annotated[
+        bool,
+        typer.Option(
+            "--no-venv/--venv",
+            help="Skip virtualenv creation and dependency installation; resolve "
+            "imports against the ambient Python environment instead.",
+        ),
+    ] = False,
     file_name: Annotated[
         Optional[Path],
         typer.Option(
@@ -144,6 +152,7 @@ def main(
         using_ray=using_ray,
         rebuild_analysis=rebuild_analysis,
         skip_tests=skip_tests,
+        no_venv=no_venv,
         file_name=file_name,
         cache_dir=cache_dir,
         clear_cache=clear_cache,

codeanalyzer/core.py

@@ -66,6 +66,7 @@ def __init__(self, options: AnalysisOptions) -> None:
         self.skip_tests = options.skip_tests
         self.using_codeql = options.using_codeql
         self.rebuild_analysis = options.rebuild_analysis
+        self.no_venv = options.no_venv
         self.cache_dir = (
             options.cache_dir.resolve() if options.cache_dir is not None else self.project_dir
         ) / ".codeanalyzer"
@@ -260,8 +261,13 @@ def __enter__(self) -> "Codeanalyzer":
         venv_path = self.cache_dir / self.project_dir.name / "virtualenv"
         # Ensure the cache directory exists for this project
         venv_path.parent.mkdir(parents=True, exist_ok=True)
+        if self.no_venv:
+            logger.info(
+                "--no-venv: using the ambient Python environment "
+                "(skipping virtualenv creation and dependency installation)"
+            )
         # Create the virtual environment if it does not exist
-        if not venv_path.exists() or self.rebuild_analysis:
+        if not self.no_venv and (not venv_path.exists() or self.rebuild_analysis):
             logger.info(f"(Re-)creating virtual environment at {venv_path}")
             self._cmd_exec_helper(
                 [str(self._get_base_interpreter()), "-m", "venv", str(venv_path)],
@@ -320,8 +326,9 @@ def __enter__(self) -> "Codeanalyzer":
         # Point Jedi at the analysis venv so it resolves the project's third-party
         # imports. This runs on both a fresh build and a lazy reuse of an existing
         # venv -- previously self.virtualenv stayed None, so the install above was
-        # never actually used by the symbol-table builder.
-        if venv_path.exists():
+        # never actually used by the symbol-table builder. With --no-venv we leave
+        # it None so Jedi resolves against the ambient interpreter instead.
+        if not self.no_venv and venv_path.exists():
             self.virtualenv = venv_path
 
         if self.using_codeql:

codeanalyzer/options/options.py

@@ -38,6 +38,7 @@ class AnalysisOptions:
     using_ray: bool = False
     rebuild_analysis: bool = False
     skip_tests: bool = True
+    no_venv: bool = False
     file_name: Optional[Path] = None
     cache_dir: Optional[Path] = None
     clear_cache: bool = False

test/test_cli.py

@@ -38,6 +38,27 @@ def test_cli_call_symbol_table_with_json(cli_runner, whole_applications__xarray)
     assert len(json_obj["symbol_table"]) > 0, "Symbol table should not be empty"
 
 
+def test_no_venv_skips_virtualenv(
+    cli_runner, single_functionalities__stuff_nested_in_functions, tmp_path
+):
+    """#46: --no-venv must skip virtualenv creation/installation and still analyze."""
+    out = tmp_path / "out"
+    cache = tmp_path / "cache"
+    result = cli_runner.invoke(
+        app,
+        [
+            "--input", str(single_functionalities__stuff_nested_in_functions),
+            "--output", str(out),
+            "--cache-dir", str(cache),
+            "--no-venv", "--no-codeql", "--no-ray",
+        ],
+        env={"NO_COLOR": "1", "TERM": "dumb"},
+    )
+    assert result.exit_code == 0, result.output
+    assert (out / "analysis.json").exists(), "analysis.json should still be produced with --no-venv"
+    assert not list(cache.rglob("virtualenv")), "--no-venv must not create a virtualenv"
+
+
 def test_single_file(cli_runner, single_functionalities__stuff_nested_in_functions):
     """Must be able to run the CLI with single file analysis using --file-name flag."""
     output_dir = single_functionalities__stuff_nested_in_functions.joinpath(".output")