teddy-cli 0.1.17.dev1399__tar.gz → 0.1.17.dev1401__tar.gz

{teddy_cli-0.1.17.dev1399 → teddy_cli-0.1.17.dev1401}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: teddy-cli
-Version: 0.1.17.dev1399
+Version: 0.1.17.dev1401
 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.dev1399 → teddy_cli-0.1.17.dev1401}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "teddy-cli"
-version = "0.1.17.dev1399"
+version = "0.1.17.dev1401"
 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.dev1399 → teddy_cli-0.1.17.dev1401}/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.dev1401/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.dev1399 → teddy_cli-0.1.17.dev1401}/src/teddy_executor/adapters/outbound/yaml_config_adapter.py

@@ -14,6 +14,13 @@ _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",
+}
+
 
 def _strict_load(text: str, source_path: str) -> Any:
     """Parse ``text`` and reject a repeated mapping key at any depth."""
@@ -114,10 +121,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():

{teddy_cli-0.1.17.dev1399 → teddy_cli-0.1.17.dev1401}/src/teddy_executor/core/services/action_factory.py

@@ -135,7 +135,7 @@ class ActionFactory(IActionFactory):
         if "timeout" not in execute_params and self._config_service:
             # Safe-by-Default: Provide hardcoded 60.0 fallback if config is missing
             default_timeout = self._config_service.get_setting(
-                "execution.default_timeout_seconds", 60.0
+                "execute.default_timeout_seconds", 60.0
             )
             if default_timeout is not None:
                 from teddy_executor.core.services.parser_infrastructure import (
@@ -154,7 +154,7 @@ class ActionFactory(IActionFactory):
         if "similarity_threshold" not in kwargs and self._config_service:
             # Safe-by-Default: Provide domain default if config is missing
             global_threshold = self._config_service.get_setting(
-                "execution.similarity_threshold", DEFAULT_SIMILARITY_THRESHOLD
+                "edit.similarity_threshold", DEFAULT_SIMILARITY_THRESHOLD
             )
             if global_threshold is not None:
                 from teddy_executor.core.services.parser_infrastructure import (

{teddy_cli-0.1.17.dev1399 → teddy_cli-0.1.17.dev1401}/src/teddy_executor/core/services/validation_rules/helpers.py

@@ -131,7 +131,7 @@ def resolve_similarity_threshold(
     Resolves in order: Action Params -> Global Config -> Domain Default.
     """
     global_threshold_raw = config_service.get_setting(
-        "execution.similarity_threshold", DEFAULT_SIMILARITY_THRESHOLD
+        "edit.similarity_threshold", DEFAULT_SIMILARITY_THRESHOLD
     )
     global_threshold = (
         float(global_threshold_raw)
@@ -139,9 +139,7 @@ def resolve_similarity_threshold(
         else DEFAULT_SIMILARITY_THRESHOLD
     )
 
-    threshold_raw = action_params.get(
-        "execution.similarity_threshold", global_threshold
-    )
+    threshold_raw = action_params.get("edit.similarity_threshold", global_threshold)
     return float(threshold_raw) if threshold_raw is not None else global_threshold
 
 

{teddy_cli-0.1.17.dev1399 → teddy_cli-0.1.17.dev1401}/src/teddy_executor/registries/infrastructure.py

@@ -76,7 +76,7 @@ def register_infrastructure(container: punq.Container) -> None:
         factory=lambda: ShellAdapter(
             command_builder=container.resolve(ShellCommandBuilder),
             max_execute_lines=container.resolve(IConfigService).get_setting(
-                "execution.max_output_lines"
+                "execute.max_output_lines", 100
             ),
             # Shared process-global guard: the SAME instance the session-loop
             # boundary installs and the orchestrator drains, so an in-flight
@@ -143,7 +143,11 @@ def register_infrastructure(container: punq.Container) -> None:
     )
     container.register(
         IRepoTreeGenerator,
-        factory=lambda: LocalRepoTreeGenerator(),
+        factory=lambda: LocalRepoTreeGenerator(
+            max_depth=container.resolve(IConfigService).get_setting(
+                "context.max_tree_depth", 0
+            )
+        ),
         scope=punq.Scope.transient,
     )
     container.register(

{teddy_cli-0.1.17.dev1399 → teddy_cli-0.1.17.dev1401}/src/teddy_executor/resources/config/config.yaml

@@ -2,14 +2,24 @@
 
 editor: ""
 
-execution:
-  default_timeout_seconds: 60       # Default timeout for EXECUTE actions (in seconds).
-  similarity_threshold: 0.95        # EDIT match threshold (1.0 = exact match; ignores relative indentation).
+execute:
+  default_timeout_seconds: 60       # Default timeout for EXECUTE actions.
   max_output_lines: 100             # Caps EXECUTE stdout/stderr output lines.
 
+edit:
+  similarity_threshold: 0.95        # EDIT match threshold (1.0 = exact match; ignores relative indentation).
+
+workspace:
+  init: true         # Initialize a missing Git repository (start and resume).
+  pre-commit: true   # Install pre-commit and post-commit git hooks (start and resume).
+  pull: true         # Fast-forward pull before starting a new session (start only).
+
 read:
   max_lines: 1000                   # Caps READ action output lines.
 
+context:
+  max_tree_depth: 4                 # Max project tree depth (0 = unlimited).
+
 research:
   max_results: 5                    # Number of search results to fetch and scrape.
 

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

@@ -1,81 +0,0 @@
-import logging
-import os
-from pathlib import Path
-from teddy_executor.core.ports.outbound.repo_tree_generator import IRepoTreeGenerator
-
-logger = logging.getLogger(__name__)
-
-
-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 = "."):
-        from teddy_executor.adapters.outbound.filesystem_helpers import (
-            load_ignore_spec,
-        )
-
-        self.root_dir = Path(root_dir).resolve()
-        self.ignore_spec = load_ignore_spec(self.root_dir)
-
-    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]]],
-    ) -> list[str]:
-        """
-        Collects one directory's visible names and recurses into its children.
-
-        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.
-        """
-        names: list[str] = []
-        try:
-            with os.scandir(directory) as iterator:
-                entries = list(iterator)
-        except PermissionError:
-            logger.debug("Skipping unreadable directory %s", directory, exc_info=True)
-            return names
-
-        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
-            names.append(entry.name)
-            if is_directory:
-                child_names = self._collect_directory(entry.path, child_path, sections)
-                sort_key = child_path.replace("/", os.sep).lower()
-                sections.append((sort_key, child_path, child_names))
-
-        names.sort(key=str.lower)
-        return names