Run kubectl operations in your team's words.

reflex = 1

description = """
Scale a service to a number of replicas.
One deployment in one environment; the number is set, never added to."""
not_for = [
  "restarting or rolling back a service",
  "resizing a database or a disk",
  "autoscaling rules",
]
tags    = ["ops"]
effect  = "write"
confirm = "Scale {service} in {env} to {replicas}?"
run     = [
  "kubectl", "-n", "{env}", "scale", "deployment", "{service}",
  "--replicas", "{replicas}",
]

[needs]
writes = ["~/.kube"]                   # the kubeconfig, and kubectl's cache beside it
hosts  = ["*"]

[args.service]
ask   = "Which service?"
vocab = "services"

[args.env]
ask   = "Which environment?"
vocab = "envs"

[args.replicas]
ask   = "How many replicas?"
pick  = "number"
range = [1, 20]

[examples]
"scale checkout to 6 in staging"   = { replicas = "6" }
"run 3 replicas of search in prod" = { replicas = "3" }
"take payments down to 1 replica"  = { replicas = "1" }

[tests]
"bring checkout up to 12 in prod" = { replicas = "12" }
"scale checkout"                  = { replicas = false }
"restart checkout"                = false

checkout = { what = "The checkout API.", value = "checkout-api" }
search   = { what = "The search API.", value = "search-api" }
payments = { what = "Payments; also 'the gateway'.", value = "payments-svc" }

import { execFile } from "node:child_process"
import { promisify } from "node:util"
import { type Vocab, reflex } from "@evoke-build/evoke"

const kubectl = async (...args: string[]) =>
  (await promisify(execFile)("kubectl", args)).stdout.trim()

export const scale = reflex({
  description: "Scale a service to a number of replicas.\n" +
    "One deployment in one environment; the number is set, never added to.",
  not_for: [
    "restarting or rolling back a service",
    "resizing a database or a disk",
    "autoscaling rules",
  ],
  effect: "write",
  confirm: "Scale {service} in {env} to {replicas}?",
  args: {
    service:  { ask: "Which service?", vocab: "services" },
    env:      { ask: "Which environment?", vocab: "envs" },
    replicas: { ask: "How many replicas?", pick: "number", range: [1, 20] },
  },
  examples: {
    "scale checkout to 6 in staging":   { replicas: "6" },
    "run 3 replicas of search in prod": { replicas: "3" },
    "take payments down to 1 replica":  { replicas: "1" },
  },
}, ({ service, env, replicas }) =>
  kubectl("-n", env, "scale", "deployment", service, `--replicas=${replicas}`))

// silence and rollback follow, the same way

// The team's names, in the file's form; from a database in a real app.
export const vocab: Vocab = {
  services: {
    checkout: { what: "The checkout API.", value: "checkout-api" },
    search:   { what: "The search API.", value: "search-api" },
    payments: { what: "Payments; also 'the gateway'.", value: "payments-svc" },
  },
  envs: {
    staging: "The pre-production cluster.",
    prod:    { what: "Production; also 'live'.", value: "production" },
  },
  hosts: {
    "db-3":  "The primary Postgres host.",
    "web-1": "The first web node.",
  },
}

// The project next to this file: evoke.toml, vocab/, overlays/.
// One sentence in, one line out.
import { load } from "@evoke-build/evoke"
import { done, handlers } from "../terminal.ts"

const ops = await load({ root: import.meta.dirname })
const handled = await ops.handle(process.argv[2] ?? "", handlers)
console.log(handled.outcome === "ran" ? handled.result.text : handled.outcome)
done()

// The reflexes above, loaded from code alone: no files,
// the team's names handed over with `with`.
import { load } from "@evoke-build/evoke"
import { jev } from "@evoke-build/evoke/jev"
import { done, handlers } from "../terminal.ts"
import { rollback, scale, silence, vocab } from "./reflexes.ts"

const reflexes = { scale, silence, rollback }
const ops = (await load({ reflexes, adapter: jev() })).with({ vocab })
const handled = await ops.handle(process.argv[2] ?? "", handlers)
console.log(handled.outcome === "ran" ? handled.result.text : handled.outcome)
done()

// The two handlers the ops and runbook apps share, and one yes/no question.
// A confirm is a question; an ask is a numbered menu, or a blank to type into.
import { createInterface } from "node:readline/promises"
import type { Handlers } from "@evoke-build/evoke"

const { stdin: input, stdout: output } = process
const terminal = createInterface({ input, output })

export const yes = async (question: string) =>
  (await terminal.question(`${question}  [y]es [n]o > `)).startsWith("y")

// Fits a project of any reflexes
export const handlers: Handlers<any> = {
  confirm: d => yes(d.prompt.template),
  ask: async d => {
    const given: Record<string, string> = {}
    for (const { arg, ask, choices } of d.missing) {
      const keys = choices.type === "options" ? Object.keys(choices.options)
        : choices.type === "vocab" ? Object.keys(choices.words) : []
      const menu = keys.map((key, i) => `[${i + 1}] ${key}`).join("  ")
      const typed = await terminal.question(`${ask}  ${menu}${menu && "  "}> `)
      given[arg] = keys[Number(typed) - 1] ?? typed
    }
    return given
  },
}

export const done = () => terminal.close()