omoctl 0.1.0__py3-none-any.whl

omoctl/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

omoctl/__main__.py

@@ -0,0 +1,3 @@
+from omoctl.cli import main
+
+main()

omoctl/cli.py

@@ -0,0 +1,268 @@
+from __future__ import annotations
+
+import argparse
+import sys
+
+from omoctl import __version__
+from omoctl.config import load_config
+from omoctl.models import enrich_cache_with_omo, load_model_cache
+from omoctl.omo import fetch_omo_config
+from omoctl.validate import print_validation_result, validate_config
+from omoctl.output import (
+    BOLD,
+    DIM,
+    GREEN,
+    RESET,
+    die,
+    print_diff,
+    print_profile_list,
+    print_profile_status,
+    print_section,
+)
+from omoctl.paths import ACTIVE_CONFIG_PATH
+from omoctl.patching import apply_patches_to_config
+from omoctl.store import (
+    activate_profile,
+    cleanup_stale,
+    get_active_alias,
+    get_profile_config,
+    save_profile,
+    remove_profile,
+)
+
+
+def cmd_status(_args: argparse.Namespace) -> None:
+    config = load_config()
+    active_alias = get_active_alias()
+
+    profile = None
+    if config.active_profile:
+        profile = config.find_profile(config.active_profile)
+    if profile is None and active_alias:
+        profile = config.find_profile(active_alias)
+
+    if profile is None:
+        print(f"{DIM}No active profile.{RESET}")
+        print(f"{DIM}Run 'omoctl list' to see available profiles.{RESET}")
+        return
+
+    print_profile_status(profile.name, profile.alias, profile.providers)
+
+
+def cmd_list(_args: argparse.Namespace) -> None:
+    config = load_config()
+    active_profile = config.get_active_profile()
+    active_alias = (
+        active_profile.alias if active_profile else get_active_alias()
+    )
+
+    profiles = [
+        (p.name, p.alias, p.providers) for p in config.profiles
+    ]
+
+    if not profiles:
+        print(f"{DIM}No profiles defined in config.{RESET}")
+        return
+
+    print_profile_list(profiles, active_alias)
+
+
+def cmd_switch(args: argparse.Namespace) -> None:
+    config = load_config()
+    profile = config.find_profile(args.profile)
+
+    if profile is None:
+        die(f"Profile {args.profile!r} not found. Run 'omoctl list' to see available profiles.")
+
+    stored_config = get_profile_config(profile.alias)
+    if stored_config is None:
+        die(
+            f"Profile {profile.name!r} has no stored config.\n"
+            f"  Run 'omoctl update {profile.alias}' first to fetch and build it."
+        )
+
+    activate_profile(profile.alias, profile.name, stored_config)
+    print(f"{GREEN}Switched to profile: {BOLD}{profile.name}{RESET}")
+
+
+def cmd_update(args: argparse.Namespace) -> None:
+    config = load_config()
+
+    if args.profile:
+        profile = config.find_profile(args.profile)
+        if profile is None:
+            die(f"Profile {args.profile!r} not found.")
+        profiles = [profile]
+    else:
+        profiles = list(config.profiles)
+
+    cache = load_model_cache()
+
+    active_profile = config.get_active_profile()
+    active_alias = active_profile.alias if active_profile else get_active_alias()
+
+    for idx, profile in enumerate(profiles):
+        if idx:
+            print()
+        print_section(profile.name)
+        print()
+
+        omo_config = fetch_omo_config(tuple(profile.providers))
+        enriched_cache = enrich_cache_with_omo(cache, omo_config)
+
+        curr_config = get_profile_config(profile.alias)
+
+        patched_config, keys = apply_patches_to_config(
+            enriched_cache, profile, omo_config, config,
+        )
+
+        save_profile(profile.alias, profile.name, patched_config)
+
+        print_diff(curr_config, patched_config, keys)
+
+    to_activate = config.get_active_profile()
+    if not to_activate and active_alias:
+        to_activate = config.find_profile(active_alias)
+    if to_activate:
+        stored = get_profile_config(to_activate.alias)
+        if stored:
+            activate_profile(to_activate.alias, to_activate.name, stored)
+
+    valid_aliases = {p.alias for p in config.profiles}
+    cleanup_stale(valid_aliases)
+
+
+def cmd_remove(args: argparse.Namespace) -> None:
+    config = load_config()
+    profile = config.find_profile(args.profile)
+
+    if profile is None:
+        die(f"Profile {args.profile!r} not found.")
+
+    remove_profile(profile.alias)
+    print(f"{GREEN}Removed profile: {BOLD}{profile.name}{RESET}")
+    print(f"{DIM}Note: the profile definition is still in config.yaml. Edit it to remove permanently.{RESET}")
+
+
+def cmd_validate(_args: argparse.Namespace) -> None:
+    config = load_config()
+    cache = load_model_cache()
+
+    all_providers = set()
+    for profile in config.profiles:
+        all_providers.update(profile.providers)
+    omo_config = fetch_omo_config(tuple(sorted(all_providers)), quiet=True)
+    enriched_cache = enrich_cache_with_omo(cache, omo_config)
+
+    errors = validate_config(config, enriched_cache)
+    if not print_validation_result(errors):
+        sys.exit(1)
+
+
+def cmd_show(args: argparse.Namespace) -> None:
+    if args.alias:
+        alias = get_active_alias()
+        if not alias:
+            die("No active profile. Run 'omoctl switch <profile>' first.")
+        print(alias)
+        return
+
+    if args.name:
+        alias = get_active_alias()
+        if not alias:
+            die("No active profile. Run 'omoctl switch <profile>' first.")
+        config = load_config()
+        profile = config.find_profile(alias)
+        if profile is None:
+            die(f"Active alias {alias!r} is not defined in config.yaml.")
+        print(profile.name)
+        return
+
+    if not ACTIVE_CONFIG_PATH.exists():
+        die(
+            f"No active config at {ACTIVE_CONFIG_PATH}.\n"
+            f"  Run 'omoctl switch <profile>' or 'omoctl update' first."
+        )
+
+    if args.json:
+        print(ACTIVE_CONFIG_PATH.read_text())
+        return
+
+    alias = get_active_alias()
+    config = load_config()
+    profile = config.find_profile(alias) if alias else None
+
+    if profile:
+        print(
+            f"{BOLD}Profile:{RESET} "
+            f"{GREEN}{profile.name}{RESET} {DIM}({profile.alias}){RESET}"
+        )
+    elif alias:
+        print(f"{BOLD}Profile:{RESET} {DIM}{alias}{RESET}")
+    print()
+    print(ACTIVE_CONFIG_PATH.read_text())
+
+
+def cmd_version(_args: argparse.Namespace) -> None:
+    print(f"omoctl {__version__}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="omoctl",
+        description="Manage oh-my-openagent (OMO) profiles",
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"omoctl {__version__}",
+    )
+    parser.set_defaults(func=cmd_status)
+
+    sub = parser.add_subparsers(dest="command")
+
+    list_p = sub.add_parser("list", help="List all profiles")
+    list_p.set_defaults(func=cmd_list)
+
+    switch_p = sub.add_parser("switch", help="Switch to a profile")
+    switch_p.add_argument("profile", help="Profile name or alias")
+    switch_p.set_defaults(func=cmd_switch)
+
+    update_p = sub.add_parser("update", help="Update profiles (fetch + patch + save)")
+    update_p.add_argument("profile", nargs="?", default=None, help="Profile name or alias (all if omitted)")
+    update_p.set_defaults(func=cmd_update)
+
+    remove_p = sub.add_parser("remove", help="Remove a stored profile")
+    remove_p.add_argument("profile", help="Profile name or alias")
+    remove_p.set_defaults(func=cmd_remove)
+
+    validate_p = sub.add_parser("validate", help="Validate config against available models/agents")
+    validate_p.set_defaults(func=cmd_validate)
+
+    show_p = sub.add_parser(
+        "show", help="Show the active profile (header + JSON by default)"
+    )
+    show_mode = show_p.add_mutually_exclusive_group()
+    show_mode.add_argument(
+        "-a", "--alias", action="store_true",
+        help="Print only the active profile alias",
+    )
+    show_mode.add_argument(
+        "-n", "--name", action="store_true",
+        help="Print only the active profile name",
+    )
+    show_mode.add_argument(
+        "-j", "--json", action="store_true",
+        help="Print only the raw JSON config (no header)",
+    )
+    show_p.set_defaults(func=cmd_show)
+
+    version_p = sub.add_parser("version", help="Print version")
+    version_p.set_defaults(func=cmd_version)
+
+    args = parser.parse_args()
+    try:
+        args.func(args)
+    except KeyboardInterrupt:
+        print("\nAborted.", file=sys.stderr)
+        sys.exit(130)

omoctl/config.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+import dataclasses
+import re
+import typing
+
+import dacite
+import yaml
+
+from omoctl.output import die
+from omoctl.paths import CONFIG_DIR, CONFIG_PATH, PROFILES_DIR
+from omoctl.types import _UNSET
+
+
+@dataclasses.dataclass
+class PatchSource:
+    provider: str | None = None
+    model: typing.Any = None
+    agent: str | None = None
+    category: str | None = None
+
+
+@dataclasses.dataclass
+class PatchTarget:
+    provider: str | None = None
+    model: typing.Any = None
+    variant: typing.Any = dataclasses.field(default=_UNSET)
+
+
+@dataclasses.dataclass
+class Patch:
+    source: PatchSource = dataclasses.field(default_factory=PatchSource)
+    target: PatchTarget = dataclasses.field(default_factory=PatchTarget)
+
+
+@dataclasses.dataclass
+class Profile:
+    name: str = ""
+    providers: list[str] = dataclasses.field(default_factory=list)
+    patches: list[Patch] | None = None
+    overrides: dict | None = None
+
+    @property
+    def alias(self) -> str:
+        return re.sub(r"[^a-z0-9]+", "-", self.name.lower()).strip("-")[:50]
+
+
+@dataclasses.dataclass
+class Config:
+    active_profile: str | None = None
+    defaults: dict | None = None
+    patches: list[Patch] | None = None
+    profiles: list[Profile] = dataclasses.field(default_factory=list)
+
+    def find_profile(self, name_or_alias: str) -> Profile | None:
+        key = name_or_alias.lower()
+        for profile in self.profiles:
+            if profile.name.lower() == key or profile.alias == key:
+                return profile
+        return None
+
+    def get_active_profile(self) -> Profile | None:
+        if self.active_profile is None:
+            return None
+        return self.find_profile(self.active_profile)
+
+    def get_effective_patches(self, profile: Profile) -> list[Patch]:
+        result: list[Patch] = []
+        if profile.patches:
+            result.extend(profile.patches)
+        if self.patches:
+            result.extend(self.patches)
+        return result
+
+    def get_effective_overrides(self, profile: Profile) -> dict | None:
+        if not self.defaults and not profile.overrides:
+            return None
+        result = dict(self.defaults) if self.defaults else {}
+        if profile.overrides:
+            result = merge_dicts(result, profile.overrides)
+        return result or None
+
+
+def merge_dicts(
+    base: dict[str, typing.Any], override: dict[str, typing.Any]
+) -> dict[str, typing.Any]:
+    result = base.copy()
+    for key, value in override.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = merge_dicts(result[key], value)
+        else:
+            result[key] = value
+    return result
+
+
+_DACITE_CONFIG = dacite.Config(check_types=False, strict=True)
+
+_DEFAULT_YAML = """\
+# active_profile: my-profile
+
+defaults:
+  disabled_hooks:
+    - context-window-monitor
+
+# patches:
+#   - source: { provider: google }
+#     target: { provider: proxy }
+
+profiles:
+  - name: Claude
+    providers: [claude]
+
+  - name: No Copilot
+    providers: [claude, gemini, openai]
+"""
+
+
+def load_config() -> Config:
+    if not CONFIG_PATH.exists():
+        CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+        PROFILES_DIR.mkdir(parents=True, exist_ok=True)
+        CONFIG_PATH.write_text(_DEFAULT_YAML)
+        die(
+            f"No config found. A default has been created at {CONFIG_PATH}\n"
+            f"  Edit it to define your profiles and re-run."
+        )
+
+    try:
+        with CONFIG_PATH.open() as f:
+            data = yaml.safe_load(f)
+    except yaml.YAMLError as e:
+        die(f"Config at {CONFIG_PATH} has invalid YAML:\n  {e}")
+
+    if not data or not data.get("profiles"):
+        die(f"No profiles defined in {CONFIG_PATH}. Add at least one profile.")
+
+    try:
+        config = dacite.from_dict(Config, data, config=_DACITE_CONFIG)
+    except dacite.DaciteError as e:
+        die(f"Config at {CONFIG_PATH} has invalid structure:\n  {e}")
+
+    seen_aliases: dict[str, str] = {}
+    for profile in config.profiles:
+        if not profile.name:
+            die("Each profile must have a 'name' field.")
+        if not profile.providers:
+            die(f"Profile {profile.name!r} must have a 'providers' field.")
+        if profile.alias in seen_aliases:
+            die(
+                f"Profile {profile.name!r} produces alias {profile.alias!r} "
+                f"which collides with profile {seen_aliases[profile.alias]!r}.\n"
+                f"  Rename one of them so they produce distinct aliases."
+            )
+        seen_aliases[profile.alias] = profile.name
+
+    return config

omoctl/models.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+import dataclasses
+import itertools
+import json
+import re
+import typing
+
+from omoctl.output import die
+from omoctl.paths import CACHED_MODELS_PATH, CUSTOM_MODELS_PATH
+from omoctl.types import ModelFilter, ModelProps
+
+DATED_MODEL_PATTERN: typing.Final[re.Pattern] = re.compile(
+    r".*("
+    r"\d{6,}"
+    r"|20\d{2}[-]\d{2}([-]\d{2})?"
+    r"|\d{2}[-]20\d{2}"
+    r"|\d{2}[-]\d{2}"
+    r")$"
+)
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class ModelCache:
+    provider_to_models: dict[str, tuple[str, ...]]
+    agent_names: tuple[str, ...] = ()
+    category_names: tuple[str, ...] = ()
+
+
+def load_model_cache() -> ModelCache:
+    if not CACHED_MODELS_PATH.exists():
+        die(
+            f"Model cache not found at {CACHED_MODELS_PATH}.\n"
+            f"  Run 'opencode' once to populate it."
+        )
+
+    try:
+        with CACHED_MODELS_PATH.open() as f:
+            data = json.load(f)
+    except json.JSONDecodeError as e:
+        die(f"Model cache at {CACHED_MODELS_PATH} is malformed:\n  {e}")
+
+    custom_data: dict = {}
+    if CUSTOM_MODELS_PATH.exists():
+        try:
+            with CUSTOM_MODELS_PATH.open() as f:
+                custom_data = json.load(f).get("provider", {})
+        except json.JSONDecodeError as e:
+            die(f"Custom models at {CUSTOM_MODELS_PATH} is malformed:\n  {e}")
+
+    providers = set(data.keys()) | set(custom_data.keys())
+
+    provider_to_models: dict[str, tuple[str, ...]] = {}
+    for provider in providers:
+        models: set[str] = set()
+        for source_data in (data, custom_data):
+            if provider in source_data and "models" in source_data[provider]:
+                provider_models = source_data[provider]["models"]
+                if isinstance(provider_models, dict):
+                    models.update(provider_models.keys())
+
+        provider_to_models[provider] = tuple(
+            sorted(
+                models,
+                key=lambda model_id: (
+                    bool(DATED_MODEL_PATTERN.match(model_id)),
+                    not model_id.endswith("latest"),
+                    len(model_id),
+                ),
+            )
+        )
+
+    return ModelCache(
+        provider_to_models=provider_to_models,
+    )
+
+
+def enrich_cache_with_omo(cache: ModelCache, omo_config: dict) -> ModelCache:
+    return ModelCache(
+        provider_to_models=cache.provider_to_models,
+        agent_names=tuple(sorted(omo_config.get("agents", {}).keys())),
+        category_names=tuple(sorted(omo_config.get("categories", {}).keys())),
+    )
+
+
+def _numbers_key(numbers: tuple[str, ...]) -> tuple[int, ...]:
+    return tuple(int(n) for n in numbers) if numbers else ()
+
+
+def find_best_matching_model(
+    provider_to_models: dict[str, tuple[str, ...]],
+    original_provider: str | None,
+    original_model: str | None,
+    target_provider: str,
+    target_hint: ModelFilter | str | None,
+) -> str:
+    if target_provider not in provider_to_models:
+        die(f"Target provider {target_provider!r} not found in cached models.")
+
+    if isinstance(target_hint, str):
+        if target_hint in provider_to_models[target_provider]:
+            return f"{target_provider}/{target_hint}"
+        die(
+            f"Explicit model {target_hint!r} not found in provider {target_provider!r}."
+        )
+
+    original_props = (
+        ModelProps.from_model_id(original_model) if original_model else None
+    )
+
+    if target_hint is not None:
+        include_words = target_hint.words_include
+        exclude_words = target_hint.words_exclude
+        include_numbers = target_hint.numbers_include
+        exclude_numbers = target_hint.numbers_exclude
+    else:
+        include_words = ()
+        exclude_words = ()
+        include_numbers = ()
+        exclude_numbers = ()
+
+    if not target_hint and original_props:
+        include_words = original_props.words
+        include_numbers = original_props.numbers
+
+    version_specified = bool(include_numbers) or bool(
+        original_props and original_props.numbers
+    )
+
+    def _matches(props: ModelProps) -> bool:
+        return (
+            all(w in props.words for w in include_words)
+            and not any(w in props.words for w in exclude_words)
+            and all(n in props.numbers for n in include_numbers)
+            and not any(n in props.numbers for n in exclude_numbers)
+        )
+
+    candidates: list[tuple[str, ModelProps]] = []
+    for model_id in provider_to_models[target_provider]:
+        props = ModelProps.from_model_id(model_id)
+        if props is not None and _matches(props):
+            candidates.append((model_id, props))
+
+    if not candidates and version_specified:
+        for model_id in provider_to_models[target_provider]:
+            props = ModelProps.from_model_id(model_id)
+            if props is None:
+                continue
+            if all(w in props.words for w in include_words) and not any(
+                w in props.words for w in exclude_words
+            ):
+                candidates.append((model_id, props))
+
+    if not candidates:
+        die(
+            f"No matching model for {original_model!r} from "
+            f"{original_provider!r} in provider {target_provider!r}."
+        )
+
+    original_words = set(original_props.words) if original_props else set()
+    original_numbers = original_props.numbers if original_props else ()
+    target_version = _numbers_key(include_numbers or original_numbers)
+
+    def _sort_key(entry: tuple[str, ModelProps]) -> tuple:
+        model_id, props = entry
+        version = _numbers_key(props.numbers)
+        word_overlap = -len(original_words & set(props.words)) if original_words else 0
+
+        return (
+            (props.provider_prefix or "") != (original_provider or ""),
+            word_overlap,
+            bool(DATED_MODEL_PATTERN.match(model_id)),
+            "latest" in props.words,
+            tuple(
+                abs(a - b)
+                for a, b in itertools.zip_longest(version, target_version, fillvalue=0)
+            )
+            if version_specified
+            else tuple(-v for v in version),
+            len(model_id),
+        )
+
+    candidates.sort(key=_sort_key)
+    return f"{target_provider}/{candidates[0][0]}"