Merge branch 'main' into fix/get-language-based-on-formatter

Author: mohammedahmed18

CLAUDE.md

@@ -57,19 +57,11 @@ codeflash/
 └── result/                 # Result types and handling
 ```
 
-### Key Patterns
-
-**Either/Result pattern for errors:**
-```python
-from codeflash.either import is_successful, Success, Failure
-result = some_operation()
-if is_successful(result):
-    value = result.unwrap()
-else:
-    error = result.failure()
-```
+### Key Rules to follow
 
-**Use libcst, not ast** - Always use `libcst` for code parsing/modification to preserve formatting.
+- Use libcst, not ast - For Python, always use `libcst` for code parsing/modification to preserve formatting.
+- Code context extraction and replacement tests must always assert for full string equality, no substring matching.
+- Any new feature or bug fix that can be tested automatically must have test cases.
 
 ## Code Style
 

codeflash/cli_cmds/cli.py

@@ -121,6 +121,15 @@ def parse_args() -> Namespace:
         "--effort", type=str, help="Effort level for optimization", choices=["low", "medium", "high"], default="medium"
     )
 
+    # Config management flags
+    parser.add_argument(
+        "--show-config", action="store_true", help="Show current or auto-detected configuration and exit."
+    )
+    parser.add_argument(
+        "--reset-config", action="store_true", help="Remove codeflash configuration from project config file."
+    )
+    parser.add_argument("-y", "--yes", action="store_true", help="Skip confirmation prompts (useful for CI/scripts).")
+
     args, unknown_args = parser.parse_known_args()
     sys.argv[:] = [sys.argv[0], *unknown_args]
     return process_and_validate_cmd_args(args)
@@ -147,6 +156,16 @@ def process_and_validate_cmd_args(args: Namespace) -> Namespace:
         logger.info(f"Codeflash version {version}")
         sys.exit()
 
+    # Handle --show-config
+    if getattr(args, "show_config", False):
+        _handle_show_config()
+        sys.exit()
+
+    # Handle --reset-config
+    if getattr(args, "reset_config", False):
+        _handle_reset_config(confirm=not getattr(args, "yes", False))
+        sys.exit()
+
     if args.command == "vscode-install":
         install_vscode_extension()
         sys.exit()
@@ -212,11 +231,22 @@ def process_pyproject_config(args: Namespace) -> Namespace:
     is_js_ts_project = pyproject_config.get("language") in ("javascript", "typescript")
     if args.tests_root is None:
         if is_js_ts_project:
-            # Try common JS test directories, or default to module_root
+            # Try common JS test directories at project root first
             for test_dir in ["test", "tests", "__tests__"]:
                 if Path(test_dir).is_dir():
                     args.tests_root = test_dir
                     break
+            # If not found at project root, try inside module_root (e.g., src/test, src/__tests__)
+            if args.tests_root is None and args.module_root:
+                module_root_path = Path(args.module_root)
+                for test_dir in ["test", "tests", "__tests__"]:
+                    test_path = module_root_path / test_dir
+                    if test_path.is_dir():
+                        args.tests_root = str(test_path)
+                        break
+            # Final fallback: default to module_root
+            # Note: This may cause issues if tests are colocated with source files
+            # In such cases, the user should explicitly configure testsRoot in package.json
             if args.tests_root is None:
                 args.tests_root = args.module_root
         else:
@@ -309,3 +339,91 @@ def handle_optimize_all_arg_parsing(args: Namespace) -> Namespace:
     else:
         args.all = Path(args.all).resolve()
     return args
+
+
+def _handle_show_config() -> None:
+    """Show current or auto-detected Codeflash configuration."""
+    from rich.table import Table
+
+    from codeflash.cli_cmds.console import console
+    from codeflash.setup.detector import detect_project, has_existing_config
+
+    project_root = Path.cwd()
+    detected = detect_project(project_root)
+
+    # Check if config exists or is auto-detected
+    config_exists = has_existing_config(project_root)
+    status = "Saved config" if config_exists else "Auto-detected (not saved)"
+
+    console.print()
+    console.print(f"[bold]Codeflash Configuration[/bold] ({status})")
+    console.print()
+
+    table = Table(show_header=True, header_style="bold cyan")
+    table.add_column("Setting", style="dim")
+    table.add_column("Value")
+
+    table.add_row("Language", detected.language)
+    table.add_row("Project root", str(detected.project_root))
+    table.add_row("Module root", str(detected.module_root))
+    table.add_row("Tests root", str(detected.tests_root) if detected.tests_root else "(not detected)")
+    table.add_row("Test runner", detected.test_runner or "(not detected)")
+    table.add_row("Formatter", ", ".join(detected.formatter_cmds) if detected.formatter_cmds else "(not detected)")
+    table.add_row(
+        "Ignore paths", ", ".join(str(p) for p in detected.ignore_paths) if detected.ignore_paths else "(none)"
+    )
+    table.add_row("Confidence", f"{detected.confidence:.0%}")
+
+    console.print(table)
+    console.print()
+
+    if not config_exists:
+        console.print("[dim]Run [bold]codeflash --file <file>[/bold] to auto-save this config.[/dim]")
+
+
+def _handle_reset_config(confirm: bool = True) -> None:
+    """Remove Codeflash configuration from project config file.
+
+    Args:
+        confirm: If True, prompt for confirmation before removing.
+
+    """
+    from codeflash.cli_cmds.console import console
+    from codeflash.setup.config_writer import remove_config
+    from codeflash.setup.detector import detect_project, has_existing_config
+
+    project_root = Path.cwd()
+
+    if not has_existing_config(project_root):
+        console.print("[yellow]No Codeflash configuration found to remove.[/yellow]")
+        return
+
+    detected = detect_project(project_root)
+
+    if confirm:
+        console.print("[bold]This will remove Codeflash configuration from your project.[/bold]")
+        console.print()
+
+        config_file = "pyproject.toml" if detected.language == "python" else "package.json"
+        console.print(f"  Config file: {project_root / config_file}")
+        console.print()
+
+        try:
+            response = console.input("[bold]Are you sure you want to remove the config? [y/N][/bold] ")
+        except (EOFError, KeyboardInterrupt):
+            console.print("\n[yellow]Cancelled.[/yellow]")
+            return
+
+        if response.lower() not in ("y", "yes"):
+            console.print("[yellow]Cancelled.[/yellow]")
+            return
+
+    success, message = remove_config(project_root, detected.language)
+
+    # Escape brackets in message to prevent Rich markup interpretation
+    escaped_message = message.replace("[", "\\[")
+
+    if success:
+        console.print(f"[green]✓[/green] {escaped_message}")
+    else:
+        console.print(f"[red]✗[/red] {escaped_message}")

codeflash/cli_cmds/cmd_init.py

@@ -607,7 +607,33 @@ def check_for_toml_or_setup_file() -> str | None:
     curdir = Path.cwd()
     pyproject_toml_path = curdir / "pyproject.toml"
     setup_py_path = curdir / "setup.py"
+    package_json_path = curdir / "package.json"
     project_name = None
+
+    # Check if this might be a JavaScript/TypeScript project that wasn't detected
+    if package_json_path.exists() and not pyproject_toml_path.exists() and not setup_py_path.exists():
+        js_redirect_panel = Panel(
+            Text(
+                f"📦 I found a package.json in {curdir}.\n\n"
+                "This looks like a JavaScript/TypeScript project!\n"
+                "Redirecting to JavaScript setup...",
+                style="cyan",
+            ),
+            title="🟨 JavaScript Project Detected",
+            border_style="bright_yellow",
+        )
+        console.print(js_redirect_panel)
+        console.print()
+        ph("cli-js-project-redirect")
+
+        # Redirect to JS init
+        from codeflash.cli_cmds.init_javascript import ProjectLanguage, detect_project_language, init_js_project
+
+        project_language = detect_project_language()
+        if project_language in (ProjectLanguage.JAVASCRIPT, ProjectLanguage.TYPESCRIPT):
+            init_js_project(project_language)
+            sys.exit(0)  # init_js_project handles its own exit, but ensure we don't continue
+
     if pyproject_toml_path.exists():
         try:
             pyproject_toml_content = pyproject_toml_path.read_text(encoding="utf8")
@@ -617,28 +643,44 @@ def check_for_toml_or_setup_file() -> str | None:
         except Exception:
             click.echo("✅ I found a pyproject.toml for your project.")
             ph("cli-pyproject-toml-found")
+    elif setup_py_path.exists():
+        setup_py_content = setup_py_path.read_text(encoding="utf8")
+        project_name_match = re.search(r"setup\s*\([^)]*?name\s*=\s*['\"](.*?)['\"]", setup_py_content, re.DOTALL)
+        if project_name_match:
+            project_name = project_name_match.group(1)
+            click.echo(f"✅ Found setup.py for your project {project_name}")
+            ph("cli-setup-py-found-name")
+        else:
+            click.echo("✅ Found setup.py.")
+            ph("cli-setup-py-found")
     else:
-        if setup_py_path.exists():
-            setup_py_content = setup_py_path.read_text(encoding="utf8")
-            project_name_match = re.search(r"setup\s*\([^)]*?name\s*=\s*['\"](.*?)['\"]", setup_py_content, re.DOTALL)
-            if project_name_match:
-                project_name = project_name_match.group(1)
-                click.echo(f"✅ Found setup.py for your project {project_name}")
-                ph("cli-setup-py-found-name")
-            else:
-                click.echo("✅ Found setup.py.")
-                ph("cli-setup-py-found")
-        toml_info_panel = Panel(
-            Text(
-                f"💡 No pyproject.toml found in {curdir}.\n\n"
-                "This file is essential for Codeflash to store its configuration.\n"
-                "Please ensure you are running `codeflash init` from your project's root directory.",
-                style="yellow",
-            ),
-            title="📋 pyproject.toml Required",
-            border_style="bright_yellow",
-        )
-        console.print(toml_info_panel)
+        # No Python config files found - show appropriate message
+        # Check again if this might be a JS project
+        if package_json_path.exists():
+            js_hint_panel = Panel(
+                Text(
+                    f"📦 I found a package.json but no pyproject.toml in {curdir}.\n\n"
+                    "If this is a JavaScript/TypeScript project, please run:\n"
+                    "  codeflash init\n\n"
+                    "from the project root directory.",
+                    style="yellow",
+                ),
+                title="🤔 Mixed Project?",
+                border_style="bright_yellow",
+            )
+            console.print(js_hint_panel)
+        else:
+            toml_info_panel = Panel(
+                Text(
+                    f"💡 No pyproject.toml found in {curdir}.\n\n"
+                    "This file is essential for Codeflash to store its configuration.\n"
+                    "Please ensure you are running `codeflash init` from your project's root directory.",
+                    style="yellow",
+                ),
+                title="📋 pyproject.toml Required",
+                border_style="bright_yellow",
+            )
+            console.print(toml_info_panel)
         console.print()
         ph("cli-no-pyproject-toml-or-setup-py")
 

codeflash/cli_cmds/console.py

@@ -129,6 +129,9 @@ def code_print(
 
 spinners = cycle(SPINNER_TYPES)
 
+# Track whether a progress bar is already active to prevent nested Live displays
+_progress_bar_active = False
+
 
 @contextmanager
 def progress_bar(
@@ -138,28 +141,38 @@ def progress_bar(
 
     If revert_to_print is True, falls back to printing a single logger.info message
     instead of showing a progress bar.
+
+    If a progress bar is already active, yields a dummy task ID to avoid Rich's
+    LiveError from nested Live displays.
     """
+    global _progress_bar_active
+
     if is_LSP_enabled():
         lsp_log(LspTextMessage(text=message, takes_time=True))
         yield
         return
 
-    if revert_to_print:
-        logger.info(message)
+    if revert_to_print or _progress_bar_active:
+        if revert_to_print:
+            logger.info(message)
 
         # Create a fake task ID since we still need to yield something
         yield DummyTask().id
     else:
-        progress = Progress(
-            SpinnerColumn(next(spinners)),
-            *Progress.get_default_columns(),
-            TimeElapsedColumn(),
-            console=console,
-            transient=transient,
-        )
-        task = progress.add_task(message, total=None)
-        with progress:
-            yield task
+        _progress_bar_active = True
+        try:
+            progress = Progress(
+                SpinnerColumn(next(spinners)),
+                *Progress.get_default_columns(),
+                TimeElapsedColumn(),
+                console=console,
+                transient=transient,
+            )
+            task = progress.add_task(message, total=None)
+            with progress:
+                yield task
+        finally:
+            _progress_bar_active = False
 
 
 @contextmanager

codeflash/cli_cmds/init_javascript.py

@@ -90,13 +90,30 @@ def detect_project_language(project_root: Path | None = None) -> ProjectLanguage
     has_package_json = (root / "package.json").exists()
     has_tsconfig = (root / "tsconfig.json").exists()
 
-    # TypeScript project
+    # TypeScript project (tsconfig.json is definitive)
     if has_tsconfig:
         return ProjectLanguage.TYPESCRIPT
 
-    # Pure JS project (has package.json but no Python files)
-    if has_package_json and not has_pyproject and not has_setup_py:
-        return ProjectLanguage.JAVASCRIPT
+    # JavaScript project - package.json without Python-specific files takes priority
+    # Note: If both package.json and pyproject.toml exist, check for typical JS project indicators
+    if has_package_json:
+        # If no Python config files, it's definitely JavaScript
+        if not has_pyproject and not has_setup_py:
+            return ProjectLanguage.JAVASCRIPT
+
+        # If package.json exists with Python files, check for JS-specific indicators
+        # Common React/Node patterns indicate a JS project
+        js_indicators = [
+            (root / "node_modules").exists(),
+            (root / ".npmrc").exists(),
+            (root / "yarn.lock").exists(),
+            (root / "package-lock.json").exists(),
+            (root / "pnpm-lock.yaml").exists(),
+            (root / "bun.lockb").exists(),
+            (root / "bun.lock").exists(),
+        ]
+        if any(js_indicators):
+            return ProjectLanguage.JAVASCRIPT
 
     # Python project (default)
     return ProjectLanguage.PYTHON

codeflash/code_utils/code_replacer.py

@@ -659,6 +659,19 @@ def _add_global_declarations_for_language(
         # Get names of existing declarations
         existing_names = {decl.name for decl in original_declarations}
 
+        # Also exclude names that are already imported (to avoid duplicating imported types)
+        original_imports = analyzer.find_imports(original_source)
+        for imp in original_imports:
+            # Add default import name
+            if imp.default_import:
+                existing_names.add(imp.default_import)
+            # Add named imports (use alias if present, otherwise use original name)
+            for name, alias in imp.named_imports:
+                existing_names.add(alias if alias else name)
+            # Add namespace import
+            if imp.namespace_import:
+                existing_names.add(imp.namespace_import)
+
         # Find new declarations (names that don't exist in original)
         new_declarations = []
         seen_sources = set()  # Track to avoid duplicates from destructuring