agentcore-cli 0.31.1__py3-none-any.whl

agentcore/cli/commands/job_history.py

@@ -0,0 +1,380 @@
+"""Job history/detail commands (ports of commands/eval, recommendations, batch-evaluations, view).
+
+- `evals history`
+- `recommendations history` / `recommendations <id>`
+- `batch-evaluations history` / `batch-evaluations <id>`
+- `view recommendation|batch-evaluation|ab-test|insights [id]` (top-level `view`, registered here)
+"""
+
+from collections.abc import Callable
+from typing import Any
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from typer import _click as click
+from typer.core import TyperGroup
+
+from agentcore.cli import interactive
+from agentcore.cli.commands._jobs_common import print_json, red, require_project
+from agentcore.cli.errors import get_error_message
+from agentcore.cli.groups import group
+from agentcore.cli.run_command import run_cli_command
+from agentcore.lib import ConfigIO, JobNotFoundError, serialize_result
+from agentcore.operations.eval.list_eval_runs import handle_list_eval_runs
+from agentcore.operations.eval.storage import get_results_path
+from agentcore.operations.jobs import JOB_CAPABILITIES, create_job_engine
+from agentcore.operations.jobs.ab_test.format import (
+    INVOCATION_PATH_HINT,
+    get_gateway_base_url,
+    get_invocation_url,
+    get_invocation_url_candidates,
+    print_ab_test_detail,
+    print_ab_test_history,
+)
+from agentcore.operations.jobs.batch_evaluation.format import (
+    print_batch_evaluation_detail,
+    print_batch_evaluation_history,
+)
+from agentcore.operations.jobs.insights.format import print_insights_detail, print_insights_history
+from agentcore.operations.jobs.recommendation.format import (
+    print_recommendation_detail,
+    print_recommendation_history,
+    short_type,
+)
+from agentcore.operations.jobs.shared.format import format_job_date, parse_int, to_fixed, to_locale_string
+
+TYPE_META: dict[str, dict[str, Any]] = {
+    "recommendation": {
+        "label": "recommendation",
+        "jsonKey": "recommendations",
+        "history": print_recommendation_history,
+        "detail": print_recommendation_detail,
+    },
+    "batch-evaluation": {
+        "label": "batch evaluation",
+        "jsonKey": "batchEvaluations",
+        "history": print_batch_evaluation_history,
+        "detail": print_batch_evaluation_detail,
+    },
+    "ab-test": {
+        "label": "A/B test",
+        "jsonKey": "abTests",
+        "history": print_ab_test_history,
+        "detail": print_ab_test_detail,
+    },
+    "insights": {
+        "label": "insights",
+        "jsonKey": "insights",
+        "history": print_insights_history,
+        "detail": print_insights_detail,
+    },
+}
+
+_SHOW_COMMAND = "__show__"
+
+
+class JobGroup(TyperGroup):
+    """Commander's ``group.argument('<id>')``: an unknown first token is the job id to show."""
+
+    def resolve_command(self, ctx: click.Context, args: list[str]):  # type: ignore[no-untyped-def]
+        name = args[0] if args else None
+        if name and not name.startswith("-") and name not in self.commands and _SHOW_COMMAND in self.commands:
+            return _SHOW_COMMAND, self.commands[_SHOW_COMMAND], args
+        return super().resolve_command(ctx, args)
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# evals history
+# ──────────────────────────────────────────────────────────────────────────────
+
+evals_app = group("evals")
+
+
+@evals_app.command("history", help="Show past on-demand eval run results saved locally")
+def evals_history(
+    runtime: str | None = typer.Option(None, "-r", "--runtime", help="Filter results by runtime name"),
+    limit: str | None = typer.Option(None, "-n", "--limit", help="Max number of runs to display"),
+    as_json: bool = typer.Option(False, "--json", help="Output as JSON"),
+) -> None:
+    require_project()
+    try:
+        result = handle_list_eval_runs(agent=runtime, limit=parse_int(limit) if limit else None)
+        if as_json:
+            print_json(serialize_result(result))
+            raise typer.Exit(0 if result.success else 1)
+        if not result.success:
+            red(str(result.error))
+            raise typer.Exit(1)
+        runs = result.value["runs"]
+        if not runs:
+            typer.echo("No eval runs found. Run `agentcore run eval` to create one.")
+            return
+        typer.echo(f"\n{'Date'.ljust(22)} {'Agent'.ljust(20)} {'Evaluators'.ljust(30)} Sessions")
+        typer.echo("─" * 90)
+        for run in runs:
+            scores = ", ".join(f"{r['evaluator']}={to_fixed(r['aggregateScore'], 2)}" for r in run.get("results") or [])
+            typer.echo(
+                f"{to_locale_string(run.get('timestamp')).ljust(22)} {str(run.get('agent')).ljust(20)} "
+                f"{scores.ljust(30)} {run.get('sessionCount')}"
+            )
+        try:
+            typer.echo(f"\nResults saved in: {get_results_path()}")
+        except Exception:  # noqa: BLE001, S110 - no project context
+            pass
+        typer.echo("")
+    except typer.Exit:
+        raise
+    except Exception as exc:  # noqa: BLE001
+        if as_json:
+            print_json({"success": False, "error": get_error_message(exc)})
+        else:
+            red(f"Error: {get_error_message(exc)}")
+        raise typer.Exit(1) from None
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# recommendations / batch-evaluations
+# ──────────────────────────────────────────────────────────────────────────────
+
+
+def _history(job_type: str, as_json: bool) -> None:
+    require_project()
+    meta = TYPE_META[job_type]
+
+    def run() -> None:
+        records = create_job_engine(ConfigIO()).list(type=job_type)
+        if as_json:
+            print_json({"success": True, meta["jsonKey"]: records})
+        else:
+            meta["history"](records)
+
+    run_cli_command(as_json, run)
+
+
+def _show(job_type: str, job_id: str, as_json: bool, not_found: str, extra: Callable[[dict], dict] | None = None):
+    require_project()
+    meta = TYPE_META[job_type]
+
+    def run() -> None:
+        record = create_job_engine(ConfigIO()).get(job_type, job_id)
+        if not record:
+            raise JobNotFoundError(not_found)
+        if as_json:
+            print_json(serialize_result({"success": True, **record, **(extra(record) if extra else {})}))
+        else:
+            meta["detail"](record)
+
+    run_cli_command(as_json, run)
+
+
+def _register_job_group(name: str, job_type: str, history_help: str, id_help: str, label: str) -> None:
+    app = group(name)
+    app.info.cls = JobGroup
+
+    @app.command("history", help=history_help)
+    def history(as_json: bool = typer.Option(False, "--json", help="Output as JSON")) -> None:
+        _history(job_type, as_json)
+
+    @app.command(_SHOW_COMMAND, hidden=True, help=id_help)
+    def show(
+        job_id: str = typer.Argument(..., metavar="<id>", help=id_help),
+        as_json: bool = typer.Option(False, "--json", help="Output as JSON"),
+    ) -> None:
+        _show(job_type, job_id, as_json, f'{label} "{job_id}" not found.')
+
+
+_register_job_group(
+    "recommendations",
+    "recommendation",
+    "List recommendation jobs (running jobs are refreshed from the service)",
+    "Recommendation job ID to view",
+    "Recommendation",
+)
+_register_job_group(
+    "batch-evaluations",
+    "batch-evaluation",
+    "List batch evaluation jobs (running jobs are refreshed from the service)",
+    "Batch evaluation job ID to view",
+    "Batch evaluation",
+)
+
+# ──────────────────────────────────────────────────────────────────────────────
+# view
+# ──────────────────────────────────────────────────────────────────────────────
+
+
+def ab_test_url_fields(record: dict[str, Any]) -> dict[str, Any]:
+    url = get_invocation_url(record)
+    if url:
+        return {"invocationUrl": url}
+    candidates = get_invocation_url_candidates(record)
+    if candidates:
+        return {"invocationUrlCandidates": candidates}
+    return {"gatewayUrl": get_gateway_base_url(record), "invocationUrlHint": INVOCATION_PATH_HINT}
+
+
+view_app = typer.Typer(help="View job history and details", no_args_is_help=True)
+
+
+def _register_view(job_type: str) -> None:
+    meta = TYPE_META[job_type]
+
+    @view_app.command(job_type, help=f"View {meta['label']} jobs")
+    def view(
+        job_id: str | None = typer.Argument(None, metavar="[id]", help=f"{meta['label']} job ID"),
+        as_json: bool = typer.Option(False, "--json", help="Output as JSON (non-interactive)"),
+        region: str | None = typer.Option(None, "--region", help="AWS region (auto-detected if omitted)"),
+    ) -> None:
+        require_project()
+        if job_id:
+            if as_json:
+                _show(
+                    job_type,
+                    job_id,
+                    True,
+                    f'{meta["label"]} "{job_id}" not found.',
+                    ab_test_url_fields if job_type == "ab-test" else None,
+                )
+                return
+            interactive.require_tty()
+            browse_detail(job_type, job_id)
+            raise typer.Exit(0)
+        if as_json:
+            _history(job_type, True)
+            return
+        interactive.require_tty()
+        browse_list(job_type)
+        raise typer.Exit(0)
+
+
+for _job_type in ("recommendation", "batch-evaluation", "ab-test", "insights"):
+    _register_view(_job_type)
+
+
+def register(app: typer.Typer) -> None:
+    app.add_typer(view_app, name="view")
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Interactive job browser (replaces the history / JobDetail TUI screens)
+# ──────────────────────────────────────────────────────────────────────────────
+
+_console = Console()
+
+
+def _summary_columns(job_type: str, record: dict[str, Any]) -> list[str]:
+    if job_type == "recommendation":
+        return [short_type(record.get("recommendationType")), record.get("agent") or ""]
+    if job_type == "ab-test":
+        return [str(record.get("lifecycleStatus") or ""), str(record.get("name") or "")]
+    if job_type == "insights":
+        return [", ".join(record.get("insights") or [])]
+    return [", ".join(record.get("evaluators") or [])]
+
+
+def _table(job_type: str, records: list[dict[str, Any]]) -> Table:
+    extra = {
+        "recommendation": ["Type", "Agent"],
+        "ab-test": ["Lifecycle", "Name"],
+        "insights": ["Insights"],
+        "batch-evaluation": ["Evaluators"],
+    }[job_type]
+    table = Table(title=f"{TYPE_META[job_type]['label'].capitalize()} jobs", show_lines=False)
+    for column in ["Date", "Status", *extra, "ID"]:
+        table.add_column(column)
+    for r in records:
+        table.add_row(
+            format_job_date(r.get("createdAt")), str(r.get("status")), *_summary_columns(job_type, r), r["id"]
+        )
+    return table
+
+
+def _validate_creds() -> bool:
+    from agentcore.aws.account import validate_aws_credentials
+
+    try:
+        validate_aws_credentials()
+        return True
+    except Exception as exc:  # noqa: BLE001
+        red("AWS credentials required")
+        typer.echo(get_error_message(exc))
+        return False
+
+
+def browse_list(job_type: str) -> None:
+    if not _validate_creds():
+        raise typer.Exit(1)
+    engine = create_job_engine(ConfigIO())
+    while True:
+        records = engine.list(type=job_type)
+        if not records:
+            TYPE_META[job_type]["history"]([])
+            return
+        _console.print(_table(job_type, records))
+        choices = [
+            interactive.Choice(f"{format_job_date(r.get('createdAt'))}  {r.get('status')}  {r['id']}", r["id"])
+            for r in records
+        ]
+        picked = interactive.select("Select a job", [*choices, interactive.Choice("Exit", None)])
+        if picked is None:
+            return
+        browse_detail(job_type, picked, engine=engine, validate=False)
+
+
+def _actions(job_type: str, record: dict[str, Any]) -> list[interactive.Choice]:
+    caps = JOB_CAPABILITIES[job_type]
+    actions = [interactive.Choice("Refresh", "refresh")]
+    if caps["canPause"]:
+        actions.append(
+            interactive.Choice("Resume", "resume")
+            if record.get("lifecycleStatus") == "PAUSED"
+            else interactive.Choice("Pause", "pause")
+        )
+    if caps["canStop"]:
+        actions.append(interactive.Choice("Stop", "stop"))
+    if caps["canPromote"]:
+        actions.append(interactive.Choice("Promote", "promote"))
+    if caps["canDebug"]:
+        actions.append(interactive.Choice("Debug", "debug"))
+    actions += [interactive.Choice("Archive", "archive"), interactive.Choice("Back", "back")]
+    return actions
+
+
+def browse_detail(job_type: str, job_id: str, engine: Any = None, validate: bool = True) -> None:
+    if validate and not _validate_creds():
+        raise typer.Exit(1)
+    engine = engine or create_job_engine(ConfigIO())
+    while True:
+        try:
+            record = engine.get(job_type, job_id)
+        except Exception as exc:  # noqa: BLE001
+            red("Job not found")
+            typer.echo(get_error_message(exc))
+            return
+        if not record:
+            red("Job not found")
+            typer.echo(f'Job "{job_id}" not found.')
+            return
+        TYPE_META[job_type]["detail"](record)
+        action = interactive.select("Action", _actions(job_type, record))
+        if action == "back":
+            return
+        if action == "refresh":
+            continue
+        if action in ("archive", "stop", "promote") and not interactive.confirm(
+            f"{action.capitalize()} {TYPE_META[job_type]['label']} {job_id}?", default=False
+        ):
+            continue
+        result = getattr(engine, action)(job_type, job_id)
+        if not result.success:
+            red(get_error_message(result.error))
+            continue
+        if action == "debug":
+            for check in result.value["checks"]:
+                mark = {"pass": "✓", "fail": "✗", "warn": "!"}.get(check["status"], "?")
+                typer.echo(f"  {mark} {check['label']}: {check['detail']}")
+            continue
+        typer.secho(f"✓ {action.capitalize()} succeeded.", fg=typer.colors.GREEN)
+        if action == "archive":
+            return

agentcore/cli/commands/logs/__init__.py

@@ -0,0 +1,53 @@
+"""`agentcore logs` default action: stream or search runtime logs (port of src/cli/commands/logs).
+
+`logs evals` belongs to the evals area and is left to its own module (stub until ported).
+"""
+
+import typer
+
+from agentcore.cli.commands.logs.action import LogsOptions, handle_logs
+from agentcore.cli.commands.logs.guards import require_project
+from agentcore.cli.errors import get_error_message
+from agentcore.cli.groups import group
+from agentcore.cli.tree import GROUPS
+
+# COMMAND_DESCRIPTIONS.logs from upstream src/cli/constants.ts.
+LOGS_DESCRIPTION = GROUPS["logs"][0]
+
+
+def logs_callback(
+    ctx: typer.Context,
+    runtime: str | None = typer.Option(None, "--runtime", help="Select specific runtime"),
+    since: str | None = typer.Option(
+        None, "--since", help='Start time — defaults to 1h ago in search mode (e.g. "1h", "30m", "2d", ISO 8601)'
+    ),
+    until: str | None = typer.Option(
+        None, "--until", help='End time — defaults to now in search mode (e.g. "now", ISO 8601)'
+    ),
+    level: str | None = typer.Option(None, "--level", help="Filter by log level (error, warn, info, debug)"),
+    limit: str | None = typer.Option(None, "-n", "--limit", help="Maximum number of log lines to return"),
+    query: str | None = typer.Option(None, "--query", help="Server-side text filter"),
+    as_json: bool = typer.Option(False, "--json", help="Output as JSON Lines"),
+) -> None:
+    if ctx.invoked_subcommand is not None:
+        return
+    require_project()
+    try:
+        result = handle_logs(
+            LogsOptions(runtime=runtime, since=since, until=until, level=level, limit=limit, query=query, json=as_json)
+        )
+    except typer.Exit:
+        raise
+    except Exception as exc:  # noqa: BLE001 - top-level command boundary, as upstream
+        typer.secho(f"Error: {get_error_message(exc)}", fg=typer.colors.RED)
+        raise typer.Exit(1) from None
+    if not result.success:
+        typer.secho(str(result.error), fg=typer.colors.RED)
+        raise typer.Exit(1)
+
+
+def register(app: typer.Typer) -> None:
+    logs = group("logs")
+    logs.callback(invoke_without_command=True, no_args_is_help=False, help=LOGS_DESCRIPTION)(logs_callback)
+    # Upstream alias `agentcore l`.
+    app.add_typer(logs, name="l", hidden=True)

agentcore/cli/commands/logs/action.py

@@ -0,0 +1,159 @@
+"""Port of src/cli/commands/logs/action.ts (runtime logs: stream or search)."""
+
+import json
+import signal
+import threading
+import time
+from dataclasses import dataclass
+from datetime import UTC, datetime
+
+import typer
+
+from agentcore.aws import cloudwatch
+from agentcore.aws._aws_errors import aws_error_name
+from agentcore.cli.commands.logs.filter_pattern import VALID_LEVELS, build_filter_pattern
+from agentcore.lib.errors.types import ResourceNotFoundError, ValidationError
+from agentcore.lib.result import Err, Ok
+from agentcore.lib.utils.time_parser import parse_time_string
+from agentcore.operations.resolve_agent import DeployedProjectConfig, load_deployed_project_config, resolve_agent
+
+# From upstream src/cli/constants.ts.
+DEFAULT_ENDPOINT_NAME = "DEFAULT"
+
+
+@dataclass
+class LogsOptions:
+    runtime: str | None = None
+    since: str | None = None
+    until: str | None = None
+    level: str | None = None
+    limit: str | None = None
+    query: str | None = None
+    json: bool = False
+
+
+@dataclass
+class AgentContext:
+    agent_id: str
+    agent_name: str
+    account_id: str
+    region: str
+    endpoint_name: str
+    log_group_name: str
+
+
+def detect_mode(options: LogsOptions) -> str:
+    return "search" if options.since or options.until else "stream"
+
+
+def _iso(timestamp_ms: int) -> str:
+    dt = datetime.fromtimestamp(timestamp_ms / 1000, tz=UTC)
+    return dt.strftime("%Y-%m-%dT%H:%M:%S.") + f"{dt.microsecond // 1000:03d}Z"
+
+
+def format_log_line(event: dict, as_json: bool) -> str:
+    ts = _iso(event["timestamp"])
+    if as_json:
+        return json.dumps({"timestamp": ts, "message": event["message"]}, separators=(",", ":"), ensure_ascii=False)
+    return f"{ts}  {event['message']}"
+
+
+def resolve_agent_context(context: DeployedProjectConfig, options: LogsOptions) -> Ok[AgentContext] | Err:
+    result = resolve_agent(context, options.runtime)
+    if not result.success:
+        return Err(ResourceNotFoundError(result.error or ""))
+    agent = result.agent
+    assert agent is not None
+    return Ok(
+        AgentContext(
+            agent_id=agent.runtime_id,
+            agent_name=agent.agent_name,
+            account_id=agent.account_id,
+            region=agent.region,
+            endpoint_name=DEFAULT_ENDPOINT_NAME,
+            log_group_name=cloudwatch.runtime_log_group(agent.runtime_id),
+        )
+    )
+
+
+def _parse_int(value: str) -> int | None:
+    """``parseInt(value, 10)``: leading integer, else None (NaN)."""
+    digits = ""
+    text = value.strip()
+    for i, ch in enumerate(text):
+        if ch.isdigit() or (i == 0 and ch in "+-"):
+            digits += ch
+        else:
+            break
+    try:
+        return int(digits)
+    except ValueError:
+        return None
+
+
+def handle_logs(options: LogsOptions) -> Ok[None] | Err:
+    if options.level and options.level.lower() not in VALID_LEVELS:
+        return Err(ValidationError(f'Invalid log level: "{options.level}". Valid levels: {", ".join(VALID_LEVELS)}'))
+
+    context = load_deployed_project_config()
+    resolution = resolve_agent_context(context, options)
+    if not resolution.success:
+        return resolution
+    agent_context = resolution.value
+
+    try:
+        filter_pattern = build_filter_pattern(level=options.level, query=options.query)
+    except Exception as exc:  # noqa: BLE001 - surfaced as a Result, as upstream
+        return Err(exc)
+
+    abort = threading.Event()
+    previous = None
+    if threading.current_thread() is threading.main_thread():
+
+        def on_sigint(_signum, _frame):
+            abort.set()
+            raise KeyboardInterrupt
+
+        previous = signal.signal(signal.SIGINT, on_sigint)
+
+    try:
+        if detect_mode(options) == "search":
+            now = int(time.time() * 1000)
+            start_ms = parse_time_string(options.since) if options.since else now - 3_600_000
+            end_ms = parse_time_string(options.until) if options.until else int(time.time() * 1000)
+            limit = _parse_int(options.limit) if options.limit else None
+            for event in cloudwatch.search_logs(
+                log_group_name=agent_context.log_group_name,
+                region=agent_context.region,
+                start_time_ms=start_ms,
+                end_time_ms=end_ms,
+                filter_pattern=filter_pattern,
+                limit=limit,
+            ):
+                typer.echo(format_log_line(event, options.json))
+        else:
+            typer.echo(f"Streaming logs for {agent_context.agent_name}... (Ctrl+C to stop)", err=True)
+            for event in cloudwatch.stream_logs(
+                log_group_name=agent_context.log_group_name,
+                region=agent_context.region,
+                account_id=agent_context.account_id,
+                filter_pattern=filter_pattern,
+                abort_signal=abort,
+            ):
+                typer.echo(format_log_line(event, options.json))
+        return Ok(None)
+    except KeyboardInterrupt:
+        return Ok(None)
+    except Exception as exc:
+        if aws_error_name(exc) == "ResourceNotFoundException":
+            return Err(
+                ResourceNotFoundError(
+                    f"No logs found for agent '{agent_context.agent_name}'. Has the agent been invoked?"
+                )
+            )
+        if abort.is_set():
+            return Ok(None)
+        raise
+    finally:
+        if previous is not None:
+            signal.signal(signal.SIGINT, previous)

agentcore/cli/commands/logs/filter_pattern.py

@@ -0,0 +1,17 @@
+"""Port of src/cli/commands/logs/filter-pattern.ts."""
+
+LEVEL_MAP = {"error": "ERROR", "warn": "WARN", "info": "INFO", "debug": "DEBUG"}
+VALID_LEVELS = list(LEVEL_MAP)
+
+
+def build_filter_pattern(level: str | None = None, query: str | None = None) -> str | None:
+    """CloudWatch filter pattern: level (uppercased) and query joined by a space (implicit AND)."""
+    parts: list[str] = []
+    if level:
+        mapped = LEVEL_MAP.get(level.lower())
+        if not mapped:
+            raise ValueError(f'Invalid log level: "{level}". Valid levels: {", ".join(VALID_LEVELS)}')
+        parts.append(mapped)
+    if query:
+        parts.append(query)
+    return " ".join(parts) if parts else None

agentcore/cli/commands/logs/guards.py

@@ -0,0 +1,51 @@
+"""Port of tui/guards/project.tsx (projectExists, getProjectRootMismatch, requireProject).
+
+Lives here because the guard isn't ported elsewhere yet; traces/fetch reuse it.
+"""
+
+import os
+
+import typer
+
+from agentcore.lib.schemas.io.path_resolver import find_config_root, get_working_directory
+
+
+def project_exists(base_dir: str | None = None) -> bool:
+    return find_config_root(base_dir or get_working_directory()) is not None
+
+
+def get_project_root_mismatch(base_dir: str | None = None) -> str | None:
+    """Project root when cwd is a subdirectory of it; None at the root or with no project."""
+    base_dir = base_dir or get_working_directory()
+    config_root = find_config_root(base_dir)
+    if not config_root:
+        return None
+    project_root = os.path.abspath(os.path.dirname(config_root))
+    return project_root if os.path.abspath(base_dir) != project_root else None
+
+
+def _fatal(message: str, detail: str | None = None, suggested_command: str | None = None) -> None:
+    """Text equivalent of the FatalError component."""
+    typer.secho(message, fg=typer.colors.RED)
+    if detail:
+        typer.echo(detail)
+    if suggested_command:
+        typer.echo("Run " + typer.style(suggested_command, fg=typer.colors.BLUE) + " to fix this.")
+
+
+def require_project(in_tui: bool = False) -> None:
+    """Exit 1 unless run from the root of an agentcore project."""
+    cwd = get_working_directory()
+    config_root = find_config_root(cwd)
+    if not config_root:
+        _fatal("No agentcore project found.", suggested_command="create" if in_tui else "agentcore create")
+        raise typer.Exit(1)
+    project_root = os.path.abspath(os.path.dirname(config_root))
+    resolved_cwd = os.path.abspath(cwd)
+    if resolved_cwd != project_root:
+        _fatal(
+            "Please run this command from your project root directory.",
+            detail=f"You are in: {resolved_cwd}\nProject root: {project_root}",
+            suggested_command=f"cd {project_root}",
+        )
+        raise typer.Exit(1)