agentcore-cli 0.31.1__py3-none-any.whl

agentcore/logging/cdk_io_host.py

@@ -0,0 +1,36 @@
+"""IoHost that captures CDK toolkit messages to an ExecLogger (port of ``logging/cdk-io-host.ts``)."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from agentcore.cdk.toolkit import IoMessage
+    from agentcore.logging.exec_logger import ExecLogger, LogLevel
+
+
+def _map_cdk_level(level: str | None) -> LogLevel:
+    if level == "error":
+        return "error"
+    if level == "warn":
+        return "warn"
+    if level in ("debug", "trace"):
+        return "debug"
+    return "info"
+
+
+class CdkIoHost:
+    def __init__(self, logger: ExecLogger) -> None:
+        self._logger = logger
+
+    def notify(self, msg: IoMessage) -> None:
+        prefix = f"[{msg.code}] " if msg.code else ""
+        text = msg.message if isinstance(msg.message, str) else ""
+        self._logger.log(f"{prefix}{text}", _map_cdk_level(msg.level))
+
+
+def create_cdk_io_host(logger: ExecLogger) -> CdkIoHost:
+    return CdkIoHost(logger)
+
+
+__all__ = ["CdkIoHost", "create_cdk_io_host"]

agentcore/logging/create_logger.py

@@ -0,0 +1,107 @@
+"""Port of src/cli/logging/create-logger.ts."""
+
+import os
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Literal
+
+from agentcore.lib.constants import CLI_LOGS_DIR, CLI_SYSTEM_DIR, CONFIG_DIR
+from agentcore.logging._common import (
+    append,
+    format_duration,
+    format_time,
+    format_timestamp_for_filename,
+    iso_now,
+    now_ms,
+    osc8_link,
+    write,
+)
+
+
+@dataclass
+class _StepInfo:
+    name: str
+    start_time: int
+
+
+class CreateLogger:
+    """Logger for `create`: <projectRoot>/agentcore/.cli/logs/create/create-<ts>.log.
+
+    Lines logged before :meth:`initialize` are buffered until the directory exists.
+    """
+
+    def __init__(self, project_root: str):
+        self.start_time = datetime.now()
+        self._start_ms = now_ms()
+        self.current_step: _StepInfo | None = None
+        self.initialized = False
+        self.pending_lines: list[str] = []
+        logs_dir = os.path.join(project_root, CONFIG_DIR, CLI_SYSTEM_DIR, CLI_LOGS_DIR, "create")
+        self.log_file_path = os.path.join(logs_dir, f"create-{format_timestamp_for_filename(self.start_time)}.log")
+
+    def initialize(self) -> None:
+        if self.initialized:
+            return
+        os.makedirs(os.path.dirname(self.log_file_path), exist_ok=True)
+        sep = "=" * 80
+        write(self.log_file_path, f"{sep}\nAGENTCORE CREATE LOG\nStarted: {iso_now(self.start_time)}\n{sep}\n\n")
+        self.initialized = True
+        for line in self.pending_lines:
+            append(self.log_file_path, line + "\n")
+        self.pending_lines = []
+
+    def append_line(self, line: str) -> None:
+        if not self.initialized:
+            self.pending_lines.append(line)
+            return
+        append(self.log_file_path, line + "\n")
+
+    def start_step(self, name: str) -> None:
+        if self.current_step:
+            self.end_step("success")
+        self.current_step = _StepInfo(name, now_ms())
+        self.append_line("")
+        self.append_line(f"[{format_time()}] STEP: {name}")
+
+    def end_step(self, status: Literal["success", "error", "warn"], error: str | None = None) -> None:
+        if not self.current_step:
+            return
+        duration = now_ms() - self.current_step.start_time
+        status_text = "SUCCESS" if status == "success" else "WARNING" if status == "warn" else "FAILED"
+        if status in ("error", "warn") and error:
+            self.append_line(f"[{format_time()}] {'Error' if status == 'error' else 'Warning'}: {error}")
+        self.append_line(f"[{format_time()}] Status: {status_text}")
+        self.append_line(f"[{format_time()}] Duration: {format_duration(duration)}")
+        self.current_step = None
+
+    def log(self, message: str, level: Literal["info", "warn", "error", "debug"] | None = None) -> None:
+        prefix = f"[{level.upper()}] " if level and level != "info" else ""
+        self.append_line(f"[{format_time()}] {prefix}{message}")
+
+    def log_sub_step(self, message: str) -> None:
+        self.append_line(f"[{format_time()}]   - {message}")
+
+    def log_command(self, command: str, args: list[str]) -> None:
+        self.append_line(f"[{format_time()}]   Running: {command} {' '.join(args)}")
+
+    def log_command_output(self, output: str) -> None:
+        if not output.strip():
+            return
+        for line in output.strip().split("\n"):
+            self.append_line(f"[{format_time()}]     > {line}")
+
+    def finalize(self, success: bool) -> None:
+        if self.current_step:
+            self.end_step("success" if success else "error")
+        sep = "=" * 80
+        self.append_line("")
+        self.append_line(sep)
+        self.append_line("COMPLETED SUCCESSFULLY" if success else "FAILED")
+        self.append_line(f"Total Duration: {format_duration(now_ms() - self._start_ms)}")
+        self.append_line(sep)
+
+    def get_relative_log_path(self) -> str:
+        return os.path.relpath(self.log_file_path, os.getcwd())
+
+    def get_clickable_log_path(self) -> str:
+        return osc8_link(self.log_file_path)

agentcore/logging/dev_logger.py

@@ -0,0 +1,63 @@
+"""Port of src/cli/logging/dev-logger.ts."""
+
+import os
+from datetime import datetime
+from typing import Literal
+
+from agentcore.lib.constants import CLI_LOGS_DIR, CLI_SYSTEM_DIR, CONFIG_DIR
+from agentcore.lib.schemas.io.path_resolver import find_config_root
+from agentcore.logging._common import (
+    append,
+    format_duration,
+    format_time,
+    format_timestamp_for_filename,
+    iso_now,
+    now_ms,
+    osc8_link,
+    write,
+)
+
+DevLogLevel = Literal["info", "system", "warn", "error", "response"]
+
+IMPORTANT_LEVELS = frozenset({"system", "warn", "error", "response"})
+
+
+class DevLogger:
+    """Writes important dev-server messages to agentcore/.cli/logs/dev/dev-<ts>.log."""
+
+    def __init__(self, base_dir: str | None = None, agent_name: str | None = None, port: int | None = None):
+        self.start_time = datetime.now()
+        self._start_ms = now_ms()
+        config_root = os.path.join(base_dir, CONFIG_DIR) if base_dir else find_config_root()
+        if not config_root or not os.path.exists(config_root):
+            raise RuntimeError("No agentcore project found. Cannot create dev logs.")
+        logs_dir = os.path.join(config_root, CLI_SYSTEM_DIR, CLI_LOGS_DIR, "dev")
+        os.makedirs(logs_dir, exist_ok=True)
+        self.log_file_path = os.path.join(logs_dir, f"dev-{format_timestamp_for_filename(self.start_time)}.log")
+        sep = "=" * 80
+        agent_line = f"Agent: {agent_name}\n" if agent_name else ""
+        port_line = f"Port: {port}\n" if port else ""
+        write(
+            self.log_file_path,
+            f"{sep}\nAGENTCORE DEV LOG\n{agent_line}{port_line}Started: {iso_now(self.start_time)}\n{sep}\n\n",
+        )
+
+    def log(self, level: DevLogLevel, message: str) -> None:
+        if level not in IMPORTANT_LEVELS:
+            return
+        prefix = "RESPONSE" if level == "response" else level.upper()
+        append(self.log_file_path, f"[{format_time()}] [{prefix}] {message}\n")
+
+    def log_sse_event(self, raw_line: str) -> None:
+        append(self.log_file_path, f"[{format_time()}] [SSE] {raw_line}\n")
+
+    def finalize(self) -> None:
+        sep = "=" * 80
+        duration = format_duration(now_ms() - self._start_ms)
+        append(self.log_file_path, f"\n{sep}\nSESSION ENDED\nDuration: {duration}\n{sep}\n")
+
+    def get_clickable_log_path(self) -> str:
+        return osc8_link(self.log_file_path)
+
+    def get_relative_log_path(self) -> str:
+        return os.path.relpath(self.log_file_path, os.getcwd())

agentcore/logging/exec_logger.py

@@ -0,0 +1,159 @@
+"""Structured per-command execution log (port of ``logging/exec-logger.ts``).
+
+Writes ``agentcore/.cli/logs/<command>/<command>-YYYYMMDD-HHMMSS.log`` with step timing and status.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import time
+from datetime import UTC, datetime
+from typing import Literal
+
+from agentcore.lib.constants import CLI_LOGS_DIR, CLI_SYSTEM_DIR, CONFIG_DIR
+from agentcore.lib.schemas.io.path_resolver import find_config_root
+
+LogLevel = Literal["info", "warn", "error", "debug"]
+StepStatus = Literal["success", "error", "warn"]
+
+_ANSI_RE = re.compile(r"\x1b\[[0-9;]*[a-zA-Z]")
+
+
+def strip_ansi(text: str) -> str:
+    return _ANSI_RE.sub("", text)
+
+
+def _now_ms() -> int:
+    return int(time.time() * 1000)
+
+
+def _iso(dt: datetime) -> str:
+    """``Date#toISOString()``: UTC with millisecond precision and a ``Z`` suffix."""
+    return dt.astimezone(UTC).strftime("%Y-%m-%dT%H:%M:%S.") + f"{dt.microsecond // 1000:03d}Z"
+
+
+def format_duration(ms: int) -> str:
+    if ms < 1000:
+        return f"{ms}ms"
+    seconds = ms / 1000
+    if seconds < 60:
+        return f"{seconds:.1f}s"
+    minutes = int(seconds // 60)
+    remaining = round(seconds % 60)
+    return f"{minutes}m {remaining}s"
+
+
+class ExecLogger:
+    """Creates a timestamped log file and tracks execution steps."""
+
+    def __init__(self, command: str, base_dir: str | None = None) -> None:
+        self.command = command
+        self.start_time = datetime.now().astimezone()
+        self._start_ms = _now_ms()
+        self._current_step: tuple[str, int] | None = None
+        self.last_failed_step: str | None = None
+
+        config_root = os.path.join(base_dir, CONFIG_DIR) if base_dir else find_config_root()
+        logs_dir = (
+            os.path.join(config_root, CLI_SYSTEM_DIR, CLI_LOGS_DIR, command)
+            if config_root
+            else os.path.join(os.getcwd(), CONFIG_DIR, CLI_SYSTEM_DIR, CLI_LOGS_DIR, command)
+        )
+        os.makedirs(logs_dir, exist_ok=True)
+        stamp = self.start_time.strftime("%Y%m%d-%H%M%S")
+        self.log_file_path = os.path.join(logs_dir, f"{command}-{stamp}.log")
+        self._write_header()
+
+    @staticmethod
+    def _format_time(dt: datetime | None = None) -> str:
+        return (dt or datetime.now()).strftime("%H:%M:%S")
+
+    def _write_header(self) -> None:
+        separator = "=" * 80
+        header = (
+            f"{separator}\nAGENTCORE {self.command.upper()} LOG\nCommand: {self.command}\n"
+            f"Started: {_iso(self.start_time)}\n{separator}\n\n"
+        )
+        with open(self.log_file_path, "w", encoding="utf-8") as fh:
+            fh.write(header)
+
+    def append_line(self, line: str) -> None:
+        with open(self.log_file_path, "a", encoding="utf-8") as fh:
+            fh.write(line + "\n")
+
+    def start_step(self, name: str) -> None:
+        if self._current_step:
+            self.end_step("success")
+        self._current_step = (name, _now_ms())
+        self.append_line("")
+        self.append_line(f"[{self._format_time()}] STEP: {name}")
+
+    def end_step(self, status: StepStatus, message: str | None = None) -> None:
+        if not self._current_step:
+            return
+        name, started = self._current_step
+        duration = _now_ms() - started
+        status_text = {"success": "SUCCESS", "warn": "WARNING"}.get(status, "FAILED")
+        if status == "error":
+            self.last_failed_step = name
+        if status in ("error", "warn") and message:
+            label = "Error" if status == "error" else "Warning"
+            self.append_line(f"[{self._format_time()}] {label}: {message}")
+        self.append_line(f"[{self._format_time()}] Status: {status_text}")
+        self.append_line(f"[{self._format_time()}] Duration: {format_duration(duration)}")
+        self._current_step = None
+
+    def log(self, message: str, level: LogLevel | None = None) -> None:
+        prefix = f"[{level.upper()}] " if level and level != "info" else ""
+        self.append_line(f"[{self._format_time()}] {prefix}{message}")
+
+    def log_diff(self, code: str, message: str) -> None:
+        """Write a CDK diff block with ANSI codes stripped."""
+        if not message:
+            return
+        clean = strip_ansi(message)
+        lines = clean.split("\n")
+        if code == "CDK_TOOLKIT_I4002":
+            self.append_line("")
+            self.append_line("─" * 80)
+            for line in lines:
+                self.append_line(line)
+            self.append_line("─" * 80)
+        elif code == "CDK_TOOLKIT_I4001":
+            self.append_line("")
+            self.append_line(clean)
+        elif len(lines) > 1:
+            for line in lines:
+                if line.strip():
+                    self.append_line(f"[{self._format_time()}] {line}")
+        else:
+            self.append_line(f"[{self._format_time()}] {clean}")
+
+    def finalize(self, success: bool) -> None:
+        if self._current_step:
+            self.end_step("success" if success else "error")
+        separator = "=" * 80
+        self.append_line("")
+        self.append_line(separator)
+        self.append_line("COMPLETED SUCCESSFULLY" if success else "FAILED")
+        self.append_line(f"Total Duration: {format_duration(_now_ms() - self._start_ms)}")
+        self.append_line(separator)
+
+    def get_failure_message(self, step_name: str | None = None) -> str:
+        prefix = f"{step_name} failed." if step_name else "Operation failed."
+        return f"{prefix}\nView details:\n{self.get_clickable_log_path()}"
+
+    def get_clickable_log_path(self) -> str:
+        """OSC 8 terminal hyperlink: short relative text linking to the file:// URL."""
+        url = f"file://{self.log_file_path}"
+        return f"\x1b]8;;{url}\x1b\\{self.get_relative_log_path()}\x1b]8;;\x1b\\"
+
+    def get_log_file_url(self) -> str:
+        return f"file://{self.log_file_path}"
+
+    def get_relative_log_path(self) -> str:
+        return os.path.relpath(self.log_file_path, os.getcwd())
+
+
+__all__ = ["ExecLogger", "format_duration", "strip_ansi"]

agentcore/logging/invoke_logger.py

@@ -0,0 +1,154 @@
+"""Port of src/cli/logging/invoke-logger.ts."""
+
+import os
+import re
+import traceback
+from datetime import datetime
+from typing import Any
+
+from agentcore.lib.constants import CLI_LOGS_DIR, CLI_SYSTEM_DIR, CONFIG_DIR
+from agentcore.lib.schemas.io.path_resolver import find_config_root
+from agentcore.logging._common import (
+    append,
+    format_time,
+    format_timestamp_for_filename,
+    iso_now,
+    js_json,
+    now_ms,
+    osc8_link,
+    write,
+)
+
+INVOKE_LOGS_SUBDIR = "invoke"
+_INTERNAL_ATTRS = frozenset({"args", "with_traceback", "add_note", "__notes__"})
+
+
+class InvokeLogger:
+    """Logs invoke requests/responses to agentcore/.cli/logs/invoke/ with JSON sections."""
+
+    def __init__(self, agent_name: str, runtime_arn: str, region: str, session_id: str | None = None):
+        self.agent_name = agent_name
+        self.runtime_arn = runtime_arn
+        self.region = region
+        self.session_id = session_id
+        self.start_time = datetime.now()
+        self.request_log: dict[str, Any] | None = None
+        self.prompt_start_time: int | None = None
+
+        config_root = find_config_root()
+        logs_dir = (
+            os.path.abspath(os.path.join(config_root, CLI_SYSTEM_DIR, CLI_LOGS_DIR, INVOKE_LOGS_SUBDIR))
+            if config_root
+            else os.path.abspath(
+                os.path.join(os.getcwd(), CONFIG_DIR, CLI_SYSTEM_DIR, CLI_LOGS_DIR, INVOKE_LOGS_SUBDIR)
+            )
+        )
+        os.makedirs(logs_dir, exist_ok=True)
+        safe_name = re.sub(r"[^a-zA-Z0-9\-_]", "_", agent_name)
+        timestamp = format_timestamp_for_filename(self.start_time)
+        self.log_file_path = os.path.abspath(os.path.join(logs_dir, f"invoke-{safe_name}-{timestamp}.log"))
+        self._write_header()
+
+    def _write_header(self) -> None:
+        sep = "=" * 80
+        write(
+            self.log_file_path,
+            f"{sep}\nAGENTCORE INVOKE LOG\nAgent: {self.agent_name}\nRuntime ARN: {self.runtime_arn}\n"
+            f"Region: {self.region}\nSession ID: {self.session_id or 'none'}\n"
+            f"Started: {iso_now(self.start_time)}\n{sep}\n\n",
+        )
+
+    def _append_line(self, line: str) -> None:
+        append(self.log_file_path, line + "\n")
+
+    def _append_json(self, label: str, data: Any) -> None:
+        self._append_line(f"\n--- {label} ---")
+        self._append_line(js_json(data))
+        self._append_line(f"--- END {label} ---\n")
+
+    def _time(self) -> str:
+        return format_time(with_ms=True)
+
+    def log_prompt(self, prompt: str, session_id: str | None = None, user_id: str | None = None) -> None:
+        self.prompt_start_time = now_ms()
+        current = session_id if session_id is not None else self.session_id
+        self.request_log = {
+            "timestamp": iso_now(),
+            "agent": self.agent_name,
+            "runtimeArn": self.runtime_arn,
+            "region": self.region,
+            "sessionId": current,
+            "userId": user_id,
+            "prompt": prompt,
+        }
+        self._append_line(f"[{self._time()}] INVOKE REQUEST (Session: {current or 'none'})")
+        self._append_json("REQUEST", self.request_log)
+
+    def update_session_id(self, session_id: str) -> None:
+        self.session_id = session_id
+        self._append_line(f"[{self._time()}] SESSION ID UPDATED: {session_id}")
+
+    def log_chunk(self, chunk: str) -> None:
+        self._append_line(f"[{self._time()}] CHUNK: {len(chunk)} chars")
+
+    def log_sse_event(self, raw_line: str) -> None:
+        self._append_line(f"[{self._time()}] SSE: {raw_line}")
+
+    def _duration(self) -> int:
+        return now_ms() - self.prompt_start_time if self.prompt_start_time else 0
+
+    def log_response(self, response: str) -> None:
+        duration = self._duration()
+        self._append_line(f"[{self._time()}] INVOKE RESPONSE ({duration}ms)")
+        self._append_json(
+            "RESPONSE", {"timestamp": iso_now(), "durationMs": duration, "success": True, "response": response}
+        )
+
+    def log_error(self, error: Any, context: str | None = None) -> None:
+        ts = self._time()
+        duration = self._duration()
+        if context:
+            self._append_line(f"[{ts}] ERROR CONTEXT: {context}")
+        response_log: dict[str, Any] = {"timestamp": iso_now(), "durationMs": duration, "success": False}
+        if isinstance(error, BaseException):
+            message = str(error)
+            name = type(error).__name__
+            stack = "".join(traceback.format_exception(error)).rstrip("\n") if error.__traceback__ else None
+            self._append_line(f"[{ts}] ERROR: {message}")
+            self._append_line(f"[{ts}] ERROR NAME: {name}")
+            metadata: dict[str, Any] = {}
+            response_log["error"] = {"message": message, "name": name, "stack": stack, "metadata": metadata}
+            if stack:
+                self._append_line(f"[{ts}] STACK TRACE:")
+                for line in stack.split("\n"):
+                    self._append_line(f"  {line}")
+            for key, value in vars(error).items():
+                if key.startswith("_") or key in _INTERNAL_ATTRS or key in ("message", "name", "stack"):
+                    continue
+                try:
+                    if isinstance(value, (dict, list)):
+                        text = js_json(value, indent=None)
+                    elif value is None:
+                        text = ""
+                    else:
+                        text = str(value)
+                    self._append_line(f"[{ts}] ERROR.{key}: {text}")
+                    metadata[key] = value
+                except Exception:  # noqa: BLE001 - ignore serialization errors, as upstream
+                    pass
+        else:
+            self._append_line(f"[{ts}] ERROR: {error}")
+            response_log["error"] = {"message": str(error), "name": "UnknownError"}
+        self._append_json("RESPONSE", response_log)
+
+    def log_info(self, message: str) -> None:
+        self._append_line(f"[{self._time()}] INFO: {message}")
+
+    def get_relative_log_path(self) -> str:
+        return os.path.relpath(self.log_file_path, os.getcwd())
+
+    def get_absolute_log_path(self) -> str:
+        return self.log_file_path
+
+    def get_clickable_log_path(self) -> str:
+        return osc8_link(self.log_file_path)

agentcore/logging/remove_logger.py

@@ -0,0 +1,95 @@
+"""Port of src/cli/logging/remove-logger.ts."""
+
+import os
+import re
+from datetime import datetime
+from typing import Any
+
+from agentcore.lib.constants import CLI_LOGS_DIR, CLI_SYSTEM_DIR, CONFIG_DIR
+from agentcore.lib.schemas.io.path_resolver import find_config_root
+from agentcore.logging._common import format_timestamp_for_filename, iso_now, js_json, write
+
+REMOVE_LOGS_SUBDIR = "remove"
+
+
+def compute_json_diff(before: Any, after: Any) -> list[str]:
+    """Unified-style LCS line diff of two JSON values (``+``/``-``/two-space prefixes)."""
+    before_lines = js_json(before).split("\n")
+    after_lines = js_json(after).split("\n")
+    m, n = len(before_lines), len(after_lines)
+    dp = [[0] * (n + 1) for _ in range(m + 1)]
+    for i in range(1, m + 1):
+        for j in range(1, n + 1):
+            if before_lines[i - 1] == after_lines[j - 1]:
+                dp[i][j] = dp[i - 1][j - 1] + 1
+            else:
+                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
+    i, j = m, n
+    out: list[str] = []
+    while i > 0 or j > 0:
+        if i > 0 and j > 0 and before_lines[i - 1] == after_lines[j - 1]:
+            out.append(f"  {before_lines[i - 1]}")
+            i -= 1
+            j -= 1
+        elif j > 0 and (i == 0 or dp[i][j - 1] >= dp[i - 1][j]):
+            out.append(f"+ {after_lines[j - 1]}")
+            j -= 1
+        elif i > 0:
+            out.append(f"- {before_lines[i - 1]}")
+            i -= 1
+    out.reverse()
+    return out
+
+
+class RemoveLogger:
+    """Writes agentcore/.cli/logs/remove/remove-<type>-<name>-<ts>.log including the schema diff."""
+
+    def __init__(self, resource_type: str, resource_name: str):
+        self.resource_type = resource_type
+        self.resource_name = resource_name
+        self.start_time = datetime.now()
+        config_root = find_config_root()
+        logs_dir = (
+            os.path.abspath(os.path.join(config_root, CLI_SYSTEM_DIR, CLI_LOGS_DIR, REMOVE_LOGS_SUBDIR))
+            if config_root
+            else os.path.abspath(
+                os.path.join(os.getcwd(), CONFIG_DIR, CLI_SYSTEM_DIR, CLI_LOGS_DIR, REMOVE_LOGS_SUBDIR)
+            )
+        )
+        os.makedirs(logs_dir, exist_ok=True)
+        safe_name = re.sub(r"[^a-zA-Z0-9\-_]", "_", resource_name)
+        timestamp = format_timestamp_for_filename(self.start_time)
+        self.log_file_path = os.path.abspath(
+            os.path.join(logs_dir, f"remove-{resource_type}-{safe_name}-{timestamp}.log")
+        )
+
+    def log_removal(self, preview: Any, success: bool, error: str | None = None) -> None:
+        """``preview`` is a ``RemovalPreview`` (summary, schema_changes[file, before, after])."""
+        sep = "=" * 80
+        lines = [
+            sep,
+            "AGENTCORE REMOVE LOG",
+            f"Resource Type: {self.resource_type}",
+            f"Resource Name: {self.resource_name}",
+            f"Timestamp: {iso_now(self.start_time)}",
+            f"Status: {'SUCCESS' if success else 'FAILED'}",
+        ]
+        if error:
+            lines.append(f"Error: {error}")
+        lines += [sep, "", "--- SUMMARY ---", *preview.summary, ""]
+        changes = getattr(preview, "schema_changes", None) or []
+        if changes:
+            lines.append("--- SCHEMA DIFF ---")
+            for change in changes:
+                lines.append(f"File: {change.file}")
+                lines.append("-" * 40)
+                lines.extend(compute_json_diff(change.before, change.after))
+                lines.append("")
+        lines += [sep, f"End of log: {iso_now()}"]
+        write(self.log_file_path, "\n".join(lines))
+
+    def get_relative_log_path(self) -> str:
+        return os.path.relpath(self.log_file_path, os.getcwd())
+
+    def get_absolute_log_path(self) -> str:
+        return self.log_file_path

agentcore/operations/agent/config_bundle_defaults.py

@@ -0,0 +1,31 @@
+"""Default config bundle for `--with-config-bundle` (port of config-bundle-defaults.ts)."""
+
+from agentcore.lib import ConfigIO
+from agentcore.lib.schemas.io.config_io import to_jsonable
+
+
+def create_config_bundle_for_agent(agent_name: str, config_base_dir: str) -> None:
+    config_io = ConfigIO(base_dir=config_base_dir)
+    project = to_jsonable(config_io.read_project_spec())
+    bundle_name = f"{agent_name}Config"
+    bundles = project.setdefault("configBundles", [])
+    if any(b["name"] == bundle_name for b in bundles):
+        return
+    bundles.append(
+        {
+            "type": "ConfigurationBundle",
+            "name": bundle_name,
+            "description": f"Configuration for {agent_name} — managed by agentcore CLI",
+            "components": {
+                f"{{{{runtime:{agent_name}}}}}": {
+                    "configuration": {
+                        "systemPrompt": "You are a helpful assistant. Use tools when appropriate.",
+                        "toolDescriptions": {"add_numbers": "Return the sum of two numbers"},
+                    }
+                }
+            },
+            "branchName": "mainline",
+            "commitMessage": "Initial configuration",
+        }
+    )
+    config_io.write_project_spec(project)

agentcore/operations/agent/generate/__init__.py

@@ -0,0 +1,28 @@
+from agentcore.operations.agent.generate.schema_mapper import (
+    GenerateConfigMappingResult,
+    apply_template_runtime_defaults,
+    compute_default_gateway_env_var_name,
+    map_generate_config_to_agent,
+    map_generate_config_to_render_config,
+    map_generate_config_to_resources,
+    map_generate_input_to_memories,
+    map_model_provider_to_credentials,
+    map_model_provider_to_identity_providers,
+)
+from agentcore.operations.agent.generate.types import GenerateConfig, MemoryOption
+from agentcore.operations.agent.generate.write_agent_to_project import write_agent_to_project
+
+__all__ = [
+    "GenerateConfig",
+    "GenerateConfigMappingResult",
+    "MemoryOption",
+    "apply_template_runtime_defaults",
+    "compute_default_gateway_env_var_name",
+    "map_generate_config_to_agent",
+    "map_generate_config_to_render_config",
+    "map_generate_config_to_resources",
+    "map_generate_input_to_memories",
+    "map_model_provider_to_credentials",
+    "map_model_provider_to_identity_providers",
+    "write_agent_to_project",
+]