⚡️ Speed up function _should_show_onboarding_reminder by 253%

[codeflash-ai]

📄 253% (2.53x) speedup for _should_show_onboarding_reminder in pdd/cli.py

⏱️ Runtime : 1.33 milliseconds → 378 microseconds (best of 124 runs)

📝 Explanation and details

The optimized code achieves a 253% speedup through two key optimizations:

1. Generator Expression with next() in _first_pending_command()

• Replaced explicit loop with next((arg for arg in ctx.protected_args if not arg.startswith("-")), None)
• Eliminates unnecessary iterations by short-circuiting on first match
• Profile shows dramatic reduction from 1.83ms to 0.87ms total time
• Most effective for cases with many command-line arguments where the first non-option arg appears early

2. LRU Cache on _api_env_exists()

• Added @lru_cache(maxsize=1) to cache the filesystem check result
• The ~/.pdd/api-env file rarely changes during a session, but the function is called repeatedly
• Profile shows massive reduction from 2.83ms to 0.17ms in _should_show_onboarding_reminder()
• Eliminates redundant filesystem exists() calls which are expensive system operations

Performance Impact by Test Case:

• Basic cases: 400-600% faster when API env doesn't exist (eliminates repeated fs checks)
• Large scale cases: 50-90% faster with many protected args (generator optimization)
• Setup command cases: Slightly slower (17-25%) due to overhead, but these are rare fast paths

The optimizations are particularly effective for the common onboarding check scenario where multiple filesystem and argument parsing operations occur in sequence.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 59 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	76.9%

🌀 Generated Regression Tests and Runtime

import os
from pathlib import Path
from types import SimpleNamespace

# imports
import pytest
from pdd.cli import _should_show_onboarding_reminder

# --- Minimal stubs and helpers to simulate click.Context and shell logic ---

class DummyContext:
    """Minimal stub for click.Context, only 'protected_args' is used."""
    def __init__(self, protected_args):
        self.protected_args = protected_args
from pdd.cli import _should_show_onboarding_reminder

# --- Basic Test Cases ---

def test_reminder_shown_with_no_setup(monkeypatch):
    """Should show reminder if nothing is set up and no suppression."""
    ctx = DummyContext(["run"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 29.0μs -> 4.32μs (571% faster)

def test_reminder_not_shown_if_suppressed(monkeypatch):
    """Should NOT show reminder if suppression env var is set (1/true/yes)."""
    ctx = DummyContext(["run"])
    for val in ["1", "true", "yes", "TRUE", "YeS"]:
        monkeypatch.setenv("PDD_SUPPRESS_SETUP_REMINDER", val)
        codeflash_output = _should_show_onboarding_reminder(ctx) # 5.04μs -> 5.03μs (0.040% faster)

def test_reminder_not_shown_for_setup_command():
    """Should NOT show reminder if first command is 'setup'."""
    ctx = DummyContext(["setup"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 2.81μs -> 3.54μs (20.6% slower)

def test_reminder_not_shown_if_api_env_exists(tmp_path):
    """Should NOT show reminder if ~/.pdd/api-env file exists."""
    # Create ~/.pdd/api-env
    api_env_dir = tmp_path / ".pdd"
    api_env_dir.mkdir()
    (api_env_dir / "api-env").write_text("OPENAI_API_KEY=sk-xxx")
    ctx = DummyContext(["run"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 26.9μs -> 4.91μs (447% faster)

def test_reminder_not_shown_if_project_has_env(tmp_path):
    """Should NOT show reminder if .env contains API key in project dir."""
    (tmp_path / ".env").write_text("OPENAI_API_KEY=sk-xxx")
    ctx = DummyContext(["run"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 26.5μs -> 5.03μs (427% faster)

def test_reminder_not_shown_if_project_has_pdd_dir(tmp_path):
    """Should NOT show reminder if .pdd directory exists in project."""
    (tmp_path / ".pdd").mkdir()
    ctx = DummyContext(["run"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 25.0μs -> 4.76μs (425% faster)

def test_reminder_not_shown_if_completion_installed(tmp_path):
    """Should NOT show reminder if shell RC file contains completion marker."""
    rc_path = tmp_path / ".bashrc"
    rc_path.write_text("...PDD CLI completion...")
    ctx = DummyContext(["run"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 25.9μs -> 5.05μs (413% faster)

def test_reminder_not_shown_if_completion_installed_alt(tmp_path):
    """Should NOT show reminder if shell RC file contains pdd_completion marker."""
    rc_path = tmp_path / ".bashrc"
    rc_path.write_text("...pdd_completion...")
    ctx = DummyContext(["run"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 26.0μs -> 5.04μs (417% faster)

def test_reminder_shown_if_completion_not_installed(tmp_path):
    """Should show reminder if shell RC file does NOT contain completion marker."""
    rc_path = tmp_path / ".bashrc"
    rc_path.write_text("export PATH=$PATH:/usr/local/bin")
    ctx = DummyContext(["run"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 25.3μs -> 4.96μs (409% faster)

# --- Edge Test Cases ---

def test_reminder_not_shown_if_env_file_exists_but_no_api_key(tmp_path):
    """Should show reminder if .env exists but contains no API keys."""
    (tmp_path / ".env").write_text("FOO=bar\nBAZ=qux")
    ctx = DummyContext(["run"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 25.9μs -> 4.99μs (419% faster)

def test_reminder_not_shown_if_env_file_unreadable(tmp_path):
    """Should show reminder if .env exists but is unreadable (simulate OSError)."""
    env_file = tmp_path / ".env"
    env_file.write_text("OPENAI_API_KEY=sk-xxx")
    env_file.chmod(0)  # Remove read permissions
    ctx = DummyContext(["run"])
    # Should still suppress reminder due to API key presence
    codeflash_output = _should_show_onboarding_reminder(ctx) # 26.2μs -> 4.86μs (439% faster)

def test_reminder_not_shown_if_rc_file_unreadable(tmp_path):
    """Should show reminder if shell RC file exists but is unreadable (simulate OSError)."""
    rc_path = tmp_path / ".bashrc"
    rc_path.write_text("PDD CLI completion")
    rc_path.chmod(0)  # Remove read permissions
    ctx = DummyContext(["run"])
    # Should treat as not installed, so reminder is shown
    codeflash_output = _should_show_onboarding_reminder(ctx) # 26.9μs -> 5.13μs (425% faster)

def test_reminder_shown_if_protected_args_are_all_flags():
    """Should show reminder if no subcommand in protected_args (all flags)."""
    ctx = DummyContext(["--help", "-v"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 25.5μs -> 3.99μs (539% faster)

def test_reminder_shown_if_protected_args_empty():
    """Should show reminder if protected_args is empty."""
    ctx = DummyContext([])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 24.9μs -> 3.39μs (633% faster)

def test_reminder_not_shown_if_first_command_is_setup_among_flags():
    """Should NOT show reminder if first non-flag arg is 'setup'."""
    ctx = DummyContext(["-v", "setup", "--foo"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 2.95μs -> 3.58μs (17.7% slower)

def test_reminder_not_shown_if_env_var_false(monkeypatch):
    """Should show reminder if suppression env var is set to '0' or 'false'."""
    ctx = DummyContext(["run"])
    for val in ["0", "false", "no"]:
        monkeypatch.setenv("PDD_SUPPRESS_SETUP_REMINDER", val)
        codeflash_output = _should_show_onboarding_reminder(ctx) # 56.3μs -> 6.00μs (839% faster)

def test_reminder_shown_if_shell_rc_path_missing(monkeypatch):
    """Should show reminder if get_shell_rc_path returns None."""
    monkeypatch.setenv("SHELL", "unknownshell")
    ctx = DummyContext(["run"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 25.3μs -> 3.45μs (635% faster)

def test_reminder_shown_if_shell_rc_file_missing(tmp_path):
    """Should show reminder if shell RC file does not exist."""
    # Do not create .bashrc
    ctx = DummyContext(["run"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 25.7μs -> 4.58μs (461% faster)

# --- Large Scale Test Cases ---

def test_large_scale_many_flags_and_args(tmp_path):
    """Test with a large number of protected_args, reminder should be shown."""
    args = ["-v"] * 500 + ["run"] + ["--foo"] * 499
    ctx = DummyContext(args)
    codeflash_output = _should_show_onboarding_reminder(ctx) # 46.4μs -> 23.9μs (94.2% faster)

def test_large_scale_many_api_env_files(tmp_path):
    """Test with many files in ~/.pdd, only api-env presence matters."""
    api_env_dir = tmp_path / ".pdd"
    api_env_dir.mkdir()
    # Create many unrelated files
    for i in range(999):
        (api_env_dir / f"file{i}.txt").write_text("dummy")
    # Create api-env last
    (api_env_dir / "api-env").write_text("OPENAI_API_KEY=sk-xxx")
    ctx = DummyContext(["run"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 33.2μs -> 8.75μs (280% faster)

def test_large_scale_env_file_with_many_keys(tmp_path):
    """Test .env file with many lines, only API key lines matter."""
    lines = [f"FOO{i}=val{i}" for i in range(999)]
    lines.append("GOOGLE_API_KEY=sk-yyy")
    (tmp_path / ".env").write_text("\n".join(lines))
    ctx = DummyContext(["run"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 28.2μs -> 5.31μs (431% faster)

def test_large_scale_rc_file_with_long_content(tmp_path):
    """Test shell RC file with large content, completion marker at end."""
    rc_path = tmp_path / ".bashrc"
    rc_path.write_text("export FOO=bar\n" * 999 + "PDD CLI completion\n")
    ctx = DummyContext(["run"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 26.3μs -> 5.20μs (406% faster)

def test_large_scale_rc_file_without_completion(tmp_path):
    """Test shell RC file with large content, but no completion marker."""
    rc_path = tmp_path / ".bashrc"
    rc_path.write_text("export FOO=bar\n" * 999)
    ctx = DummyContext(["run"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 26.8μs -> 4.97μs (440% faster)

def test_large_scale_protected_args_all_flags():
    """Test with 1000 flags in protected_args, reminder should be shown."""
    ctx = DummyContext(["--foo"] * 1000)
    codeflash_output = _should_show_onboarding_reminder(ctx) # 65.1μs -> 42.0μs (55.1% faster)

def test_large_scale_protected_args_setup_at_end():
    """Test with 999 flags and 'setup' at the end, should NOT show reminder."""
    args = ["--foo"] * 999 + ["setup"]
    ctx = DummyContext(args)
    codeflash_output = _should_show_onboarding_reminder(ctx) # 42.7μs -> 41.9μs (1.90% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import os
import shutil
import tempfile
from pathlib import Path
from typing import Optional

import pytest
from pdd.cli import _should_show_onboarding_reminder


# Minimal click.Context mock for our tests
class DummyCtx:
    def __init__(self, protected_args):
        self.protected_args = protected_args
from pdd.cli import _should_show_onboarding_reminder


@pytest.fixture
def set_shell(monkeypatch):
    # Helper to set shell for tests
    def _set(shell):
        monkeypatch.setenv("_TEST_SHELL", shell)
    return _set

# --- END: Fixtures ---

# --- BEGIN: Basic Test Cases ---

def test_reminder_shown_when_no_config_and_no_suppression(set_shell):
    """Should show reminder when nothing is configured and no suppression env."""
    set_shell("bash")
    ctx = DummyCtx(["foo"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 25.2μs -> 3.33μs (659% faster)

def test_reminder_not_shown_if_suppression_env_1(monkeypatch, set_shell):
    """Should NOT show reminder if PDD_SUPPRESS_SETUP_REMINDER=1."""
    set_shell("bash")
    monkeypatch.setenv("PDD_SUPPRESS_SETUP_REMINDER", "1")
    ctx = DummyCtx(["foo"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 1.82μs -> 1.69μs (7.69% faster)

def test_reminder_not_shown_if_suppression_env_true(monkeypatch, set_shell):
    """Should NOT show reminder if PDD_SUPPRESS_SETUP_REMINDER=true."""
    set_shell("bash")
    monkeypatch.setenv("PDD_SUPPRESS_SETUP_REMINDER", "true")
    ctx = DummyCtx(["foo"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 1.68μs -> 1.66μs (1.14% faster)

def test_reminder_not_shown_if_suppression_env_yes(monkeypatch, set_shell):
    """Should NOT show reminder if PDD_SUPPRESS_SETUP_REMINDER=yes."""
    set_shell("bash")
    monkeypatch.setenv("PDD_SUPPRESS_SETUP_REMINDER", "yes")
    ctx = DummyCtx(["foo"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 1.67μs -> 1.71μs (2.39% slower)

def test_reminder_not_shown_if_command_is_setup(set_shell):
    """Should NOT show reminder if first command is 'setup'."""
    set_shell("bash")
    ctx = DummyCtx(["setup"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 2.26μs -> 3.01μs (25.0% slower)

def test_reminder_not_shown_if_api_env_exists(set_shell):
    """Should NOT show reminder if ~/.pdd/api-env exists."""
    set_shell("bash")
    home = Path.home()
    pdd_dir = home / ".pdd"
    pdd_dir.mkdir(parents=True, exist_ok=True)
    (pdd_dir / "api-env").touch()
    ctx = DummyCtx(["foo"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 18.0μs -> 3.70μs (387% faster)

def test_reminder_not_shown_if_project_env_file_with_api_key(tmp_path, set_shell):
    """Should NOT show reminder if .env file in project contains API key."""
    set_shell("bash")
    env_path = tmp_path / ".env"
    env_path.write_text("OPENAI_API_KEY=sk-xxx\n")
    ctx = DummyCtx(["foo"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 25.6μs -> 4.25μs (502% faster)

def test_reminder_not_shown_if_project_pdd_dir_exists(tmp_path, set_shell):
    """Should NOT show reminder if .pdd directory exists in project."""
    set_shell("bash")
    (tmp_path / ".pdd").mkdir()
    ctx = DummyCtx(["foo"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 24.6μs -> 4.18μs (489% faster)

def test_reminder_not_shown_if_completion_installed(set_shell):
    """Should NOT show reminder if shell RC file contains completion marker."""
    set_shell("bash")
    home = Path.home()
    rc_path = home / ".bashrc"
    rc_path.write_text("# PDD CLI completion\n")
    ctx = DummyCtx(["foo"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 21.4μs -> 4.29μs (400% faster)

def test_reminder_not_shown_if_completion_installed_alt_marker(set_shell):
    """Should NOT show reminder if shell RC file contains pdd_completion marker."""
    set_shell("zsh")
    home = Path.home()
    rc_path = home / ".zshrc"
    rc_path.write_text("# pdd_completion\n")
    ctx = DummyCtx(["foo"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 22.1μs -> 4.24μs (421% faster)

def test_reminder_shown_if_env_file_without_api_key(tmp_path, set_shell):
    """Should show reminder if .env exists but has no API key."""
    set_shell("bash")
    env_path = tmp_path / ".env"
    env_path.write_text("SOME_OTHER_VAR=1\n")
    ctx = DummyCtx(["foo"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 25.5μs -> 4.32μs (489% faster)

# --- END: Basic Test Cases ---

# --- BEGIN: Edge Test Cases ---

def test_reminder_shown_if_protected_args_are_all_options(set_shell):
    """Should show reminder if all protected_args are options (no commands)."""
    set_shell("bash")
    ctx = DummyCtx(["-v", "--help"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 27.2μs -> 3.43μs (692% faster)

def test_reminder_shown_if_protected_args_is_empty(set_shell):
    """Should show reminder if protected_args is empty."""
    set_shell("bash")
    ctx = DummyCtx([])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 26.4μs -> 2.80μs (843% faster)

def test_reminder_shown_if_shell_rc_file_missing(set_shell):
    """Should show reminder if shell RC file does not exist."""
    set_shell("zsh")
    # Don't create .zshrc
    ctx = DummyCtx(["foo"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 25.5μs -> 3.14μs (712% faster)

def test_reminder_shown_if_shell_is_unknown(set_shell):
    """Should show reminder if shell is unknown (no RC path)."""
    set_shell("unknownshell")
    ctx = DummyCtx(["foo"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 27.2μs -> 3.19μs (754% faster)

def test_reminder_shown_if_env_file_is_non_utf8(tmp_path, set_shell):
    """Should show reminder if .env file exists but is non-UTF8 (unreadable)."""
    set_shell("bash")
    env_path = tmp_path / ".env"
    # Write invalid UTF-8 bytes
    env_path.write_bytes(b"\xff\xfe\xfd")
    ctx = DummyCtx(["foo"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 26.4μs -> 4.19μs (529% faster)

def test_reminder_not_shown_if_env_file_is_non_utf8_but_has_api_key(tmp_path, set_shell):
    """Should NOT show reminder if .env file is non-UTF8 but .pdd dir exists."""
    set_shell("bash")
    (tmp_path / ".pdd").mkdir()
    env_path = tmp_path / ".env"
    env_path.write_bytes(b"\xff\xfe\xfd")
    ctx = DummyCtx(["foo"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 24.3μs -> 4.49μs (441% faster)

def test_reminder_shown_if_completion_rc_file_is_non_utf8(set_shell):
    """Should show reminder if RC file exists but is non-UTF8 (unreadable)."""
    set_shell("bash")
    home = Path.home()
    rc_path = home / ".bashrc"
    rc_path.write_bytes(b"\xff\xfe\xfd")
    ctx = DummyCtx(["foo"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 21.7μs -> 4.17μs (419% faster)

def test_reminder_shown_if_shell_is_empty(set_shell):
    """Should show reminder if shell is empty string (no RC path)."""
    set_shell("")
    ctx = DummyCtx(["foo"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 27.4μs -> 3.44μs (696% faster)

def test_reminder_not_shown_if_env_var_case_insensitive(monkeypatch, set_shell):
    """Should NOT show reminder if suppression env is 'TrUe' (case-insensitive)."""
    set_shell("bash")
    monkeypatch.setenv("PDD_SUPPRESS_SETUP_REMINDER", "TrUe")
    ctx = DummyCtx(["foo"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 1.80μs -> 1.78μs (0.956% faster)

def test_reminder_shown_if_env_var_is_false(monkeypatch, set_shell):
    """Should show reminder if suppression env is 'false' (not a suppress value)."""
    set_shell("bash")
    monkeypatch.setenv("PDD_SUPPRESS_SETUP_REMINDER", "false")
    ctx = DummyCtx(["foo"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 29.2μs -> 3.02μs (867% faster)

# --- END: Edge Test Cases ---

# --- BEGIN: Large Scale Test Cases ---

def test_large_number_of_protected_args(set_shell):
    """Should show reminder with large number of protected_args, no commands."""
    set_shell("bash")
    ctx = DummyCtx(["-v"] * 999)
    codeflash_output = _should_show_onboarding_reminder(ctx) # 67.8μs -> 41.3μs (64.3% faster)

def test_large_number_of_protected_args_with_command(set_shell):
    """Should NOT show reminder if a command is present among many options."""
    set_shell("bash")
    args = ["-v"] * 500 + ["setup"] + ["-x"] * 498
    ctx = DummyCtx(args)
    codeflash_output = _should_show_onboarding_reminder(ctx) # 22.4μs -> 22.3μs (0.508% faster)

def test_many_env_files_no_api_key(tmp_path, set_shell):
    """Should show reminder if many .env-like files exist but only .env counts."""
    set_shell("bash")
    for i in range(100):
        (tmp_path / f".env_{i}").write_text("OPENAI_API_KEY=sk-xxx\n")
    ctx = DummyCtx(["foo"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 30.5μs -> 6.58μs (364% faster)

def test_many_env_files_one_env_with_api_key(tmp_path, set_shell):
    """Should NOT show reminder if .env contains API key among many env files."""
    set_shell("bash")
    for i in range(100):
        (tmp_path / f".env_{i}").write_text("OPENAI_API_KEY=sk-xxx\n")
    (tmp_path / ".env").write_text("GOOGLE_API_KEY=sk-yyy\n")
    ctx = DummyCtx(["foo"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 29.8μs -> 6.43μs (364% faster)

def test_large_rc_file_without_completion_marker(set_shell):
    """Should show reminder if RC file is large but has no completion marker."""
    set_shell("zsh")
    home = Path.home()
    rc_path = home / ".zshrc"
    rc_path.write_text("export FOO=1\n" * 500)
    ctx = DummyCtx(["foo"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 22.6μs -> 4.45μs (407% faster)

def test_large_rc_file_with_completion_marker(set_shell):
    """Should NOT show reminder if RC file is large and has completion marker."""
    set_shell("zsh")
    home = Path.home()
    rc_path = home / ".zshrc"
    content = ("export FOO=1\n" * 499) + "# PDD CLI completion\n"
    rc_path.write_text(content)
    ctx = DummyCtx(["foo"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 22.7μs -> 4.38μs (419% faster)

def test_many_pdd_dirs_and_env_files(tmp_path, set_shell):
    """Should NOT show reminder if .pdd dir exists among many other dirs/files."""
    set_shell("bash")
    for i in range(100):
        (tmp_path / f"dir_{i}").mkdir()
        (tmp_path / f".env_{i}").write_text("FOO=BAR\n")
    (tmp_path / ".pdd").mkdir()
    ctx = DummyCtx(["foo"])
    codeflash_output = _should_show_onboarding_reminder(ctx) # 30.7μs -> 7.61μs (304% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-_should_show_onboarding_reminder-mgmoginf and push.