iac-code 0.1.0__py3-none-any.whl

iac_code/skills/renderer.py

@@ -0,0 +1,157 @@
+"""Prompt rendering pipeline — argument substitution, variable replacement, shell execution."""
+
+from __future__ import annotations
+
+import asyncio
+import re
+import shlex
+
+from iac_code.skills.skill_definition import SkillContext, SkillDefinition
+
+# Shell command matching patterns
+BLOCK_PATTERN = re.compile(r"```!\s*\n?([\s\S]*?)\n?```")
+INLINE_PATTERN = re.compile(r"(?:^|\s)!`([^`]+)`")
+
+
+async def render_skill_prompt(
+    skill: SkillDefinition,
+    args: str,
+    context: SkillContext,
+) -> str:
+    """Complete rendering pipeline for a skill prompt."""
+    content = skill.content
+
+    # Step 1: Base directory prefix
+    if skill.skill_root:
+        content = f"Base directory for this skill: {skill.skill_root}\n\n{content}"
+
+    # Step 2: Argument substitution
+    content = substitute_arguments(
+        content, args, append_if_no_placeholder=True, argument_names=skill.frontmatter.arguments
+    )
+
+    # Step 3: Built-in variable substitution
+    content = content.replace("${SKILL_DIR}", context.skill_dir or "")
+    content = content.replace("${SESSION_ID}", context.session_id or "")
+
+    # Step 4: Shell command execution
+    content = await execute_shell_commands(content, cwd=context.cwd)
+
+    return content
+
+
+def substitute_arguments(
+    content: str,
+    args: str,
+    *,
+    append_if_no_placeholder: bool = True,
+    argument_names: list[str] | None = None,
+) -> str:
+    """Substitute argument placeholders in skill content.
+
+    Supports:
+    - Named arguments: $argName
+    - Indexed arguments: $ARGUMENTS[0], $ARGUMENTS[1]
+    - Short indexed: $0, $1
+    - Full arguments: $ARGUMENTS
+    """
+    if not args:
+        return content
+
+    original = content
+    parsed_args = _parse_arguments(args)
+    argument_names = argument_names or []
+
+    # 1. Named argument substitution: $foo, $bar
+    for i, name in enumerate(argument_names):
+        if i < len(parsed_args):
+            content = re.sub(
+                rf"\${re.escape(name)}(?![\[\w])",
+                parsed_args[i],
+                content,
+            )
+
+    # 2. Indexed argument substitution: $ARGUMENTS[0], $ARGUMENTS[1]
+    content = re.sub(
+        r"\$ARGUMENTS\[(\d+)\]",
+        lambda m: parsed_args[int(m.group(1))] if int(m.group(1)) < len(parsed_args) else "",
+        content,
+    )
+
+    # 3. Short indexed: $0, $1
+    content = re.sub(
+        r"\$(\d+)(?!\w)",
+        lambda m: parsed_args[int(m.group(1))] if int(m.group(1)) < len(parsed_args) else "",
+        content,
+    )
+
+    # 4. Full arguments substitution: $ARGUMENTS
+    content = content.replace("$ARGUMENTS", args)
+
+    # 5. Append if no placeholder was used
+    if content == original and append_if_no_placeholder and args:
+        content += f"\n\nARGUMENTS: {args}"
+
+    return content
+
+
+def _parse_arguments(args: str) -> list[str]:
+    """Parse space-separated arguments, respecting quotes."""
+    try:
+        return shlex.split(args)
+    except ValueError:
+        return args.split()
+
+
+async def execute_shell_commands(content: str, *, cwd: str = "") -> str:
+    """Execute inline shell commands in skill content and replace with output.
+
+    Two syntaxes:
+    - Inline: !`command`  -> replaced with stdout (trimmed)
+    - Block:  ```!\\ncommand\\n```  -> replaced with stdout
+    """
+
+    async def _replace_block(match: re.Match) -> str:
+        cmd = match.group(1).strip()
+        return await _run_shell(cmd, cwd=cwd)
+
+    async def _replace_inline(match: re.Match) -> str:
+        cmd = match.group(1).strip()
+        output = await _run_shell(cmd, cwd=cwd)
+        return output.strip()
+
+    # Replace block commands
+    content = await _replace_async(content, BLOCK_PATTERN, _replace_block)
+
+    # Replace inline commands
+    content = await _replace_async(content, INLINE_PATTERN, _replace_inline)
+
+    return content
+
+
+async def _run_shell(cmd: str, *, cwd: str = "", timeout: float = 30.0) -> str:
+    """Run a shell command and return its stdout."""
+    try:
+        proc = await asyncio.create_subprocess_shell(
+            cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            cwd=cwd or None,
+        )
+        stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=timeout)
+        return stdout.decode("utf-8", errors="replace")
+    except (asyncio.TimeoutError, OSError) as e:
+        return f"[shell error: {e}]"
+
+
+async def _replace_async(text: str, pattern: re.Pattern, replacer) -> str:
+    """Async version of re.sub — awaits the replacer coroutine for each match."""
+    result_parts: list[str] = []
+    last_end = 0
+    for match in pattern.finditer(text):
+        result_parts.append(text[last_end : match.start()])
+        replacement = await replacer(match)
+        result_parts.append(replacement)
+        last_end = match.end()
+    result_parts.append(text[last_end:])
+    return "".join(result_parts)

iac_code/skills/skill_definition.py

@@ -0,0 +1,82 @@
+"""Core skill definition types."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Protocol
+
+from iac_code.skills.frontmatter import SkillFrontmatter
+from iac_code.types.skill_source import SkillSource
+
+
+class SkillPromptProvider(Protocol):
+    """Protocol for skill prompt generation."""
+
+    async def get_prompt(self, args: str, context: SkillContext) -> str:
+        """Generate the final prompt content for this skill."""
+        ...
+
+
+@dataclass
+class SkillContext:
+    """Context available during skill prompt generation."""
+
+    cwd: str
+    session_id: str = ""
+    skill_dir: str = ""
+    skill_root: str = ""
+
+
+@dataclass
+class SkillDefinition:
+    """Complete definition of a skill."""
+
+    name: str
+    description: str
+    frontmatter: SkillFrontmatter
+    content: str
+    source: SkillSource = SkillSource.PROJECT
+    file_path: str = ""
+    skill_root: str = ""
+    content_length: int = 0
+
+    # Bundled skills can provide a custom prompt generator
+    _prompt_provider: SkillPromptProvider | None = field(default=None, repr=False)
+
+    @property
+    def is_user_invocable(self) -> bool:
+        return self.frontmatter.user_invocable
+
+    @property
+    def allowed_tools(self) -> list[str]:
+        return self.frontmatter.allowed_tools
+
+    @property
+    def model_override(self) -> str:
+        return self.frontmatter.model
+
+    @property
+    def effort_override(self) -> str:
+        return self.frontmatter.effort
+
+    @property
+    def context_mode(self) -> str:
+        """'inline' or 'fork'"""
+        return self.frontmatter.context
+
+    @property
+    def agent_type(self) -> str:
+        return self.frontmatter.agent
+
+    @property
+    def when_to_use(self) -> str:
+        return self.frontmatter.when_to_use
+
+    async def get_prompt(self, args: str, context: SkillContext) -> str:
+        """Generate the final prompt content."""
+        if self._prompt_provider is not None:
+            return await self._prompt_provider.get_prompt(args, context)
+
+        from iac_code.skills.renderer import render_skill_prompt
+
+        return await render_skill_prompt(self, args, context)

iac_code/skills/skill_tool.py

@@ -0,0 +1,261 @@
+"""SkillTool — registered in ToolRegistry, allows the model to invoke skills."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from loguru import logger
+
+from iac_code.i18n import _
+from iac_code.tools.base import Tool, ToolContext, ToolResult
+from iac_code.types.skill_source import SkillSource
+
+if TYPE_CHECKING:
+    from iac_code.commands.registry import CommandRegistry
+
+
+class SkillTool(Tool):
+    """Tool that allows the model to invoke skills during conversation.
+
+    Looks up skills from the unified CommandRegistry (PromptCommand instances).
+    Supports two execution modes:
+    - inline: Expands skill content into the current conversation context.
+    - fork: Runs skill in an isolated sub-agent.
+    """
+
+    def __init__(
+        self,
+        command_registry: CommandRegistry,
+        *,
+        session_id: str = "",
+        cwd: str = "",
+        provider_manager: Any = None,
+        tool_registry: Any = None,
+        system_prompt: str = "",
+    ) -> None:
+        self._command_registry = command_registry
+        self._session_id = session_id
+        self._cwd = cwd
+        self._provider_manager = provider_manager
+        self._tool_registry = tool_registry
+        self._system_prompt = system_prompt
+
+    @property
+    def name(self) -> str:
+        return "skill"
+
+    @property
+    def description(self) -> str:
+        return "Execute a skill within the current conversation."
+
+    @property
+    def input_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "properties": {
+                "skill": {
+                    "type": "string",
+                    "description": "The skill name to execute.",
+                },
+                "args": {
+                    "type": "string",
+                    "description": "Optional arguments for the skill.",
+                },
+            },
+            "required": ["skill"],
+        }
+
+    async def execute(self, *, tool_input: dict[str, Any], context: ToolContext) -> ToolResult:
+        import time
+
+        from iac_code.services.telemetry import log_event
+        from iac_code.services.telemetry.names import Events
+        from iac_code.services.telemetry.sanitize import sanitize_skill_name
+
+        skill_name = self._normalize_name(tool_input["skill"])
+        args = tool_input.get("args", "")
+
+        from iac_code.commands.registry import PromptCommand
+
+        command = self._command_registry.get(skill_name)
+        if not isinstance(command, PromptCommand):
+            return ToolResult.error(f"Skill not found: '{skill_name}'")
+
+        # Record usage
+        self._command_registry.record_skill_usage(skill_name)
+
+        skill = command.skill
+        if skill is None:
+            return ToolResult.error(f"Skill definition missing for: '{skill_name}'")
+
+        # Emit skill invoked event
+        safe_name = sanitize_skill_name(skill_name)
+        log_event(
+            Events.SKILL_INVOKED,
+            {
+                "skill_name": safe_name,
+                "invocation_source": "explicit",
+            },
+        )
+        started = time.monotonic()
+
+        # Execute based on context mode
+        if skill.context_mode == "fork":
+            return await self._execute_forked(command, args, context, safe_name, started)
+        else:
+            return await self._execute_inline(command, args, safe_name, started)
+
+    async def _execute_inline(
+        self, command: Any, args: str, safe_name: str | None = None, started: float | None = None
+    ) -> ToolResult:
+        """Inline mode: expand skill content into current conversation context."""
+        import time
+
+        from iac_code.services.telemetry import log_event
+        from iac_code.services.telemetry.names import Events
+        from iac_code.skills.processor import process_prompt_command
+
+        try:
+            result = await process_prompt_command(command, args, session_id=self._session_id)
+            if safe_name is not None and started is not None:
+                log_event(
+                    Events.SKILL_COMPLETED,
+                    {
+                        "skill_name": safe_name,
+                        "duration_ms": int((time.monotonic() - started) * 1000),
+                        "outcome": "success",
+                    },
+                )
+            return ToolResult(
+                content=_("Skill '{name}' loaded (inline).").format(name=result.skill_name),
+                is_error=False,
+                new_messages=result.new_messages,
+                context_modifier=result.context_modifier,
+            )
+        except Exception as e:
+            if safe_name is not None and started is not None:
+                log_event(
+                    Events.SKILL_COMPLETED,
+                    {
+                        "skill_name": safe_name,
+                        "duration_ms": int((time.monotonic() - started) * 1000),
+                        "outcome": "error",
+                    },
+                )
+            logger.exception("Skill inline execution failed: %s", command.name)
+            return ToolResult.error(f"Skill execution failed: {e}")
+
+    async def _execute_forked(
+        self,
+        command: Any,
+        args: str,
+        tool_context: ToolContext,
+        safe_name: str | None = None,
+        started: float | None = None,
+    ) -> ToolResult:
+        """Fork mode: run skill in an isolated sub-agent."""
+        import time
+
+        from iac_code.agent.agent_tool import run_sub_agent
+        from iac_code.services.telemetry import log_event
+        from iac_code.services.telemetry.names import Events
+        from iac_code.skills.processor import process_prompt_command
+
+        try:
+            result = await process_prompt_command(command, args, session_id=self._session_id)
+            skill = command.skill
+            result_text, progress = await run_sub_agent(
+                prompt=result.prompt_content,
+                agent_type=skill.agent_type,
+                cwd=tool_context.cwd,
+                parent_provider_manager=self._provider_manager,
+                parent_tool_registry=self._tool_registry,
+                parent_system_prompt=self._system_prompt,
+            )
+            if safe_name is not None and started is not None:
+                log_event(
+                    Events.SKILL_COMPLETED,
+                    {
+                        "skill_name": safe_name,
+                        "duration_ms": int((time.monotonic() - started) * 1000),
+                        "outcome": "success",
+                    },
+                )
+            return ToolResult.success(
+                f"{result_text}\n\n"
+                f"[Skill '{skill.name}' completed: "
+                f"{progress.tool_use_count} tool calls, "
+                f"{progress.token_count} tokens]"
+            )
+        except Exception as e:
+            if safe_name is not None and started is not None:
+                log_event(
+                    Events.SKILL_COMPLETED,
+                    {
+                        "skill_name": safe_name,
+                        "duration_ms": int((time.monotonic() - started) * 1000),
+                        "outcome": "error",
+                    },
+                )
+            logger.exception("Skill forked execution failed: %s", command.name)
+            return ToolResult.error(f"Skill forked execution failed: {e}")
+
+    @staticmethod
+    def _normalize_name(name: str) -> str:
+        """Normalize skill name: strip leading /, lowercase."""
+        return name.lstrip("/").strip().lower()
+
+    # --- UI rendering ---
+
+    def render_tool_use_message(self, input: dict, *, verbose: bool = False) -> str | None:
+        return input.get("skill", "") or None
+
+    def user_facing_name(self, input: dict | None = None) -> str:
+        return _("Skill")
+
+    def is_read_only(self, input: dict | None = None) -> bool:
+        return True  # Skill itself is just prompt injection
+
+    def is_concurrency_safe(self, tool_input: dict[str, Any]) -> bool:
+        return True
+
+    # --- Permission check ---
+
+    async def check_permissions(self, input: dict, context: dict | None = None) -> Any:
+        """Skill permission check:
+
+        1. Bundled skill -> auto-allow
+        2. Skill with only safe properties -> auto-allow
+        3. Others -> ask user
+        """
+        from iac_code.commands.registry import PromptCommand
+        from iac_code.types.permissions import PermissionResult
+
+        skill_name = self._normalize_name(input.get("skill", ""))
+        command = self._command_registry.get(skill_name)
+        if not isinstance(command, PromptCommand):
+            return PermissionResult(behavior="deny", message=f"Skill not found: {skill_name}")
+        skill = command.skill
+
+        # Bundled skills are fully trusted
+        if command.source == SkillSource.BUNDLED:
+            return PermissionResult(behavior="allow")
+
+        # Safe-only skills auto-allow
+        if self._has_only_safe_properties(skill):
+            return PermissionResult(behavior="allow")
+
+        # Others ask user
+        return PermissionResult(
+            behavior="ask",
+            message=f"Allow skill '{skill_name}' (source: {skill.source if skill else 'unknown'})?",
+        )
+
+    @staticmethod
+    def _has_only_safe_properties(skill: Any) -> bool:
+        """Check if a skill only has safe properties (no tools, no shell commands)."""
+        if skill.frontmatter.allowed_tools:
+            return False
+        if "!`" in skill.content or "```!" in skill.content:
+            return False
+        return True

iac_code/state/__init__.py

@@ -0,0 +1,5 @@
+"""State management module"""
+
+from iac_code.state.app_state import AppState, AppStateStore
+
+__all__ = ["AppState", "AppStateStore"]

iac_code/state/app_state.py

@@ -0,0 +1,122 @@
+"""Application state management."""
+
+from __future__ import annotations
+
+import os
+from collections import OrderedDict
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+from iac_code.types.permissions import PermissionDecision, PermissionMode
+
+_PERMISSION_CACHE_MAX_SIZE = 128
+
+
+def lookup_permission(
+    cache: OrderedDict[str, PermissionDecision] | None,
+    tool_name: str,
+) -> PermissionDecision | None:
+    """Look up a sticky permission decision and mark it as most-recent.
+
+    Returns None when the cache is missing or the tool has no recorded
+    decision. When found, the entry is moved to the end so LRU eviction
+    preserves recency-of-use.
+    """
+    if cache is None:
+        return None
+    decision = cache.get(tool_name)
+    if decision is None:
+        return None
+    cache.move_to_end(tool_name)
+    return decision
+
+
+def record_permission(
+    cache: OrderedDict[str, PermissionDecision] | None,
+    tool_name: str,
+    decision: PermissionDecision,
+) -> None:
+    """Record a sticky permission decision, enforcing the LRU size cap."""
+    if cache is None:
+        return
+    cache[tool_name] = decision
+    cache.move_to_end(tool_name)
+    _evict_lru(cache, _PERMISSION_CACHE_MAX_SIZE)
+
+
+def _evict_lru(
+    cache: OrderedDict[str, PermissionDecision],
+    max_size: int,
+) -> None:
+    """Drop oldest entries until ``cache`` fits within ``max_size``."""
+    while len(cache) > max_size:
+        cache.popitem(last=False)
+
+
+@dataclass
+class AppState:
+    """Global application state."""
+
+    model: str = ""
+    cwd: str = field(default_factory=os.getcwd)
+    permission_mode: PermissionMode = PermissionMode.DEFAULT
+    messages: list = field(default_factory=list)  # list[Message]
+    is_busy: bool = False
+    always_allow_rules: OrderedDict[str, PermissionDecision] = field(default_factory=OrderedDict)
+    spinner_text: str = ""
+    context_usage_percent: float = 0.0
+    effort_level: Any | None = None  # EffortLevel enum or None (avoid circular import)
+
+
+class AppStateStore:
+    """State store.
+
+    Provides get/set/subscribe interfaces, UI components listen to state changes via subscribe.
+    """
+
+    def __init__(self, initial_state: AppState | None = None) -> None:
+        self._state = initial_state or AppState()
+        self._listeners: list[Callable[[AppState], None]] = []
+
+    def get_state(self) -> AppState:
+        """Get current state"""
+        return self._state
+
+    def set_state(self, updater: Callable[[AppState], AppState] | None = None, **kwargs) -> None:
+        """Update state
+
+        Two usage patterns:
+        1. store.set_state(lambda s: dataclasses.replace(s, is_busy=True))
+        2. store.set_state(is_busy=True)  # Shortcut
+        """
+        import dataclasses
+
+        if updater is not None:
+            self._state = updater(self._state)
+        elif kwargs:
+            self._state = dataclasses.replace(self._state, **kwargs)
+        self._notify()
+
+    def subscribe(self, listener: Callable[[AppState], None]) -> Callable[[], None]:
+        """Subscribe to state changes, return unsubscribe function"""
+        self._listeners.append(listener)
+
+        def unsubscribe():
+            if listener in self._listeners:
+                self._listeners.remove(listener)
+
+        return unsubscribe
+
+    def _notify(self) -> None:
+        """Notify all listeners"""
+        for listener in self._listeners:
+            listener(self._state)
+
+
+__all__ = [
+    "AppState",
+    "AppStateStore",
+    "_PERMISSION_CACHE_MAX_SIZE",
+    "lookup_permission",
+    "record_permission",
+]

iac_code/tasks/__init__.py

@@ -0,0 +1 @@
+# Task management package.

iac_code/tasks/notification_queue.py

@@ -0,0 +1,28 @@
+"""Notification queue for background agent completion events."""
+
+from __future__ import annotations
+
+from collections import deque
+from dataclasses import dataclass
+
+
+@dataclass
+class TaskNotification:
+    task_id: str
+    message: str
+
+
+class NotificationQueue:
+    def __init__(self, max_pending: int = 100):
+        self._queue: deque[TaskNotification] = deque(maxlen=max_pending)
+
+    def enqueue(self, task_id: str, message: str) -> None:
+        self._queue.append(TaskNotification(task_id=task_id, message=message))
+
+    def dequeue(self) -> TaskNotification | None:
+        if self._queue:
+            return self._queue.popleft()
+        return None
+
+    def has_pending(self) -> bool:
+        return len(self._queue) > 0