agentcore-cli 0.31.1__py3-none-any.whl

agentcore/cli/commands/import_/__init__.py

@@ -0,0 +1,167 @@
+"""`agentcore import` (port of src/cli/commands/import).
+
+The package is named ``import_`` because ``import`` is a Python keyword. ``register`` attaches
+``import --source`` (the starter-toolkit YAML flow, as the group callback) and the
+``import runtime|memory|evaluator|online-eval|gateway`` subcommands to the shared ``import`` group.
+"""
+
+from __future__ import annotations
+
+import os
+
+import typer
+
+from agentcore.cli import interactive
+from agentcore.cli.constants import ANSI
+from agentcore.cli.groups import group
+from agentcore.lib.errors.types import ValidationError
+
+from .actions import ImportOptions, handle_import
+from .import_evaluator import register_import_evaluator
+from .import_gateway import register_import_gateway
+from .import_memory import register_import_memory
+from .import_online_eval import register_import_online_eval
+from .import_runtime import register_import_runtime
+
+
+def run_source_import(source: str, target: str | None, yes: bool) -> None:
+    warnings: list[str] = []
+    green, red, yellow, cyan, dim, reset = ANSI.green, ANSI.red, ANSI.yellow, ANSI.cyan, ANSI.dim, ANSI.reset
+
+    def on_progress(message: str) -> None:
+        if message.startswith("Warning"):
+            warnings.append(message)
+        elif message.startswith("Skipping"):
+            typer.echo(f"{dim}[skip]{reset}  {message}")
+        else:
+            typer.echo(f"{green}[done]{reset}  {message}")
+
+    if not os.path.exists(source):
+        result_error: BaseException | None = ValidationError(f"Source file not found: {source}")
+        result = None
+    else:
+        result = handle_import(ImportOptions(source=source, target=target, yes=yes or None, on_progress=on_progress))
+        result_error = None if result.success else result.error
+
+    if result is not None and result.success:
+        typer.echo("")
+        typer.echo(f"{green}Import complete!{reset}")
+        typer.echo("")
+        typer.echo(f"{dim}Imported:{reset}")
+        typer.echo(f"  Stack: {result.stack_name}")
+        for agent in result.imported_agents or []:
+            typer.echo(f"  Agent: {agent}")
+        for mem in result.imported_memories or []:
+            typer.echo(f"  Memory: {mem}")
+        if warnings:
+            typer.echo("")
+            for w in warnings:
+                typer.echo(f"{yellow}[warn]{reset}  {w}")
+        typer.echo("")
+        typer.echo("To continue:")
+        typer.echo("")
+        typer.echo(f"  {cyan}agentcore deploy{reset}     {dim}Deploy the imported stack{reset}")
+        typer.echo(f"  {cyan}agentcore status{reset}     {dim}Verify resource status{reset}")
+        typer.echo(f"  {cyan}agentcore invoke{reset}     {dim}Test your agent{reset}")
+        typer.echo("")
+        if result.log_path:
+            typer.echo(f"Log: {result.log_path}")
+        return
+
+    typer.echo(f"\n{red}[error]{reset} Import failed: {result_error}", err=True)
+    if result is not None and result.log_path:
+        typer.echo(f"Log: {result.log_path}", err=True)
+    raise typer.Exit(1)
+
+
+def run_interactive_import() -> None:
+    """Prompt-based replacement for upstream's ImportFlow TUI."""
+    from agentcore.lib.schemas.io.path_resolver import find_config_root
+
+    from .import_evaluator import handle_import_evaluator
+    from .import_gateway import handle_import_gateway
+    from .import_memory import handle_import_memory
+    from .import_online_eval import handle_import_online_eval
+    from .import_runtime import handle_import_runtime, print_failure, print_success
+    from .types import ImportResourceOptions, RuntimeImportOptions
+
+    if not find_config_root():
+        typer.echo("No agentcore project found. Run `agentcore create` first.", err=True)
+        raise typer.Exit(1)
+    interactive.require_tty()
+
+    kind = interactive.select(
+        "What would you like to import?",
+        [
+            interactive.Choice("Runtime", "runtime", "Import an existing AgentCore Runtime"),
+            interactive.Choice("Memory", "memory", "Import an existing AgentCore Memory"),
+            interactive.Choice("Gateway", "gateway", "Import an existing AgentCore Gateway (with targets)"),
+            interactive.Choice("Evaluator", "evaluator", "Import an existing AgentCore Evaluator"),
+            interactive.Choice("Online eval config", "online-eval", "Import an existing Online Evaluation Config"),
+            interactive.Choice("Starter toolkit project", "yaml", "Import from a .bedrock_agentcore.yaml file"),
+        ],
+    )
+    if kind == "yaml":
+        source = interactive.text(
+            "Path to .bedrock_agentcore.yaml",
+            default=".bedrock_agentcore.yaml",
+            validate=lambda v: None if v else "Required",
+        )
+        run_source_import(source, None, True)
+        return
+
+    arn = interactive.text("ARN (leave empty to list resources in your account)").strip() or None
+    if kind == "runtime":
+        code = interactive.text(
+            "Path to the directory containing the entrypoint file", validate=lambda v: None if v else "Required"
+        )
+        result = handle_import_runtime(RuntimeImportOptions(arn=arn, code=code))
+    else:
+        handler = {
+            "memory": handle_import_memory,
+            "gateway": handle_import_gateway,
+            "evaluator": handle_import_evaluator,
+            "online-eval": handle_import_online_eval,
+        }[kind]
+        result = handler(ImportResourceOptions(arn=arn))
+    if result.success:
+        label = {
+            "runtime": "Runtime",
+            "memory": "Memory",
+            "gateway": "Gateway",
+            "evaluator": "Evaluator",
+            "online-eval": "Online eval config",
+        }[kind]
+        print_success(label, result, [])
+    else:
+        print_failure(result)
+
+
+def register(app: typer.Typer) -> None:  # noqa: ARG001 - group() is mounted by cli/main.py
+    import_app = group("import")
+    # Bare `agentcore import` runs the callback (YAML flow or the interactive picker) instead of help.
+    import_app.info.no_args_is_help = False
+
+    @import_app.callback(invoke_without_command=True)
+    def import_callback(
+        ctx: typer.Context,
+        source: str | None = typer.Option(
+            None, "--source", help="Path to the .bedrock_agentcore.yaml configuration file"
+        ),
+        target: str | None = typer.Option(
+            None, "--target", help="Deployment target name (only needed if project has multiple targets)"
+        ),
+        yes: bool = typer.Option(False, "-y", "--yes", help="Auto-confirm prompts"),
+    ) -> None:
+        if ctx.invoked_subcommand is not None:
+            return
+        if not source:
+            run_interactive_import()
+            return
+        run_source_import(source, target, yes)
+
+    register_import_runtime(import_app)
+    register_import_memory(import_app)
+    register_import_evaluator(import_app)
+    register_import_online_eval(import_app)
+    register_import_gateway(import_app)

agentcore/cli/commands/import_/_js.py

@@ -0,0 +1,72 @@
+"""Small JavaScript-semantics helpers used by the import port (truthiness, ``String()``, ``Number()``)."""
+
+from __future__ import annotations
+
+import math
+import re
+from typing import Any
+
+_DEC = re.compile(r"^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$")
+_PREFIXED = re.compile(r"^0([xXoObB])([0-9a-fA-F]+)$")
+
+
+def truthy(value: Any) -> bool:
+    """JavaScript truthiness: ``{}`` and ``[]`` are truthy; ``0``, ``""``, ``None``, NaN are not."""
+    if value is None or value is False:
+        return False
+    if isinstance(value, (int, float)) and not isinstance(value, bool):
+        return value != 0 and not (isinstance(value, float) and math.isnan(value))
+    if isinstance(value, str):
+        return value != ""
+    return True
+
+
+def js_number(text: str) -> float | int | None:
+    """``Number(text)``; None for NaN. Integral values come back as ``int``."""
+    s = text.strip()
+    if s == "":
+        return 0
+    value: float
+    if _DEC.match(s):
+        value = float(s)
+    elif s in ("Infinity", "+Infinity"):
+        value = math.inf
+    elif s == "-Infinity":
+        value = -math.inf
+    else:
+        m = _PREFIXED.match(s)
+        if not m:
+            return None
+        base = {"x": 16, "o": 8, "b": 2}[m.group(1).lower()]
+        try:
+            return int(m.group(2), base)
+        except ValueError:
+            return None
+    if math.isfinite(value) and value == int(value) and abs(value) < 1e21:
+        return int(value)
+    return value
+
+
+def js_string(value: Any) -> str:
+    """``String(value)`` for the scalar/plain values the YAML parser produces."""
+    if value is None:
+        return "null"
+    if value is True:
+        return "true"
+    if value is False:
+        return "false"
+    if isinstance(value, int):
+        return str(value)
+    if isinstance(value, float):
+        if math.isnan(value):
+            return "NaN"
+        if math.isinf(value):
+            return "Infinity" if value > 0 else "-Infinity"
+        if value == int(value) and abs(value) < 1e21:
+            return str(int(value))
+        return repr(value)
+    if isinstance(value, dict):
+        return "[object Object]"
+    if isinstance(value, list):
+        return ",".join("" if v is None else js_string(v) for v in value)
+    return str(value)