@catladder/cli 0.0.0-new-release-a895e12e → 0.0.0-new-cli-80ac360a

package/src/commands/project/commandSecretsClearBackups.ts

@@ -0,0 +1,19 @@
+import { defineCommand } from "../../core/defineCommand";
+import { clearBackups } from "../../utils/gitlab";
+
+export const commandSecretsClearBackups = defineCommand({
+  name: "project-secrets-clear-backups",
+  description: "clears all backups",
+  group: "project",
+  inputs: {
+    keep: {
+      type: "number",
+      message: "How many backups should we keep? 🤔",
+      default: 1,
+    },
+  },
+  execute: async (ctx) => {
+    const keep = await ctx.get("keep");
+    await clearBackups(ctx, keep);
+  },
+});

package/src/commands/project/commandSecurityEvaluate.ts

@@ -0,0 +1,22 @@
+import { defineCommand } from "../../core/defineCommand";
+import {
+  evaluateSecurityAudit,
+  makeSecurityAuditOverview,
+} from "../../apps/catci/commands/security/evaluateSecurityAudit";
+import { getGitRoot } from "../../utils/projects";
+
+export const commandSecurityEvaluate = defineCommand({
+  name: "project-security-evaluate",
+  description: "evaluate project's security audit document",
+  group: "project",
+  inputs: {},
+  execute: async (ctx) => {
+    const gitRoot = await getGitRoot();
+    const result = await evaluateSecurityAudit({ path: gitRoot });
+    if (result.isErr()) {
+      ctx.log(`Could not evaluate security audit document: ${result.error}`);
+    } else {
+      ctx.log(makeSecurityAuditOverview(result.value));
+    }
+  },
+});

package/src/commands/project/commandSetup.ts

@@ -0,0 +1,16 @@
+import { defineCommand } from "../../core/defineCommand";
+import { setupProject } from "../../apps/cli/commands/project/setup";
+
+export const commandSetup = defineCommand({
+  name: "project-setup",
+  description:
+    "Initializes all environments and creates required resources, service accounts, etc.",
+  group: "project",
+  inputs: {
+    component: { type: "string", message: "component name", positional: true },
+  },
+  execute: async (ctx) => {
+    const component = await ctx.get("component");
+    await setupProject(ctx, component);
+  },
+});

package/src/commands/project/commandTriggerCronjob.ts

@@ -0,0 +1,99 @@
+import type { V1ObjectMeta } from "@kubernetes/client-node";
+import { V1Job } from "@kubernetes/client-node";
+import { defineCommand } from "../../core/defineCommand";
+import { getk8sApiBatch, getk8sApiBatchBeta } from "../../k8sApi";
+import { logError } from "../../utils/log";
+import { getProjectNamespace } from "../../utils/projects";
+import { ensureCluster } from "../../apps/cli/commands/project/utils/ensureCluster";
+import { envAndComponents } from "../../apps/cli/commands/project/utils/autocompletions";
+
+const getCronjobChoices = async (namespace: string) => {
+  const {
+    body: { items: jobs },
+  } = await getk8sApiBatchBeta().listNamespacedCronJob(namespace);
+  return jobs.map((j: any) => j.metadata.name) as string[];
+};
+
+const runCronjob = async (
+  io: { log: (msg: string) => void },
+  namespace: string,
+  jobName: string,
+) => {
+  const {
+    body: { items: jobs },
+  } = await getk8sApiBatchBeta().listNamespacedCronJob(namespace);
+
+  const cronjob = jobs.find((j: any) => j.metadata.name === jobName);
+  const jobSpec = (cronjob as any).spec.jobTemplate.spec;
+
+  const job = new V1Job();
+  const metadata: Partial<V1ObjectMeta> = {
+    name: `manual-${Math.round(Date.now() / 1000)}-${(cronjob as any).metadata.name}`,
+  };
+
+  job.metadata = metadata as V1ObjectMeta;
+  job.spec = jobSpec;
+  try {
+    const result = await getk8sApiBatch().createNamespacedJob(namespace, job);
+    io.log("");
+    io.log(
+      `yeah, you got a job, man. 😺 ${(result as any).body.metadata.name}`,
+    );
+    io.log("");
+  } catch (e: any) {
+    logError(io, "command failed", e.body);
+  }
+};
+
+export const commandTriggerCronjobGeneral = defineCommand({
+  name: "trigger-cronjob",
+  description: "trigger cronjob",
+  group: "general",
+  inputs: {
+    namespace: {
+      type: "string",
+      message: "kubernetes namespace",
+      positional: true,
+    },
+    jobName: {
+      type: "string",
+      message: "Which cronjob? 🤔",
+      choices: async (ctx) => getCronjobChoices(await ctx.get("namespace")),
+    },
+  },
+  execute: async (ctx) => {
+    const namespace = await ctx.get("namespace");
+    const jobName = await ctx.get("jobName");
+    await runCronjob(ctx, namespace, jobName);
+  },
+});
+
+export const commandTriggerCronjobProject = defineCommand({
+  name: "project-trigger-cronjob",
+  description: "trigger cronjob",
+  group: "project",
+  inputs: {
+    envComponent: {
+      type: "string",
+      message: "environment:component",
+      positional: true,
+      choices: async () => envAndComponents(),
+    },
+    jobName: {
+      type: "string",
+      message: "Which cronjob? 🤔",
+      choices: async (ctx) => {
+        const envComponent = await ctx.get("envComponent");
+        const namespace = await getProjectNamespace(envComponent);
+        return getCronjobChoices(namespace);
+      },
+    },
+  },
+  execute: async (ctx) => {
+    const envComponent = await ctx.get("envComponent");
+    await ensureCluster(ctx, envComponent);
+    const namespace = await getProjectNamespace(envComponent);
+    const jobName = await ctx.get("jobName");
+    await runCronjob(ctx, namespace, jobName);
+  },
+});

package/src/completion.ts

@@ -0,0 +1,221 @@
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import type { CommandDef, InputDef } from "./core/types";
+
+/**
+ * Generate completions for the current command line.
+ *
+ * @param allCommands - All registered command definitions
+ * @param words - The words typed so far (argv without the binary name)
+ * @param cursorWord - The word currently being completed (may be empty)
+ * @returns Array of completion strings
+ */
+export async function getCompletions(
+  allCommands: CommandDef[],
+  words: string[],
+  cursorWord: string,
+): Promise<string[]> {
+  // If no command yet, complete command names
+  if (words.length === 0) {
+    return allCommands
+      .map((c) => c.name)
+      .filter((name) => name.startsWith(cursorWord));
+  }
+
+  const commandName = words[0];
+  const command = allCommands.find((c) => c.name === commandName);
+
+  // If the first word doesn't match a command, complete command names
+  if (!command) {
+    return allCommands
+      .map((c) => c.name)
+      .filter((name) => name.startsWith(commandName));
+  }
+
+  // We have a valid command. Figure out what to complete.
+  const argsAfterCommand = words.slice(1);
+
+  // Check if we're completing a --flag value
+  const prevWord = argsAfterCommand[argsAfterCommand.length - 1];
+  if (prevWord?.startsWith("--")) {
+    // Previous word is a flag, complete its values
+    const flagName = prevWord.replace(/^--/, "");
+    const inputName = flagNameToInputName(flagName);
+    const inputDef = command.inputs[inputName];
+    if (inputDef && "choices" in inputDef && inputDef.choices) {
+      return resolveChoicesForCompletion(inputDef, cursorWord);
+    }
+    return [];
+  }
+
+  // Check if we're typing a --flag name
+  if (cursorWord.startsWith("--")) {
+    return getFlagCompletions(command, cursorWord);
+  }
+
+  // Otherwise, complete positional inputs
+  const positionalInputs = getPositionalInputs(command);
+  const positionalArgs = argsAfterCommand.filter((w) => !w.startsWith("--"));
+
+  // Which positional index are we on?
+  const positionalIndex = positionalArgs.length;
+  const targetInput = positionalInputs[positionalIndex];
+
+  if (targetInput) {
+    const [, inputDef] = targetInput;
+    if ("choices" in inputDef && inputDef.choices) {
+      return resolveChoicesForCompletion(inputDef, cursorWord);
+    }
+  }
+
+  return [];
+}
+
+function getPositionalInputs(command: CommandDef): [string, InputDef][] {
+  return Object.entries(command.inputs).filter(([, def]) => def.positional);
+}
+
+function getFlagCompletions(command: CommandDef, cursorWord: string): string[] {
+  const flags: string[] = [];
+  for (const [name, inputDef] of Object.entries(command.inputs)) {
+    if (inputDef.positional) continue;
+    const flagName = `--${name.replace(/([A-Z])/g, "-$1").toLowerCase()}`;
+    flags.push(flagName);
+  }
+  flags.push("--inputs");
+  flags.push("--yes");
+  return flags.filter((f) => f.startsWith(cursorWord));
+}
+
+function flagNameToInputName(flagName: string): string {
+  return flagName.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+
+async function resolveChoicesForCompletion(
+  inputDef: InputDef,
+  cursorWord: string,
+): Promise<string[]> {
+  if (!("choices" in inputDef) || !inputDef.choices) return [];
+  try {
+    // Create a minimal ctx that returns empty for any get() call.
+    // This works for choices functions that don't depend on other inputs
+    // (like envAndComponents). For dependent choices, completion won't work
+    // but that's acceptable -- those are typically non-positional.
+    const noopCtx = {
+      get: () => Promise.reject(new Error("not available during completion")),
+      log: () => {},
+      confirm: () => Promise.resolve(true),
+      promptDirect: () =>
+        Promise.reject(new Error("not available during completion")),
+    };
+    const choices = await inputDef.choices(noopCtx);
+    return choices
+      .map((c) => (typeof c === "string" ? c : c.value))
+      .filter((v) => v.startsWith(cursorWord));
+  } catch {
+    // If choices function fails (e.g., needs other inputs), return nothing
+    return [];
+  }
+}
+
+/**
+ * Generate the zsh completion script.
+ * The user adds `eval "$(catladder completion zsh)"` to their .zshrc.
+ */
+export function generateZshCompletionScript(binaryName: string): string {
+  const funcName = binaryName.replace(/-/g, "_");
+  return `
+###-begin-${funcName}-completions-###
+_${funcName}_completions() {
+  local -a completions
+  local current_word="\${words[$CURRENT]}"
+
+  # Words after the binary name, excluding the current word being completed
+  local -a cmd_words=(\${words:1:$((CURRENT-2))})
+
+  # Call the CLI's __complete command
+  completions=(\${(f)"$(${binaryName} __complete -- "\${cmd_words[*]}" "$current_word" 2>/dev/null)"})
+
+  if [[ \${#completions[@]} -gt 0 ]]; then
+    compadd -a completions
+  fi
+}
+
+compdef _${funcName}_completions ${binaryName}
+###-end-${funcName}-completions-###
+`.trim();
+}
+
+const BEGIN_MARKER = (name: string) =>
+  `###-begin-${name.replace(/-/g, "_")}-completions-###`;
+
+function getZshrcPath(): string {
+  return join(homedir(), ".zshrc");
+}
+
+/**
+ * Install completions by adding an eval line to .zshrc.
+ */
+export async function installCompletions(binaryName: string): Promise<void> {
+  const zshrcPath = getZshrcPath();
+  const evalLine = `eval "$(${binaryName} completion zsh)"`;
+  const marker = BEGIN_MARKER(binaryName);
+
+  let content = "";
+  if (existsSync(zshrcPath)) {
+    content = readFileSync(zshrcPath, "utf-8");
+  }
+
+  if (content.includes(marker)) {
+    console.log(
+      `Completions for ${binaryName} are already installed in ${zshrcPath}`,
+    );
+    return;
+  }
+
+  const addition = `\n# ${binaryName} shell completions\n${evalLine}\n`;
+  writeFileSync(zshrcPath, content + addition);
+  console.log(`Installed completions for ${binaryName} in ${zshrcPath}`);
+  console.log(`Restart your shell or run: source ${zshrcPath}`);
+}
+
+/**
+ * Remove completions from .zshrc.
+ */
+export async function uninstallCompletions(binaryName: string): Promise<void> {
+  const zshrcPath = getZshrcPath();
+  if (!existsSync(zshrcPath)) {
+    console.log("No .zshrc found");
+    return;
+  }
+
+  const content = readFileSync(zshrcPath, "utf-8");
+  const evalLine = `eval "$(${binaryName} completion zsh)"`;
+  const commentLine = `# ${binaryName} shell completions`;
+
+  if (!content.includes(evalLine)) {
+    console.log(`No completions for ${binaryName} found in ${zshrcPath}`);
+    return;
+  }
+
+  const cleaned = content
+    .replace(
+      new RegExp(
+        `\\n?${commentLine.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\n?`,
+        "g",
+      ),
+      "\n",
+    )
+    .replace(
+      new RegExp(
+        `\\n?${evalLine.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\n?`,
+        "g",
+      ),
+      "\n",
+    );
+
+  writeFileSync(zshrcPath, cleaned);
+  console.log(`Removed completions for ${binaryName} from ${zshrcPath}`);
+  console.log(`Restart your shell or run: source ${zshrcPath}`);
+}

package/src/config/getProjectConfig.ts

@@ -11,7 +11,7 @@ import {
   getSecretVarName,
 } from "@catladder/pipeline";
 
-import type { CommandInstance } from "vorpal";
+import type { IO } from "../core/types";
 import { getAllVariables, getVariableValueByRawName } from "../utils/gitlab";
 
 import { getGitRoot } from "../utils/projects";
@@ -94,6 +94,7 @@ export const getAllComponentsWithAllEnvsHierarchical = async (): Promise<{
 
 export const getAllPipelineContexts = async (
   onlyComponent?: string | string[],
+  { includeLocal = false }: { includeLocal?: boolean } = {},
 ) => {
   const onlyComponentsArray = onlyComponent
     ? Array.isArray(onlyComponent)
@@ -102,7 +103,7 @@ export const getAllPipelineContexts = async (
     : null;
   return Promise.all(
     (await getAllComponentsWithAllEnvsFlat())
-      .filter((c) => c.env !== "local")
+      .filter((c) => includeLocal || c.env !== "local")
       .filter(
         (c) =>
           !onlyComponentsArray || onlyComponentsArray.includes(c.componentName),
@@ -120,20 +121,20 @@ export const getEnvironment = async (env: string, componentName: string) => {
 };
 
 export const getGitlabVar = async (
-  vorpal: CommandInstance,
+  io: IO,
   env: string,
   componentName: string,
   variableName: string,
 ) => {
   const rawVariableName = getSecretVarName(env, componentName, variableName);
-  return await getVariableValueByRawName(vorpal, rawVariableName);
+  return await getVariableValueByRawName(io, rawVariableName);
 };
 
 const resolveSecrets = async (
-  vorpal: CommandInstance | null,
+  io: IO | null,
   varSets: EnvironmentEnvVars[],
 ): Promise<Record<string, string>> => {
-  const allVariablesInGitlab = await getAllVariables(vorpal);
+  const allVariablesInGitlab = await getAllVariables(io);
 
   return Object.fromEntries(
     varSets.flatMap(({ envVars, secretEnvVarKeys }) =>
@@ -157,7 +158,7 @@ const resolveSecrets = async (
 };
 
 export const getEnvVarsResolved = async (
-  vorpal: CommandInstance | null,
+  io: IO | null,
   env: string,
   componentName: string | null,
 ) => {
@@ -169,7 +170,7 @@ export const getEnvVarsResolved = async (
 
   // in the pipeline the secrets alreadyy exists  and bash will expand them
   // but here we need to manually load them
-  return resolveSecrets(vorpal, [
+  return resolveSecrets(io, [
     {
       envVars: envionment.envVars,
       secretEnvVarKeys: envionment.secretEnvVarKeys,
@@ -182,12 +183,12 @@ export const getEnvVarsResolved = async (
  * is used to get job only vars that should also be editable locally with catladder.
  */
 export const getJobOnlyEnvVarsResolved = async (
-  vorpal: CommandInstance,
+  io: IO,
   env: string,
   componentName: string,
 ) => {
   const envionment = await getEnvironment(env, componentName);
-  return resolveSecrets(vorpal, [
+  return resolveSecrets(io, [
     envionment.jobOnlyVars.build,
     envionment.jobOnlyVars.deploy,
   ]);

package/src/core/defineCommand.ts

@@ -0,0 +1,32 @@
+import type { CommandDef, InputDef } from "./types";
+
+/**
+ * Type-safe builder for command definitions.
+ * Infers TInputs from the definition object so that
+ * `ctx.get("...")` is fully typed.
+ *
+ * @example
+ * ```ts
+ * export const myCommand = defineCommand({
+ *   name: "my-command",
+ *   description: "Does something",
+ *   inputs: {
+ *     envComponent: { type: "string", message: "env:component", positional: true },
+ *     podName: { type: "string", message: "Which pod?", choices: async () => ["a", "b"] },
+ *     mr: { type: "number", message: "Which MR?" },
+ *     confirmed: { type: "boolean", message: "Continue?" },
+ *   },
+ *   execute: async (ctx) => {
+ *     const env = await ctx.get("envComponent");  // string
+ *     const pod = await ctx.get("podName");        // string
+ *     const mr = await ctx.get("mr");              // number
+ *     const ok = await ctx.get("confirmed");       // boolean
+ *   },
+ * });
+ * ```
+ */
+export function defineCommand<const TInputs extends Record<string, InputDef>>(
+  def: CommandDef<TInputs>,
+): CommandDef<TInputs> {
+  return def;
+}

package/src/core/index.ts

@@ -0,0 +1,23 @@
+export type {
+  CommandContext,
+  CommandDef,
+  IO,
+  InputDef,
+  InputResultType,
+  InputsSchema,
+  StringInputDef,
+  StringArrayInputDef,
+  NumberInputDef,
+  BooleanInputDef,
+  PromptChoice,
+  ChoicesFn,
+} from "./types";
+export { MissingInputError } from "./types";
+export { defineCommand } from "./defineCommand";
+export {
+  registerCommand,
+  getCommand,
+  getAllCommands,
+  getCommandsByGroup,
+} from "./registry";
+export { runCommand } from "./runner";

package/src/core/registry.ts

@@ -0,0 +1,22 @@
+import type { CommandDef } from "./types";
+
+const commands: Map<string, CommandDef> = new Map();
+
+export function registerCommand(def: CommandDef): void {
+  if (commands.has(def.name)) {
+    throw new Error(`Command "${def.name}" is already registered`);
+  }
+  commands.set(def.name, def);
+}
+
+export function getCommand(name: string): CommandDef | undefined {
+  return commands.get(name);
+}
+
+export function getAllCommands(): CommandDef[] {
+  return Array.from(commands.values());
+}
+
+export function getCommandsByGroup(group: string): CommandDef[] {
+  return getAllCommands().filter((c) => c.group === group);
+}

package/src/core/runner.ts

@@ -0,0 +1,31 @@
+import type { CommandDef, InputsSchema } from "./types";
+import { createProgrammaticContext } from "../adapters/programmatic";
+
+/**
+ * Run a command programmatically.
+ * This is the main entry point for calling commands from code.
+ *
+ * @example
+ * ```ts
+ * import { commandPortForward } from "./commands/project/portForward";
+ * import { runCommand } from "./core/runner";
+ *
+ * await runCommand(commandPortForward, {
+ *   inputs: { envComponent: "dev:web", podName: "web-abc", localPort: 3000, remotePort: 3000 },
+ * });
+ * ```
+ */
+export async function runCommand<TInputs extends InputsSchema>(
+  command: CommandDef<TInputs>,
+  options: {
+    inputs?: Record<string, unknown>;
+    onLog?: (message: string) => void;
+  } = {},
+): Promise<void> {
+  const ctx = createProgrammaticContext(command, {
+    inputs: options.inputs,
+    onLog: options.onLog,
+  });
+
+  await command.execute(ctx);
+}