iac-code 0.1.0__py3-none-any.whl

iac_code/commands/resume.py

@@ -0,0 +1,49 @@
+"""/resume command — pick or jump to a saved session."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from iac_code.i18n import _
+
+
+async def resume_command(context=None, args: list[str] | None = None, **_kwargs: Any) -> str:
+    """Resume a previous session.
+
+    With an argument, resolves the input as a session id (or unique id
+    prefix). Without arguments, opens an interactive picker.
+
+    Cross-project sessions never hot-swap — they print the
+    ``cd ... && iac-code --resume <id>`` command and (best-effort) copy
+    it to the clipboard.
+    """
+    if context is None or not hasattr(context, "repl"):
+        return _("Resume is only available in interactive mode.")
+    repl = context.repl
+    arg_str = " ".join(args or []).strip()
+
+    index = getattr(repl, "session_index", None)
+    if index is None:
+        return _("Resume is unavailable: session index not initialised.")
+
+    if arg_str:
+        entry = index.find_by_id_or_prefix(arg_str)
+        if entry is None:
+            return _("Session not found: {arg}").format(arg=arg_str)
+        await repl.swap_or_announce_session(entry)
+        return ""
+
+    from iac_code.ui.dialogs.resume_picker import ResumePicker
+
+    picker = ResumePicker(
+        index=index,
+        current_cwd=repl._original_cwd,
+        current_session_id=repl.session_id,
+        keybinding_manager=getattr(repl, "_keybinding_manager", None),
+        renderer=getattr(repl, "renderer", None),
+    )
+    selected = picker.run()
+    if selected is None:
+        return _("Resume cancelled")
+    await repl.swap_or_announce_session(selected)
+    return ""

iac_code/commands/tasks.py

@@ -0,0 +1,41 @@
+"""The /tasks command — view and manage background agents."""
+
+from __future__ import annotations
+
+from iac_code.tasks.task_state import TaskManager
+
+
+class TasksCommand:
+    def __init__(self, task_manager: TaskManager):
+        self._manager = task_manager
+
+    @property
+    def name(self) -> str:
+        return "tasks"
+
+    @property
+    def description(self) -> str:
+        return "List and manage background tasks. Usage: /tasks [stop <id>]"
+
+    def execute(self, args: str) -> str:
+        parts = args.strip().split()
+        if parts and parts[0] == "stop" and len(parts) >= 2:
+            return self._stop_task(parts[1])
+        return self._list_tasks()
+
+    def _list_tasks(self) -> str:
+        tasks = self._manager.list_all()
+        if not tasks:
+            return "No background tasks."
+        lines = []
+        for t in tasks:
+            icon = {"running": "*", "completed": "+", "failed": "!", "stopped": "-"}.get(t.status.value, "?")
+            lines.append(f"  [{icon}] {t.id}  {t.status.value:<10}  [{t.agent_type}] {t.description}")
+        return f"Background Tasks ({len(tasks)}):\n" + "\n".join(lines)
+
+    def _stop_task(self, task_id: str) -> str:
+        task = self._manager.get(task_id)
+        if not task:
+            return f"Task '{task_id}' not found."
+        self._manager.stop(task_id)
+        return f"Task '{task_id}' stopped."

iac_code/config.py

@@ -0,0 +1,304 @@
+"""Configuration paths for iac-code.
+
+Provides unified configuration directory and file paths under
+``~/.iac-code/``.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+# Default LLM model used when no model is saved in settings
+DEFAULT_MODEL = "qwen3.6-plus"
+
+# Configuration directory
+_CONFIG_DIR_NAME = ".iac-code"
+
+# Configuration files
+_CREDENTIALS_FILE = ".credentials.yml"
+_SETTINGS_FILE = "settings.yml"
+_CLOUD_CREDENTIALS_FILE = ".cloud-credentials.yml"
+_HISTORY_FILE = ".input_history"
+
+
+# ---------------------------------------------------------------------------
+# YAML helpers
+# ---------------------------------------------------------------------------
+
+
+def _load_yaml(path: Path) -> dict[str, Any]:
+    """Read a YAML file, returning {} when the file does not exist."""
+    if not path.exists():
+        return {}
+    try:
+        data = yaml.safe_load(path.read_text())
+        return data if isinstance(data, dict) else {}
+    except Exception:
+        return {}
+
+
+def _save_yaml(path: Path, data: dict[str, Any]) -> None:
+    """Write *data* to a YAML file, creating parent directories as needed."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(yaml.dump(data, default_flow_style=False, allow_unicode=True))
+
+
+# ---------------------------------------------------------------------------
+# Provider name normalization (env-facing PascalCase ↔ internal key_name)
+# ---------------------------------------------------------------------------
+
+# Canonical PascalCase display values for IAC_CODE_PROVIDER.
+# Order is the order shown in error messages.
+_PROVIDER_CANONICAL_NAMES: tuple[str, ...] = (
+    "Anthropic",
+    "OpenAI",
+    "DashScope",
+    "DashScopeTokenPlan",
+    "DeepSeek",
+    "OpenAPICompatible",
+)
+
+# Lowercased canonical name -> internal key_name (matches settings.yml `keyName`).
+_PROVIDER_NAME_TO_KEY: dict[str, str] = {
+    "anthropic": "anthropic",
+    "openai": "openai",
+    "dashscope": "dashscope",
+    "dashscopetokenplan": "dashscope_token_plan",
+    "deepseek": "deepseek",
+    "openapicompatible": "openapi_compatible",
+}
+
+# key_name -> credentials.yml slot. After the rename, slots match key_name 1:1.
+_KEY_NAME_TO_CRED_SLOT: dict[str, str] = {
+    "anthropic": "anthropic",
+    "openai": "openai",
+    "dashscope": "dashscope",
+    "dashscope_token_plan": "dashscope_token_plan",
+    "deepseek": "deepseek",
+    "openapi_compatible": "openapi_compatible",
+}
+
+# Legacy key_name aliases accepted when reading settings.yml (write path always uses
+# the canonical key on the right). Keep DashScope's old "bailian" name readable.
+_LEGACY_KEY_NAME_ALIASES: dict[str, str] = {
+    "bailian": "dashscope",
+}
+
+# Module-level flag — warn once per process when IAC_CODE_BASE_URL is set
+# but the active provider is not OpenAPICompatible. Reset by tests.
+_warned_base_url_ignored: bool = False
+
+
+# ---------------------------------------------------------------------------
+# Environment variable overrides
+# ---------------------------------------------------------------------------
+
+
+def _get_env_overrides() -> dict[str, str | None]:
+    """Read IAC_CODE_* env vars and return a normalized override dict.
+
+    Returns dict with keys: ``provider_key`` (internal key_name or None),
+    ``model``, ``api_base``, ``api_key``. Empty/whitespace values are normalized
+    to None. Invalid ``IAC_CODE_PROVIDER`` raises ``ValueError`` listing canonical
+    names.
+    """
+    import os
+
+    def _read(name: str) -> str | None:
+        raw = os.environ.get(name, "")
+        stripped = raw.strip() if raw else ""
+        return stripped or None
+
+    provider_raw = _read("IAC_CODE_PROVIDER")
+    provider_key: str | None = None
+    if provider_raw is not None:
+        key = _PROVIDER_NAME_TO_KEY.get(provider_raw.lower())
+        if key is None:
+            valid = ", ".join(_PROVIDER_CANONICAL_NAMES)
+            raise ValueError(
+                f"Invalid IAC_CODE_PROVIDER value: {provider_raw!r}. Valid values (case-insensitive): {valid}"
+            )
+        provider_key = key
+
+    return {
+        "provider_key": provider_key,
+        "model": _read("IAC_CODE_MODEL"),
+        "api_base": _read("IAC_CODE_BASE_URL"),
+        "api_key": _read("IAC_CODE_API_KEY"),
+    }
+
+
+# ---------------------------------------------------------------------------
+# Path helpers
+# ---------------------------------------------------------------------------
+
+
+def get_config_dir() -> Path:
+    """Get iac-code config directory (~/.iac-code/).
+
+    Creates the directory if it doesn't exist.
+    """
+    config_dir = Path.home() / _CONFIG_DIR_NAME
+    config_dir.mkdir(parents=True, exist_ok=True)
+    return config_dir
+
+
+def get_credentials_path() -> Path:
+    """Get credentials file path (~/.iac-code/.credentials.yml)."""
+    return get_config_dir() / _CREDENTIALS_FILE
+
+
+def get_settings_path() -> Path:
+    """Get settings file path (~/.iac-code/settings.yml)."""
+    return get_config_dir() / _SETTINGS_FILE
+
+
+def get_cloud_credentials_path() -> Path:
+    """Get cloud credentials file path (~/.iac-code/.cloud-credentials.yml)."""
+    return get_config_dir() / _CLOUD_CREDENTIALS_FILE
+
+
+def get_history_path() -> Path:
+    """Get input history file path (~/.iac-code/.input_history)."""
+    return get_config_dir() / _HISTORY_FILE
+
+
+# ---------------------------------------------------------------------------
+# Config loaders
+# ---------------------------------------------------------------------------
+
+
+def get_active_provider_key() -> str | None:
+    """Return the keyName of the currently active provider, or None.
+
+    ``IAC_CODE_PROVIDER`` env var takes precedence over settings.yml.
+    Legacy keyNames in settings.yml (e.g. ``bailian``) are normalized to the
+    canonical name (``dashscope``).
+    """
+    env_key = _get_env_overrides()["provider_key"]
+    if env_key:
+        return env_key
+    settings = _load_yaml(get_settings_path())
+    active = settings.get("activeProvider")
+    if isinstance(active, str) and active:
+        return _LEGACY_KEY_NAME_ALIASES.get(active, active)
+    return None
+
+
+def get_provider_config(key_name: str) -> dict[str, Any]:
+    """Return the persisted per-provider config dict (empty when unset).
+
+    When ``key_name`` is the active provider, IAC_CODE_MODEL and
+    IAC_CODE_BASE_URL env values are overlaid. IAC_CODE_BASE_URL only
+    applies when the active provider is ``openapi_compatible``; setting
+    it for other providers logs a one-time warning and is ignored.
+    """
+    global _warned_base_url_ignored
+
+    settings = _load_yaml(get_settings_path())
+    providers = settings.get("providers")
+    entry: dict[str, Any] = {}
+    if isinstance(providers, dict):
+        raw = providers.get(key_name)
+        if not isinstance(raw, dict):
+            for legacy, canonical in _LEGACY_KEY_NAME_ALIASES.items():
+                if canonical == key_name:
+                    legacy_raw = providers.get(legacy)
+                    if isinstance(legacy_raw, dict):
+                        raw = legacy_raw
+                        break
+        if isinstance(raw, dict):
+            entry = dict(raw)
+
+    env = _get_env_overrides()
+    active_key = env["provider_key"]
+    if active_key is None:
+        active = settings.get("activeProvider")
+        if isinstance(active, str) and active:
+            active_key = _LEGACY_KEY_NAME_ALIASES.get(active, active)
+
+    if key_name == active_key:
+        if env["model"]:
+            entry["model"] = env["model"]
+        if env["api_base"]:
+            if active_key == "openapi_compatible":
+                entry["apiBase"] = env["api_base"]
+            elif not _warned_base_url_ignored:
+                from loguru import logger
+
+                logger.warning(
+                    "IAC_CODE_BASE_URL is set but active provider is "
+                    f"{active_key!r}; the value is ignored. "
+                    "IAC_CODE_BASE_URL only applies to OpenAPICompatible."
+                )
+                _warned_base_url_ignored = True
+
+    return entry
+
+
+def load_saved_model() -> str | None:
+    """Load the active provider's saved model from settings.yml."""
+    key = get_active_provider_key()
+    if not key:
+        return None
+    model = get_provider_config(key).get("model")
+    return model if isinstance(model, str) and model else None
+
+
+def load_saved_effort() -> str | None:
+    """Load saved effort level from settings.yml."""
+    settings = _load_yaml(get_settings_path())
+    effort = settings.get("effort")
+    return effort if isinstance(effort, str) else None
+
+
+def load_active_provider_config() -> dict[str, Any] | None:
+    """Load the active provider's full config, including its keyName."""
+    key = get_active_provider_key()
+    if not key:
+        return None
+    cfg = dict(get_provider_config(key))
+    cfg["keyName"] = key
+    return cfg
+
+
+def load_credentials() -> dict[str, str]:
+    """Load API credentials from ``.credentials.yml`` with env override applied.
+
+    Returns a dict with five fixed slots: ``anthropic``, ``openai``,
+    ``dashscope``, ``deepseek``, ``openapi_compatible``. The ``dashscope``
+    slot also accepts the legacy ``bailian`` key in the YAML file (file's
+    ``dashscope`` value takes precedence when both are present).
+
+    When ``IAC_CODE_API_KEY`` is set and an active provider is determined
+    (via env or settings.yml), the env value overrides the active provider's
+    slot. With no active provider, the env value is ignored.
+    """
+    try:
+        raw = _load_yaml(get_credentials_path())
+    except Exception:
+        raw = {}
+    if not isinstance(raw, dict):
+        raw = {}
+
+    creds: dict[str, str] = {
+        "anthropic": str(raw.get("anthropic", "") or ""),
+        "openai": str(raw.get("openai", "") or ""),
+        "dashscope": str(raw.get("dashscope", "") or raw.get("bailian", "") or ""),
+        "dashscope_token_plan": str(raw.get("dashscope_token_plan", "") or ""),
+        "deepseek": str(raw.get("deepseek", "") or ""),
+        "openapi_compatible": str(raw.get("openapi_compatible", "") or ""),
+    }
+
+    env = _get_env_overrides()
+    if env["api_key"]:
+        active_key = env["provider_key"] or get_active_provider_key()
+        if active_key:
+            slot = _KEY_NAME_TO_CRED_SLOT.get(active_key)
+            if slot:
+                creds[slot] = env["api_key"]
+
+    return creds

iac_code/i18n/__init__.py

@@ -0,0 +1,141 @@
+"""Internationalization (i18n) module for iac-code.
+
+This module provides translation capabilities using Python's standard gettext library.
+"""
+
+import gettext
+import os
+from pathlib import Path
+from typing import Callable
+
+# Supported languages
+SUPPORTED_LANGUAGES = ["en", "zh"]
+
+# Default language (English is the source language, no .po file needed)
+DEFAULT_LANGUAGE = "en"
+
+# Module-level mutable reference to the actual gettext function
+# Initially set to a pass-through function that returns the original string
+
+
+def _default_gettext(message: str) -> str:
+    """Default pass-through translation function (before setup)."""
+    return message
+
+
+_gettext_func: Callable[[str], str] = _default_gettext
+_current_language: str = DEFAULT_LANGUAGE
+
+
+def _(message: str) -> str:
+    """Translate a message string.
+
+    Delegates to the current gettext function. This wrapper function
+    remains stable after import, while the underlying translation
+    function can be updated via setup_i18n().
+
+    Args:
+        message: The message string to translate.
+
+    Returns:
+        The translated message string.
+    """
+    return _gettext_func(message)
+
+
+# Typer/Click built-in strings that need translation
+# These are referenced here so pybabel can extract them into messages.pot
+# They are actually used by Typer/Click's internal gettext calls
+_TYPER_CLICK_STRINGS = [
+    _("Options"),
+    _("Commands"),
+    _("Arguments"),
+    _("Show this message and exit."),
+    _("Install completion for the current shell."),
+    _("Show completion for the current shell, to copy it or customize the installation."),
+    _("default: {default}"),
+    _("required"),
+    _("env var: {var}"),
+    _("(dynamic)"),
+    _("Aborted!"),
+]
+
+
+def get_current_language() -> str:
+    """Return the currently detected language code (e.g., 'zh', 'en')."""
+    return _current_language
+
+
+def _detect_language() -> str:
+    """Detect system language from environment variables.
+
+    Detection priority:
+    1. LANGUAGE
+    2. LC_ALL
+    3. LC_MESSAGES
+    4. LANG
+    5. Default to 'en'
+
+    Returns:
+        Two-letter language code (e.g., 'zh', 'en')
+    """
+    env_vars = ["LANGUAGE", "LC_ALL", "LC_MESSAGES", "LANG"]
+
+    for var in env_vars:
+        value = os.environ.get(var)
+        if value:
+            # Extract the language code (first two characters before any underscore or dot)
+            # e.g., 'zh_CN.UTF-8' -> 'zh', 'en_US' -> 'en'
+            lang_code = value.split("_")[0].split(".")[0].lower()
+            if lang_code in SUPPORTED_LANGUAGES:
+                return lang_code
+
+    return DEFAULT_LANGUAGE
+
+
+def setup_i18n() -> None:
+    """Initialize internationalization.
+
+    This function sets up gettext with the detected system language.
+    It updates the module-level `_` function to use the appropriate translation.
+
+    The locales directory is expected to be at `locales/` relative to this file.
+    English is the default fallback language (source strings are in English).
+
+    It also binds the `messages` text domain via `gettext.bindtextdomain` /
+    `gettext.textdomain`, so that Typer/Click's module-level
+    `from gettext import gettext as _` (which captures the function object at
+    import time) can still resolve translations at call time. This avoids any
+    reliance on import ordering or monkey-patching of the `gettext` module.
+    """
+    global _gettext_func, _current_language
+
+    lang = _detect_language()
+    _current_language = lang
+
+    # Get the locales directory path
+    locales_dir = Path(__file__).parent / "locales"
+
+    if lang == DEFAULT_LANGUAGE:
+        # For English, use a null translation (strings are already in English)
+        translation = gettext.NullTranslations()
+    else:
+        try:
+            translation = gettext.translation(
+                "messages",
+                localedir=str(locales_dir),
+                languages=[lang],
+                fallback=True,  # Fall back to source strings if translation not found
+            )
+        except Exception:
+            # If any error occurs, fall back to null translation
+            translation = gettext.NullTranslations()
+
+    # Update the mutable reference for our own `_()` calls.
+    _gettext_func = translation.gettext
+
+    # Bind the text domain so that `gettext.gettext(msg)` -> `dgettext('messages', msg)`
+    # resolves via this localedir. This is the key mechanism that lets Click's
+    # captured `_` reference work without patching or import-order tricks.
+    gettext.bindtextdomain("messages", str(locales_dir))
+    gettext.textdomain("messages")