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

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

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

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.1 → 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.1 → 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.1 → 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
@@ -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.0}/src/iac_code/agent/agent_loop.py

@@ -15,6 +15,7 @@ from loguru import logger
 from iac_code.agent.message import ContentBlock, TextBlock, ThinkingBlock, ToolResultBlock, ToolUseBlock
 from iac_code.i18n import _
 from iac_code.services.context_manager import ContextManager
+from iac_code.services.session_usage import SessionUsageStore, SessionUsageTotals
 from iac_code.tools.base import ToolContext, ToolRegistry, ToolResult
 from iac_code.tools.result_storage import ResultStorage
 from iac_code.tools.tool_executor import ToolCallRequest, ToolExecutor
@@ -65,6 +66,7 @@ class AgentLoop:
         tool_registry: ToolRegistry,
         max_turns: int = 100,
         session_storage: Any = None,  # SessionStorage
+        session_usage_store: SessionUsageStore | None = None,
         session_id: str | None = None,
         resume_messages: list | None = None,
         cwd: str | None = None,
@@ -79,6 +81,8 @@ class AgentLoop:
         self._session_storage = session_storage
         self._session_id = session_id or str(uuid.uuid4())[:8]
         self._cwd = cwd or os.getcwd()
+        self._session_usage_store = session_usage_store or SessionUsageStore()
+        self._session_usage_totals = self._session_usage_store.load(self._cwd, self._session_id)
         self._permission_context = permission_context
         self._permission_context_getter = permission_context_getter
         self._auto_trigger_skills = auto_trigger_skills or []
@@ -113,6 +117,10 @@ class AgentLoop:
             self.system_prompt = system_prompt
             self.context_manager.set_system_prompt(system_prompt)
 
+    def set_auto_trigger_skills(self, skill_commands: list[Any] | None) -> None:
+        """Refresh skills considered for automatic trigger injection."""
+        self._auto_trigger_skills = list(skill_commands or [])
+
     def _get_tool_definitions(self):
         """Convert tool registry to provider ToolDefinition format."""
         from iac_code.providers.base import ToolDefinition
@@ -250,6 +258,7 @@ class AgentLoop:
                             final_text_chunks.append(event.text)
                         if isinstance(event, MessageEndEvent):
                             final_stop_reason = event.stop_reason
+                            self._record_session_usage(event.usage)
                         yield event
                 except asyncio.CancelledError:
                     log_event(Events.SESSION_CANCELLED, {"stage": "in_query"})
@@ -609,6 +618,7 @@ class AgentLoop:
                 messages=[ProviderMessage.user(compaction_prompt)],
                 system="You are a helpful assistant that summarizes conversations concisely.",
             )
+            self._record_response_usage(response)
             if response.text:
                 original, new = self.context_manager.apply_compaction(response.text)
                 duration_ms = int((time.monotonic() - started) * 1000)
@@ -650,6 +660,7 @@ class AgentLoop:
                 messages=[ProviderMessage.user(compaction_prompt)],
                 system="You are a helpful assistant that summarizes conversations concisely.",
             )
+            self._record_response_usage(response)
             if response.text:
                 original, compacted = self.context_manager.apply_compaction(response.text)
                 return CompactResult(
@@ -691,6 +702,7 @@ class AgentLoop:
         self.context_manager.reset()
         if resume_messages:
             self.context_manager.load_messages(resume_messages)
+        self._session_usage_totals = self._session_usage_store.load(self._cwd, self._session_id)
         self._result_storage = ResultStorage(
             storage_dir=os.path.join(str(get_config_dir()), "tool-results", session_id),
         )
@@ -712,5 +724,54 @@ class AgentLoop:
         self._auto_loaded_skills.clear()
         self.context_manager.reset()
 
+    @property
+    def session_id(self) -> str:
+        return self._session_id
+
+    @property
+    def max_turns(self) -> int:
+        return self._max_turns
+
     def get_context_usage(self) -> dict:
         return self.context_manager.get_usage()
+
+    def get_session_usage(self) -> SessionUsageTotals:
+        return self._session_usage_totals.copy()
+
+    def _record_session_usage(self, usage: Usage) -> None:
+        if not self._session_usage_totals.add(usage):
+            return
+
+        provider = self._get_runtime_provider_key()
+        model = self._provider_manager.get_model_name() if hasattr(self._provider_manager, "get_model_name") else ""
+        try:
+            self._session_usage_store.append(
+                self._cwd,
+                self._session_id,
+                usage,
+                provider=provider,
+                model=model,
+            )
+        except Exception as exc:
+            logger.debug("Failed to persist session usage for {}: {}", self._session_id, exc)
+
+    def _record_response_usage(self, response: Any) -> None:
+        usage = getattr(response, "usage", None)
+        if isinstance(usage, Usage):
+            self._record_session_usage(usage)
+
+    def _get_runtime_provider_key(self) -> str:
+        if hasattr(self._provider_manager, "get_provider_key"):
+            try:
+                provider_key = self._provider_manager.get_provider_key()
+            except Exception:
+                pass
+            else:
+                if isinstance(provider_key, str):
+                    return provider_key
+        try:
+            from iac_code.config import get_active_provider_key
+
+            return get_active_provider_key() or ""
+        except Exception:
+            return ""

{iac_code-0.3.1 → iac_code-0.4.0}/src/iac_code/cli/main.py

@@ -86,7 +86,7 @@ def main(
     debug: bool = typer.Option(False, "--debug", "-d", help=_("Enable debug logging")),
     verbose: bool = typer.Option(False, "--verbose", help=_("Show headless progress on stderr")),
     version: bool = typer.Option(False, "--version", "-v", "-V", is_eager=True, help=_("Show version and exit")),
-    resume: str = typer.Option("", "--resume", "-r", help=_("Resume a session by ID")),
+    resume: str = typer.Option("", "--resume", "-r", help=_("Resume a session by ID or name")),
     continue_session: bool = typer.Option(False, "--continue", "-c", help=_("Resume the most recent session")),
     install_completion: bool = typer.Option(
         None,

{iac_code-0.3.1 → iac_code-0.4.0}/src/iac_code/commands/__init__.py

@@ -7,9 +7,13 @@ from iac_code.commands.debug import debug_command
 from iac_code.commands.effort import effort_command
 from iac_code.commands.exit import exit_command
 from iac_code.commands.help import help_command
+from iac_code.commands.memory import memory_command
 from iac_code.commands.model import model_command
-from iac_code.commands.registry import Command, CommandRegistry, LocalCommand, PromptCommand
+from iac_code.commands.registry import Command, CommandRegistry, CommandResult, LocalCommand, PromptCommand
+from iac_code.commands.rename import rename_command
 from iac_code.commands.resume import resume_command
+from iac_code.commands.skills import skills_command
+from iac_code.commands.status import status_command
 from iac_code.i18n import _
 
 
@@ -87,6 +91,15 @@ def create_default_registry() -> CommandRegistry:
             history_mode="session",
         )
     )
+    registry.register(
+        LocalCommand(
+            name="memory",
+            description=_("View and manage persistent memories"),
+            handler=memory_command,
+            arg_hint=_("[<name>|search <query>|delete <name>|help]"),
+            history_mode="session",
+        )
+    )
     registry.register(
         LocalCommand(
             name="resume",
@@ -96,7 +109,32 @@ def create_default_registry() -> CommandRegistry:
             history_mode="session",
         )
     )
+    registry.register(
+        LocalCommand(
+            name="rename",
+            description=_("Rename the current session"),
+            handler=rename_command,
+            arg_hint="<name>",
+            history_mode="session",
+        )
+    )
+    registry.register(
+        LocalCommand(
+            name="skills",
+            description=_("Manage skills"),
+            handler=skills_command,
+            history_mode="session",
+        )
+    )
+    registry.register(
+        LocalCommand(
+            name="status",
+            description=_("Show current session status"),
+            handler=status_command,
+            history_mode="session",
+        )
+    )
     return registry
 
 
-__all__ = ["Command", "CommandRegistry", "LocalCommand", "PromptCommand", "create_default_registry"]
+__all__ = ["Command", "CommandRegistry", "CommandResult", "LocalCommand", "PromptCommand", "create_default_registry"]