iac-code 0.1.0__py3-none-any.whl

iac_code/commands/clear.py

@@ -0,0 +1,34 @@
+"""Clear command — clears conversation history and screen."""
+
+from __future__ import annotations
+
+
+async def clear_command(context=None, **kwargs) -> str:
+    """Clear conversation history and the terminal screen."""
+    store = context.store if context else kwargs.get("store")
+    if store:
+        store.set_state(messages=[])
+
+    if context and hasattr(context, "repl"):
+        agent_loop = getattr(context.repl, "_agent_loop", None)
+        if agent_loop:
+            agent_loop.context_manager.reset()
+
+    if context and hasattr(context, "console"):
+        console = context.console
+        if console is None:
+            return ""
+        # ESC[H  — cursor home
+        # ESC[2J — erase visible screen
+        # ESC[3J — erase scrollback buffer
+        console.file.write("\033[H\033[2J\033[3J")
+        console.file.flush()
+
+        # Re-render the welcome banner
+        from iac_code.ui.banner import render_welcome_banner
+
+        state = store.get_state() if store else None
+        if state:
+            console.print(render_welcome_banner(state.model, state.cwd))
+
+    return ""

iac_code/commands/compact.py

@@ -0,0 +1,43 @@
+"""Compact command - compresses conversation context."""
+
+from __future__ import annotations
+
+from iac_code.i18n import _
+
+
+async def compact_command(**kwargs) -> str:
+    """Compact conversation context by summarizing history."""
+    context = kwargs.get("context")
+    if context is None:
+        return _("Compact command requires a context.")
+
+    repl = getattr(context, "repl", None)
+    if repl is None:
+        return _("No active REPL.")
+
+    agent_loop = getattr(repl, "_agent_loop", None)
+    if agent_loop is None:
+        return _("No active agent loop.")
+
+    result = await agent_loop.compact()
+    if result.status == "empty":
+        return _("Nothing to compact: conversation is empty.")
+    if result.status == "too_short":
+        return _(
+            "Conversation too short to compact: all messages are within the recent {turns}-turn preservation window."
+        ).format(turns=result.preserve_recent_turns)
+    if result.status == "failed":
+        return _("Compaction failed. See logs for details.")
+
+    usage_after = agent_loop.get_context_usage()
+    percent = (1 - result.compacted_tokens / result.original_tokens) * 100 if result.original_tokens > 0 else 0
+    return _(
+        "Context compacted: {original} → {compacted} tokens "
+        "({percent_display} reduction). "
+        "Context usage: {usage_display}"
+    ).format(
+        original=result.original_tokens,
+        compacted=result.compacted_tokens,
+        percent_display=f"{percent:.0f}%",
+        usage_display=f"{usage_after['usage_percent']:.0f}%",
+    )

iac_code/commands/debug.py

@@ -0,0 +1,45 @@
+"""Debug command — toggle debug logging at runtime."""
+
+from __future__ import annotations
+
+from iac_code.i18n import _
+from iac_code.utils.log import (
+    current_log_file,
+    disable_debug_at_runtime,
+    enable_debug_at_runtime,
+    is_debug_enabled,
+)
+
+
+async def debug_command(**kwargs) -> str:
+    """Show or toggle debug logging.
+
+    Usage: /debug [on|off]
+    """
+    context = kwargs.get("context")
+    if context is None:
+        return _("Debug command requires a context.")
+
+    repl = getattr(context, "repl", None)
+    session_id = getattr(repl, "_session_id", None) if repl else None
+    if not session_id:
+        return _("No active session.")
+
+    args = kwargs.get("args") or []
+    action = args[0].lower() if args else ""
+
+    if action == "" or action == "status":
+        if is_debug_enabled():
+            log_path = current_log_file()
+            return _("Debug logging is on. Log file: {path}").format(path=log_path)
+        return _("Debug logging is off.")
+
+    if action == "on":
+        log_path = enable_debug_at_runtime(session_id)
+        return _("Debug logging enabled. Log file: {path}").format(path=log_path)
+
+    if action == "off":
+        disable_debug_at_runtime()
+        return _("Debug logging disabled.")
+
+    return _("Usage: /debug [on|off]")

iac_code/commands/effort.py

@@ -0,0 +1,116 @@
+"""Effort command — show or change the thinking/reasoning effort level."""
+
+from __future__ import annotations
+
+import sys
+from typing import TYPE_CHECKING
+
+from iac_code.commands.auth import _BACK, PROVIDERS, LLMProvider, _select, save_active_provider_config
+from iac_code.config import get_active_provider_key, get_provider_config
+from iac_code.i18n import _
+
+if TYPE_CHECKING:
+    from iac_code.ui.dialogs.model_picker import EffortLevel
+    from iac_code.ui.repl import CommandContext
+
+
+def _load_picker_module():
+    """Lazy import to avoid a circular import through iac_code.ui.__init__."""
+    import importlib
+
+    return importlib.import_module("iac_code.ui.dialogs.model_picker")
+
+
+def _active_provider() -> LLMProvider | None:
+    key = get_active_provider_key()
+    if not key:
+        return None
+    for p in PROVIDERS:
+        if str(p["key_name"]) == key:
+            return p
+    return None
+
+
+def _load_current_effort(key_name: str, fallback: "EffortLevel") -> "EffortLevel":
+    picker = _load_picker_module()
+    level_by_value = {lvl.value: lvl for lvl in picker.EffortLevel}
+    saved = get_provider_config(key_name).get("effort")
+    if isinstance(saved, str) and saved in level_by_value:
+        return level_by_value[saved]
+    return fallback
+
+
+async def effort_command(
+    context: "CommandContext | None" = None,
+    args: list[str] | None = None,
+    **kwargs,
+) -> str | None:
+    """Show or change the thinking effort level for the active model."""
+    store = context.store if context else kwargs.get("store")
+    args = args or []
+
+    provider = _active_provider()
+    if not provider:
+        return _("No configured providers. Run /auth first.")
+
+    current_model = store.get_state().model if store else ""
+    if not current_model:
+        return _("No model selected. Run /model first.")
+
+    from iac_code.providers.thinking import get_thinking_spec
+
+    picker = _load_picker_module()
+    provider_key = str(provider["key_name"])
+    spec = get_thinking_spec(provider_key, current_model)
+    if not spec.supports_effort:
+        return _("Model {model} does not support effort.").format(model=current_model)
+
+    allowed = list(spec.allowed_efforts)
+    level_by_value = {lvl.value: lvl for lvl in picker.EffortLevel}
+
+    assert spec.default_effort is not None  # guarded by supports_effort above
+    current = _load_current_effort(provider_key, spec.default_effort)
+
+    # Non-interactive: /effort <level>
+    if args:
+        token = args[0].strip().lower()
+        target = level_by_value.get(token)
+        if target is None or target not in allowed:
+            labels = ", ".join(lvl.value for lvl in allowed)
+            return _("Invalid effort. Allowed: {labels}").format(labels=labels)
+        return _apply_effort(provider, current_model, target, store)
+
+    # Interactive: show picker
+    if not context or not context.console:
+        return _("Current effort: {effort}").format(effort=current.value)
+
+    options = [f"{picker.EFFORT_SYMBOLS[lvl]}  {lvl.value}" for lvl in allowed]
+    default_idx = allowed.index(current) if current in allowed else 0
+
+    sys.stdout.write("\033[?1049h")
+    sys.stdout.flush()
+    try:
+        idx = _select(
+            _("Select effort for {model}").format(model=current_model),
+            options,
+            default_index=default_idx,
+        )
+    finally:
+        sys.stdout.write("\033[?1049l")
+        sys.stdout.flush()
+
+    if idx is None or idx is _BACK:
+        return _("Kept effort as {effort}").format(effort=current.value)
+
+    selected = allowed[idx]
+    if selected == current:
+        return _("Kept effort as {effort}").format(effort=current.value)
+
+    return _apply_effort(provider, current_model, selected, store)
+
+
+def _apply_effort(provider: LLMProvider, model: str, effort: "EffortLevel", store) -> str:
+    save_active_provider_config(provider, model, effort=effort.value)
+    if store is not None:
+        store.set_state(effort_level=effort)
+    return _("Effort switched to: {effort}").format(effort=effort.value)

iac_code/commands/exit.py

@@ -0,0 +1,10 @@
+"""Exit command"""
+
+from __future__ import annotations
+
+
+async def exit_command(**kwargs) -> str:
+    """Exit application by raising ExitREPLError."""
+    from iac_code.ui.repl import ExitREPLError
+
+    raise ExitREPLError()

iac_code/commands/help.py

@@ -0,0 +1,49 @@
+"""Help command"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from rich.text import Text
+
+from iac_code.i18n import _
+
+if TYPE_CHECKING:
+    from iac_code.commands.registry import CommandRegistry
+    from iac_code.ui.repl import CommandContext
+
+
+async def help_command(
+    registry: "CommandRegistry",
+    context: "CommandContext",
+    **kwargs,
+) -> str | None:
+    """Show help information inline."""
+    text = Text()
+
+    text.append("iac-code", style="bold cyan")
+    text.append(" - ")
+    text.append(_("AI-powered infrastructure orchestration tool"), style="dim")
+    text.append("\n\n")
+
+    text.append(_("Commands:"), style="bold")
+    text.append("\n")
+    for cmd in registry.get_all():
+        text.append(f"  /{cmd.name:<12}", style="cyan")
+        text.append(f"  {cmd.description}\n")
+
+    text.append("\n")
+    text.append(_("Shortcuts:"), style="bold")
+    text.append("\n")
+    shortcuts = [
+        ("Enter", _("Send message")),
+        ("Esc+Enter", _("New line")),
+        ("/", _("Show command suggestions")),
+        ("Ctrl+C", _("Exit")),
+    ]
+    for key, description in shortcuts:
+        text.append(f"  {key:<14}", style="cyan")
+        text.append(f"  {description}\n")
+
+    context.console.print(text)
+    return None

iac_code/commands/model.py

@@ -0,0 +1,130 @@
+"""Model command — switch or display current model."""
+
+from __future__ import annotations
+
+import sys
+from typing import TYPE_CHECKING
+
+from iac_code.commands.auth import (
+    _BACK,
+    PROVIDERS,
+    LLMProvider,
+    _classify_base_url,
+    get_configured_providers,
+    save_active_provider_config,
+    select_model_interactive,
+)
+from iac_code.config import _load_yaml, get_active_provider_key, get_settings_path
+from iac_code.i18n import _
+from iac_code.services.telemetry import log_event
+from iac_code.services.telemetry.names import Events
+
+if TYPE_CHECKING:
+    from iac_code.ui.repl import CommandContext
+
+
+def _get_active_provider() -> LLMProvider | None:
+    """Get the currently active provider config from settings."""
+    key_name = get_active_provider_key()
+    if not key_name:
+        return None
+    for p in PROVIDERS:
+        if str(p["key_name"]) == key_name:
+            return p
+    return None
+
+
+def _get_active_provider_models() -> list[str]:
+    """Get model list for the currently active provider."""
+    provider = _get_active_provider()
+    if provider:
+        return list(provider["models"])
+    return []
+
+
+async def model_command(context: "CommandContext | None" = None, args: list[str] | None = None, **kwargs) -> str | None:
+    """Switch or display current model."""
+    store = context.store if context else kwargs.get("store")
+    args = args or []
+
+    if args:
+        new_model = args[0]
+        provider = _get_active_provider()
+        if provider:
+            # Get current custom base URL if any
+            settings = _load_yaml(get_settings_path())
+            active = settings.get("activeProvider")
+            custom_base_url = None
+            if isinstance(active, dict):
+                custom_base_url = active.get("apiBase")
+
+            save_active_provider_config(provider, new_model)
+
+            # Log telemetry event
+            log_event(
+                Events.AUTH_CONFIGURED,
+                {
+                    "provider": provider["name"],
+                    "has_custom_base_url": bool(custom_base_url),
+                    "custom_base_url_host_kind": _classify_base_url(custom_base_url),
+                },
+            )
+
+        if store:
+            store.set_state(model=new_model)
+        return _("Model switched to: {model}").format(model=new_model)
+
+    if not context or not context.console:
+        state = store.get_state() if store else None
+        return _("Current model: {model}").format(model=state.model if state else "")
+
+    if not get_configured_providers():
+        return _("No configured providers. Run /auth first.")
+
+    provider = _get_active_provider()
+    if not provider:
+        return _("No configured providers. Run /auth first.")
+
+    current_model = store.get_state().model if store else ""
+    models = list(provider["models"])
+
+    # Use alternate screen for clean UI
+    sys.stdout.write("\033[?1049h")
+    sys.stdout.flush()
+    try:
+        selected = select_model_interactive(
+            models,
+            current_model=current_model,
+            provider_display_name=str(provider["display_name"]),
+        )
+    finally:
+        sys.stdout.write("\033[?1049l")
+        sys.stdout.flush()
+
+    if selected is _BACK or selected is None:
+        return _("Kept model as {model}").format(model=current_model)
+
+    new_model = str(selected)
+
+    # Get current custom base URL if any
+    settings = _load_yaml(get_settings_path())
+    active = settings.get("activeProvider")
+    custom_base_url = None
+    if isinstance(active, dict):
+        custom_base_url = active.get("apiBase")
+
+    save_active_provider_config(provider, new_model)
+
+    # Log telemetry event
+    log_event(
+        Events.AUTH_CONFIGURED,
+        {
+            "provider": provider["name"],
+            "has_custom_base_url": bool(custom_base_url),
+            "custom_base_url_host_kind": _classify_base_url(custom_base_url),
+        },
+    )
+
+    if store:
+        store.set_state(model=new_model)
+    return _("Model switched to: {model}").format(model=new_model)

iac_code/commands/registry.py

@@ -0,0 +1,245 @@
+"""Command registry — unified registration for local commands and skill-based commands."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Awaitable, Callable
+
+from iac_code.types.skill_source import SkillSource
+
+if TYPE_CHECKING:
+    from iac_code.skills.skill_definition import SkillDefinition
+
+
+@dataclass
+class Command:
+    """Base class for all commands (both local and skill-based).
+
+    Common fields shared by all command types.
+    """
+
+    name: str
+    description: str
+    aliases: list[str] = field(default_factory=list)
+    hidden: bool = False
+
+    @property
+    def is_skill(self) -> bool:
+        return False
+
+
+@dataclass
+class LocalCommand(Command):
+    """Built-in slash command with a handler function.
+
+    Examples: /help, /model, /clear, /compact
+    """
+
+    handler: Callable[..., Awaitable[Any]] | None = None
+    arg_names: list[str] = field(default_factory=list)
+    arg_hint: str | None = None
+    """Inline hint shown as ghost text after the command name (e.g. "[on|off]")."""
+    progress_label: str | None = None
+    """When set, the REPL shows a spinner with this label while the handler runs.
+    Use for commands that perform slow async work (e.g. an LLM call)."""
+
+
+@dataclass
+class PromptCommand(Command):
+    """Skill-based command backed by a SkillDefinition.
+
+    No handler needed — REPL and SkillTool both route through
+    process_prompt_command() directly based on is_skill check.
+    """
+
+    skill: SkillDefinition | None = field(default=None, repr=False)
+    source: SkillSource = SkillSource.PROJECT
+
+    @property
+    def is_skill(self) -> bool:
+        return True
+
+    @property
+    def when_to_use(self) -> str:
+        return self.skill.when_to_use if self.skill else ""
+
+    @property
+    def user_invocable(self) -> bool:
+        return self.skill.is_user_invocable if self.skill else True
+
+    @property
+    def model_invocable(self) -> bool:
+        return True
+
+    @property
+    def content_length(self) -> int:
+        return self.skill.content_length if self.skill else 0
+
+
+# Type alias
+AnyCommand = LocalCommand | PromptCommand
+
+
+def _subsequence_score(query: str, target: str) -> float | None:
+    """Check if query is a subsequence of target, return score (lower is better) or None."""
+    query = query.lower()
+    target = target.lower()
+    qi = 0
+    positions: list[int] = []
+    for ti, ch in enumerate(target):
+        if qi < len(query) and ch == query[qi]:
+            positions.append(ti)
+            qi += 1
+    if qi < len(query):
+        return None
+    # Score: prefer consecutive matches and matches near the start
+    gap_penalty = sum(positions[i] - positions[i - 1] - 1 for i in range(1, len(positions)))
+    start_penalty = positions[0] if positions else 0
+    return start_penalty + gap_penalty
+
+
+@dataclass
+class FuzzyMatch:
+    """A fuzzy match result with scoring."""
+
+    command: Command
+    name: str  # The matched name (could be alias)
+    priority: int  # 0=exact, 1=prefix, 2=alias_exact, 3=alias_prefix, 4=subsequence, 5=desc_keyword
+    score: float  # Lower is better within the same priority
+
+
+class CommandRegistry:
+    """Unified registry for both local commands and prompt skills."""
+
+    def __init__(self) -> None:
+        self._commands: dict[str, Command] = {}
+        self._skill_usage_counts: dict[str, int] = {}
+
+    def register(self, command: Command) -> None:
+        """Register a command or skill."""
+        self._commands[command.name] = command
+        for alias in command.aliases:
+            self._commands[alias] = command
+
+    def get(self, name: str) -> Command | None:
+        """Get command by name or alias."""
+        return self._commands.get(name)
+
+    def get_all(self) -> list[Command]:
+        """Get all unique, non-hidden commands (including skills)."""
+        seen = set()
+        result = []
+        for cmd in self._commands.values():
+            if cmd.name not in seen and not cmd.hidden:
+                seen.add(cmd.name)
+                result.append(cmd)
+        return sorted(result, key=lambda c: c.name)
+
+    # --- Skill-specific queries ---
+
+    def get_skills(self) -> list[PromptCommand]:
+        """Return all prompt-type commands (skills)."""
+        return [c for c in self.get_all() if isinstance(c, PromptCommand)]
+
+    def get_user_invocable_skills(self) -> list[PromptCommand]:
+        """Return skills that users can invoke via /skill-name."""
+        return [c for c in self.get_skills() if c.user_invocable]
+
+    def get_model_invocable_skills(self) -> list[PromptCommand]:
+        """Return skills that the model can invoke via Skill tool."""
+        return [c for c in self.get_skills() if c.model_invocable]
+
+    def record_skill_usage(self, name: str) -> None:
+        """Record a skill usage for frequency-based sorting."""
+        self._skill_usage_counts[name] = self._skill_usage_counts.get(name, 0) + 1
+
+    # --- Existing methods ---
+
+    def get_completions(self, prefix: str) -> list[str]:
+        """Auto-completion: return command names matching prefix"""
+        return sorted(name for name in self._commands if name.startswith(prefix) and not self._commands[name].hidden)
+
+    def fuzzy_search(self, query: str) -> list[FuzzyMatch]:
+        """Fuzzy search commands. Returns matches sorted by priority then score.
+
+        Priority order:
+        0 - Exact name match
+        1 - Name prefix match
+        2 - Exact alias match
+        3 - Alias prefix match
+        4 - Subsequence match on name
+        5 - Description keyword match
+        """
+        if not query:
+            return [FuzzyMatch(command=cmd, name=cmd.name, priority=0, score=0) for cmd in self.get_all()]
+
+        q = query.lower()
+        matches: list[FuzzyMatch] = []
+
+        for cmd in self.get_all():
+            name_lower = cmd.name.lower()
+
+            # Exact name match
+            if name_lower == q:
+                matches.append(FuzzyMatch(cmd, cmd.name, priority=0, score=0))
+                continue
+
+            # Name prefix match
+            if name_lower.startswith(q):
+                matches.append(FuzzyMatch(cmd, cmd.name, priority=1, score=len(cmd.name)))
+                continue
+
+            # Alias matches
+            alias_matched = False
+            for alias in cmd.aliases:
+                alias_lower = alias.lower()
+                if alias_lower == q:
+                    matches.append(FuzzyMatch(cmd, alias, priority=2, score=0))
+                    alias_matched = True
+                    break
+                if alias_lower.startswith(q):
+                    matches.append(FuzzyMatch(cmd, alias, priority=3, score=len(alias)))
+                    alias_matched = True
+                    break
+            if alias_matched:
+                continue
+
+            # Subsequence match on name
+            sub_score = _subsequence_score(q, cmd.name)
+            if sub_score is not None:
+                matches.append(FuzzyMatch(cmd, cmd.name, priority=4, score=sub_score))
+                continue
+
+            # Description keyword match
+            desc_lower = cmd.description.lower()
+            if q in desc_lower:
+                matches.append(FuzzyMatch(cmd, cmd.name, priority=5, score=desc_lower.index(q)))
+                continue
+
+        matches.sort(key=lambda m: (m.priority, m.score))
+        return matches
+
+    def get_best_prefix_match(self, partial: str) -> str | None:
+        """Find the best prefix-matching command name for ghost text."""
+        if not partial:
+            return None
+        q = partial.lower()
+        for cmd in self.get_all():
+            if cmd.name.lower().startswith(q):
+                return cmd.name
+        for cmd in self.get_all():
+            for alias in cmd.aliases:
+                if alias.lower().startswith(q):
+                    return alias
+        return None
+
+    def is_command(self, text: str) -> bool:
+        """Check if text is a command"""
+        return text.startswith("/")
+
+    def parse(self, text: str) -> tuple[str, list[str]]:
+        """Parse command text, return (command name, argument list)"""
+        parts = text.lstrip("/").split()
+        name = parts[0] if parts else ""
+        args = parts[1:] if len(parts) > 1 else []
+        return name, args