teddy-cli 0.1.17.dev1400__tar.gz → 0.1.17.dev1402__tar.gz

{teddy_cli-0.1.17.dev1400 → teddy_cli-0.1.17.dev1402}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: teddy-cli
-Version: 0.1.17.dev1400
+Version: 0.1.17.dev1402
 Summary: The local-first, test-driven agentic engineering harness. Because you should own the means of development.
 Author: Raphael Atteritano
 License: AGPL-3.0-only

{teddy_cli-0.1.17.dev1400 → teddy_cli-0.1.17.dev1402}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "teddy-cli"
-version = "0.1.17.dev1400"
+version = "0.1.17.dev1402"
 description = "The local-first, test-driven agentic engineering harness. Because you should own the means of development."
 readme = "README.md"
 keywords = [

{teddy_cli-0.1.17.dev1400 → teddy_cli-0.1.17.dev1402}/src/teddy_executor/__main__.py

@@ -11,6 +11,7 @@ import typer
 from teddy_executor.core.domain.models import (
     ExecutionReport,
 )
+from teddy_executor.core.domain.models.exceptions import ConfigurationError
 from teddy_executor.core.ports.outbound.config_service import IConfigService
 from teddy_executor.core.ports.outbound.system_environment import ISystemEnvironment
 
@@ -129,6 +130,20 @@ def _display_init_drift(container) -> None:
     _display_checks_footer(_display_drift_notification(container))
 
 
+def _resolve_config_or_exit(container) -> IConfigService:
+    """Resolve the config service, failing fast on an invalid configuration.
+
+    A value that cannot be coerced to its declared type raises
+    ``ConfigurationError`` during adapter construction. Printing the message
+    and exiting keeps the failure visible instead of escaping as a traceback.
+    """
+    try:
+        return container.resolve(IConfigService)
+    except ConfigurationError as error:
+        typer.secho(f"Error: {error}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(code=1) from error
+
+
 def _ensure_project_initialized(container, root_dir: str | None = None) -> None:
     """Lazily performs project anchoring and initialization.
 
@@ -246,7 +261,7 @@ def start(  # noqa: PLR0913
 
     container = get_container()
     _ensure_project_initialized(container)
-    config_service = container.resolve(IConfigService)
+    config_service = _resolve_config_or_exit(container)
 
     from teddy_executor.adapters.inbound.cli_helpers import normalize_context_values
 
@@ -538,7 +553,7 @@ def resume(  # noqa: PLR0913
 
     container = get_container()
     _ensure_project_initialized(container)
-    config_service = container.resolve(IConfigService)
+    config_service = _resolve_config_or_exit(container)
 
     interactive = not (_resolve_yolo(yolo, config_service) or pipeline)
     system_env = container.resolve(ISystemEnvironment)

{teddy_cli-0.1.17.dev1400 → teddy_cli-0.1.17.dev1402}/src/teddy_executor/adapters/inbound/session_cli_handlers.py

@@ -1,4 +1,5 @@
 import logging
+import os
 import shutil
 import signal
 import subprocess  # nosec B404
@@ -244,10 +245,179 @@ def _check_git_initialized() -> None:
     )
 
 
-def _run_health_checks() -> None:
-    """Run all startup health checks and display notifications if needed."""
-    _ensure_commit_hooks()
-    _check_git_initialized()
+def _warn_disabled_workspace_steps(config_service: IConfigService) -> None:
+    """Print one warning per disabled workspace step with a real consequence.
+
+    A disabled hook installer warns because the unskippable post-commit test
+    gate then depends on a hook that never landed. A disabled git init warns
+    only when the workspace is not already a repository, because an existing
+    repository needs no initialization.
+    """
+    if not config_service.get_setting("workspace.pre-commit", True):
+        typer.secho(
+            "⚠ Pre-commit hook installation is disabled. "
+            "The post-commit test gate will not run.",
+            fg=typer.colors.YELLOW,
+            err=True,
+        )
+    init_disabled = not config_service.get_setting("workspace.init", True)
+    if init_disabled and not (Path.cwd() / ".git").exists():
+        typer.secho(
+            "⚠ Git repository not initialized. Version control actions will fail.",
+            fg=typer.colors.YELLOW,
+            err=True,
+        )
+
+
+def _run_health_checks(config_service: IConfigService) -> None:
+    """Run each startup health check the workspace toggles allow.
+
+    A disabled step is skipped, and ``_warn_disabled_workspace_steps`` reports
+    the ones that carry a real consequence.
+    """
+    if config_service.get_setting("workspace.pre-commit", True):
+        _ensure_commit_hooks()
+    if config_service.get_setting("workspace.init", True):
+        _check_git_initialized()
+    _warn_disabled_workspace_steps(config_service)
+
+
+_GIT_PULL_TIMEOUT_SECONDS = 15
+_PULL_SKIPPED_WARNING = "⚠ Workspace pull skipped; continuing with the current branch."
+_PULL_TIMEOUT_WARNING = "⚠ Workspace pull timed out; continuing without it."
+_IN_PROGRESS_GIT_MARKERS = (
+    "rebase-merge",
+    "rebase-apply",
+    "MERGE_HEAD",
+    "CHERRY_PICK_HEAD",
+)
+
+
+def _pull_workspace_on_start(
+    config_service: IConfigService,
+    run_func: Optional[Callable[..., Any]] = None,
+) -> None:
+    """Fast-forward the workspace before starting a new session.
+
+    The pull runs only when ``workspace.pull`` is enabled and the workspace is
+    a Git repository, so a disabled toggle or a non-repository directory stays
+    silent. A detached HEAD, a missing upstream, or an in-progress operation
+    also stays silent, because there is nothing safe to fast-forward. A dirty
+    worktree or a failed pull reports one warning and leaves the workspace
+    unchanged. A successful fast-forward names the number of commits it moved.
+
+    The Git process is injected through ``run_func`` so every decision is
+    testable without spawning a real repository.
+    """
+    if not config_service.get_setting("workspace.pull", True):
+        return
+    if not (Path.cwd() / ".git").exists():
+        return
+    git_run = run_func or subprocess.run
+    try:
+        _fast_forward_workspace(git_run)
+    except subprocess.TimeoutExpired:
+        typer.secho(_PULL_TIMEOUT_WARNING, fg=typer.colors.YELLOW, err=True)
+
+
+def _fast_forward_workspace(git_run: Callable[..., Any]) -> None:
+    """Run the pull decision table through the injected Git runner.
+
+    Each precondition is probed before the pull so an unsafe state never
+    reaches ``git pull``. A dirty worktree reports one warning, while every
+    other unsafe state stays silent because it has nothing to report.
+    """
+    skip_reason = _pull_skip_reason(git_run)
+    if skip_reason is not None:
+        if skip_reason:
+            typer.secho(skip_reason, fg=typer.colors.YELLOW, err=True)
+        return
+    before = _read_head(git_run)
+    result = git_run(
+        ["git", "pull", "--ff-only"],
+        env={**os.environ, "GIT_TERMINAL_PROMPT": "0"},
+        capture_output=True,
+        text=True,
+        timeout=_GIT_PULL_TIMEOUT_SECONDS,
+    )
+    if result.returncode != 0:
+        typer.secho(_PULL_SKIPPED_WARNING, fg=typer.colors.YELLOW, err=True)
+        return
+    _report_fast_forward(git_run, before, _read_head(git_run))
+
+
+def _pull_skip_reason(git_run: Callable[..., Any]) -> Optional[str]:
+    """Return the outcome text to print, or None when the pull may proceed.
+
+    An empty string marks a silent skip, because the workspace holds no safe
+    fast-forward and reporting it would only add noise. A dirty worktree
+    returns the skipped warning, because tracked changes can conflict.
+    """
+    git_dir = Path.cwd() / ".git"
+    if any((git_dir / marker).exists() for marker in _IN_PROGRESS_GIT_MARKERS):
+        return ""
+    detached = git_run(
+        ["git", "symbolic-ref", "-q", "HEAD"],
+        capture_output=True,
+        timeout=_GIT_PULL_TIMEOUT_SECONDS,
+    )
+    if detached.returncode != 0:
+        return ""
+    upstream = git_run(
+        ["git", "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"],
+        capture_output=True,
+        timeout=_GIT_PULL_TIMEOUT_SECONDS,
+    )
+    if upstream.returncode != 0:
+        return ""
+    status = git_run(
+        ["git", "status", "--porcelain"],
+        capture_output=True,
+        text=True,
+        timeout=_GIT_PULL_TIMEOUT_SECONDS,
+    )
+    tracked_changes = [
+        line
+        for line in status.stdout.splitlines()
+        if line and not line.startswith("??")
+    ]
+    if tracked_changes:
+        return _PULL_SKIPPED_WARNING
+    return None
+
+
+def _read_head(git_run: Callable[..., Any]) -> str:
+    """Read the current commit id through the injected Git runner."""
+    return git_run(
+        ["git", "rev-parse", "HEAD"],
+        capture_output=True,
+        text=True,
+        timeout=_GIT_PULL_TIMEOUT_SECONDS,
+    ).stdout.strip()
+
+
+def _report_fast_forward(git_run: Callable[..., Any], before: str, after: str) -> None:
+    """Report how many commits the fast-forward moved, or stay silent.
+
+    A pull that moves no commit has nothing to report, so it prints nothing.
+    """
+    if after == before:
+        return
+    count_output = git_run(
+        ["git", "rev-list", "--count", f"{before}..{after}"],
+        capture_output=True,
+        text=True,
+        timeout=_GIT_PULL_TIMEOUT_SECONDS,
+    ).stdout.strip()
+    commits = int(count_output) if count_output else 0
+    if commits <= 0:
+        return
+    noun = "commit" if commits == 1 else "commits"
+    typer.secho(
+        f"Workspace fast-forwarded ({commits} {noun})",
+        fg=typer.colors.GREEN,
+        err=True,
+    )
 
 
 def _start_background_update_check(container: Container) -> list[str]:
@@ -285,7 +455,7 @@ def _run_startup_preamble(
     its ``agent`` so the preflight validates the agent prompt; ``resume``
     leaves it ``None`` and validates no agent.
     """
-    _run_health_checks()
+    _run_health_checks(container.resolve(IConfigService))
     typer.echo("Checking configurations...", err=True)
     fired.extend(
         _run_cli_preflight_check(
@@ -692,6 +862,7 @@ def handle_new_session(  # noqa: PLR0913
             setup_editor=setup_editor,
             setup_api_key=setup_api_key,
         )
+        _pull_workspace_on_start(container.resolve(IConfigService))
         _echo_config_success(container, agent, model=model)
 
         session_manager: ISessionManager = container.resolve(ISessionManager)

teddy_cli-0.1.17.dev1402/src/teddy_executor/adapters/outbound/local_repo_tree_generator.py

@@ -0,0 +1,138 @@
+import logging
+import os
+from pathlib import Path
+from teddy_executor.core.ports.outbound.repo_tree_generator import IRepoTreeGenerator
+
+logger = logging.getLogger(__name__)
+
+UNREADABLE_MARKER = "[... directory not expanded (unreadable): 0 folders, 0 files]"
+
+
+class LocalRepoTreeGenerator(IRepoTreeGenerator):
+    """
+    An adapter that generates a file tree for the local repository,
+    respecting .gitignore and .teddyignore rules.
+    """
+
+    def __init__(self, root_dir: str = ".", max_depth: int = 0):
+        from teddy_executor.adapters.outbound.filesystem_helpers import (
+            load_ignore_spec,
+        )
+
+        assert max_depth >= 0, f"max_depth must be non-negative, got {max_depth}"
+        self.root_dir = Path(root_dir).resolve()
+        self.ignore_spec = load_ignore_spec(self.root_dir)
+        self._max_depth = max_depth
+
+    def generate_tree(self) -> str:
+        """
+        Generates a string representation of the file tree in a single pass.
+        """
+        sections: list[tuple[str, str, list[str]]] = []
+        root_names = self._collect_directory(self.root_dir, "", sections)
+        # Sections sort by their relative path, and the root resolves to ".",
+        # so a top-level name below "." (for example "!important") renders
+        # before the root block. The "." key preserves that exact order.
+        sections.append((".", "", root_names))
+        sections.sort(key=lambda item: item[0])
+
+        rendered: list[str] = []
+        for _sort_key, relative_path, names in sections:
+            if not names:
+                continue
+            if relative_path:
+                rendered.append("\n".join([f"./{relative_path}:"] + names))
+            else:
+                rendered.append("\n".join(names))
+        return "\n\n".join(rendered)
+
+    def _collect_directory(
+        self,
+        directory: str | Path,
+        relative_path: str,
+        sections: list[tuple[str, str, list[str]]],
+        depth: int = 0,
+    ) -> list[str]:
+        """
+        Collects one directory's visible names and recurses into its children.
+
+        A directory at or beyond the configured depth limit renders one
+        omission marker instead of expanding, so truncation is never silent.
+        An unreadable directory renders an explicit marker rather than an
+        empty section, so it never looks like a readable empty directory.
+        Directory and symlink flags come from the scan cache, so each entry
+        costs no additional stat call. Symlinks are listed as files and are
+        never followed, which keeps circular links from recursing.
+        """
+        if self._max_depth > 0 and depth >= self._max_depth:
+            marker = self._depth_limit_marker(directory, relative_path)
+            return [marker] if marker else []
+
+        entries = self._scan_visible_entries(directory, relative_path)
+        if entries is None:
+            return [UNREADABLE_MARKER]
+
+        names: list[str] = []
+        for entry, is_directory, child_path in entries:
+            names.append(entry.name)
+            if is_directory:
+                child_names = self._collect_directory(
+                    entry.path, child_path, sections, depth + 1
+                )
+                sort_key = child_path.replace("/", os.sep).lower()
+                sections.append((sort_key, child_path, child_names))
+
+        names.sort(key=str.lower)
+        return names
+
+    def _scan_visible_entries(
+        self, directory: str | Path, relative_path: str
+    ) -> list[tuple[os.DirEntry, bool, str]] | None:
+        """
+        Returns one visible immediate child per entry after ignore rules.
+
+        The scan is materialized before its context closes, so each DirEntry
+        still answers its cached directory flag. An unreadable directory
+        returns ``None`` so callers can tell it apart from a readable empty
+        one, which returns an empty list.
+        """
+        try:
+            with os.scandir(directory) as iterator:
+                entries = list(iterator)
+        except PermissionError:
+            logger.debug("Skipped unreadable directory %s", directory, exc_info=True)
+            return None
+        visible: list[tuple[os.DirEntry, bool, str]] = []
+        for entry in entries:
+            is_directory = entry.is_dir(follow_symlinks=False)
+            child_path = (
+                f"{relative_path}/{entry.name}" if relative_path else entry.name
+            )
+            match_path = (child_path + "/") if is_directory else child_path
+            if self.ignore_spec.match_file(match_path):
+                continue
+            visible.append((entry, is_directory, child_path))
+        return visible
+
+    def _depth_limit_marker(self, directory: str | Path, relative_path: str) -> str:
+        """
+        Renders the omission marker for a directory at the depth limit.
+
+        Counts only the visible immediate children after ignore rules. An
+        unreadable directory renders the unreadable marker instead. Returns an
+        empty string when no child is visible, so a genuinely empty directory
+        renders no section rather than a misleading marker.
+        """
+        entries = self._scan_visible_entries(directory, relative_path)
+        if entries is None:
+            return UNREADABLE_MARKER
+        folders = sum(1 for _entry, is_directory, _path in entries if is_directory)
+        files = len(entries) - folders
+        if not folders and not files:
+            return ""
+        folder_noun = "folder" if folders == 1 else "folders"
+        file_noun = "file" if files == 1 else "files"
+        return (
+            f"[... directory not expanded (depth limit {self._max_depth}): "
+            f"{folders} {folder_noun}, {files} {file_noun}]"
+        )

{teddy_cli-0.1.17.dev1400 → teddy_cli-0.1.17.dev1402}/src/teddy_executor/adapters/outbound/yaml_config_adapter.py

@@ -5,6 +5,11 @@ from importlib import resources
 from typing import Any, Dict, Optional
 import yaml
 from dotenv import dotenv_values, set_key
+from teddy_executor.core.domain.models.config_schema import (
+    construct_app_config,
+    is_declared_key,
+    read_declared_value,
+)
 from teddy_executor.core.domain.models.exceptions import ConfigurationError
 from teddy_executor.core.ports.outbound.config_service import IConfigService
 
@@ -14,6 +19,17 @@ _INTERPOLATION_PATTERN = re.compile(
 
 _MERGE_TAG = "tag:yaml.org,2002:merge"
 
+# Legacy ``execution.<key>`` names and the canonical group each one now lives in.
+_LEGACY_EXECUTION_KEY_GROUPS = {
+    "default_timeout_seconds": "execute",
+    "max_output_lines": "execute",
+    "similarity_threshold": "edit",
+}
+
+# ``llm.*`` keys pass straight through to LiteLLM and stay on the live walk,
+# because a mid-run ``.env`` write must remain visible on the same adapter.
+_PASSTHROUGH_KEY_PREFIX = "llm."
+
 
 def _strict_load(text: str, source_path: str) -> Any:
     """Parse ``text`` and reject a repeated mapping key at any depth."""
@@ -76,6 +92,15 @@ class YamlConfigAdapter(IConfigService):
         else:
             self._config_path = config_path
         self._config: Dict[str, Any] = self._load_layered_config()
+        self._refresh_typed_view()
+
+    def _refresh_typed_view(self) -> None:
+        """Rebuild the typed view from the current merged cache.
+
+        The view is a frozen snapshot, so it must be reconstructed whenever
+        the merged cache changes, or a read would return a stale value.
+        """
+        self.app_config = construct_app_config(self._maybe_interpolate(self._config))
 
     def _load_layered_config(self) -> Dict[str, Any]:
         """Loads the baseline config and merges it with the user config."""
@@ -114,10 +139,35 @@ class YamlConfigAdapter(IConfigService):
         try:
             with open(self._config_path, "r", encoding="utf-8") as f:
                 data = _strict_load(f.read(), self._config_path)
-                return data if isinstance(data, dict) else {}
+                user_config = data if isinstance(data, dict) else {}
         except (yaml.YAMLError, OSError):
             return {}
 
+        self._migrate_legacy_execution_keys(user_config)
+        return user_config
+
+    def _migrate_legacy_execution_keys(self, user_config: Dict[str, Any]) -> None:
+        """Copies tuned legacy ``execution.*`` values to their canonical groups.
+
+        A user file written before the execute/edit split still holds these
+        keys. The copy runs on the in-memory user dict before the baseline
+        merge, so the canonical key resolves while the user file stays
+        untouched. An absent or non-mapping legacy parent is left alone, a
+        ``None`` value is skipped, and an existing canonical key wins.
+        """
+        legacy = user_config.get("execution")
+        if not isinstance(legacy, dict):
+            return
+        for legacy_key, group in _LEGACY_EXECUTION_KEY_GROUPS.items():
+            value = legacy.get(legacy_key)
+            if value is None:
+                continue
+            target = user_config.get(group)
+            if not isinstance(target, dict):
+                target = {}
+                user_config[group] = target
+            target.setdefault(legacy_key, value)
+
     def _merge_dicts(self, base: Dict[str, Any], overrides: Dict[str, Any]) -> None:
         """Recursively merges overrides into base. Prunes keys set to None."""
         for key, value in overrides.items():
@@ -135,15 +185,24 @@ class YamlConfigAdapter(IConfigService):
         """
         Retrieves a configuration value by its key from the loaded YAML.
         Supports nested keys using dot notation (e.g., 'outer.inner').
+
+        A schema-declared key resolves through the typed view, so its value is
+        coerced to the declared type. Every other key resolves through the live
+        dict walk, which covers undeclared keys and the ``llm.*`` passthrough.
         """
         if not key:
             return default
 
-        # 1. Try exact match first (highest priority: top-level user overrides)
+        # 1. Declared keys resolve through the typed view. Passthrough keys are
+        #    excluded because a construction-time snapshot would go stale.
+        if not key.startswith(_PASSTHROUGH_KEY_PREFIX) and is_declared_key(key):
+            return read_declared_value(self.app_config, key)
+
+        # 2. Try exact match first (highest priority: top-level user overrides)
         if key in self._config:
             return self._maybe_interpolate(self._config[key])
 
-        # 2. Try nested resolution (standard hierarchical structure)
+        # 3. Try nested resolution (standard hierarchical structure)
         parts = key.split(".")
         result = self._resolve_nested(parts)
 
@@ -270,10 +329,12 @@ class YamlConfigAdapter(IConfigService):
             f.write(text)
 
         # 4. Rebuild the merged cache from disk so a subsequent get_setting()
-        #    on THIS adapter resolves exactly what a fresh adapter resolves.
+        #    on THIS adapter resolves exactly what a fresh adapter resolves,
+        #    then refresh the typed view so app_config reflects the write.
         merged = self._load_layered_config()
         self._config.clear()
         self._config.update(merged)
+        self._refresh_typed_view()
 
     def _scalar_repr(self, value: Any) -> str:
         """Render a scalar value as YAML text with no document-end marker."""