alysis-code 0.13.0__py3-none-any.whl

alysis_code/capabilities.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+from collections.abc import Collection, Iterator
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True)
+class CapabilityDefinition:
+    """A user-meaningful capability whose readiness is controlled by runtime state."""
+
+    name: str
+    description: str
+    config_path: tuple[str, ...]
+    required_tool_names: tuple[str, ...] = ()
+    success_event_types: tuple[str, ...] = ()
+    success_tool_names: tuple[str, ...] = ()
+    minimum_success_tool_events: int = 0
+    materializes_artifacts: bool = False
+    disabled_reason: str = "This capability is disabled for this session."
+    disabled_resolution: str = "Enable the capability and start a new chat session."
+    unavailable_in_mode_reason: str = "This capability is unavailable in the current mode."
+    unavailable_in_mode_resolution: str = "Switch to a write-capable mode and retry."
+    unavailable_in_mode_requires_new_session: bool = False
+
+
+@dataclass(frozen=True)
+class CapabilityStatus:
+    name: str
+    available: bool
+    reason_code: str | None = None
+    reason: str | None = None
+    resolution: str | None = None
+    requires_new_session: bool = False
+
+
+_CAPABILITY_DEFINITIONS: tuple[CapabilityDefinition, ...] = (
+    CapabilityDefinition(
+        name="external_research",
+        description=("Research dependency and framework behavior with the configured web tools."),
+        config_path=("web_tools_enabled",),
+        required_tool_names=("web_fetch", "web_search"),
+        success_tool_names=("web_fetch", "web_search"),
+        minimum_success_tool_events=1,
+        disabled_reason="External research is disabled for this session.",
+        disabled_resolution=("Enable web tools and web search, then start a new chat session."),
+        unavailable_in_mode_reason=(
+            "External research is unavailable because this session does not expose "
+            "both web_fetch and web_search."
+        ),
+        unavailable_in_mode_resolution=(
+            "Configure web search and enable web tools, then start a new chat session."
+        ),
+        unavailable_in_mode_requires_new_session=True,
+    ),
+    CapabilityDefinition(
+        name="image_generation",
+        description=(
+            "Create production raster images and save validated image files in the workspace."
+        ),
+        config_path=("image_generation", "enabled"),
+        required_tool_names=("image_generate",),
+        success_event_types=("image_generated",),
+        materializes_artifacts=True,
+        disabled_reason="Image generation is disabled for this session.",
+        disabled_resolution=(
+            "Set an image-provider credential, run "
+            "`alysis config set image_generation.enabled true`, then start a new chat session."
+        ),
+        unavailable_in_mode_reason=(
+            "Image generation is not available in the current session mode."
+        ),
+        unavailable_in_mode_resolution=(
+            "Switch to `review`, `auto`, or `fullaccess` mode and retry."
+        ),
+    ),
+)
+
+_CAPABILITY_BY_NAME = {definition.name: definition for definition in _CAPABILITY_DEFINITIONS}
+
+
+def iter_capability_definitions() -> Iterator[CapabilityDefinition]:
+    return iter(_CAPABILITY_DEFINITIONS)
+
+
+def get_capability_definition(name: str) -> CapabilityDefinition | None:
+    return _CAPABILITY_BY_NAME.get(str(name or "").strip().casefold())
+
+
+def _config_flag(cfg: Any, path: tuple[str, ...]) -> bool:
+    current = cfg
+    for segment in path:
+        if current is None:
+            return False
+        current = getattr(current, segment, None)
+    return bool(current)
+
+
+def resolve_capability_status(
+    name: str,
+    *,
+    cfg: Any,
+    available_tool_names: Collection[str] | None = None,
+) -> CapabilityStatus:
+    definition = get_capability_definition(name)
+    clean_name = str(name or "").strip().casefold()
+    if definition is None:
+        return CapabilityStatus(
+            name=clean_name,
+            available=False,
+            reason_code="unknown_capability",
+            reason=f"Unknown capability: {clean_name or '(empty)'}.",
+        )
+
+    if not _config_flag(cfg, definition.config_path):
+        return CapabilityStatus(
+            name=definition.name,
+            available=False,
+            reason_code="capability_disabled",
+            reason=definition.disabled_reason,
+            resolution=definition.disabled_resolution,
+            requires_new_session=True,
+        )
+
+    if available_tool_names is not None and definition.required_tool_names:
+        available = {str(item or "").strip() for item in available_tool_names}
+        if any(tool_name not in available for tool_name in definition.required_tool_names):
+            return CapabilityStatus(
+                name=definition.name,
+                available=False,
+                reason_code="capability_unavailable_in_mode",
+                reason=definition.unavailable_in_mode_reason,
+                resolution=definition.unavailable_in_mode_resolution,
+                requires_new_session=definition.unavailable_in_mode_requires_new_session,
+            )
+
+    return CapabilityStatus(name=definition.name, available=True)

alysis_code/chatgpt_codex_static_provider.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from functools import lru_cache
+from importlib import resources
+from typing import Any
+
+from .model_metadata_utils import parse_positive_int
+
+CHATGPT_CODEX_SUBSCRIPTION_CATALOG_SOURCE = "bundled_chatgpt_codex_subscription_snapshot"
+_CATALOG_PACKAGE = "alysis_code.model_catalog"
+_CATALOG_FILENAME = "chatgpt_codex_subscription_snapshot.json"
+
+
+@dataclass(frozen=True, slots=True)
+class ChatGPTCodexStaticModel:
+    id: str
+    label: str
+    description: str
+    priority: int
+    context_window_tokens: int | None
+    max_output_tokens: int | None
+    input_modalities: tuple[str, ...]
+    reasoning_efforts: tuple[tuple[str, str], ...]
+    default_reasoning_effort: str | None
+
+
+def _clean_string(value: Any) -> str:
+    return str(value or "").strip()
+
+
+def _parse_model(raw: Any) -> ChatGPTCodexStaticModel | None:
+    if not isinstance(raw, dict):
+        return None
+    model_id = _clean_string(raw.get("id"))
+    if not model_id:
+        return None
+    try:
+        priority = int(raw.get("priority") or 9999)
+    except (TypeError, ValueError):
+        priority = 9999
+
+    modalities_raw = raw.get("input_modalities")
+    modalities = (
+        tuple(
+            dict.fromkeys(
+                _clean_string(item).casefold() for item in modalities_raw if _clean_string(item)
+            )
+        )
+        if isinstance(modalities_raw, list)
+        else ()
+    )
+    if not modalities:
+        modalities = ("text",)
+
+    efforts: list[tuple[str, str]] = []
+    efforts_raw = raw.get("reasoning_efforts")
+    if isinstance(efforts_raw, list):
+        for item in efforts_raw:
+            if not isinstance(item, dict):
+                continue
+            effort_id = _clean_string(item.get("id"))
+            if effort_id:
+                efforts.append((effort_id, _clean_string(item.get("description"))))
+
+    default_effort = _clean_string(raw.get("default_reasoning_effort")) or None
+    return ChatGPTCodexStaticModel(
+        id=model_id,
+        label=_clean_string(raw.get("label")) or model_id,
+        description=_clean_string(raw.get("description")),
+        priority=priority,
+        context_window_tokens=parse_positive_int(raw.get("context_window_tokens")),
+        max_output_tokens=parse_positive_int(raw.get("max_output_tokens")),
+        input_modalities=modalities,
+        reasoning_efforts=tuple(efforts),
+        default_reasoning_effort=default_effort,
+    )
+
+
+@lru_cache(maxsize=1)
+def load_chatgpt_codex_static_models() -> tuple[ChatGPTCodexStaticModel, ...]:
+    try:
+        text = (
+            resources.files(_CATALOG_PACKAGE)
+            .joinpath(_CATALOG_FILENAME)
+            .read_text(encoding="utf-8")
+        )
+        payload = json.loads(text)
+    except (
+        FileNotFoundError,
+        ModuleNotFoundError,
+        OSError,
+        UnicodeDecodeError,
+        json.JSONDecodeError,
+    ):
+        return ()
+    if not isinstance(payload, dict):
+        return ()
+    if payload.get("source") != CHATGPT_CODEX_SUBSCRIPTION_CATALOG_SOURCE:
+        return ()
+    raw_models = payload.get("models")
+    if not isinstance(raw_models, list):
+        return ()
+    models = tuple(model for raw in raw_models if (model := _parse_model(raw)) is not None)
+    return tuple(
+        sorted(models, key=lambda model: (model.priority, model.label.casefold(), model.id))
+    )
+
+
+def resolve_chatgpt_codex_static_model(model_name: str) -> ChatGPTCodexStaticModel | None:
+    requested = _clean_string(model_name).casefold()
+    if not requested:
+        return None
+    candidates = {requested}
+    if "/" in requested:
+        candidates.add(requested.rsplit("/", 1)[-1])
+    return next(
+        (
+            model
+            for model in load_chatgpt_codex_static_models()
+            if model.id.casefold() in candidates
+        ),
+        None,
+    )
+
+
+__all__ = [
+    "CHATGPT_CODEX_SUBSCRIPTION_CATALOG_SOURCE",
+    "ChatGPTCodexStaticModel",
+    "load_chatgpt_codex_static_models",
+    "resolve_chatgpt_codex_static_model",
+]

alysis_code/cli.py

@@ -0,0 +1,51 @@
+# ruff: noqa: F401,F403,F405,E402
+from __future__ import annotations
+
+
+def _harden_stdio() -> None:
+    """Make stdout/stderr tolerant of glyphs the console encoding can't map
+    (e.g. the rich UI's box-drawing ``│`` on a non-UTF-8 Windows console such as
+    Greek cp1253), so the first surfaced warning/error no longer crashes with
+    UnicodeEncodeError. ``backslashreplace`` degrades an unmappable glyph to a
+    readable escape instead of aborting. We change only the error handler, not
+    the encoding, so redirected/piped output keeps its locale codec for
+    downstream readers. Runs once at process start, before any output."""
+    import sys
+
+    for stream in (sys.stdout, sys.stderr):
+        reconfigure = getattr(stream, "reconfigure", None)
+        if reconfigure is None:
+            continue
+        try:
+            reconfigure(errors="backslashreplace")
+        except (ValueError, OSError):  # detached buffer / unsupported stream
+            pass
+
+
+_harden_stdio()
+
+# Source-alignment markers for checks that read this legacy entrypoint after the
+# command implementation moved into cli_impl/commands.
+# Chat command marker: "/forge"
+# Prompt hotkey marker: @kb.add("c-b")
+from .cli_impl.commands.cli_surface import *
+
+
+def legacy_app() -> None:
+    """Entry point for the deprecated ``sylliptor`` command.
+
+    Behaves identically to ``alysis``; the only difference is a notice on
+    stderr, so piping stdout to another program is unaffected.
+    """
+    import sys as _sys
+
+    print(
+        "note: 'sylliptor' has been renamed to 'alysis'. This alias still works "
+        "but will be removed in a future release.",
+        file=_sys.stderr,
+    )
+    app()
+
+
+if __name__ == "__main__":
+    app()

alysis_code/cli_impl/__init__.py

@@ -0,0 +1 @@
+"""Internal CLI implementation modules."""