@digigov/cli 1.1.2-daaf7bdf → 2.0.0-0c4be34e

package/README.md

@@ -19,7 +19,7 @@ $ npm install -g @digigov/cli
 $ digigov COMMAND
 running command...
 $ digigov (-v|--version|version)
-@digigov/cli/1.1.2-daaf7bdf linux-x64 node-v18.20.4
+@digigov/cli/1.1.1 linux-x64 node-v18.20.3
 $ digigov --help [COMMAND]
 USAGE
   $ digigov COMMAND

package/index.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+import { DigigovCommand } from "./lib/command.js";
+import { loadCommands } from "./load-commands.js";
+
+const program = new DigigovCommand("digigov", import.meta.url);
+
+await loadCommands(program);
+
+await program.parseAsync(process.argv);

package/lib/command.js

@@ -0,0 +1,130 @@
+import fs from "fs-extra";
+import path from "path";
+import * as execa from "execa";
+import * as commander from "commander";
+import { fileURLToPath } from "url";
+import { logger } from "./logger.js";
+import { findPackageJson } from "./project-utils.cjs";
+
+/**
+ * A class that extends the Commander Command class with additional
+ * functionality.
+ *
+ * @extends commander.Command
+ */
+export class DigigovCommand extends commander.Command {
+  /**
+   * The id of the command used for logging
+   * @private
+   * @type {string}
+   */
+  #id;
+  /** @type {string | null} */
+  context;
+
+  /**
+   * @constructor
+   * @param {string} name - The name of the command
+   * @param {string} [importMetaUrl] - The import.meta.url of the command
+   */
+  constructor(name, importMetaUrl) {
+    super(name);
+    this.#id = name;
+    this.context = importMetaUrl
+      ? path.dirname(fileURLToPath(importMetaUrl))
+      : null;
+
+    this.option("-d, --debug", "display debug information");
+
+    this.configureOutput({
+      writeErr: (str) => logger.error(str.replace(/^error: /i, "")),
+    });
+
+    if (this.context) {
+      if (this.context.endsWith("dist")) {
+        this.context = path.dirname(this.context);
+      }
+      const pkgPath = findPackageJson(this.context);
+      if (!pkgPath)
+        this.#throwError(`No package.json found in ${this.context}`);
+      const pkg = fs.readJSONSync(pkgPath);
+      this.description(pkg.description).version(pkg.version);
+    }
+  }
+
+  /**
+   * Display error message and exit
+   * @override
+   * @param {string} message - The message to log
+   * @param {commander.ErrorOptions} [errorOptions] - The error options
+   */
+  error(message, errorOptions) {
+    logger.error(message);
+    process.exit(errorOptions?.exitCode);
+  }
+
+  /**
+   * @override
+   * @param {(...args: any[]) => void | Promise<void>} fn - The function to run
+   * @returns {DigigovCommand} `this` command for chaining
+   */
+  action(fn) {
+    return super.action(async (...args) => {
+      try {
+        logger.time(`"${this.#id}" execution time`);
+        await fn(...args);
+        logger.timeEnd(`"${this.#id}" execution time`);
+      } catch (error) {
+        this.#throwError(error);
+      }
+    });
+  }
+
+  /**
+   * Executes a script with the given arguments
+   *
+   * @param {string} script - The script to run
+   * @param {string[]} args - The arguments to pass to the script
+   * @param {execa.Options} [config] - The configuration for the script
+   */
+  exec(script, args, config) {
+    const __dirname =
+      this.context ?? path.dirname(fileURLToPath(import.meta.url));
+    const binLocation = [process.cwd(), __dirname].find((location) => {
+      return fs.existsSync(path.join(location, "node_modules", ".bin", script));
+    });
+    if (!binLocation || !fs.existsSync(binLocation)) {
+      this.#throwError(`Executable ${script} not installed`);
+    }
+    const executablePath = path.join(
+      binLocation,
+      "node_modules",
+      ".bin",
+      script,
+    );
+    const executableName = path.basename(executablePath);
+    logger.log(`Running: ${executableName} ${args.join(" ")}`);
+    try {
+      return execa.execa(executablePath, args, {
+        ...config,
+        stdio: "inherit",
+      });
+    } catch (error) {
+      this.#throwError(error.message);
+    }
+  }
+
+  /**
+   * @private
+   */
+  #throwError(error) {
+    if (typeof error === "string") logger.error(error);
+    if (typeof error === "object" && error) {
+      logger.error("stack" in error ? error.stack : error);
+      if ("exitCode" in error && typeof error.exitCode === "number") {
+        process.exit(error.exitCode);
+      }
+    }
+    process.exit(1);
+  }
+}

package/lib/index.js

@@ -1,5 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.run = void 0;
-var command_1 = require("@oclif/command");
-Object.defineProperty(exports, "run", { enumerable: true, get: function () { return command_1.run; } });
+export * from "./command.js";
+export * from "./project-utils.cjs";
+export * from "./logger.js";

package/lib/logger.js

@@ -0,0 +1,53 @@
+import chalk from "chalk";
+
+const args = process.argv.slice(2);
+const IS_DEBUG = args.includes("--debug") || args.includes("-d");
+
+function log(...data) {
+  console.log(chalk.bgWhite.black(" LOG "), ...data);
+}
+
+function info(...data) {
+  console.log(chalk.bgBlue(" INFO "), chalk.blue(...data));
+}
+function error(...data) {
+  console.error(chalk.bgRed(" ERROR "), chalk.red(...data));
+}
+
+function success(...data) {
+  console.log("✅ ", chalk.green(...data));
+}
+
+function warn(...data) {
+  console.log(chalk.bgYellow.black(" WARN "), chalk.yellow(...data));
+}
+
+function debug(...data) {
+  if (IS_DEBUG)
+    console.log(chalk.dim.bgWhite.black(" DEBUG "), chalk.dim(...data));
+}
+
+/**
+ * @param {string} label - The label for the timer
+ */
+function time(label) {
+  console.time(chalk.bgMagenta("⏱️ " + label));
+}
+
+/**
+ * @param {string} label - The label for the timer
+ */
+function timeEnd(label) {
+  console.timeEnd(chalk.bgMagenta("⏱️ " + label));
+}
+
+export const logger = {
+  log,
+  info,
+  error,
+  success,
+  warn,
+  debug,
+  time,
+  timeEnd,
+};

package/{resolveProject.js → lib/project-utils.cjs}

@@ -1,19 +1,27 @@
-const pkgUp = require("pkg-up");
 const fs = require("fs-extra");
 const path = require("path");
 const merge = require("deepmerge");
+const rushLib = require("@microsoft/rush-lib");
 
+/**
+ * Resolve the project configuration from the nearest package.json
+ *
+ * @param {string} [dir] - The directory to start package searching from
+ */
 function resolveProject(dir) {
-  const pkg = pkgUp.sync({ cwd: dir || process.cwd() });
+  const pkg = findPackageJson(dir);
+  if (!pkg) throw new Error("No package.json found"); // TODO: reconsider this
   const root = path.dirname(pkg);
   let externalLockFile = false;
-  if (fs.existsSync(path.join(root, "yarn.lock")) ||
-    fs.existsSync(path.join(root, "package-lock.json"))) {
+  if (
+    fs.existsSync(path.join(root, "yarn.lock")) ||
+    fs.existsSync(path.join(root, "package-lock.json"))
+  ) {
     externalLockFile = true;
   }
   let distDir = "dist";
   let src = "src";
-  let workspace = {};
+
   if (!fs.existsSync(path.join(root, src))) {
     src = ".";
     distDir = ".";
@@ -24,12 +32,16 @@ function resolveProject(dir) {
   let isApp = false;
   let isDocs = false;
 
-  if (fs.existsSync(path.join(root, "next.config.js")) ||
-    fs.existsSync(path.join(root, "pages"))) {
+  if (
+    fs.existsSync(path.join(root, "next.config.js")) ||
+    fs.existsSync(path.join(root, "pages"))
+  ) {
     isApp = true;
   }
-  if (fs.existsSync(path.join(root, "docusaurus.config.js")) &&
-    fs.existsSync(path.join(root, "docs"))) {
+  if (
+    fs.existsSync(path.join(root, "docusaurus.config.js")) &&
+    fs.existsSync(path.join(root, "docs"))
+  ) {
     isDocs = true;
   }
   if (fs.existsSync(path.join(root, "src")) && !isApp) {
@@ -37,16 +49,18 @@ function resolveProject(dir) {
   }
 
   const rush = resolveWorkspace();
-  if (rush) {
-    isWorkspace = true;
-    workspace = {
-      config: rush,
-      root: rush.rushJsonFolder,
-    };
-  }
+  if (rush) isWorkspace = true;
+
+  const workspace = rush
+    ? {
+        config: rush,
+        root: rush.rushJsonFolder,
+      }
+    : {};
 
   const isNodeLib = !isLib && !isApp && !isWorkspace && !isDocs;
 
+  /** @type {string | null} */
   let ignore = path.resolve(root, ".gitignore");
   if (!fs.existsSync(ignore) && workspace.root) {
     ignore = path.resolve(workspace.root, ".gitignore");
@@ -58,13 +72,13 @@ function resolveProject(dir) {
 
   let digigov = {};
   if (fs.existsSync(path.join(root, "digigovrc.json"))) {
-    digigov = require(path.join(root, "digigovrc.json"));
+    digigov = fs.readJSONSync(path.join(root, "digigovrc.json"));
   }
   if (fs.existsSync(path.join(root, "digigovrc.js"))) {
     digigov = require(path.join(root, "digigovrc.js"));
   }
 
-  const packageJS = require(pkg);
+  const packageJS = fs.readJSONSync(pkg);
 
   const devDependencies = packageJS.devDependencies || {};
   const dependencies = packageJS.dependencies || {};
@@ -95,20 +109,52 @@ function resolveProject(dir) {
     externalLockFile,
   };
 }
-function localRequire(file, dflt) {
+
+/**
+ * Recursively find the nearest package.json by walking up the directory tree.
+ *
+ * @param {string} startDir - The directory to start searching from
+ * @returns {string | undefined} package.json path, or undefined if not found.
+ */
+function findPackageJson(startDir = process.cwd()) {
+  let currentDir = startDir;
+
+  if (!fs.existsSync(currentDir) || !fs.lstatSync(currentDir).isDirectory()) {
+    throw new Error(
+      `The start directory "${startDir}" is not a valid directory.`,
+    );
+  }
+
+  while (true) {
+    const packageJsonPath = path.join(currentDir, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+      return packageJsonPath;
+    }
+    const parentDir = path.resolve(currentDir, "..");
+    if (parentDir === currentDir) return undefined;
+
+    currentDir = parentDir;
+  }
+}
+
+/**
+ * Require a file relative to the project root
+ *
+ * @param {string} file - The file to require
+ */
+function localRequire(file) {
   const project = resolveProject();
   const filePath = path.join(project.root, file);
-  if (fs.existsSync(filePath)) {
-    return require(filePath);
-  }
-  return dflt;
+  if (!fs.existsSync(filePath)) return {};
+  if (file.endsWith(".json")) return fs.readJSONSync(filePath);
+  else return require(filePath);
 }
-function makeConfig(file, cfg) {
+function makeConfig(file, cfg = {}) {
   let hook = {};
   if (file && typeof file !== "string") {
     hook = file;
   } else if (typeof file === "string") {
-    hook = localRequire(file, {});
+    hook = localRequire(file);
   }
   if (typeof hook === "function") {
     return hook(cfg);
@@ -117,56 +163,71 @@ function makeConfig(file, cfg) {
     return merge(cfg, hook);
   }
 }
-function resolveWorkspace(dir) {
+
+/**
+ * Resolve the project's Rush workspace configuration
+ *
+ * @returns {rushLib.RushConfiguration | null} - The Rush configuration or null if not found
+ */
+function resolveWorkspace() {
   try {
-    const rushLib = require("@microsoft/rush-lib");
     const rushConfiguration = rushLib.RushConfiguration.loadFromDefaultLocation(
       {
         startingFolder: process.cwd(),
-      }
+      },
     );
     return rushConfiguration;
   } catch (err) {
-    // console.log(err);
+    console.error(err);
   }
+  return null;
 }
-/*
-Identify if project running the command from, is lerna-enabled. If so, return
-lerna registered projects metadata.
-*/
-function resolveLocalPackages(dir, dependencies) {
-  const packages = {};
-  const rush = resolveWorkspace(dir);
+
+/**
+ * @param {string[]} dependencies - The dependencies to resolve
+ * @returns {{ [key: string]: ReturnType<typeof resolveProject> }} - The local packages
+ */
+function resolveLocalPackages(dependencies) {
+  const rush = resolveWorkspace();
+  let localPackages = {};
   if (rush) {
-    rush.projects.forEach((p) => {
-      if (dependencies.includes(p.packageName)) {
-        packages[p.packageName] = resolveProject(p.projectFolder);
+    const rushProjects = rush.projects;
+    for (const project of rushProjects) {
+      if (dependencies.includes(project.packageName)) {
+        localPackages[project.packageName] = resolveProject(
+          project.projectFolder,
+        );
       }
-    });
-    return packages;
+    }
   }
-  return {};
+  return localPackages;
 }
 /**
  * Map `resolveLocalPackages` result to a babel/jest compatible package aliases
  * object. Use only packages which are declared as a dependency for the current
  * project
+ *
+ * @param {boolean} absolute=false - Whether to return absolute paths
+ * @returns {{ [key: string]: string }} - The aliases object
+ *
  */
-function aliases(dir, absolute = false) {
+function aliases(absolute = false) {
   const aliases = {};
-  const project = resolveProject(dir);
+  const project = resolveProject();
   const depKeys = ["dependencies", "peerDependencies", "devDependencies"];
   const root = project.root;
   const deps = depKeys.reduce((deps, key) => {
     return deps.concat(Object.keys(project.package[key] || {}));
   }, []);
-  const packages = resolveLocalPackages(project.root, deps);
+  const packages = resolveLocalPackages(deps);
   Object.keys(packages).forEach((key) => {
     const project = packages[key];
-    if (deps.includes(project.name) &&
+    if (
+      deps.includes(project.name) &&
       project.package.devDependencies &&
       project.package.devDependencies["@digigov/cli-build"] &&
-      project.isWorkspace) {
+      project.isWorkspace
+    ) {
       const projectSrc = path.join(project.root, project.src);
       if (absolute) {
         aliases[project.name] = path.resolve(root, projectSrc);
@@ -182,36 +243,12 @@ function aliases(dir, absolute = false) {
   }
   return aliases;
 }
-const extractCommandArgs = (config, commandArgs) => {
-  const vars = Object.values(args).reduce((values, v) => {
-    return {
-      ...values,
-      ...(v.default && { [v.var]: v.default }),
-    };
-  }, {});
-
-  const exclude = [];
-  commandArgs.forEach((arg, idx) => {
-    if (exclude.includes(idx)) {
-      return;
-    }
-    if (args[arg]) {
-      if (args[arg].type) {
-        vars[args[arg].var] = args[arg].type(commandArgs[idx + 1]);
-        exclude.push(idx + 1);
-      } else {
-        vars[args[arg].var] = true;
-      }
-    }
-  });
-  return vars;
-};
 
 module.exports = {
-  makeConfig,
-  resolveLocalPackages,
-  aliases,
   resolveProject,
+  findPackageJson,
   resolveWorkspace,
-  extractCommandArgs,
-};
+  resolveLocalPackages,
+  aliases,
+  makeConfig,
+};

package/load-commands.js

@@ -0,0 +1,49 @@
+import fs from "fs-extra";
+import path from "path";
+import { fileURLToPath } from "url";
+import { logger } from "./lib/index.js";
+import { DigigovCommand, findPackageJson } from "./lib/index.js";
+
+/**
+ * @param {DigigovCommand} program - The program to load commands into
+ */
+export async function loadCommands(program) {
+  const packageFilePath = findPackageJson();
+  if (!packageFilePath) {
+    logger.warn("No package.json found");
+    return;
+  }
+  const packageFile = fs.readFileSync(packageFilePath);
+
+  const { dependencies, devDependencies } = JSON.parse(packageFile.toString());
+  const commandPackages = Object.keys({
+    ...dependencies,
+    ...devDependencies,
+  }).filter((p) => p.match(/@digigov\/cli-.*?/));
+  for (const commandPackage of commandPackages) {
+    try {
+      const modulePath = path.resolve(
+        process.cwd(),
+        "node_modules",
+        commandPackage,
+        "index.js",
+      );
+      const realPath = fs.realpathSync(modulePath);
+      const command = await import(
+        fileURLToPath(new URL(`file://${realPath}`))
+      );
+      program.addCommand(command.default);
+    } catch (error) {
+      const errorPrefix = `Could not load command package: ${commandPackage}`;
+      if (
+        error instanceof Error &&
+        error.message.endsWith("undefined (reading '_name')")
+      )
+        logger.warn(
+          errorPrefix,
+          "| Did you forget to default export the command?",
+        );
+      else logger.warn(errorPrefix, error);
+    }
+  }
+}

package/package.json

@@ -1,74 +1,42 @@
 {
   "name": "@digigov/cli",
   "description": "CLI for Digigov apps and libs with plugin support",
-  "version": "1.1.2-daaf7bdf",
+  "version": "2.0.0-0c4be34e",
   "author": "GRNET Devs <devs@lists.grnet.gr>",
+  "type": "module",
   "bin": {
-    "digigov": "./bin/run"
+    "digigov": "./index.js"
   },
   "dependencies": {
-    "@oclif/command": "1.8.0",
-    "@oclif/config": "1",
-    "@oclif/plugin-help": "3",
-    "tslib": "2.6.2",
-    "cli-ux": "5.5.1",
-    "@oclif/errors": "1.3.4",
-    "pkg-up": "3.1.0",
     "fs-extra": "11.2.0",
-    "deepmerge": "4.2.2",
-    "execa": "5.0.0",
-    "rimraf": "3.0.2",
-    "glob": "7.1.6",
-    "publint": "0.1.8"
+    "deepmerge": "4.3.1",
+    "execa": "8.0.1",
+    "@microsoft/rush-lib": "5.133.4",
+    "commander": "12.1.0",
+    "chalk": "4.1.0"
   },
   "devDependencies": {
-    "@oclif/dev-cli": "1",
-    "@oclif/test": "1",
-    "@types/chai": "4",
-    "@types/mocha": "5",
-    "@types/node": "18.19.0",
-    "chai": "4",
-    "globby": "11.0.0",
-    "mocha": "5",
-    "nyc": "14",
-    "ts-node": "10.9.2",
-    "typescript": "5.6.2",
-    "publint": "0.1.8",
-    "@microsoft/rush-lib": "5.133.4"
+    "publint": "0.1.8"
   },
   "engines": {
-    "node": ">=12.13.0"
+    "node": ">=18"
   },
   "files": [
-    "/bin",
+    "index.js",
+    "load-commands.js",
     "/lib",
-    "/lib.js",
-    "/resolveProject.js",
-    "/npm-shrinkwrap.json",
-    "/oclif.manifest.json"
-  ],
-  "homepage": "https://github.com/tooling/cli",
-  "keywords": [
-    "oclif"
+    "tsconfig.cli.json"
   ],
-  "main": "lib/index.js",
-  "oclif": {
-    "commands": "./lib/commands",
-    "bin": "digigov",
-    "plugins": [
-      "@oclif/plugin-help"
-    ],
-    "hooks": {
-      "init": "./lib/hooks/init/addcommand"
+  "main": "./index.js",
+  "exports": {
+    ".": "./index.js",
+    "./lib": {
+      "require": "./lib/project-utils.cjs",
+      "default": "./lib/index.js"
     }
   },
-  "types": "lib/index.d.ts",
   "scripts": {
     "publint": "publint",
-    "lint": "echo 'no lint needed (yet)'",
-    "prepublish": "tsc",
-    "test": "nyc --extension .ts mocha --forbid-only \"test/**/*.test.ts\"",
-    "version": "oclif-dev readme && git add README.md",
-    "build": "tsc"
+    "lint": "echo 'no lint needed (yet)'"
   }
 }

package/tsconfig.cli.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "sourceMap": true,
+    "allowJs": true,
+    "declaration": true,
+    "strict": true,
+    "allowSyntheticDefaultImports": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "noImplicitReturns": true,
+    "noImplicitThis": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "alwaysStrict": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "skipDefaultLibCheck": true
+  }
+}

package/bin/run

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-
-require('@oclif/command').run()
-.then(require('@oclif/command/flush'))
-.catch(require('@oclif/errors/handle'))

package/bin/run.cmd

@@ -1,3 +0,0 @@
-@echo off
-
-node "%~dp0\run" %*

package/lib/commands/hello.d.ts

@@ -1,9 +0,0 @@
-import { Command } from '@oclif/command';
-export default class Hello extends Command {
-    static description: string;
-    static examples: string[];
-    static args: {
-        name: string;
-    }[];
-    run(): Promise<void>;
-}

package/lib/commands/hello.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const command_1 = require("@oclif/command");
-class Hello extends command_1.Command {
-    async run() {
-        var _a;
-        const { args, flags } = this.parse(Hello);
-        const name = (_a = flags.name) !== null && _a !== void 0 ? _a : 'world';
-        this.log(`hello ${name} from ./src/commands/hello.ts`);
-        if (args.file && flags.force) {
-            this.log(`you input --force and --file: ${args.file}`);
-        }
-    }
-}
-Hello.description = 'describe the command here';
-Hello.examples = [
-    `$ digigov hello
-hello world from ./src/hello.ts!
-`,
-];
-Hello.args = [{ name: 'file' }];
-exports.default = Hello;

package/lib/hooks/init/addcommand.d.ts

@@ -1,2 +0,0 @@
-declare const hook: (this: any) => Promise<void>;
-export default hook;

package/lib/hooks/init/addcommand.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// @ts-nocheck
-const Config = require("@oclif/config");
-const pkgUp = require("pkg-up");
-const fs = require('fs');
-const packageFile = pkgUp.sync();
-const { dependencies, devDependencies } = JSON.parse(fs.readFileSync(packageFile).toString());
-const plugins = Object.keys(Object.assign(Object.assign({}, dependencies), devDependencies)).filter(p => p.match(/@digigov\/cli-.*?/));
-class DynamicPlugin extends Config.Plugin {
-    get hooks() { return {}; }
-    get topics() {
-        return [];
-    }
-    get commandIDs() {
-        return plugins.map(p => p.match(/@digigov\/cli-(.*?)$/)[1]);
-    }
-    get commands() {
-        return plugins.map(plugin => {
-            return require(plugin);
-        });
-    }
-}
-const hook = async function () {
-    this.config.plugins.push(new DynamicPlugin(this.config));
-};
-exports.default = hook;

package/lib/index.d.ts

@@ -1 +0,0 @@
-export { run } from '@oclif/command';

package/lib.js

@@ -1,45 +0,0 @@
-const fs = require("fs-extra");
-const path = require("path");
-const execa = require("execa");
-const glob = require("glob");
-const { Command } = require("@oclif/command");
-const {
-  makeConfig,
-  resolveLocalPackages,
-  aliases,
-  resolveProject,
-  resolveWorkspace,
-  extractCommandArgs
-} = require("./resolveProject");
-
-
-class DigigovCommand extends Command {
-  async exec(script, args, config) {
-    const binLocation = [process.cwd(), this.dirname, __dirname].find(
-      (location) => {
-        return fs.existsSync(
-          path.join(location, "node_modules", ".bin", script),
-        );
-      },
-    );
-    if (!binLocation || !fs.existsSync(binLocation)) {
-      throw new Error(`Executable ${script} not installed`);
-    }
-    let executable = path.join(binLocation, "node_modules", ".bin", script);
-    console.log("Running ", executable, ...args);
-    try {
-      return await execa(executable, args, { ...config, stdio: "inherit" });
-    } catch (err) {
-      process.exit(err.exitCode);
-    }
-  }
-}
-module.exports = {
-  makeConfig,
-  resolveLocalPackages,
-  aliases,
-  DigigovCommand,
-  resolveProject,
-  resolveWorkspace,
-  extractCommandArgs,
-};

package/oclif.manifest.json

@@ -1 +0,0 @@
-{"version":"1.1.2-daaf7bdf","commands":{"hello":{"id":"hello","description":"describe the command here","pluginName":"@digigov/cli","pluginType":"core","aliases":[],"examples":["$ digigov hello\nhello world from ./src/hello.ts!\n"],"flags":{},"args":[{"name":"file"}]}}}