Skip to content

hashgraph-online/awesome-codex-plugins / plugins/beastlabai/multi-llm-plugin/skills/multi-llm

multi-llm

Flagged

Orchestrate plan reviews, task generation, implementation and code reviews across several LLM CLIs in parallel, or ask every model one free-text question about a plan. Use when the user says: review my plan, multi-llm, run a code review, generate tasks from a plan, implement this plan, ask the models about my plan.

FileKindSize
SKILL.mdskill md4.0 KB
apply_code_fixes_orchestrator.pyscript57.0 KB
apply_commit_fixes_orchestrator.pyscript2.3 KB
apply_suggestions_orchestrator.pyscript4.6 KB
apply_task_suggestions_orchestrator.pyscript19.2 KB
ask_orchestrator.pyscript162.5 KB
assets/icons/Anthropic.svgother584 B
assets/icons/Codex.svgother1.3 KB
assets/icons/Copilot.svgother1.5 KB
assets/icons/Cursor.svgother793 B
assets/icons/GoogleGemini.svgother623 B
assets/icons/Goose.svgother3.2 KB
assets/icons/Kilocode.svgother531 B
assets/icons/MiniMax.pngbinary1.5 KB
assets/icons/Mistral.svgother717 B
assets/icons/MoonshotAI.svgother957 B
assets/icons/Nvidia.svgother2.4 KB
assets/icons/OhMyPi.svgother434 B
assets/icons/OpenAI.svgother1.7 KB
assets/icons/Opencode.svgother325 B
assets/icons/Pi.svgother440 B
assets/icons/Qwen.svgother1.7 KB
assets/icons/Zhipu.pngbinary442 B
assets/icons/xAI.svgother343 B
assets/omp/overlay.ymlconfig2.4 KB
check_workflow_prerequisites.pyscript77.8 KB
code_review_orchestrator.pyscript326.3 KB
display_decisions.pyscript9.8 KB
finalize_tracking.pyscript1.3 KB
full_workflow_orchestrator.pyscript69.7 KB
generate_tasks_orchestrator.pyscript44.2 KB
hosts/capabilities.yamlconfig50.2 KB
hosts/codex/plugin-skill.md.tmplother2.8 KB
hosts/codex/shim.md.tmplother7.3 KB
hosts/opencode/plugin-command.md.tmplother2.2 KB
hosts/opencode/shim.md.tmplother6.8 KB
hosts/render_capabilities.pyscript48.4 KB
hosts/snippets/poll-loop.mdmarkdown4.4 KB
hosts/snippets/uv-preflight.mdmarkdown2.2 KB
hosts/uv-missing.txtmarkdown1.5 KB
implement_orchestrator.pyscript156.4 KB
improve_code_orchestrator.pyscript1.6 KB
improve_commits_orchestrator.pyscript2.5 KB
improve_plan_orchestrator.pyscript1.6 KB
init_config.pyscript58.0 KB
instructions/apply-code-fixes.mdmarkdown56.2 KB
instructions/apply-commit-fixes.mdmarkdown10.3 KB
instructions/apply-suggestions.mdmarkdown48.9 KB
instructions/apply-task-suggestions.mdmarkdown54.5 KB
instructions/ask.mdmarkdown27.6 KB
instructions/full-workflow.mdmarkdown25.3 KB
instructions/generate-tasks.mdmarkdown18.1 KB
instructions/implement.mdmarkdown55.8 KB
instructions/improve-code.mdmarkdown25.7 KB
instructions/improve-commits.mdmarkdown25.5 KB
instructions/improve-plan.mdmarkdown26.7 KB
instructions/init-config.mdmarkdown6.6 KB
instructions/review-code.mdmarkdown44.0 KB
instructions/review-commits.mdmarkdown11.4 KB
instructions/review-plan.mdmarkdown38.8 KB
instructions/review-tasks.mdmarkdown38.2 KB
modes.pyscript58.8 KB
multi_llm.pyscript101.1 KB
prompts/ask.txtmarkdown948 B
prompts/code_review.txtmarkdown4.5 KB
prompts/commit_review.txtmarkdown6.2 KB
prompts/consolidate_suggestions.txtmarkdown3.1 KB
prompts/implementation_task.txtmarkdown1.4 KB
prompts/plan_review.txtmarkdown8.0 KB
prompts/task_review.txtmarkdown8.3 KB
providers.yamlconfig20.7 KB
pyproject.tomlmanifest7.0 KB
references/apply-write-executor.mdmarkdown3.5 KB
references/consolidation.mdmarkdown5.6 KB
references/host-capabilities.mdmarkdown13.5 KB
references/human-decision-batch.mdmarkdown17.2 KB
references/implement-prerequisites.mdmarkdown6.0 KB
references/implement-write-executor.mdmarkdown5.4 KB
references/interrupted-run-recovery.mdmarkdown3.1 KB
references/own-check.mdmarkdown4.3 KB
references/resume-detection.mdmarkdown8.5 KB
references/revalidation.mdmarkdown6.9 KB
references/review-code-apply-fixes.mdmarkdown4.3 KB
references/salvage-handling.mdmarkdown12.5 KB
references/summary-format.mdmarkdown10.0 KB
references/uv-check.mdmarkdown5.7 KB
references/wave-batching.mdmarkdown5.2 KB
review_commits_orchestrator.pyscript2.3 KB
review_plan_orchestrator.pyexecutablescript24.6 KB
review_tasks_orchestrator.pyscript10.7 KB
schemas/cascade_record.schema.jsonconfig6.6 KB
schemas/code_review_issues.schema.jsonconfig2.0 KB
schemas/consolidated.schema.jsonconfig6.8 KB
schemas/consolidation_batch.schema.jsonconfig3.7 KB
schemas/generated_tasks.schema.jsonconfig3.1 KB
schemas/host_capabilities.schema.jsonconfig38.3 KB
schemas/human_decision_verdicts.schema.jsonconfig2.6 KB
schemas/result_line.schema.jsonconfig10.1 KB
schemas/review_suggestions.schema.jsonconfig2.4 KB
schemas/state_file.schema.jsonconfig23.3 KB
schemas/status_file.schema.jsonconfig24.9 KB
schemas/status_json.schema.jsonconfig10.8 KB
schemas/subagent_tasks.schema.jsonconfig20.5 KB
schemas/task_decomposition.schema.jsonconfig1.2 KB
schemas/write_batch_result.schema.jsonconfig8.8 KB
templates/config/providers.override.yamlconfig17.8 KB
templates/consolidated_report_template.htmlother44.1 KB
templates/pr_report_template.htmlother181.2 KB
templates/report_template.htmlother67.5 KB
templates/shared/report_core.cssother4.1 KB
templates/shared/report_core.jsscript25.5 KB
update_plan_tasks.pyscript20.9 KB
utils/__init__.pyscript284 B
utils/advisory.pyscript4.8 KB
utils/apply_orchestrator_base.pyscript229.0 KB
utils/apply_output_helpers.pyscript10.9 KB
utils/apply_path_helpers.pyscript683 B
utils/apply_report.pyscript51.6 KB
utils/apply_selection_helpers.pyscript6.8 KB
utils/apply_suggestion_phase.pyscript11.7 KB
utils/atomic_io.pyscript12.9 KB
utils/attempt_classifier.pyscript33.2 KB
utils/backup.pyscript2.0 KB
utils/batch_done.pyscript81.3 KB
utils/batch_ledger.pyscript27.7 KB
utils/batch_prompt.pyscript30.1 KB
utils/batch_prompt_builder.pyscript13.2 KB
utils/batch_reply.pyscript32.9 KB
utils/batch_suppressions.pyscript15.5 KB
utils/cascade_archive.pyscript50.6 KB
utils/cascade_ledger.pyscript39.3 KB
utils/cascade_provenance.pyscript22.0 KB
utils/check_records.pyscript59.7 KB
utils/check_reply.pyscript9.5 KB
utils/check_tree.pyscript1.2 KB
utils/cli_common.pyscript94.3 KB
utils/cli_version_cache.pyscript14.0 KB
utils/clock.pyscript3.5 KB
utils/code_fix_batcher.pyscript31.4 KB
utils/codex_trust.pyscript12.9 KB
utils/commit_apply.pyscript73.3 KB
utils/commit_attribution.pyscript21.2 KB
utils/commit_brief.pyscript32.2 KB
utils/commit_front_door.pyscript81.9 KB
utils/commit_paths.pyscript18.0 KB
utils/commit_range.pyscript61.2 KB
utils/commit_report.pyscript19.9 KB
utils/commit_review.pyscript413 B
utils/commit_spelling.pyscript7.9 KB
utils/commit_write_guard.pyscript9.9 KB
utils/concurrency.pyscript11.6 KB
utils/consolidation.pyscript89.0 KB
utils/detach.pyscript187.9 KB
utils/dispatch_spawn.pyscript62.4 KB
utils/doctor.pyscript76.7 KB
utils/env_vars.pyscript20.5 KB
utils/failure_capture.pyscript10.1 KB
utils/file_discovery.pyscript11.0 KB
utils/filtering.pyscript19.9 KB
utils/fresh_reset.pyscript3.9 KB
utils/git_diff.pyscript23.6 KB
utils/git_utils.pyscript86.6 KB
utils/held_folder.pyscript21.3 KB
utils/host_capabilities.pyscript48.0 KB
utils/host_install.pyscript77.6 KB
utils/host_paths.pyscript12.0 KB
utils/host_routes/__init__.pyscript5.7 KB
utils/host_routes/codex.pyscript18.3 KB
utils/host_routes/npm.pyscript12.2 KB
utils/host_shim.pyscript14.7 KB
utils/html_report_generator.pyscript118.9 KB
utils/human_decisions.pyscript38.3 KB
utils/human_task_plan.pyscript30.2 KB
utils/importance.pyscript6.2 KB
utils/improve_cascade.pyscript63.7 KB
utils/improve_cascade_next.pyscript22.2 KB
utils/improve_steps.pyscript33.1 KB
utils/improve_workflow.pyscript120.9 KB
utils/interactive.pyscript31.6 KB
utils/json_extractor.pyscript83.1 KB
utils/judge_vocab.pyscript5.3 KB
utils/known_checks.pyscript41.6 KB
utils/landlock_dispatch.pyscript103.8 KB
utils/landlock_exec.pyscript21.4 KB
utils/launch_limiter.pyscript13.5 KB
utils/llm_client.pyscript142.7 KB
utils/manual_tasks.pyscript14.9 KB
utils/metrics.pyscript68.1 KB
utils/next_phase.pyscript96.7 KB
utils/next_phase_words.pyscript6.4 KB
utils/output_handler.pyscript23.2 KB
utils/phase_walk.pyscript6.4 KB
utils/plan_updater.pyscript17.9 KB
utils/positionals.pyscript5.8 KB
utils/prior_changes.pyscript28.7 KB
utils/probe_state.pyscript17.9 KB
utils/process_capture.pyscript44.1 KB
utils/process_control.pyscript228.7 KB
utils/process_state.pyscript6.6 KB
utils/progress_tracker.pyscript92.2 KB

utils/host_routes/npm.py

View on GitHub
"""The npm route resolver: a spec declared in the host's JSON config, then one stat.

Config first, cache second (see :func:`_npm_route`). Used by
``host_install.package_route`` through its ``_ROUTE_RESOLVERS`` table.
"""

from __future__ import annotations

import json
import os
import re
from pathlib import Path
from typing import Any, Dict, List, Optional, Tuple

from . import PackageRoute

from ..host_paths import (
    SCOPE_GLOBAL,
    SCOPE_PROJECT,
    Refused,
    _is_user_rooted,
    _join,
    checked_entry,
    expand_path_tokens,
    user_home,
)
from ..json_extractor import strip_jsonc as _strip_jsonc


def _package_name(spec: str) -> str:
    """A spec's package name: strip a trailing ``@<range>``, keep a leading scope."""
    if spec.startswith("@"):
        scope, _, rest = spec.partition("/")
        return f"{scope}/{rest.split('@', 1)[0]}" if rest else spec
    return spec.split("@", 1)[0]


def _config_dirs(
    host_id: str,
    entry: Dict[str, Any],
    *,
    env: Optional[Dict[str, str]] = None,
    project_root: Optional[Path] = None,
) -> List[Path]:
    """The config directories a command directory *implies*, in merge order.

    Derived from ``install_paths`` rather than restated: a command directory's
    *parent* is the config directory, which is the same relation on every host
    that has both. That keeps this probe out of the business of knowing where a
    given host keeps its config, which is exactly the kind of second table this
    project refuses to maintain.

    It is only ever **half** the set, and the half a command directory can reach:
    a host also reads config from places it installs no command into — an
    environment redirect, a per-user ``~/.<host>`` — and those are added by
    :func:`_config_files`, which is what a route probe must iterate.
    """
    dirs: List[Path] = []
    for scope in (SCOPE_PROJECT, SCOPE_GLOBAL):
        for raw in entry["install_paths"].get(scope) or []:
            try:
                expanded = expand_path_tokens(
                    raw, env=env, project_root=project_root
                )
            except Refused:
                continue
            parent = expanded.parent
            if parent not in dirs:
                dirs.append(parent)
    return dirs


def _config_env_names(host_id: str) -> Tuple[str, str]:
    """``($<HOST>_CONFIG, $<HOST>_CONFIG_DIR)`` — the redirect pair, derived.

    A convention rather than a per-host table: the host id upper-cased with
    non-alphanumerics folded to ``_``. Deriving the names is what keeps a second
    "where does this host keep its config" map out of this file, and a wrong
    guess costs nothing — an unset variable contributes no candidate and the
    derived directories still answer. OpenCode's pair is exactly this pair.
    """
    stem = re.sub(r"[^A-Z0-9]+", "_", host_id.upper()).strip("_")
    return f"{stem}_CONFIG", f"{stem}_CONFIG_DIR"


def _project_config_dirs(
    entry: Dict[str, Any],
    *,
    env: Optional[Dict[str, str]] = None,
    project_root: Optional[Path] = None,
) -> List[Path]:
    """The project config directories, walked upward from *project_root*.

    A host that merges a project ``.opencode`` merges the tree's, not only the
    one sitting in the directory a command happened to run in, so the same name
    is looked for in each ancestor, nearest first. The directory *name* is
    derived and never restated: it is the first segment of each project-scope
    ``install_paths`` entry (``.opencode/commands`` → ``.opencode``).

    **The walk is bounded on purpose.** It stops at the worktree root — the first
    ancestor holding a ``.git`` — or at the user's home, whichever comes first.
    Climbing past either reads a tree the project does not belong to, and
    answering with somebody else's declaration is exactly the false positive this
    whole probe is arranged to avoid.
    """
    start = Path(os.path.abspath(
        str(project_root) if project_root is not None else os.getcwd()
    ))
    names: List[str] = []
    for raw in entry["install_paths"].get(SCOPE_PROJECT) or []:
        if _is_user_rooted(raw):
            continue
        try:
            text = checked_entry(raw)
        except Refused:
            continue
        head = next(
            (segment for segment in re.split(r"[/\\]", text) if segment), ""
        )
        if head and head not in names:
            names.append(head)
    if not names:
        return []
    home = user_home(env)
    dirs: List[Path] = []
    for ancestor in [start, *start.parents]:
        dirs.extend(ancestor / name for name in names)
        if ancestor == home or (ancestor / ".git").exists():
            break
    return dirs


def _config_files(
    host_id: str,
    entry: Dict[str, Any],
    *,
    env: Optional[Dict[str, str]] = None,
    project_root: Optional[Path] = None,
) -> List[Path]:
    """Every file a declaration could live in, in probe order — environment first.

    The probe has to read the set the host's own installer is driven from, and
    ``install_paths`` cannot express all of it. Three sources have no command
    directory to be derived from, and all three are live:

    * ``$<HOST>_CONFIG`` — an explicit config **file**, read *instead of* the
      per-user one, so a probe ignoring it reads a config the host is not.
    * ``$<HOST>_CONFIG_DIR`` — the same redirect, one level up.
    * ``~/.<host>`` — the per-user directory that holds config but no commands.

    Missing them was not a quiet gap. A user declaring the package in any of them
    got ``route is None``, which makes row 1 fail with the ``install-host``
    repair — telling them to write the duplicate **file** route the shadowing
    note exists to prevent. Environment first, then the project tree, then the
    directories ``install_paths`` implies, then the per-user directory.
    """
    environment = os.environ if env is None else env
    file_var, dir_var = _config_env_names(host_id)
    files: List[Path] = []
    seen: set = set()

    def add(candidate: Path) -> None:
        resolved = Path(os.path.abspath(str(candidate)))
        if resolved not in seen:
            seen.add(resolved)
            files.append(resolved)

    def expanded(value: str) -> Path:
        # ``~`` against the *injected* home, never the interpreter's: this probe
        # is called with a temp ``env`` in tests and under a redirected ``$HOME``
        # in the container, and ``os.path.expanduser`` would answer for neither.
        if value == "~" or value[:2] in ("~/", "~\\"):
            return _join(user_home(environment), value[1:].lstrip("/\\"))
        return Path(os.path.abspath(value))

    explicit = (environment.get(file_var) or "").strip()
    if explicit:
        # A file, named by the user: its basename is theirs, not the host id's.
        add(expanded(explicit))

    dirs: List[Path] = []
    redirected = (environment.get(dir_var) or "").strip()
    if redirected:
        dirs.append(expanded(redirected))
    dirs.extend(_project_config_dirs(entry, env=env, project_root=project_root))
    dirs.extend(_config_dirs(host_id, entry, env=env, project_root=project_root))
    dirs.append(user_home(environment) / f".{host_id}")

    for directory in dirs:
        for suffix in (".json", ".jsonc"):
            add(directory / f"{host_id}{suffix}")
    return files


def _cache_root(
    host_id: str, *, env: Optional[Dict[str, str]] = None
) -> Optional[Path]:
    """Where the host's package installer extracts to.

    ``$XDG_CACHE_HOME/<host>`` when set, else ``~/.cache/<host>``. **This is the
    POSIX formula and it is the only one computed** — whether a host roots its
    cache under ``%LOCALAPPDATA%`` on Windows is unverified, so name the
    consequence rather than discover it: on a Windows machine whose cache lives
    elsewhere, a genuinely installed package route stats as missing and is
    reported as *declared but not resolved*. That is the wrong posture but the
    safe one — the note still warns about a declaration the user really has, and
    it never invents a live route or a repair line.
    """
    environment = os.environ if env is None else env
    xdg = environment.get("XDG_CACHE_HOME")
    if xdg:
        return Path(xdg) / host_id
    home = environment.get("HOME") or environment.get("USERPROFILE")
    if not home:
        return None
    return Path(home) / ".cache" / host_id


def _npm_payload_path(
    host_id: str, spec: str, *, env: Optional[Dict[str, str]] = None
) -> Optional[Path]:
    """``<cache>/packages/<normalized spec>/node_modules/<name>``.

    **The innermost component is load-bearing, not decoration.** Measured: the
    spec directory is created *before* resolution is attempted and survives every
    failure as an empty directory — offline, and online against a spec the
    registry 404s. A probe stopping one directory short would report a live route
    for a package that does not exist on the registry at all, which is precisely
    the posture every reader is in before the first publish.

    The directory is the **normalized** spec, not the config string:
    ``"opencode-multi-llm"`` caches at ``…@latest``, and a scoped name nests.
    """
    root = _cache_root(host_id, env=env)
    if root is None:
        return None
    normalized = spec if "@" in spec.lstrip("@") else f"{spec}@latest"
    return root / "packages" / normalized / "node_modules" / _package_name(spec)


#: One probe per registry. Keyed on the ``package.registry`` discriminator so a
#: second host on a second registry adds a row rather than a branch — and
#: :func:`package_route` refuses an unkeyed registry rather than probing ``None``,
#: which is what makes the row mandatory instead of merely conventional.
_PAYLOAD_PROBES: Dict[str, Any] = {"npm": _npm_payload_path}


def _npm_route(
    host_id: str,
    entry: Dict[str, Any],
    package: Dict[str, Any],
    *,
    env: Optional[Dict[str, str]] = None,
    project_root: Optional[Path] = None,
) -> Optional[PackageRoute]:
    """Is a package route *declared*, and did it resolve? Config first, cache second.

    **Detection order matters, and a cache glob would get it backwards.** An
    extracted cache tree is not evidence of an install: uninstalling is deleting
    the config line and it leaves that tree behind forever, every version ever
    pinned stays next to the current one, and a package can be extracted for a
    different project's config. A glob would report a live route for all three —
    and since the entire purpose of this probe is to warn about *shadowing*, a
    false shadowing warning is worse than no warning at all.

    So: find the declaration in the merged config first. No entry, no route —
    nothing is stat-ed and the output is byte-unchanged from what it was. Only
    then normalize that entry's spec and stat exactly one computed location.
    """
    probe = _PAYLOAD_PROBES["npm"]
    key = package["config_key"]
    wanted = package["name"]

    for config in _config_files(
        host_id, entry, env=env, project_root=project_root
    ):
        declared = _declared_spec(config, key, wanted)
        if declared is None:
            continue
        payload = probe(host_id, declared, env=env)
        return PackageRoute(
            spec=declared,
            name=_package_name(declared),
            payload=payload,
            resolved=bool(payload and payload.is_dir()),
            declared_in=config,
        )
    return None


def _declared_spec(config: Path, key: str, wanted: str) -> Optional[str]:
    """The spec in *config*'s *key* list whose package name is *wanted*."""
    if not config.is_file():
        return None
    try:
        raw = config.read_text(encoding="utf-8")
    except OSError:
        return None
    try:
        document = json.loads(_strip_jsonc(raw))
    except (ValueError, TypeError):
        # A config we cannot parse is not a declaration we can act on, and a
        # --check that died on someone's trailing comma would be worse than one
        # that stays quiet about a route it could not read.
        return None
    if not isinstance(document, dict):
        return None
    declared = document.get(key)
    if not isinstance(declared, list):
        return None
    for item in declared:
        if isinstance(item, str) and _package_name(item) == wanted:
            return item
    return None
receiving-code-reviewobra/superpowersUse when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementationStars: 322kUpdated Claude CodeCodexVerifiedInstall
requesting-code-reviewobra/superpowersUse when completing tasks, implementing major features, or before merging to verify work meets requirementsStars: 322kUpdated Claude CodeCodexVerifiedInstall
using-git-worktreesobra/superpowersUse when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallbackStars: 322kUpdated Claude CodeCodexVerifiedInstall
verification-before-completionobra/superpowersUse when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions alwaysStars: 322kUpdated Claude CodeCodexVerifiedInstall