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

package/package.json

@@ -53,15 +53,17 @@
     }
   ],
   "license": "MIT",
-  "version": "0.0.0-new-release-a895e12e",
+  "version": "0.0.0-new-cli-80ac360a",
   "scripts": {
     "lint": "eslint \"src/**/*.ts\"",
     "lint:fix": "eslint \"src/**/*.ts\" --fix",
     "test": "yarn run lint",
-    "build": "yarn build:compile && yarn build:bundle",
+    "build": "yarn build:compile && yarn build:inline-variables && yarn build:bundle",
+    "build:inline-variables": "yarn babel --keep-file-extension --extensions \".ts,.js\" --config-file ./babel-inline.json dist --out-dir dist",
     "build:bundle": "./scripts/bundle",
     "build:compile": "yarn tsc && yarn tsc-alias",
-    "build:watch": "yarn tsc -w"
+    "dev:own-catenv": "cd ../ && node cli/bin/catenv-dev",
+    "build:watch": "tsc-watch --onSuccess \"yarn dev:own-catenv\""
   },
   "bin": {
     "catci": "./bin/catci",
@@ -74,6 +76,9 @@
     "node": ">=18.0.0"
   },
   "devDependencies": {
+    "@babel/cli": "^7.28.6",
+    "@babel/core": "^7.29.0",
+    "@babel/plugin-syntax-typescript": "^7.28.6",
     "@gitbeaker/rest": "^39.28.0",
     "@kubernetes/client-node": "^0.16.2",
     "@tsconfig/node14": "^1.0.1",
@@ -88,6 +93,7 @@
     "@types/vorpal": "^1.12.0",
     "@types/websocket": "^0.0.40",
     "@types/yargs": "^17.0.33",
+    "babel-plugin-transform-inline-environment-variables": "^0.4.4",
     "child-process-promise": "^2.2.1",
     "clipboardy": "^2.0.0",
     "command-exists-promise": "^2.0.2",
@@ -102,13 +108,16 @@
     "prettier": "^3.3.3",
     "tmp-promise": "^2.0.2",
     "ts-results-es": "^4.2.0",
-    "tsc-alias": "^1.8.10",
+    "tsc-alias": "^1.8.16",
+    "tsc-watch": "^7.2.0",
     "typescript": "^5.4.5",
     "vorpal": "^1.12.0",
     "yaml": "^2.5.0"
   },
   "dependencies": {
-    "tsx": "^4.19.0"
+    "@inquirer/prompts": "^8.4.3",
+    "commander": "^14.0.3",
+    "tsx": "^4.21.0"
   },
   "stableVersion": "0.0.0"
 }

package/src/adapters/baseContext.ts

@@ -0,0 +1,55 @@
+import type {
+  CommandContext,
+  CommandDef,
+  InputDef,
+  InputResultType,
+  InputsSchema,
+} from "../core/types";
+
+/**
+ * Base class for CommandContext implementations.
+ * Handles caching, the `get()` method, and `promptDirect` delegation.
+ * Subclasses only implement the adapter-specific resolution logic.
+ */
+export abstract class BaseContext<TInputs extends InputsSchema>
+  implements CommandContext<TInputs>
+{
+  private cache = new Map<string, Promise<any>>();
+
+  constructor(protected readonly command: CommandDef<TInputs>) {}
+
+  abstract log(message: string): void;
+  abstract confirm(message: string): Promise<boolean>;
+
+  /**
+   * Resolve a single input value. Called once per input (result is cached).
+   * Implementations check pre-supplied values, prompt interactively, use defaults, or throw.
+   */
+  protected abstract resolveInput<P extends InputDef>(
+    name: string,
+    spec: P,
+  ): Promise<InputResultType<P>>;
+
+  get<K extends keyof TInputs & string>(
+    name: K,
+  ): Promise<InputResultType<TInputs[K]>> {
+    if (!this.cache.has(name)) {
+      const spec = this.command.inputs[name];
+      if (!spec) {
+        return Promise.reject(
+          new Error(
+            `Input "${name}" is not declared in command "${this.command.name}"`,
+          ),
+        );
+      }
+      this.cache.set(name, this.resolveInput(name, spec));
+    }
+    return this.cache.get(name)!;
+  }
+
+  async promptDirect<P extends InputDef>(
+    spec: P & { name: string },
+  ): Promise<InputResultType<P>> {
+    return this.resolveInput(spec.name, spec);
+  }
+}

package/src/adapters/programmatic.ts

@@ -0,0 +1,88 @@
+import type {
+  CommandDef,
+  IO,
+  InputDef,
+  InputResultType,
+  InputsSchema,
+} from "../core/types";
+import { MissingInputError } from "../core/types";
+import { BaseContext } from "./baseContext";
+
+export interface ProgrammaticOptions {
+  /** Pre-supplied values keyed by input name */
+  inputs?: Record<string, unknown>;
+  /** Called on every log message. Defaults to no-op. */
+  onLog?: (message: string) => void;
+}
+
+class ProgrammaticContext<
+  TInputs extends InputsSchema,
+> extends BaseContext<TInputs> {
+  private inputs: Record<string, unknown>;
+  private onLog?: (message: string) => void;
+
+  constructor(command: CommandDef<TInputs>, options: ProgrammaticOptions) {
+    super(command);
+    this.inputs = options.inputs ?? {};
+    this.onLog = options.onLog;
+  }
+
+  log(message: string): void {
+    this.onLog?.(message);
+  }
+
+  async confirm(): Promise<boolean> {
+    return true; // programmatic mode always confirms
+  }
+
+  protected async resolveInput<P extends InputDef>(
+    name: string,
+    spec: P,
+  ): Promise<InputResultType<P>> {
+    if (name in this.inputs && this.inputs[name] !== undefined) {
+      return this.inputs[name] as InputResultType<P>;
+    }
+    if ("default" in spec && spec.default !== undefined) {
+      return spec.default as InputResultType<P>;
+    }
+    throw new MissingInputError(name, spec.message);
+  }
+}
+
+/**
+ * Create a CommandContext that resolves inputs from pre-supplied values.
+ * Used for non-interactive CLI mode and programmatic invocation.
+ */
+export function createProgrammaticContext<TInputs extends InputsSchema>(
+  command: CommandDef<TInputs>,
+  options: ProgrammaticOptions = {},
+): ProgrammaticContext<TInputs> {
+  return new ProgrammaticContext(command, options);
+}
+
+/**
+ * Create a bare IO instance for helper functions that only need log + promptDirect.
+ */
+export function createProgrammaticIO(options: ProgrammaticOptions = {}): IO {
+  const { inputs = {}, onLog } = options;
+
+  return {
+    log(message: string): void {
+      onLog?.(message);
+    },
+    async confirm(): Promise<boolean> {
+      return true;
+    },
+    async promptDirect<P extends InputDef>(
+      spec: P & { name: string },
+    ): Promise<InputResultType<P>> {
+      if (spec.name in inputs && inputs[spec.name] !== undefined) {
+        return inputs[spec.name] as InputResultType<P>;
+      }
+      if ("default" in spec && spec.default !== undefined) {
+        return spec.default as InputResultType<P>;
+      }
+      throw new MissingInputError(spec.name, spec.message);
+    },
+  };
+}

package/src/adapters/terminal.ts

@@ -0,0 +1,202 @@
+import type {
+  CommandDef,
+  IO,
+  InputDef,
+  InputResultType,
+  InputsSchema,
+  PromptChoice,
+} from "../core/types";
+import { MissingInputError } from "../core/types";
+import { BaseContext } from "./baseContext";
+
+/**
+ * Resolve choices from a choices function.
+ */
+async function resolveChoices(
+  choices: (ctx: any) => PromptChoice[] | Promise<PromptChoice[]>,
+  ctx: any,
+): Promise<{ name: string; value: string }[]> {
+  const raw = await choices(ctx);
+  return raw.map((c) => (typeof c === "string" ? { name: c, value: c } : c));
+}
+
+/**
+ * Prompt the user interactively using @inquirer/prompts.
+ * The UI is determined by the value type + presence of choices.
+ */
+async function promptInteractive<P extends InputDef>(
+  spec: P & { name: string },
+  ctx: any,
+): Promise<InputResultType<P>> {
+  const inquirer = await import("@inquirer/prompts");
+
+  switch (spec.type) {
+    case "string": {
+      if (spec.choices) {
+        const choices = await resolveChoices(spec.choices, ctx);
+        return inquirer.select({
+          message: spec.message,
+          choices,
+        }) as Promise<InputResultType<P>>;
+      }
+      return inquirer.input({
+        message: spec.message,
+        default: spec.default,
+      }) as Promise<InputResultType<P>>;
+    }
+    case "string[]": {
+      if (spec.choices) {
+        const choices = await resolveChoices(spec.choices, ctx);
+        return inquirer.checkbox({
+          message: spec.message,
+          choices,
+        }) as Promise<InputResultType<P>>;
+      }
+      const raw = await inquirer.input({ message: spec.message });
+      return (
+        raw ? raw.split(",").map((s: string) => s.trim()) : []
+      ) as InputResultType<P>;
+    }
+    case "number":
+      return inquirer.number({
+        message: spec.message,
+        default: spec.default,
+      }) as Promise<InputResultType<P>>;
+    case "boolean":
+      return inquirer.confirm({
+        message: spec.message,
+        default: spec.default,
+      }) as Promise<InputResultType<P>>;
+    default:
+      throw new Error(`Unsupported input type: ${(spec as InputDef).type}`);
+  }
+}
+
+export interface TerminalOptions {
+  /** Pre-supplied values from CLI flags/positional args, keyed by input name */
+  cliOptions?: Record<string, unknown>;
+  /** Pre-supplied values from --inputs JSON flag */
+  jsonInputs?: Record<string, unknown>;
+  /** Whether interactive prompts are allowed (default: auto-detect from TTY) */
+  interactive?: boolean;
+  /** If true, all confirm() calls return true without prompting (--yes flag) */
+  yes?: boolean;
+}
+
+class TerminalContext<
+  TInputs extends InputsSchema,
+> extends BaseContext<TInputs> {
+  constructor(
+    command: CommandDef<TInputs>,
+    private options: TerminalOptions,
+  ) {
+    super(command);
+  }
+
+  log(message: string): void {
+    console.log(message);
+  }
+
+  async confirm(message: string): Promise<boolean> {
+    if (this.options.yes) return true;
+    const isInteractive =
+      this.options.interactive ?? process.stdin.isTTY === true;
+    if (!isInteractive) return true;
+    const inquirer = await import("@inquirer/prompts");
+    return inquirer.confirm({ message });
+  }
+
+  protected async resolveInput<P extends InputDef>(
+    name: string,
+    spec: P,
+  ): Promise<InputResultType<P>> {
+    const { cliOptions = {}, jsonInputs = {}, interactive } = this.options;
+    const isInteractive = interactive ?? process.stdin.isTTY === true;
+
+    // Helper: validate a pre-supplied value against choices if they exist
+    const validateAgainstChoices = async (value: unknown): Promise<void> => {
+      if (!("choices" in spec) || !spec.choices) return;
+      const choices = await resolveChoices(spec.choices, this);
+      const validValues = choices.map((c) => c.value);
+      if (Array.isArray(value)) {
+        const invalid = (value as string[]).filter(
+          (v) => !validValues.includes(v),
+        );
+        if (invalid.length > 0) {
+          throw new Error(
+            `Invalid value(s) for "${name}": ${invalid.join(", ")}. Valid choices: ${validValues.join(", ")}`,
+          );
+        }
+      } else if (!validValues.includes(value as string)) {
+        throw new Error(
+          `Invalid value for "${name}": "${value}". Valid choices: ${validValues.join(", ")}`,
+        );
+      }
+    };
+
+    // 1. CLI flag or positional arg
+    if (name in cliOptions && cliOptions[name] !== undefined) {
+      await validateAgainstChoices(cliOptions[name]);
+      return cliOptions[name] as InputResultType<P>;
+    }
+
+    // 2. JSON inputs
+    if (name in jsonInputs && jsonInputs[name] !== undefined) {
+      await validateAgainstChoices(jsonInputs[name]);
+      return jsonInputs[name] as InputResultType<P>;
+    }
+
+    // 3. Interactive prompt
+    if (isInteractive) {
+      return promptInteractive({ ...spec, name }, this);
+    }
+
+    // 4. Default
+    if ("default" in spec && spec.default !== undefined) {
+      return spec.default as InputResultType<P>;
+    }
+
+    // 5. Throw
+    throw new MissingInputError(name, spec.message);
+  }
+}
+
+/**
+ * Create a CommandContext for terminal usage.
+ */
+export function createTerminalContext<TInputs extends InputsSchema>(
+  command: CommandDef<TInputs>,
+  options: TerminalOptions = {},
+): TerminalContext<TInputs> {
+  return new TerminalContext(command, options);
+}
+
+/**
+ * Create a bare IO instance for terminal helper functions.
+ */
+export function createTerminalIO(options: TerminalOptions = {}): IO {
+  return {
+    log(message: string): void {
+      console.log(message);
+    },
+    async confirm(message: string): Promise<boolean> {
+      if (options.yes) return true;
+      const isInteractive = options.interactive ?? process.stdin.isTTY === true;
+      if (!isInteractive) return true;
+      const inquirer = await import("@inquirer/prompts");
+      return inquirer.confirm({ message });
+    },
+    async promptDirect<P extends InputDef>(
+      spec: P & { name: string },
+    ): Promise<InputResultType<P>> {
+      const isInteractive = options.interactive ?? process.stdin.isTTY === true;
+      if (isInteractive) {
+        return promptInteractive(spec, null);
+      }
+      if ("default" in spec && spec.default !== undefined) {
+        return spec.default as InputResultType<P>;
+      }
+      throw new MissingInputError(spec.name, spec.message);
+    },
+  };
+}

package/src/apps/catenv/catenv.ts

@@ -1,21 +1,27 @@
 import { getProjectConfig } from "../../config/getProjectConfig";
 import { printVariables } from "./printVariables";
 import type { Choice } from "./types";
+import { printVerboseBanner } from "./verboseBanner";
 import { writeDotEnvFiles } from "./writeDotEnvFiles";
 import { writeDTsFiles } from "./writeEnvDTs";
 import {
-  FileWriter,
   createCatenvContext,
   generatePipelineFiles,
 } from "@catladder/pipeline";
 
-export default async (choice?: Choice) => {
+type Options = {
+  verbose?: boolean;
+};
+export default async (choice?: Choice, options?: Options) => {
   const config = await getProjectConfig();
   if (!config) {
     return;
   }
 
   const context = createCatenvContext(config);
+  if (options?.verbose) {
+    printVerboseBanner();
+  }
 
   await Promise.all([
     generatePipelineFiles(context, config.pipelineType ?? "gitlab"),

package/src/apps/catenv/verboseBanner.ts

@@ -0,0 +1,33 @@
+import {
+  getEnvironment,
+  getProjectConfig,
+} from "../../config/getProjectConfig";
+
+export const printVerboseBanner = async () => {
+  const config = await getProjectConfig();
+  if (!config) {
+    return;
+  }
+
+  const allCompontsWithPorts = await Promise.all(
+    Object.keys(config.components).map(async (componentName) => {
+      const environment = await getEnvironment("local", componentName);
+      const port = environment.envVars.PORT;
+      if (!port) {
+        return null;
+      }
+      return `${componentName}: http://localhost:${port}`;
+    }),
+  ).then((lines) => lines.filter(Boolean));
+
+  const lines = [
+    "catenv",
+    "-------",
+    "running on:",
+    "",
+    ...allCompontsWithPorts,
+  ];
+  for (const line of lines) {
+    console.log(line);
+  }
+};

package/src/apps/cli/commands/project/commandConfigSecrets.ts

@@ -1,8 +1,7 @@
 import { getSecretVarName } from "@catladder/pipeline";
 import { stripIndents } from "common-tags";
 import { difference } from "lodash";
-import type { CommandInstance } from "vorpal";
-import type Vorpal from "vorpal";
+import type { IO } from "../../../../core/types";
 import {
   getAllComponentsWithAllEnvsHierarchical,
   getEnvironment,
@@ -14,7 +13,6 @@ import {
 import { editAsFile } from "../../../../utils/editAsFile";
 import { upsertAllVariables } from "../../../../utils/gitlab";
 import { delay } from "../../../../utils/promise";
-import { allEnvsAndAllComponents } from "./utils/autocompletions";
 
 type Vars = {
   [env: string]: {
@@ -62,7 +60,7 @@ const getSecretEnvVarKeysToConfigure = async (
     .map((k) => k.key);
 };
 const getEnvVarsToEdit = async (
-  instance: CommandInstance,
+  instance: IO,
   env: string,
   componentName: string,
 ) => {
@@ -92,7 +90,7 @@ const getEnvVarsToEdit = async (
   );
 };
 const doItFor = async (
-  instance: CommandInstance,
+  instance: IO,
   envAndComponents: {
     [componentName: string]: string[];
   },
@@ -161,12 +159,7 @@ const doItFor = async (
           }
 
           await delay(1000);
-          const { shouldContinue } = await instance.prompt({
-            default: true,
-            message: "Try again? 🤔",
-            name: "shouldContinue",
-            type: "confirm",
-          });
+          const shouldContinue = await instance.confirm("Try again? 🤔");
 
           if (!shouldContinue) {
             throw new Error("abort");
@@ -197,40 +190,22 @@ const doItFor = async (
   instance.log("");
 };
 
-export const projectConfigSecrets = async (
-  vorpal: CommandInstance,
-  envComponent?: string,
-) => {
+export const projectConfigSecrets = async (io: IO, envComponent?: string) => {
   if (!envComponent) {
     const allEnvAndcomponents = await getAllComponentsWithAllEnvsHierarchical();
-    await doItFor(vorpal, allEnvAndcomponents);
+    await doItFor(io, allEnvAndcomponents);
   } else {
     const { env, componentName } = parseChoice(envComponent);
 
     // componentName can be null. in this case, iterate over all  components
     if (!componentName) {
       const components = await getProjectComponents();
-      await doItFor(
-        vorpal,
-        Object.fromEntries(components.map((c) => [c, [env]])),
-      );
+      await doItFor(io, Object.fromEntries(components.map((c) => [c, [env]])));
     }
     if (componentName) {
-      await doItFor(vorpal, {
+      await doItFor(io, {
         [componentName]: [env],
       });
     }
   }
 };
-
-export default async (vorpal: Vorpal) => {
-  vorpal
-    .command(
-      "project-config-secrets [envComponent]",
-      "setup/update secrets stored in pass",
-    )
-    .autocomplete(await allEnvsAndAllComponents())
-    .action(async function ({ envComponent }) {
-      return await projectConfigSecrets(this, envComponent);
-    });
-};

package/src/apps/cli/commands/project/setup/index.ts

@@ -1,4 +1,4 @@
-import type { CommandInstance } from "vorpal";
+import type { IO } from "../../../../../core/types";
 import { getAllPipelineContexts } from "../../../../../config/getProjectConfig";
 import { setupAccessTokens } from "./setupAccessTokens";
 import { setupContext } from "./setupContext";
@@ -7,7 +7,7 @@ import { setupAgents } from "./setupAgents";
 import { logSection } from "./logSection";
 
 export const setupProject = async (
-  instance: CommandInstance,
+  instance: IO,
   onlyComponents?: string | string[],
 ) => {
   const allContext = await getAllPipelineContexts(onlyComponents);

package/src/apps/cli/commands/project/setup/logSection.ts

@@ -1,7 +1,7 @@
-import type { CommandInstance } from "vorpal";
+import type { IO } from "../../../../../core/types";
 
 export const logSection = async (
-  instance: CommandInstance,
+  instance: IO,
   title: string,
   work: () => Promise<void>,
 ) => {

package/src/apps/cli/commands/project/setup/setupAccessTokens.ts

@@ -1,10 +1,10 @@
-import type { CommandInstance } from "vorpal";
+import type { IO } from "../../../../../core/types";
 import { add, format } from "date-fns";
 import { doGitlabRequest, getProjectInfo } from "../../../../../utils/gitlab";
 
 const TOKEN_NAME = "semantic-release";
 
-export const setupAccessTokens = async (instance: CommandInstance) => {
+export const setupAccessTokens = async (instance: IO) => {
   const { id: projectId } = await getProjectInfo(instance);
 
   const projectTokens = await doGitlabRequest(