@catladder/cli 0.0.0-refactore-catenv-command-validates-argument-78d05852 → 0.0.0-reference-database-url-1befbbee

package/src/utils/boxWithAscii.ts

@@ -0,0 +1,9 @@
+// thx copilot
+export const boxWithAsci = (str: string) => {
+  const length = str.length;
+  const box = "╔" + "═".repeat(length + 3) + "╗";
+  const empty = "║ " + " ".repeat(length + 1) + " ║";
+  const text = "║ " + str + " ║";
+  const bottom = "╚" + "═".repeat(length + 3) + "╝";
+  return [box, empty, text, empty, bottom].join("\n");
+};

package/src/utils/editAsFile.ts

@@ -1,12 +1,12 @@
 import { withFile } from "tmp-promise";
-import { dump, load } from "js-yaml";
+import { parse, stringify } from "yaml";
 
 import { readFile, writeFile } from "fs-extra";
 import getEditor from "./getEditor";
 
 export const editAsFile = async <T>(
   inObject: T,
-  preamble?: string
+  preamble?: string,
 ): Promise<T> => {
   const fullPreamble = preamble
     ? `#
@@ -15,16 +15,17 @@ export const editAsFile = async <T>(
 
 `
     : "\n";
-  const asString = fullPreamble + dump(inObject, { noRefs: true });
+  const asString =
+    fullPreamble + stringify(inObject, { aliasDuplicateObjects: false });
   let newContent: T;
 
   await withFile(
     async ({ path: tmpFilePath }) => {
       await writeFile(tmpFilePath, asString);
       await (await getEditor()).open(tmpFilePath);
-      newContent = load((await readFile(tmpFilePath)).toString("utf-8")) as T;
+      newContent = parse((await readFile(tmpFilePath)).toString("utf-8")) as T;
     },
-    { postfix: ".yml" }
+    { postfix: ".yml" },
   );
 
   return newContent;

package/src/utils/files.ts

@@ -1,8 +1,6 @@
-import fs from "fs-extra";
-import yaml from "js-yaml";
+import { readFile as fsExtraReadFile } from "fs-extra";
 
-const readFile = async (file: string) =>
-  fs.readFile(file, { encoding: "utf-8" });
+const readFile = (file: string) => fsExtraReadFile(file, { encoding: "utf-8" });
 
 export const readFileOrError = async (filePath: string) => {
   try {
@@ -12,11 +10,3 @@ export const readFileOrError = async (filePath: string) => {
     return [e];
   }
 };
-
-export const readYaml = async <T = Record<string, any>>(filename: string) => {
-  try {
-    return yaml.load(await readFile(filename)) as T;
-  } catch (e) {
-    return null;
-  }
-};

package/src/utils/getEditor.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
 import { spawn } from "child-process-promise";
 import commandExists from "command-exists-promise";
 

package/src/utils/gitlab.ts

@@ -1,11 +1,11 @@
 import { getSecretVarName } from "@catladder/pipeline";
-import { exec } from "child-process-promise";
 import { has, isObject } from "lodash";
 import memoizee from "memoizee";
 import fetch from "node-fetch";
 import open from "open";
 import type { CommandInstance } from "vorpal";
 import { getPreference, hasPreference, setPreference } from "./preferences";
+import { getGitRemoteHostAndPath } from "../git/gitProjectInformation";
 
 const TOKEN_KEY = "gitlab-personal-access-token";
 
@@ -14,17 +14,21 @@ export const setupGitlabToken = async (vorpal: CommandInstance) => {
   vorpal.log("");
   vorpal.log("☝ in order to access the api, we need a personal access token");
   vorpal.log("Its best to create one specifically for catladder");
+  vorpal.log("Scopes needed: api");
   vorpal.log("");
   vorpal.log("☝ we open up the settings page for you!");
   vorpal.log("");
-  const { shouldContinue } = await vorpal.prompt({
-    default: true,
-    message: "Ok",
-    name: "shouldContinue",
-    type: "prompt",
-  });
+  const [{ shouldContinue }, { gitRemoteHost }] = await Promise.all([
+    vorpal.prompt({
+      default: true,
+      message: "Ok",
+      name: "shouldContinue",
+      type: "prompt",
+    }),
+    getGitRemoteHostAndPath(),
+  ]);
 
-  open("https://git.panter.ch/-/profile/personal_access_tokens");
+  open(`https://${gitRemoteHost}/-/user_settings/personal_access_tokens`);
 
   vorpal.log("Please type in gitlab's personal access token");
 
@@ -42,7 +46,7 @@ export const getGitlabToken = async (vorpal: CommandInstance | null) => {
   if (!(await hasGitlabToken())) {
     if (!vorpal) {
       console.error(
-        "⚠️ gitlab token missing, please run catladder to set it up"
+        "⚠️ gitlab token missing, please run catladder to set it up",
       );
       process.exit(1);
     }
@@ -56,13 +60,16 @@ export const doGitlabRequest = async <T = any>(
   vorpal: CommandInstance | null,
   path: string,
   data: any = undefined,
-  method: Method = "GET"
+  method: Method = "GET",
 ): Promise<T> => {
-  const rootToken = await getGitlabToken(vorpal);
+  const [rootToken, { gitRemoteHost }] = await Promise.all([
+    getGitlabToken(vorpal),
+    getGitRemoteHostAndPath(),
+  ]);
 
   //const method = data ? (update ? "PUT" : "POST") : "GET";
 
-  const result = await fetch(`https://git.panter.ch/api/v4/${path}`, {
+  const result = await fetch(`https://${gitRemoteHost}/api/v4/${path}`, {
     method,
     headers: {
       "Content-Type": "application/json",
@@ -84,23 +91,17 @@ export const doGitlabRequest = async <T = any>(
   throw new Error(
     `Could not send request to gitlab api ${path}: ${result.status} "${
       result.statusText
-    }".\nResponse: ${JSON.stringify(await result.json(), null, 2)}`
+    }".\nResponse: ${JSON.stringify(await result.json(), null, 2)}`,
   );
 };
 
 export const getProjectInfo = async (
-  vorpal: CommandInstance | null
+  vorpal: CommandInstance | null,
 ): Promise<{ id: string; web_url: string }> => {
-  const gitRemoteOriginUrl = (
-    await exec("git config --get remote.origin.url")
-  ).stdout.trim();
-  const projectPath =
-    /(https:\/\/|git@)git\.panter\.ch[:/]([^.]*)(\.git)?/g.exec(
-      gitRemoteOriginUrl
-    );
+  const { gitRemotePath } = await getGitRemoteHostAndPath();
   const project = await doGitlabRequest(
     vorpal,
-    `projects/${encodeURIComponent(projectPath[2])}`
+    `projects/${encodeURIComponent(gitRemotePath)}`,
   );
   return project;
 };
@@ -114,28 +115,44 @@ type GitlabVariable = {
   environment_scope: string;
 };
 export const getAllVariables = memoizee(
-  async (vorpal: CommandInstance | null): Promise<Array<GitlabVariable>> => {
+  async (
+    vorpal: CommandInstance | null,
+    n = 5, // how many requests to do in parallel, 5 seems a good value for many projects, ideally we would do one request in parallel per component
+  ): Promise<Array<GitlabVariable>> => {
     const { id } = await getProjectInfo(vorpal);
+
     let all: Array<GitlabVariable> = [];
-    let result: Array<GitlabVariable>;
+    let result: Array<Array<GitlabVariable>> = [];
     let page = 1;
+
     do {
-      result = await doGitlabRequest(
-        vorpal,
-        // 100 is max page size
-        `projects/${id}/variables?per_page=100&page=${page}`
-      );
-      page++;
-      all = [...all, ...result];
-    } while (result?.length > 0);
+      // Create an array of promises for N pages
+      const promises = Array.from({ length: n }, (_, i) => {
+        return doGitlabRequest(
+          vorpal,
+          `projects/${id}/variables?per_page=100&page=${page + i}`,
+        );
+      });
+
+      // Wait for all promises to resolve
+      result = await Promise.all(promises);
+
+      // Increment the page by N
+      page += n;
+
+      // Flatten the result array and add it to 'all'
+      all = [...all, ...result.flat()];
+      // Continue only if the last page had results
+    } while (result.length > 0 && result[result.length - 1].length > 0);
+
     return all;
   },
-  { promise: true }
+  { promise: true },
 );
 
 export const getVariableValueByRawName = async (
   vorpal: CommandInstance,
-  rawName: string
+  rawName: string,
 ) => {
   const allVariables = await getAllVariables(vorpal);
   return allVariables.find((v) => v.key === rawName)?.value;
@@ -150,7 +167,7 @@ const createVariable = async (
   key: string,
   value: string,
   masked = true,
-  environment_scope = "*"
+  environment_scope = "*",
 ) => {
   return await doGitlabRequest(
     vorpal,
@@ -161,7 +178,7 @@ const createVariable = async (
       masked: masked && isMaskable(value),
       environment_scope,
     },
-    "POST"
+    "POST",
   );
 };
 
@@ -170,7 +187,7 @@ const updateVariable = async (
   projectId: string,
   key: string,
   value: string,
-  masked = true
+  masked = true,
 ) => {
   return await doGitlabRequest(
     vorpal,
@@ -179,20 +196,20 @@ const updateVariable = async (
       value,
       masked: masked && isMaskable(value),
     },
-    "PUT"
+    "PUT",
   );
 };
 
 const deleteVariable = async (
   vorpal: CommandInstance,
   projectId: string,
-  key: string
+  key: string,
 ) => {
   return await doGitlabRequest(
     vorpal,
     `projects/${projectId}/variables/${key}`,
     undefined,
-    "DELETE"
+    "DELETE",
   );
 };
 
@@ -233,7 +250,7 @@ const getAllCatladderEnvVarsInGitlab = async (vorpal: CommandInstance) => {
       }
 
       return acc;
-    }, {})
+    }, {}),
   );
   return allVariables;
 };
@@ -260,7 +277,7 @@ export const upsertAllVariables = async (
   env: string,
   componentName: string,
   backup = true,
-  masked = true // FIXME: would be better to have this per variable
+  masked = true, // FIXME: would be better to have this per variable
 ): Promise<void> => {
   const { id } = await getProjectInfo(vorpal);
 
@@ -286,7 +303,7 @@ export const upsertAllVariables = async (
             getBackupKey(fullKey, new Date().getTime()),
             oldValue,
             masked,
-            "_backup"
+            "_backup",
           );
         }
       } else {

package/src/utils/log.ts

@@ -1,13 +1,113 @@
+import type { CommandInstance } from "vorpal";
+
+type AnyMessagesFn = (message?: any, ...optionalParams: any[]) => void;
+type StringMessagesFn = (message?: string, ...optionalParams: string[]) => void;
+type AnyMessageFn = (message?: any) => void;
+type StringMessageFn = (message?: string) => void;
+type StringMessageSpreadFn = (...message: string[]) => void;
+type AnyMessageSpreadFn = (...message: any[]) => void;
+type SomeKindOfLogFn =
+  | AnyMessagesFn
+  | StringMessagesFn
+  | AnyMessageFn
+  | StringMessageFn
+  | StringMessageSpreadFn
+  | AnyMessageSpreadFn;
+type HasSomeKindOfLogMethod = { log: SomeKindOfLogFn };
+
+/**
+ * Something that has a .log method taking a string argument.
+ *
+ * null and undefined will fall back to console.log.
+ */
+export type LoggerCmdInstance =
+  | CommandInstance
+  | Console
+  | HasSomeKindOfLogMethod
+  | null
+  | undefined;
+
+type LinesArgItem =
+  | string
+  | number
+  | boolean
+  | Date
+  | RegExp
+  | null
+  | undefined;
+type LinesArg = LinesArgItem | LinesArgItem[];
+
+/**
+ * Logs multiple lines using the log method of the provided {@link LoggerCmdInstance}.
+ *
+ * Line items that are `null` or `undefined` are logged as empty lines.
+ *
+ * @param cmd - The logger instance to use. If `null` or `undefined`, `console` will be used.
+ *
+ * @example
+ * ```ts
+ * logLines(cmd, "line 1", "line 2", null, "line 3");
+ * logLines(cmd, ...linesArray); // arrays can be spread into the function
+ * logLines(cmd, linesArray); // but it will flatten the plain array for convenience
+ * ```
+ */
+export function logLines(
+  cmd: LoggerCmdInstance = console,
+  ...lines: LinesArg[]
+) {
+  for (const line of lines.flat()) {
+    (cmd ?? console).log(`${line ?? ""}`);
+  }
+}
+
+/**
+ * Logs an error message using the log method of the provided {@link LoggerCmdInstance}.
+ *
+ * Line items that are `null` or `undefined` are logged as empty lines.
+ *
+ * @example
+ * ```ts
+ * logError(cmd, "Message");
+ * logError(cmd, "Message", "Additional message");
+ * logError(cmd, "Message", "Additional message", "Another additional message line");
+ * logError(cmd, "Message", ...additionalMessages); // arrays can be spread into the function
+ * logError(cmd, "Message", additionalMessages); // but it will flatten the plain array for convenience
+ * ```
+ */
 export const logError = (
-  cmd: any,
+  cmd: LoggerCmdInstance = console,
+  message: string,
+  ...additionalMessages: LinesArg[]
+) => {
+  logLines(cmd, "", `[ERROR] 🙀 :${message}`);
+  if (additionalMessages?.length) {
+    logLines(cmd, ...additionalMessages.flat());
+  }
+  logLines(cmd, "");
+};
+
+/**
+ * Logs a warning message using the log method of the provided {@link LoggerCmdInstance}.
+ *
+ * Line items that are `null` or `undefined` are logged as empty lines.
+ *
+ * @example
+ * ```ts
+ * logWarning(cmd, "Message");
+ * logWarning(cmd, "Message", "Additional message");
+ * logWarning(cmd, "Message", "Additional message", "Another additional message line");
+ * logWarning(cmd, "Message", ...additionalMessages); // arrays can be spread into the function
+ * logWarning(cmd, "Message", additionalMessages); // but it will flatten the plain array for convenience
+ * ```
+ */
+export const logWarning = (
+  cmd: LoggerCmdInstance = console,
   message: string,
-  additionalMessage?: any
+  ...additionalMessages: LinesArg[]
 ) => {
-  cmd.log("");
-  cmd.log(`[ERROR] 🙀 :${message}`);
-  cmd.log("");
-  if (additionalMessage) {
-    cmd.log(additionalMessage);
-    cmd.log("");
+  logLines(cmd, "", `[WARNING] ⚠️ : ${message}`);
+  if (additionalMessages?.length) {
+    logLines(cmd, ...additionalMessages.flat());
   }
+  logLines(cmd, "");
 };

package/src/utils/portForwards.ts

@@ -34,7 +34,7 @@ const addPortForward = (name: string, portForward: PortForward) => {
 
 export const startPortForwardCommand = async (
   name: string,
-  command: string
+  command: string,
 ) => {
   // stop if already there
   await stopPortForward(name);

package/src/utils/preferences.ts

@@ -0,0 +1,60 @@
+import { readFile, writeFile, mkdir, cp, chmod } from "fs/promises";
+import { existsSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+import { parse, stringify } from "yaml";
+
+const legacyPreferencesPath = join(homedir(), ".catladder/preferences.yml");
+const preferencesPath = join(homedir(), ".config/catladder/preferences.yml");
+
+const ensurePreferencesFile = async () => {
+  if (existsSync(preferencesPath)) {
+    return;
+  }
+  await mkdir(dirname(preferencesPath), { recursive: true, mode: 0o700 });
+  if (!existsSync(legacyPreferencesPath)) {
+    return writeFile(preferencesPath, "---\n{}", {
+      encoding: "utf-8",
+      mode: 0o600,
+    });
+  }
+  await cp(legacyPreferencesPath, preferencesPath);
+  await chmod(preferencesPath, 0o600);
+  await cp(
+    preferencesPath,
+    join(dirname(preferencesPath), "old_preferences_backup.yml"),
+  );
+};
+
+const loadPreferences = async () => {
+  await ensurePreferencesFile();
+  return readFile(preferencesPath, { encoding: "utf-8" });
+};
+
+export const getPreferences = async () => {
+  const yamlContent = await loadPreferences();
+  return (parse(yamlContent) ?? {}) as Record<string, string>;
+};
+
+export const hasPreference = async (key: string) => {
+  const preferences = await getPreferences();
+  return key in preferences;
+};
+export const getPreference = async (key: string) => {
+  const preferences = await getPreferences();
+  return preferences[key];
+};
+
+export const setPreference = async (key: string, value: string | number) => {
+  const preferences = await getPreferences();
+
+  const newPreferences = {
+    ...preferences,
+    [key]: value,
+  };
+
+  await writeFile(preferencesPath, stringify(newPreferences), {
+    encoding: "utf-8",
+    mode: 0o600,
+  });
+};

package/src/utils/projects/index.ts

@@ -4,8 +4,13 @@ import { getProjectConfig, parseChoice } from "../../config/getProjectConfig";
 import { readFileOrError } from "../files";
 import { exec } from "child-process-promise";
 
-export const getGitRoot = async (): Promise<string> => {
-  return (await exec(`git rev-parse --show-toplevel`)).stdout.trim();
+export const getGitRoot = async (): Promise<string | null> => {
+  try {
+    return (await exec(`git rev-parse --show-toplevel`)).stdout.trim();
+  } catch (e) {
+    // not a git repo
+    return null;
+  }
 };
 
 export const getRootGitlabCiFile = async () => {

package/src/utils/promise.ts

@@ -1,11 +1,13 @@
 export async function filter<T>(
   arr: T[],
-  iterator: (item: T) => Promise<boolean>
+  iterator: (item: T) => Promise<boolean>,
 ) {
   const fail = Symbol("fail");
-  return ((await Promise.all(
-    arr.map(async item => ((await iterator(item)) ? item : fail))
-  )).filter(i => i !== fail) as any) as Promise<T[]>;
+  return (
+    await Promise.all(
+      arr.map(async (item) => ((await iterator(item)) ? item : fail)),
+    )
+  ).filter((i) => i !== fail) as any as Promise<T[]>;
 }
 
-export const delay = (ms: number) => new Promise(res => setTimeout(res, ms));
+export const delay = (ms: number) => new Promise((res) => setTimeout(res, ms));

package/tsconfig.json

@@ -1,16 +1,20 @@
 {
   "compilerOptions": {
-    "lib": ["es2021", "DOM"],
+    "lib": ["es2022", "DOM"],
     "module": "CommonJS",
+    "downlevelIteration": true,
     "declaration": true,
-    "noImplicitAny": true,
+    "target": "ES2018",
     "moduleResolution": "node",
     "esModuleInterop": true,
     "sourceMap": true,
     "outDir": "dist",
     "strict": false,
     "incremental": true,
-    "resolveJsonModule": true
+    "resolveJsonModule": true,
+    "paths": {
+      "@catladder/pipeline": ["../pipeline/src/index.ts"]
+    }
   },
   "include": ["./src/**/*"]
 }

package/.nvmrc

@@ -1 +0,0 @@
-16

package/dist/apps/catci/catci.js

@@ -1,86 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-exports.__esModule = true;
-exports.runCatCi = void 0;
-var vorpal_1 = __importDefault(require("vorpal"));
-var packageInfos_1 = __importDefault(require("../../packageInfos"));
-var commands_1 = __importDefault(require("./commands/security/commands"));
-function reconstructArgs(args) {
-    return __spreadArray([args[0]], args.slice(1).map(function (arg) { return "\"".concat(arg, "\""); }), true).join(" ");
-}
-function runCatCi() {
-    return __awaiter(this, void 0, void 0, function () {
-        var vorpal, isInteractive, args;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    vorpal = new vorpal_1["default"]();
-                    process.exitCode = 0;
-                    vorpal.delimiter("catci $").history("catci").version(packageInfos_1["default"].version);
-                    (0, commands_1["default"])(vorpal);
-                    isInteractive = process.argv.length <= 2;
-                    if (!isInteractive) return [3 /*break*/, 1];
-                    vorpal.log("Catladder CI Tools \uD83D\uDE3B\uD83D\uDD28 version ".concat(packageInfos_1["default"].version)).show();
-                    return [3 /*break*/, 3];
-                case 1:
-                    process.exitCode = 1;
-                    args = reconstructArgs(process.argv.slice(2));
-                    return [4 /*yield*/, vorpal.exec(args)];
-                case 2:
-                    _a.sent();
-                    process.exit();
-                    _a.label = 3;
-                case 3: return [2 /*return*/];
-            }
-        });
-    });
-}
-exports.runCatCi = runCatCi;
-//# sourceMappingURL=catci.js.map

package/dist/apps/catci/catci.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"catci.js","sourceRoot":"","sources":["../../../src/apps/catci/catci.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,kDAA4B;AAC5B,oEAA6C;AAC7C,0EAA4D;AAE5D,SAAS,eAAe,CAAC,IAAc;IACrC,OAAO,eAAC,IAAI,CAAC,CAAC,CAAC,GAAK,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,UAAC,GAAG,IAAK,OAAA,YAAI,GAAG,OAAG,EAAV,CAAU,CAAC,QAAE,IAAI,CAAC,GAAG,CAAC,CAAC;AACxE,CAAC;AAED,SAAsB,QAAQ;;;;;;oBACtB,MAAM,GAAG,IAAI,mBAAM,EAAE,CAAC;oBAE5B,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAC;oBACrB,MAAM,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,yBAAW,CAAC,OAAO,CAAC,CAAC;oBAE1E,IAAA,qBAAgB,EAAC,MAAM,CAAC,CAAC;oBAEnB,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,CAAC;yBAC3C,aAAa,EAAb,wBAAa;oBACf,MAAM,CAAC,GAAG,CAAC,8DAAmC,yBAAW,CAAC,OAAO,CAAE,CAAC,CAAC,IAAI,EAAE,CAAC;;;oBAE5E,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAC;oBACf,IAAI,GAAG,eAAe,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;oBACpD,qBAAM,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAA;;oBAAvB,SAAuB,CAAC;oBACxB,OAAO,CAAC,IAAI,EAAE,CAAC;;;;;;CAElB;AAjBD,4BAiBC"}

package/dist/apps/catci/commands/security/auditDocument.d.ts

@@ -1,19 +0,0 @@
-export declare function makeTemplate(): string;
-export declare type SecurityEvaluation = {
-    topics: {
-        description: string;
-        responsibles: string[];
-        note: string;
-        isUnknown: boolean;
-        isAnswered: boolean;
-        isSecured: boolean;
-    }[];
-    score: {
-        rating: number;
-        totalTopics: number;
-        answeredTopics: number;
-        securedTopics: number;
-        unknownTopics: number;
-    };
-};
-export declare function evaluateDocument(document: string): SecurityEvaluation;