algo-cli-runtime 0.14.0__py3-none-any.whl

algo_cli/intelligence/acrobat_config.py

@@ -0,0 +1,307 @@
+"""B166, B167, B170, B177: Acrobat-derived config/dispatch/theme/telemetry patterns.
+
+- B166: Locale-Sharded Resources with Default Fallback
+- B167: Service Endpoint Dispatch Table
+- B170: State-Based Declarative Theming
+- B177: Telemetry Endpoint Config Separation
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+# ── B166: Locale-Sharded Resources with Default Fallback ─────────────
+
+
+@dataclass
+class LocaleResource:
+    """A locale-specific resource (B166)."""
+    locale: str
+    resource_id: str
+    content: Any = None
+    fallback_used: bool = False
+
+
+class LocaleResourceStore:
+    """Locale-sharded resources with deterministic fallback (B166)."""
+
+    def __init__(self, default_locale: str = "ENU") -> None:
+        self._default = default_locale
+        self._resources: dict[tuple[str, str], LocaleResource] = {}
+
+    def register(self, locale: str, resource_id: str, content: Any) -> None:
+        self._resources[(locale, resource_id)] = LocaleResource(
+            locale=locale, resource_id=resource_id, content=content,
+        )
+
+    def get(self, locale: str, resource_id: str) -> LocaleResource | None:
+        """Get a resource with fallback: exact locale -> language -> default."""
+        # Try exact locale
+        key = (locale, resource_id)
+        if key in self._resources:
+            return self._resources[key]
+
+        # Try language prefix
+        lang = locale.split("_")[0].upper()
+        key = (lang, resource_id)
+        if key in self._resources:
+            r = self._resources[key]
+            return LocaleResource(
+                locale=lang, resource_id=resource_id,
+                content=r.content, fallback_used=True,
+            )
+
+        # Try default
+        key = (self._default, resource_id)
+        if key in self._resources:
+            r = self._resources[key]
+            return LocaleResource(
+                locale=self._default, resource_id=resource_id,
+                content=r.content, fallback_used=True,
+            )
+        return None
+
+    def available_locales(self) -> list[str]:
+        return sorted({loc for loc, _ in self._resources.keys()})
+
+    def has_resource(self, locale: str, resource_id: str) -> bool:
+        return (locale, resource_id) in self._resources
+
+
+# ── B167: Service Endpoint Dispatch Table ────────────────────────────
+
+
+@dataclass
+class ServiceEndpoint:
+    """A single service endpoint (B167)."""
+    operation: str
+    url: str
+    version: str = "v1"
+    scope: str = "GM"  # "PR" (pre-release) or "GM" (general release)
+
+
+@dataclass
+class DispatchTable:
+    """A dispatch table for service endpoints (B167)."""
+    scope: str = "GM"
+    endpoints: dict[str, ServiceEndpoint] = field(default_factory=dict)
+    signature: str = ""
+
+    def add(self, endpoint: ServiceEndpoint) -> None:
+        self.endpoints[endpoint.operation] = endpoint
+
+    def resolve(self, operation: str) -> ServiceEndpoint | None:
+        """Resolve an operation to its endpoint."""
+        return self.endpoints.get(operation)
+
+    def operations(self) -> list[str]:
+        return list(self.endpoints.keys())
+
+
+class ServiceDispatchRegistry:
+    """Registry of dispatch tables with scope variants (B167)."""
+
+    def __init__(self) -> None:
+        self._tables: dict[str, DispatchTable] = {}
+        self._active_scope: str = "GM"
+
+    def register_table(self, table: DispatchTable) -> None:
+        self._tables[table.scope] = table
+
+    def set_scope(self, scope: str) -> None:
+        self._active_scope = scope
+
+    def resolve(self, operation: str) -> ServiceEndpoint | None:
+        """Resolve an operation using the active scope's dispatch table."""
+        table = self._tables.get(self._active_scope)
+        if not table:
+            return None
+        return table.resolve(operation)
+
+    def available_scopes(self) -> list[str]:
+        return list(self._tables.keys())
+
+    def all_operations(self) -> list[str]:
+        table = self._tables.get(self._active_scope)
+        return table.operations() if table else []
+
+
+# ── B170: State-Based Declarative Theming ─────────────────────────────
+
+
+@dataclass
+class ThemeStyle:
+    """A style with state variants (B170)."""
+    style_id: str
+    states: dict[str, str] = field(default_factory=dict)  # state -> color
+
+    def get(self, state: str = "normal") -> str | None:
+        """Get the color for a state, falling back to normal."""
+        return self.states.get(state, self.states.get("normal"))
+
+
+@dataclass
+class Theme:
+    """A declarative theme (B170)."""
+    theme_id: str
+    title: str = ""
+    icon_set: str = ""
+    styles: dict[str, ThemeStyle] = field(default_factory=dict)
+
+    def get_color(self, style_id: str, state: str = "normal") -> str | None:
+        """Resolve a color for a style + state."""
+        style = self.styles.get(style_id)
+        if not style:
+            return None
+        return style.get(state)
+
+
+class ThemeManager:
+    """Manages themes with swap support (B170)."""
+
+    def __init__(self) -> None:
+        self._themes: dict[str, Theme] = {}
+        self._active: str = ""
+
+    def register(self, theme: Theme) -> None:
+        self._themes[theme.theme_id] = theme
+        if not self._active:
+            self._active = theme.theme_id
+
+    def set_active(self, theme_id: str) -> bool:
+        if theme_id in self._themes:
+            self._active = theme_id
+            return True
+        return False
+
+    def get_active(self) -> Theme | None:
+        return self._themes.get(self._active)
+
+    def get_color(self, style_id: str, state: str = "normal") -> str | None:
+        theme = self.get_active()
+        if not theme:
+            return None
+        return theme.get_color(style_id, state)
+
+    def all_themes(self) -> list[str]:
+        return list(self._themes.keys())
+
+
+def default_dark_theme() -> Theme:
+    """Create a default dark theme from Acrobat's DarkTheme.acrotheme."""
+    return Theme(
+        theme_id="DarkTheme",
+        title="Dark Theme",
+        icon_set="DarkIcons",
+        styles={
+            "RegularBackground": ThemeStyle("RegularBackground", {"normal": "0x4D4D4D"}),
+            "ProminentBackground": ThemeStyle("ProminentBackground", {"normal": "0x424242", "hover": "0x3A3A3A"}),
+            "DocumentBackground": ThemeStyle("DocumentBackground", {"normal": "0x282828"}),
+            "Border": ThemeStyle("Border", {"normal": "0x3A3A3A"}),
+            "Icon": ThemeStyle("Icon", {
+                "normal": "0xC2C2C2", "hover": "0x51AAFE",
+                "active": "0x2175C8", "checked": "0x51AAFE",
+            }),
+            "RegularText": ThemeStyle("RegularText", {
+                "normal": "0xEAEAEA", "hover": "0x51AAFE",
+                "active": "0x2175C8", "checked": "0x51AAFE",
+                "disabled": "0x9B9B9B",
+            }),
+            "Hyperlink": ThemeStyle("Hyperlink", {"normal": "0x70D4FF", "hover": "0x1DBBFF"}),
+        },
+    )
+
+
+def default_light_theme() -> Theme:
+    """Create a default light theme from Acrobat's LightTheme.acrotheme."""
+    return Theme(
+        theme_id="LightTheme",
+        title="Light Theme",
+        icon_set="LightIcons",
+        styles={
+            "RegularBackground": ThemeStyle("RegularBackground", {"normal": "0xFAFAFA"}),
+            "ProminentBackground": ThemeStyle("ProminentBackground", {"normal": "0xEAEAEA", "hover": "0xE1E1E1"}),
+            "DocumentBackground": ThemeStyle("DocumentBackground", {"normal": "0x999999"}),
+            "Border": ThemeStyle("Border", {"normal": "0xCBCBCB"}),
+            "Icon": ThemeStyle("Icon", {
+                "normal": "0x6F6F6F", "hover": "0x2175C8",
+                "active": "0x0E539B", "checked": "0x2175C8",
+            }),
+            "RegularText": ThemeStyle("RegularText", {
+                "normal": "0x4D4D4D", "hover": "0x2175C8",
+                "active": "0x0E539B", "checked": "0x2175C8",
+                "disabled": "0x949494",
+            }),
+            "Hyperlink": ThemeStyle("Hyperlink", {"normal": "0x0252A3"}),
+        },
+    )
+
+
+# ── B177: Telemetry Endpoint Config Separation ────────────────────────
+
+
+@dataclass
+class TelemetryEndpoint:
+    """A telemetry endpoint (B177)."""
+    name: str
+    url: str
+    port: int = 443
+
+
+class TelemetryConfig:
+    """Telemetry endpoint configuration loaded from a config file (B177)."""
+
+    def __init__(self) -> None:
+        self._endpoints: dict[str, TelemetryEndpoint] = {}
+        self._enabled: bool = True
+
+    def set_endpoint(self, name: str, url: str, port: int = 443) -> None:
+        self._endpoints[name] = TelemetryEndpoint(name=name, url=url, port=port)
+
+    def get_endpoint(self, name: str) -> TelemetryEndpoint | None:
+        if not self._enabled:
+            return None
+        return self._endpoints.get(name)
+
+    def load_from_lines(self, lines: list[str]) -> None:
+        """Load config from key=value lines."""
+        for line in lines:
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            if "=" not in line:
+                continue
+            key, value = line.split("=", 1)
+            key = key.strip()
+            value = value.strip()
+            if key.endswith("-url"):
+                name = key[:-4]
+                port = 443
+                port_key = f"{name}-port"
+                if port_key in self._endpoints:
+                    port = self._endpoints[port_key].port
+                self.set_endpoint(name, value, port)
+            elif key.endswith("-port"):
+                name = key[:-5]
+                if name in self._endpoints:
+                    self._endpoints[name].port = int(value)
+                else:
+                    self._endpoints[name] = TelemetryEndpoint(name=name, url="", port=int(value))
+
+    def disable(self) -> None:
+        self._enabled = False
+
+    def enable(self) -> None:
+        self._enabled = True
+
+    def is_enabled(self) -> bool:
+        return self._enabled
+
+    def all_endpoints(self) -> list[str]:
+        return list(self._endpoints.keys())
+
+    def missing_endpoints(self, required: list[str]) -> list[str]:
+        """Return names of required endpoints that are missing."""
+        return [name for name in required if name not in self._endpoints]

algo_cli/intelligence/acrobat_manifests.py

@@ -0,0 +1,338 @@
+"""B154-B156, B162, B168, B171: Acrobat-derived manifest/tool/dependency patterns.
+
+- B154: Declarative Tool/App Manifest UI
+- B155: Edition / Entitlement Overlay Manifests
+- B156: Plugin Silo + Host Adapter Tree
+- B162: Web Plugin Version Map and Resource Provenance
+- B168: Explicit Dependency Manifest
+- B171: Declarative Task/Filter Registry
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+
+# ── B154: Declarative Tool/App Manifest UI ─────────────────────────────
+
+
+@dataclass
+class UIComponent:
+    """A single UI component in a declarative tool manifest."""
+    type: str
+    name: str = ""
+    label: str = ""
+    children: list["UIComponent"] = field(default_factory=list)
+    attributes: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class ToolCommand:
+    """A command declared in a tool manifest."""
+    name: str
+    execute_after_layout: bool = False
+    prompt_user: bool = False
+
+
+@dataclass
+class ToolManifest:
+    """Declarative tool/app manifest (B154).
+
+    Defines tools, panels, buttons, commands, and layouts without
+    hardcoding UI in Python.
+    """
+    id: str
+    title: str
+    version: str = "1.0"
+    requires_context: bool = False
+    commands: list[ToolCommand] = field(default_factory=list)
+    layouts: dict[str, list[UIComponent]] = field(default_factory=dict)
+    metadata: dict[str, str] = field(default_factory=dict)
+
+    def validate(self, command_registry: set[str], component_registry: set[str]) -> list[str]:
+        """Validate manifest against registries. Returns list of errors (empty = valid)."""
+        errors: list[str] = []
+        for cmd in self.commands:
+            if cmd.name not in command_registry:
+                errors.append(f"unknown command: {cmd.name}")
+        for layout_name, components in self.layouts.items():
+            for comp in components:
+                if comp.name and comp.name not in component_registry:
+                    errors.append(f"unbound component '{comp.name}' in layout '{layout_name}'")
+        return errors
+
+
+class ToolManifestLoader:
+    """Loads and validates tool manifests."""
+
+    def __init__(self) -> None:
+        self._manifests: dict[str, ToolManifest] = {}
+        self._command_registry: set[str] = set()
+        self._component_registry: set[str] = set()
+
+    def register_command(self, name: str) -> None:
+        self._command_registry.add(name)
+
+    def register_component(self, name: str) -> None:
+        self._component_registry.add(name)
+
+    def load(self, manifest: ToolManifest) -> list[str]:
+        """Load a manifest, returning validation errors. Empty list = success."""
+        errors = manifest.validate(self._command_registry, self._component_registry)
+        if not errors:
+            self._manifests[manifest.id] = manifest
+        return errors
+
+    def get(self, manifest_id: str) -> ToolManifest | None:
+        return self._manifests.get(manifest_id)
+
+    def all_manifests(self) -> list[ToolManifest]:
+        return list(self._manifests.values())
+
+
+# ── B155: Edition / Entitlement Overlay Manifests ──────────────────────
+
+
+@dataclass
+class EditionOverlay:
+    """An edition overlay for a tool (B155)."""
+    edition: str  # "reader", "pro", "enterprise", "local", "cloud"
+    disabled_commands: list[str] = field(default_factory=list)
+    hidden_components: list[str] = field(default_factory=list)
+    metadata_overrides: dict[str, str] = field(default_factory=dict)
+    paywall_message: str = ""
+
+
+@dataclass
+class ResolvedManifest:
+    """The effective manifest after overlay resolution."""
+    manifest: ToolManifest
+    disabled_commands: set[str] = field(default_factory=set)
+    hidden_components: set[str] = field(default_factory=set)
+    paywall_message: str = ""
+    edition: str = ""
+
+
+class EditionResolver:
+    """Resolves base tool manifest + edition overlay into effective manifest."""
+
+    def __init__(self) -> None:
+        self._overlays: dict[tuple[str, str], EditionOverlay] = {}
+
+    def register_overlay(self, tool_id: str, overlay: EditionOverlay) -> None:
+        self._overlays[(tool_id, overlay.edition)] = overlay
+
+    def resolve(self, tool_id: str, edition: str, entitled: bool = True) -> ResolvedManifest | None:
+        """Resolve a tool manifest with edition overlay."""
+        # In a real system, this would look up the base manifest
+        # For testing, we accept a simple resolution
+        overlay = self._overlays.get((tool_id, edition))
+        if overlay is None:
+            return None
+        if not entitled:
+            # Return a paywall-only manifest
+            return ResolvedManifest(
+                manifest=ToolManifest(id=tool_id, title=""),
+                disabled_commands=set(overlay.disabled_commands),
+                hidden_components=set(overlay.hidden_components),
+                paywall_message=overlay.paywall_message or "Not entitled",
+                edition=edition,
+            )
+        return ResolvedManifest(
+            manifest=ToolManifest(id=tool_id, title=""),
+            disabled_commands=set(overlay.disabled_commands),
+            hidden_components=set(overlay.hidden_components),
+            paywall_message="",
+            edition=edition,
+        )
+
+
+# ── B156: Plugin Silo + Host Adapter Tree ─────────────────────────────
+
+
+@dataclass
+class HostAdapter:
+    """A host-specific adapter for a plugin (B156)."""
+    host: str  # "word", "outlook", "autocad", etc.
+    version: str  # "2019", "365", etc.
+    platform: str  # "win", "mac", "linux"
+    path: str = ""
+    available: bool = True
+
+
+@dataclass
+class PluginSilo:
+    """A plugin silo with core capability and host adapters (B156)."""
+    id: str
+    name: str
+    core_api_version: str = "1.0"
+    adapters: list[HostAdapter] = field(default_factory=list)
+    shared_common: str = ""  # path to shared common utilities
+
+    def select_adapter(self, host: str, version: str, platform: str) -> HostAdapter | None:
+        """Select the best adapter for the given host/version/platform."""
+        # Try exact match first
+        for adapter in self.adapters:
+            if (
+                adapter.host == host
+                and adapter.version == version
+                and adapter.platform == platform
+                and adapter.available
+            ):
+                return adapter
+        # Try host + platform, any version
+        for adapter in self.adapters:
+            if adapter.host == host and adapter.platform == platform and adapter.available:
+                return adapter
+        # Try host only
+        for adapter in self.adapters:
+            if adapter.host == host and adapter.available:
+                return adapter
+        return None
+
+    def unsupported_hosts(self) -> list[str]:
+        """List hosts that have no available adapters."""
+        hosts_with_adapters = {a.host for a in self.adapters if a.available}
+        return sorted(set(a.host for a in self.adapters) - hosts_with_adapters)
+
+
+class PluginSiloRegistry:
+    """Registry of plugin silos."""
+
+    def __init__(self) -> None:
+        self._silos: dict[str, PluginSilo] = {}
+
+    def register(self, silo: PluginSilo) -> None:
+        self._silos[silo.id] = silo
+
+    def get(self, silo_id: str) -> PluginSilo | None:
+        return self._silos.get(silo_id)
+
+    def all_silos(self) -> list[PluginSilo]:
+        return list(self._silos.values())
+
+
+# ── B162: Web Plugin Version Map and Resource Provenance ───────────────
+
+
+@dataclass
+class ResourceProvenance:
+    """Provenance for a web resource (B162)."""
+    plugin_ids: list[str]
+    schema_version: int = 1
+    git_path: str = ""
+    git_commit: str = ""
+    git_repo: str = ""
+
+
+@dataclass
+class PluginGroup:
+    """A group of plugins with shared provenance (B162)."""
+    name: str
+    provenance: ResourceProvenance
+
+    def resolves(self, plugin_id: str) -> bool:
+        return plugin_id in self.provenance.plugin_ids
+
+
+class WebPluginVersionMap:
+    """Maps plugin IDs to code provenance, resource bundles, and versions."""
+
+    def __init__(self) -> None:
+        self._groups: dict[str, PluginGroup] = {}
+
+    def register(self, group: PluginGroup) -> None:
+        self._groups[group.name] = group
+
+    def resolve(self, plugin_id: str) -> PluginGroup | None:
+        """Resolve a plugin ID to its group."""
+        matches = [g for g in self._groups.values() if g.resolves(plugin_id)]
+        if len(matches) == 1:
+            return matches[0]
+        if len(matches) > 1:
+            # Ambiguous - return first but caller should check
+            return matches[0]
+        return None
+
+    def provenance(self, plugin_id: str) -> ResourceProvenance | None:
+        group = self.resolve(plugin_id)
+        return group.provenance if group else None
+
+    def all_groups(self) -> list[PluginGroup]:
+        return list(self._groups.values())
+
+
+# ── B168: Explicit Dependency Manifest ─────────────────────────────────
+
+
+@dataclass
+class DependencyEntry:
+    """A single dependency declaration (B168)."""
+    name: str
+    required: bool = True
+    version: str = ""
+
+
+@dataclass
+class DependencyManifest:
+    """Explicit dependency manifest (B168)."""
+    identity_name: str
+    version: str = "1.0.0"
+    arch: str = "amd64"
+    files: list[DependencyEntry] = field(default_factory=list)
+    external_dependencies: list[str] = field(default_factory=list)
+
+    def check(self, existing_files: set[str]) -> tuple[list[str], list[str]]:
+        """Check dependencies against existing files.
+        Returns (missing_required, missing_optional).
+        """
+        missing_required: list[str] = []
+        missing_optional: list[str] = []
+        for dep in self.files:
+            if dep.name not in existing_files:
+                if dep.required:
+                    missing_required.append(dep.name)
+                else:
+                    missing_optional.append(dep.name)
+        return missing_required, missing_optional
+
+
+# ── B171: Declarative Task/Filter Registry ─────────────────────────────
+
+
+@dataclass
+class TaskFilter:
+    """A task/filter mapping (B171)."""
+    menu_item_id: str
+    filter_id: str
+    handler: Callable[[dict], Any] | None = None
+
+
+class TaskFilterRegistry:
+    """Maps user-facing menu items to format handlers via filter IDs (B171)."""
+
+    def __init__(self) -> None:
+        self._tasks: dict[str, TaskFilter] = {}
+        self._handlers: dict[str, Callable[[dict], Any]] = {}
+
+    def register(self, task: TaskFilter) -> None:
+        self._tasks[task.menu_item_id] = task
+        if task.handler:
+            self._handlers[task.filter_id] = task.handler
+
+    def register_handler(self, filter_id: str, handler: Callable[[dict], Any]) -> None:
+        self._handlers[filter_id] = handler
+
+    def dispatch(self, menu_item_id: str, context: dict | None = None) -> Any:
+        """Dispatch a menu item to its handler."""
+        task = self._tasks.get(menu_item_id)
+        if not task:
+            raise KeyError(f"unknown task: {menu_item_id}")
+        handler = self._handlers.get(task.filter_id)
+        if not handler:
+            raise KeyError(f"no handler for filter: {task.filter_id}")
+        return handler(context or {})
+
+    def available_tasks(self) -> list[str]:
+        return list(self._tasks.keys())