iac-code 0.3.1__tar.gz → 0.4.1__tar.gz

{iac_code-0.3.1 → iac_code-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iac_code
-Version: 0.3.1
+Version: 0.4.1
 Summary: Your AI-powered Infrastructure as Code assistant
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10

iac_code-0.4.1/src/iac_code/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.4.1"
+__release_date__ = "2026-06-05"

{iac_code-0.3.1 → iac_code-0.4.1}/src/iac_code/a2a/executor.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import logging
 import os
 import uuid
@@ -27,7 +28,7 @@ from iac_code.a2a.types import (
 )
 from iac_code.services.agent_factory import AgentFactoryOptions, create_agent_runtime
 from iac_code.services.session_storage import SessionStorage
-from iac_code.services.telemetry import use_session_id
+from iac_code.services.telemetry import use_session_id, use_user_id
 
 logger = logging.getLogger(__name__)
 _CONTEXT_LOCK_ACQUIRE_TIMEOUT_SECONDS = 1
@@ -87,6 +88,7 @@ class IacCodeA2AExecutor(AgentExecutor):
                 getattr(context, "message", None), "metadata", None
             )
             cwd = self._resolve_cwd(metadata)
+            user_id = self._resolve_user_id(metadata)
             prompt = self._prompt_from_context(context, cwd=cwd)
         except Exception as exc:
             if _is_retryable_executor_error(exc):
@@ -222,7 +224,8 @@ class IacCodeA2AExecutor(AgentExecutor):
                     context_id=context_id,
                     state=TaskState.TASK_STATE_WORKING,
                 )
-                with use_session_id(ctx.session_id):
+                user_id_ctx = use_user_id(user_id) if user_id else contextlib.nullcontext()
+                with use_session_id(ctx.session_id), user_id_ctx:
                     async for event in runtime.agent_loop.run_streaming(prompt):
                         text_chunk = await publish_stream_event(
                             event_queue,
@@ -348,6 +351,19 @@ class IacCodeA2AExecutor(AgentExecutor):
             resolved_cwd.mkdir(parents=True, exist_ok=True)
         return str(resolved_cwd)
 
+    def _resolve_user_id(self, metadata: Any | None) -> str | None:
+        if metadata is not None and hasattr(metadata, "DESCRIPTOR"):
+            metadata = MessageToDict(metadata, preserving_proto_field_name=False)
+        if not isinstance(metadata, Mapping):
+            return None
+        raw_iac_meta = metadata.get("iac_code")
+        if not isinstance(raw_iac_meta, Mapping):
+            return None
+        raw_user_id = raw_iac_meta.get("user_id")
+        if isinstance(raw_user_id, str) and raw_user_id.strip():
+            return raw_user_id.strip()
+        return None
+
     def _prompt_from_context(self, context: RequestContext, *, cwd: str) -> str:
         message = getattr(context, "message", None)
         if not isinstance(message, Message):

{iac_code-0.3.1 → iac_code-0.4.1}/src/iac_code/acp/server.py

@@ -18,8 +18,12 @@ from iac_code.acp.types import ACPContentBlock, MCPServer
 from iac_code.acp.version import negotiate_version
 from iac_code.commands import LocalCommand, create_default_registry
 from iac_code.config import DEFAULT_MODEL, get_active_provider_key, load_saved_model
+from iac_code.i18n import _
 from iac_code.services.agent_factory import AgentFactoryOptions, create_agent_runtime
+from iac_code.services.session_index import SessionEntry, SessionIndex
+from iac_code.services.session_resolver import ResolutionStatus, resolve_session_argument
 from iac_code.services.session_storage import SessionStorage
+from iac_code.utils.project_paths import format_resume_command, same_project_path
 
 SESSION_IDLE_TIMEOUT = 3600  # 1 hour
 CLEANUP_INTERVAL = 300  # 5 minutes
@@ -152,7 +156,12 @@ class ACPServer:
             runtime.session_id,
         )
         session = ACPSession(
-            runtime.session_id, runtime.agent_loop, self.conn, mcp_configs=mcp_configs, metrics=self.metrics
+            runtime.session_id,
+            runtime.agent_loop,
+            self.conn,
+            mcp_configs=mcp_configs,
+            metrics=self.metrics,
+            memory_manager=getattr(runtime, "memory_manager", None),
         )
         self.sessions[session.id] = session
         self.metrics.record_session_created()
@@ -228,25 +237,16 @@ class ACPServer:
         cwd: str | None = None,
         **kwargs: Any,
     ) -> acp.schema.ListSessionsResponse:
-        from iac_code.utils.project_paths import get_project_dir, get_projects_dir
-
-        session_ids: list[str] = []
-        if cwd:
-            project_dir = get_project_dir(cwd)
-            if project_dir.exists():
-                session_ids = [p.stem for p in project_dir.glob("*.jsonl")]
-        else:
-            projects_root = get_projects_dir()
-            if projects_root.exists():
-                session_ids = [p.stem for p in projects_root.glob("*/*.jsonl")]
+        index = SessionIndex()
+        entries = index.list_for_cwd(cwd) if cwd else index.list_all_projects()
         return acp.schema.ListSessionsResponse(
             sessions=[
                 acp.schema.SessionInfo(
-                    session_id=session_id,
-                    cwd=cwd or "",
-                    title=session_id,
+                    session_id=entry.session_id,
+                    cwd=entry.cwd or cwd or "",
+                    title=entry.title,
                 )
-                for session_id in session_ids
+                for entry in entries
             ],
             next_cursor=None,
         )
@@ -297,7 +297,14 @@ class ACPServer:
             runtime.agent_loop.context_manager.load_messages(history)
 
         # 4. Register session
-        session = ACPSession(session_id, runtime.agent_loop, self.conn, mcp_configs=mcp_configs, metrics=self.metrics)
+        session = ACPSession(
+            session_id,
+            runtime.agent_loop,
+            self.conn,
+            mcp_configs=mcp_configs,
+            metrics=self.metrics,
+            memory_manager=getattr(runtime, "memory_manager", None),
+        )
         self.sessions[session_id] = session
         self.metrics.record_session_created()
         logger.info("Session loaded, session_id=%s, history_messages=%d", session_id, len(history))
@@ -360,7 +367,12 @@ class ACPServer:
 
         # 4. Register the forked session
         session = ACPSession(
-            new_session_id, runtime.agent_loop, self.conn, mcp_configs=mcp_configs, metrics=self.metrics
+            new_session_id,
+            runtime.agent_loop,
+            self.conn,
+            mcp_configs=mcp_configs,
+            metrics=self.metrics,
+            memory_manager=getattr(runtime, "memory_manager", None),
         )
         self.sessions[new_session_id] = session
         self.metrics.record_session_created()
@@ -384,20 +396,66 @@ class ACPServer:
         mcp_servers: list[MCPServer] | None = None,
         **kwargs: Any,
     ) -> acp.schema.ResumeSessionResponse:
-        # 1. If session is still active in memory, return directly
-        if session_id in self.sessions:
+        # 1. If session is still active in memory by exact id, enforce project ownership before returning.
+        active_session = self.sessions.get(session_id)
+        if active_session is not None:
+            error = _active_session_project_error(cwd, session_id, session_id, active_session)
+            if error is not None:
+                raise error
             await self._push_available_commands(session_id)
             return acp.schema.ResumeSessionResponse()
 
         if self.conn is None:
             raise acp.RequestError.internal_error({"error": "ACP client not connected"})
 
-        # 2. Try to load persisted history from SessionStorage
+        resolution = resolve_session_argument(SessionIndex(), cwd, session_id)
+        if resolution.status == ResolutionStatus.NOT_FOUND:
+            raise _invalid_params(_("Session not found"), {"session_id": session_id})
+        if resolution.status == ResolutionStatus.AMBIGUOUS_NAME:
+            candidate_ids = [entry.session_id for entry in resolution.candidates]
+            message = _("Session name is ambiguous. Candidates: {candidates}").format(
+                candidates=", ".join(candidate_ids)
+            )
+            raise _invalid_params(
+                message,
+                {
+                    "session_id": session_id,
+                    "candidates": [_resume_candidate_data(entry) for entry in resolution.candidates],
+                },
+            )
+
+        entry = resolution.entry
+        if entry is None:  # pragma: no cover - defensive guard for inconsistent resolver output
+            raise _invalid_params(_("Session not found"), {"session_id": session_id})
+
+        resolved_session_id = entry.session_id
+        if entry.cwd and not same_project_path(entry.cwd, cwd):
+            hint = _resume_command(entry.cwd, resolved_session_id)
+            message = _("Session belongs to another project. Run: {hint}").format(hint=hint)
+            raise _invalid_params(
+                message,
+                {
+                    "session_id": session_id,
+                    "resolved_session_id": resolved_session_id,
+                    "cwd": entry.cwd,
+                    "hint": hint,
+                },
+            )
+
+        active_session = self.sessions.get(resolved_session_id)
+        if active_session is not None:
+            error = _active_session_project_error(cwd, session_id, resolved_session_id, active_session)
+            if error is not None:
+                raise error
+            await self._push_available_commands(resolved_session_id)
+            return acp.schema.ResumeSessionResponse()
+
+        # 2. Try to load persisted history from SessionStorage.
         storage = SessionStorage()
-        if not storage.exists(cwd, session_id):
-            raise acp.RequestError.invalid_params({"session_id": "Session not found"})
+        if not storage.exists(cwd, resolved_session_id):
+            raise _invalid_params(_("Session not found"), {"session_id": session_id})
 
-        history = storage.load(cwd, session_id)
+        history = storage.load(cwd, resolved_session_id)
         history = SessionStorage.repair_interrupted(history)
 
         # Convert MCP server configs from ACP protocol types to internal dicts
@@ -405,7 +463,7 @@ class ACPServer:
 
         # 3. Rebuild agent runtime with restored history
         model = load_saved_model() or DEFAULT_MODEL
-        runtime = self._create_runtime_with_auth_check(model=model, session_id=session_id, cwd=cwd)
+        runtime = self._create_runtime_with_auth_check(model=model, session_id=resolved_session_id, cwd=cwd)
         replace_bash_with_acp_terminal(
             runtime.tool_registry,
             self.client_capabilities,
@@ -418,10 +476,17 @@ class ACPServer:
             runtime.agent_loop.context_manager.load_messages(history)
 
         # 4. Register the resumed session
-        session = ACPSession(session_id, runtime.agent_loop, self.conn, mcp_configs=mcp_configs, metrics=self.metrics)
-        self.sessions[session_id] = session
+        session = ACPSession(
+            resolved_session_id,
+            runtime.agent_loop,
+            self.conn,
+            mcp_configs=mcp_configs,
+            metrics=self.metrics,
+            memory_manager=getattr(runtime, "memory_manager", None),
+        )
+        self.sessions[resolved_session_id] = session
         self.metrics.record_session_created()
-        await self._push_available_commands(session_id)
+        await self._push_available_commands(resolved_session_id)
 
         return acp.schema.ResumeSessionResponse()
 
@@ -619,6 +684,48 @@ def _convert_mcp_servers(mcp_servers: list[MCPServer] | None) -> list[dict[str,
     return configs
 
 
+def _invalid_params(message: str, data: dict[str, Any] | None = None) -> acp.RequestError:
+    """Create an ACP invalid-params error with a useful message."""
+    return acp.RequestError(-32602, message, data)
+
+
+def _resume_command(cwd: str, session_id: str) -> str:
+    return format_resume_command(cwd, session_id)
+
+
+def _active_session_cwd(session: ACPSession) -> str | None:
+    cwd = getattr(session.agent_loop, "_cwd", None)
+    return cwd if isinstance(cwd, str) and cwd else None
+
+
+def _active_session_project_error(
+    cwd: str, session_id: str, resolved_session_id: str, session: ACPSession
+) -> acp.RequestError | None:
+    active_cwd = _active_session_cwd(session)
+    if not active_cwd or same_project_path(active_cwd, cwd):
+        return None
+    hint = _resume_command(active_cwd, resolved_session_id)
+    message = _("Session belongs to another project. Run: {hint}").format(hint=hint)
+    return _invalid_params(
+        message,
+        {
+            "session_id": session_id,
+            "resolved_session_id": resolved_session_id,
+            "cwd": active_cwd,
+            "hint": hint,
+        },
+    )
+
+
+def _resume_candidate_data(entry: SessionEntry) -> dict[str, str | None]:
+    return {
+        "session_id": entry.session_id,
+        "name": entry.name,
+        "cwd": entry.cwd,
+        "command": _resume_command(entry.cwd, entry.session_id),
+    }
+
+
 # ---------------------------------------------------------------------------
 # Auth methods declaration
 # ---------------------------------------------------------------------------

{iac_code-0.3.1 → iac_code-0.4.1}/src/iac_code/acp/session.py

@@ -157,6 +157,20 @@ _PREFIX_ALLOW_RULE = "allow_rule:"
 _PREFIX_DENY_RULE = "deny_rule:"
 
 
+def _tool_supports_blanket_allow(agent_loop, tool_name: str) -> bool:
+    """Return False only when the registered tool explicitly disables blanket allow."""
+    registry = getattr(agent_loop, "tool_registry", None)
+    get_tool = getattr(registry, "get", None)
+    if get_tool is None:
+        return True
+
+    tool = get_tool(tool_name)
+    if tool is None:
+        return True
+
+    return bool(getattr(tool, "supports_blanket_allow", True))
+
+
 class ACPSession:
     def __init__(
         self,
@@ -165,9 +179,11 @@ class ACPSession:
         conn: acp.Client,
         mcp_configs: list[dict] | None = None,
         metrics: ACPMetrics | None = None,
+        memory_manager=None,
     ) -> None:
         self.id = session_id
         self.agent_loop = agent_loop
+        self.memory_manager = memory_manager
         self._conn = conn
         self._current_task: asyncio.Task | None = None
         self._replay_task: asyncio.Task[None] | None = None
@@ -292,7 +308,11 @@ class ACPSession:
         prompt_text = acp_blocks_to_prompt_text(prompt)
         slash_registry = ACPSlashRegistry()
         if slash_registry.is_slash_command(prompt_text):
-            result = await slash_registry.execute(prompt_text, self.agent_loop)
+            result = await slash_registry.execute(
+                prompt_text,
+                self.agent_loop,
+                memory_manager=self.memory_manager,
+            )
             await self._conn.session_update(
                 session_id=self.id,
                 update=acp.schema.AgentMessageChunk(
@@ -451,7 +471,7 @@ class ACPSession:
                     kind="allow_always",
                 )
             )
-        else:
+        elif _tool_supports_blanket_allow(self.agent_loop, tool_name):
             options.append(
                 acp.schema.PermissionOption(
                     option_id=_OPTION_ALLOW_ALWAYS,

{iac_code-0.3.1 → iac_code-0.4.1}/src/iac_code/acp/slash_registry.py

@@ -1,7 +1,7 @@
 """ACP slash command registry.
 
 Manages commands supported over the ACP protocol.
-Only /compact, /clear, and /debug are allowed;
+Only /compact, /clear, /debug, /memory, and /rename are allowed;
 all other slash commands are rejected with a clear message.
 """
 
@@ -10,10 +10,12 @@ from __future__ import annotations
 import logging
 
 from iac_code.i18n import _
+from iac_code.services.session_metadata import normalize_session_name
+from iac_code.services.session_storage import SessionStorage
 
 logger = logging.getLogger(__name__)
 
-ACP_SUPPORTED_COMMANDS: frozenset[str] = frozenset({"compact", "clear", "debug"})
+ACP_SUPPORTED_COMMANDS: frozenset[str] = frozenset({"compact", "clear", "debug", "memory", "rename"})
 
 
 class ACPSlashRegistry:
@@ -51,6 +53,10 @@ class ACPSlashRegistry:
             return await self._handle_clear(agent_loop)
         if cmd_name == "debug":
             return self._handle_debug(args_str)
+        if cmd_name == "memory":
+            return self._handle_memory(args_str, context.get("memory_manager"))
+        if cmd_name == "rename":
+            return self._handle_rename(args_str, agent_loop)
 
         # Should not reach here
         return _("Command '/{cmd_name}' handler not implemented.").format(cmd_name=cmd_name)  # pragma: no cover
@@ -123,3 +129,36 @@ class ACPSlashRegistry:
             return _("Debug logging disabled.")
 
         return _("Usage: /debug [on|off]")
+
+    def _handle_memory(self, args: str, memory_manager) -> str:
+        """View and manage persistent memories."""
+        if memory_manager is None:
+            return _("Memory manager is unavailable.")
+
+        from iac_code.commands.memory import execute_memory_command
+
+        return execute_memory_command(memory_manager, args.split())
+
+    def _handle_rename(self, args: str, agent_loop) -> str:
+        """Rename the current ACP session non-interactively."""
+        parts = args.split()
+        if len(parts) != 1:
+            return _("Usage: /rename <name>")
+
+        cwd = getattr(agent_loop, "_cwd", None)
+        session_id = getattr(agent_loop, "_session_id", None)
+        git_branch = getattr(agent_loop, "_current_git_branch", None)
+        if not isinstance(cwd, str) or not isinstance(session_id, str):
+            return _("Rename is only available after a session is created.")
+        if not isinstance(git_branch, str):
+            git_branch = None
+
+        try:
+            name = normalize_session_name(parts[0])
+            result = SessionStorage().rename_session(cwd, session_id, name, git_branch=git_branch)
+        except ValueError as exc:
+            return str(exc)
+
+        if result == "unchanged":
+            return _("Session is already named {name}").format(name=name)
+        return _("Renamed session to {name}").format(name=name)

{iac_code-0.3.1 → iac_code-0.4.1}/src/iac_code/acp/tools.py

@@ -5,6 +5,7 @@ from contextlib import suppress
 
 import acp
 
+from iac_code.i18n import _
 from iac_code.tools.base import Tool, ToolContext, ToolResult
 
 TERMINAL_TIMEOUT = 300  # 5 minutes default timeout
@@ -32,9 +33,37 @@ class ACPTerminalBashTool(Tool):
     def timeout(self) -> float | None:
         return self._original.timeout
 
+    @property
+    def supports_blanket_allow(self) -> bool:
+        return self._original.supports_blanket_allow
+
+    def user_facing_name(self, input: dict | None = None) -> str:
+        return self._original.user_facing_name(input)
+
+    def get_activity_description(self, input: dict | None = None) -> str | None:
+        return self._original.get_activity_description(input)
+
+    def get_tool_use_summary(self, input: dict | None = None) -> str | None:
+        return self._original.get_tool_use_summary(input)
+
+    def render_tool_use_message(self, input: dict, *, verbose: bool = False) -> str | None:
+        return self._original.render_tool_use_message(input, verbose=verbose)
+
+    def render_tool_result_message(self, output: str, *, is_error: bool = False, verbose: bool = False) -> str | None:
+        return self._original.render_tool_result_message(output, is_error=is_error, verbose=verbose)
+
+    def render_tool_use_error_message(self, error: str) -> str | None:
+        return self._original.render_tool_use_error_message(error)
+
+    def streaming_preview_fields(self) -> list[str]:
+        return self._original.streaming_preview_fields()
+
     def is_read_only(self, input: dict | None = None) -> bool:
         return self._original.is_read_only(input)
 
+    def is_concurrency_safe(self, tool_input: dict) -> bool:
+        return self._original.is_concurrency_safe(tool_input)
+
     def is_destructive(self, input: dict | None = None) -> bool:
         return self._original.is_destructive(input)
 
@@ -44,7 +73,7 @@ class ACPTerminalBashTool(Tool):
     async def execute(self, *, tool_input: dict, context: ToolContext) -> ToolResult:
         command = tool_input.get("command")
         if not command:
-            return ToolResult.error("Bash command is required.")
+            return ToolResult.error(_("Bash command is required."))
 
         timeout = tool_input.get("timeout", TERMINAL_TIMEOUT)
         terminal_id: str | None = None
@@ -74,7 +103,7 @@ class ACPTerminalBashTool(Tool):
             except asyncio.TimeoutError:
                 with suppress(Exception):
                     await self._conn.kill_terminal(session_id=self._session_id, terminal_id=terminal_id)
-                return ToolResult.error(f"Command timed out after {timeout} seconds")
+                return ToolResult.error(_("Command timed out after {timeout} seconds").format(timeout=timeout))
 
             if output.exit_status:
                 exit_status = output.exit_status
@@ -84,9 +113,15 @@ class ACPTerminalBashTool(Tool):
             # at the session layer in a future phase.
 
             if exit_status.signal:
-                return ToolResult.error(f"Command terminated by signal: {exit_status.signal}\n{output.output}")
+                return ToolResult.error(
+                    _("Command terminated by signal: {signal}").format(signal=exit_status.signal) + "\n" + output.output
+                )
             if exit_status.exit_code not in (None, 0):
-                return ToolResult.error(f"Command failed with exit code {exit_status.exit_code}\n{output.output}")
+                return ToolResult.error(
+                    _("Command failed with exit code {exit_code}").format(exit_code=exit_status.exit_code)
+                    + "\n"
+                    + output.output
+                )
             return ToolResult.success(output.output)
         except asyncio.CancelledError:
             if terminal_id is not None: