iac-code 0.3.0__tar.gz → 0.4.0__tar.gz

{iac_code-0.3.0 → iac_code-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iac_code
-Version: 0.3.0
+Version: 0.4.0
 Summary: Your AI-powered Infrastructure as Code assistant
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
@@ -74,6 +74,20 @@ Reading from stdin is also supported:
 echo "Create an OSS Bucket" | iac-code --prompt -
 ```
 
+## Contributing
+
+Install [uv](https://docs.astral.sh/uv/getting-started/installation/), then:
+
+```bash
+make install   # install dependencies and pre-commit hooks
+make dev       # run in debug mode
+make test      # run tests
+make lint      # run linters
+make format    # format code
+```
+
+See the [Contributing Guide](https://aliyun.github.io/iac-code/getting-started/contributing) for details.
+
 ## Contact Us
 
 | [DingTalk](https://qr.dingtalk.com/action/joingroup?code=v1,k1,ubm/77U7qRh/STFZUNBP26X4PNg2z6+uhiPcLGtDNfU=&_dt_no_comment=1&origin=11) | [Discord](https://discord.gg/qECFuFBwF) |

{iac_code-0.3.0 → iac_code-0.4.0}/README.md

@@ -55,6 +55,20 @@ Reading from stdin is also supported:
 echo "Create an OSS Bucket" | iac-code --prompt -
 ```
 
+## Contributing
+
+Install [uv](https://docs.astral.sh/uv/getting-started/installation/), then:
+
+```bash
+make install   # install dependencies and pre-commit hooks
+make dev       # run in debug mode
+make test      # run tests
+make lint      # run linters
+make format    # format code
+```
+
+See the [Contributing Guide](https://aliyun.github.io/iac-code/getting-started/contributing) for details.
+
 ## Contact Us
 
 | [DingTalk](https://qr.dingtalk.com/action/joingroup?code=v1,k1,ubm/77U7qRh/STFZUNBP26X4PNg2z6+uhiPcLGtDNfU=&_dt_no_comment=1&origin=11) | [Discord](https://discord.gg/qECFuFBwF) |

{iac_code-0.3.0 → iac_code-0.4.0}/pyproject.toml

@@ -21,6 +21,7 @@ dependencies = [
     "pyperclip>=1.8.0",
     "openai>=1.50",
     "httpx>=0.27.0",
+    "packaging>=24.0",
     "tiktoken>=0.7.0",
     "jsonschema>=4.20",
     "alibabacloud-ros20190910>=3.0.0",
@@ -32,8 +33,8 @@ dependencies = [
     "pillow==12.2.0",
     "cryptography>=42.0",
     "keyring>=25.0",
-    "tree-sitter>=0.23",
-    "tree-sitter-bash>=0.23",
+    "tree-sitter>=0.25,<0.26",
+    "tree-sitter-bash>=0.25,<0.26",
 ]
 
 [project.optional-dependencies]

iac_code-0.4.0/src/iac_code/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.4.0"
+__release_date__ = "2026-06-03"

{iac_code-0.3.0 → iac_code-0.4.0}/src/iac_code/a2a/client.py

@@ -7,6 +7,7 @@ from time import monotonic
 from typing import Any, AsyncIterator
 
 import httpx
+from a2a.types import Role
 
 from iac_code.a2a.signing import AgentCardSignature, agent_card_signature_jwks_url, verify_agent_card_dict
 from iac_code.a2a.transport import A2AAuthConfig, A2ATransportBinding, UnsupportedA2ATransportError, headers_for_auth
@@ -31,19 +32,52 @@ class A2AClientResponse:
         if not isinstance(result, dict):
             return ""
         text = result.get("text")
-        if isinstance(text, str):
+        if isinstance(text, str) and text:
             return text
         status = result.get("status")
-        if not isinstance(status, dict):
-            return ""
-        message = status.get("message")
-        if not isinstance(message, dict):
-            return ""
-        parts = message.get("parts")
-        if not isinstance(parts, list) or not parts or not isinstance(parts[0], dict):
-            return ""
-        value = parts[0].get("text")
-        return value if isinstance(value, str) else ""
+        if isinstance(status, dict):
+            extracted = _extract_parts_text(status.get("message"))
+            if extracted:
+                return extracted
+        task = result.get("task")
+        if isinstance(task, dict):
+            task_status = task.get("status")
+            if isinstance(task_status, dict):
+                extracted = _extract_parts_text(task_status.get("message"))
+                if extracted:
+                    return extracted
+            history = task.get("history")
+            if isinstance(history, list):
+                for entry in reversed(history):
+                    extracted = _extract_agent_entry_text(entry)
+                    if extracted:
+                        return extracted
+        return ""
+
+
+_AGENT_ROLE_NAME = Role.Name(Role.ROLE_AGENT)
+
+
+def _extract_agent_entry_text(entry: Any) -> str:
+    if not isinstance(entry, dict) or entry.get("role") != _AGENT_ROLE_NAME:
+        return ""
+    return _extract_parts_text(entry)
+
+
+def _extract_parts_text(message: Any) -> str:
+    if not isinstance(message, dict):
+        return ""
+    parts = message.get("parts")
+    if not isinstance(parts, list):
+        return ""
+    pieces: list[str] = []
+    for part in parts:
+        if not isinstance(part, dict):
+            continue
+        value = part.get("text")
+        if isinstance(value, str):
+            pieces.append(value)
+    return "".join(pieces)
 
 
 class A2AClient:

{iac_code-0.3.0 → iac_code-0.4.0}/src/iac_code/a2a/transports/base.py

@@ -9,7 +9,7 @@ from urllib.parse import urlparse
 from iac_code.a2a.transport import A2ATransportBinding, UnsupportedA2ATransportError
 from iac_code.i18n import _
 
-RUNNABLE_TRANSPORTS = frozenset({"http", "stdio", "unix", "websocket", "grpc", "grpc-jsonrpc", "redis-streams"})
+SUPPORTED_TRANSPORTS = frozenset({"http", "stdio", "unix", "websocket", "grpc", "grpc-jsonrpc", "redis-streams"})
 
 
 class A2ATransportConfigError(ValueError):
@@ -159,8 +159,16 @@ def select_binding(bindings: Sequence[A2ATransportBinding]) -> A2ATransportBindi
     raise UnsupportedA2ATransportError(f"No runnable A2A transport found. Candidate bindings: {names}")
 
 
+def validate_transport_supported(transport: str) -> None:
+    """Raise ValueError if the transport name is not recognised."""
+    if transport not in SUPPORTED_TRANSPORTS:
+        supported = ", ".join(sorted(SUPPORTED_TRANSPORTS))
+        raise ValueError(f"Unsupported transport '{transport}'. Supported values: {supported}")
+
+
 def validate_transport_for_platform(transport: str) -> None:
-    """Raise RuntimeError if the transport is unavailable on the current platform."""
+    """Raise an error if the transport is unsupported or unavailable on the current platform."""
+    validate_transport_supported(transport)
     if transport == "unix" and sys.platform == "win32":
         raise RuntimeError(
             _(

{iac_code-0.3.0 → iac_code-0.4.0}/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.0 → iac_code-0.4.0}/src/iac_code/acp/session.py

@@ -165,9 +165,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 +294,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(

{iac_code-0.3.0 → iac_code-0.4.0}/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
@@ -91,7 +97,7 @@ class ACPSlashRegistry:
     async def _handle_clear(self, agent_loop) -> str:
         """Clear the agent_loop conversation history."""
         try:
-            agent_loop.context_manager.reset()
+            agent_loop.reset()
         except Exception as exc:
             logger.warning("ACP /clear failed: %s", exc)
             return _("Clear failed: {error}").format(error=exc)
@@ -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)