kube-noob

Open an OpenShift must-gather (or oc adm inspect output) safely and say what is wrong, most severe first: the cluster version and update, cluster operators, nodes, machine config pools, OLM operators, pods, warning events and etcd log hints. Each finding has its evidence file, its signals, read-only commands to confirm it, and the known OpenShift bugs and team memory entries that match it for the version the cluster runs. Nothing is extracted or run and Secrets are never read. Local: reads the path you give on this machine.

Removed/deprecated Kubernetes APIs relevant to a target version, and the OpenShift->Kubernetes version map.

Full deterministic audit: security, network exposure, storage access modes, reliability and red-team scenarios. Findings carry rule ids, line numbers, fixes, citations and matching RHACS policy names.

Read a failed GitHub Actions, Jenkins, Tekton or OpenShift build log: the failing step (and why it is that step), the error line and its template, the cause class (dependency fetch, compile, test, image push, registry auth, quota, timeout, out of memory, permissions) with its evidence, reported issues, team memory and the fix for that CI system. Read-only.

Evaluate NetworkPolicies offline: can the source reach the destination on this port? Checks egress from the source and ingress to the destination, names the policy and rule that decide each, says why the other rules did not match, and proposes the smallest NetworkPolicy that would allow it.

Check a (partial) generator blueprint and return blocking questions and stated assumptions.

Read the SARIF that Semgrep, Bandit, SpotBugs/FindSecBugs, ESLint or CodeQL wrote (kube-noob has no analysis engine of its own): one finding per file, line and CWE across tools, suppressed and fixed results excluded with the reason, lint kept apart. With Containerfiles, each file is followed into the images that ship it (copied or built; tests and tools are not shipped); with manifests, findings rank by exposure and privileges with the attack path. With scanner reports and dependency files, each language-package vulnerability points at the file and line to change. Local only.

Effective configuration (webEnabled, cluster access, model), version and knowledge stats.

Static checks of a Containerfile or Dockerfile: base images pinned by digest, a non-root USER, no credentials in ENV, ARG, LABEL, RUN or copied files, no download piped into a shell, package caches cleaned, a health check or probes, a multi-stage build. Each finding names its fix and source. The CLI (kube-noob build audit) also reads the build context and the built image's layers.

Match pasted events / describe output / logs / CLI errors or an Alertmanager webhook payload against troubleshooting playbooks, ranked by matching patterns and by the signals the text carries (alert names, reasons); returns the signals, ranked root causes, read-only checks with names filled in, fixes, reported issues for the version and policy denials.

Explain an admission denial policy by policy: Kyverno, OPA Gatekeeper, ValidatingAdmissionPolicy, Pod Security Admission, OpenShift SCC, RHACS, ResourceQuota, LimitRange or RBAC. Returns the policy and rule, the failing field, read-only commands with names filled in, the fix (with a patch for Pod Security and RBAC) and the audit rules that catch it before deploy.

Rationale, remediation, citations for a rule id.

Read the canonical names in an error: Alertmanager alert names (webhook payload or text), event and ClusterOperator condition reasons, container reasons, admission rules, components and normalised error templates, plus the alerts its words imply. Returns each signal with where it was found, the catalogue entry (components, playbooks, upstream source) and the playbooks it points at. Read-only and offline.

Migrates removed APIs, fixes wrong API groups, hardens securityContext, adds Route TLS, unblocks PDBs, reorders EgressFirewall rules, swaps RWO-only classes for RWX claims. Returns the diff log and manual follow-ups. Does not touch any cluster.

Same as generate_manifests but packaged as a Helm chart (Chart.yaml v2, values.yaml, values.schema.json, templates). Returns file contents.

Deterministic, audited manifests for kubernetes / openshift / rosa-classic / rosa-hcp from a blueprint (name, namespace, image, replicas, port, probes, storage, exposure, egress).

Fetch the full text of a chunk id (kn:<doc>#<n>) or every chunk of a document id.

Deterministic reward for a completion against a benchmark task: task correctness (audit engine or QA rules), source-attribution credit for valid [kn:...] citations, format, penalties.

An incident with its evidence (redacted), diagnosis, policy denials, reported issues, rollout change, every occurrence, the fixes a person confirmed, and confirmed fixes for the same problem elsewhere.

AFTER the user confirms it worked: store the cause and fix on the incident (and as a learning note), so the next occurrence comes with it. Summaries only; never leaves the machine.

Open (or resolved) incidents from the local incident ledger: workload, signal, how often it came back, the diagnosis and what changed before it started. Read this first when asked what is wrong.

Start here for anything the user pastes. Names what the input is (events, pod status, logs, an Alertmanager payload, a policy denial, a ticket, manifests, a Helm template, a build log, a Containerfile, an SBOM or scanner report, a packet trace, must-gather paths, a question; several at once) and runs every analyser that applies: diagnosis with reported issues and team memory, the denial explainer, the audit, the documentation. Returns every finding with its source, read-only next steps and what was not analysed and why. Read-only, local.

Match an error or symptom against the issues listed in the OpenShift release notes (known issues and issues fixed in each update) and, when this install keeps a local copy of Red Hat's public Jira, against those tickets too. Returns the issue id and link, what became of it (fixed and in which version, still open, closed as not a bug, won't fix or a duplicate), the workaround and Red Hat's remarks from the comments; with `version`, only issues that can affect that version.

Exercise prompt, starter YAML, hints and points.

Lesson content with objectives, key points and citations. A shared HTTP server records no progress, so the learner id only selects whose tally to show when one is kept.

Credits earned and completed items.

Fetch a quiz question (no choice) or answer it (choice index). A shared HTTP server marks the answer the same way but records nothing, and says so in the result.

Grade YAML offline with the audit engine; awards credits and returns feedback. A shared HTTP server grades the same way but records nothing, and says so in the result.

Tracks, lessons, exercises and the learner's progress.

Save a short symptom -> cause -> fix note to the local learning file AFTER the user confirms it worked. Summaries only: credentials, manifests and raw logs are rejected. Never leaves the machine.

Save platform, versions and team conventions the user stated, so later answers fit their setup.

The user's environment profile (platform, versions, conventions), confirmed troubleshooting notes (cite as [kn:local-N#0]) and the most frequent playbooks/rules. Read this before tailoring advice.

All rule ids with stage, category and default severity.

Generate ValidatingAdmissionPolicy (with binding) and/or Kyverno ValidatingPolicy YAML from kube-noob's audit rules, in audit (warn and record) or enforce mode, for a platform. One policy per rule decidable from one object; each names its rule, fix and source. Rules that need other objects or that the API server already enforces are listed with the reason. Nothing is applied.

Kyverno 1.20 removes the kyverno.io ClusterPolicy, Policy, CleanupPolicy and legacy PolicyException. Lint them rule by rule against the policies.kyverno.io types: direct, inverted (a deny or a negated pattern: the CEL validation must state what is allowed), manual (JMESPath, API calls, anchors, strategic merge patches) or blocked (no documented CEL equivalent), each with the field path, the target kind, the reason and the Kyverno documentation section (pinned commit). Rules that map directly get a draft CEL policy and a kyverno test fixture skeleton to prove it. Nothing is applied or rewritten.

The newest daily report in this install's data folder: objects added, removed and changed since the previous snapshot (with the fields that changed), findings new and fixed, and open findings by namespace, owner and rule. Local data only.

Rank the paths from an exposure (Route, Ingress, LoadBalancer or NodePort Service) to what a compromised pod could do: node access (privileged, hostPath, host namespaces) or Kubernetes API rights through its ServiceAccount token (read Secrets, exec, create workloads, escalate). Score = exposure x blast radius; every step names the field that proves it, with a fix. Secret objects are dropped unread.

Hostile-auditor scenarios: node crash, zone outage, RWX split-brain, exposure, privilege escalation, upgrade blocking, secret leaks, resource starvation, supply chain.

Map every policy in an RHACS (StackRox) export to kube-noob rules by name and criteria: overlap (same setting, with severity and scope differences), related (the same risk seen through image, runtime or API-event data), gap (a deploy-time setting kube-noob has no rule for), outside (image contents, runtime behaviour, API events, label conventions) or unexplained (criteria kube-noob does not know). Lists disagreements and the rules no policy covers. Local only.

Clarify -> Validate -> Research -> Audit -> Calibrate -> Generate -> Red Team for a request with existing manifests or a generator blueprint. Returns the Audit & Validation Brief, the production manifest, and Red Team findings with safeguards. Use this first for any design/review request.

BM25 search over the built-in curated knowledge and the ingested corpus (Kubernetes/OpenShift/ROSA/Helm/StackRox docs, Terraform modules, public RHACS Jira insights). Results include chunk ids to cite as [kn:...] plus source URL and license.

From manifests: entry points, trust boundaries, data stores and identities, and per element the STRIDE threats with status (open, mitigated, not assessed), the evidence, the kube-noob rules, generated admission policies and RHACS policies that mitigate each, and MITRE ATT&CK for Containers technique ids. Deterministic; Secrets are dropped unread.

One ticket from this install's local copy of Red Hat's public Jira (OCPBUGS, ROX, HOSTEDCP...): its status, what became of it, fix versions and whether `version` already has the fix, the workaround and remarks from the comments, and linked tickets. Local data only; nothing is fetched.

Reconcile the local copy of Red Hat's public Jira: tickets fixed (with fix versions), closed as not a bug, won't fix or duplicate, reopened, given a fix version or opened since a date, with links, and the open tickets per project and verdict. Read-only and local; each sync records the changes.

Before updating OpenShift from one x.y.z version to another: the risks Red Hat declares for that update in the public update graph (conditional updates, as an OpenShift Update Service serves them), from a bundled snapshot, offline. Each risk has its name, message, link, the version that fixes it and a verdict: applies (declared for every cluster), check (one fact decides it, with the read-only command or must-gather file that shows it) or cannot evaluate offline (its PromQL, as written). Whether the update is in your channel is not checked.

Strict schema validation (Kubernetes 1.35 + OpenShift/OVN-K/StackRox/Gateway API CRDs), apiVersion vs kind, OpenShift-only APIs on vanilla Kubernetes, removed/deprecated APIs, selector wiring.

Read Trivy or Grype JSON, CycloneDX or SPDX SBOMs, or an RHACS image scan into one finding per package, version and CVE (with the fix version); apply Red Hat VEX (a not-affected or already-fixed finding drops out, citing the statement); mark CISA KEV entries; and, with the manifests, rank by exposure, privileges and RBAC reach with each finding's attack path. SBOM packages are matched against Red Hat VEX. Local only.