@gabaltech/cli 0.1.0

package/bin/gabal.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+'use strict';
+
+const { Command } = require('commander');
+
+const configCmd     = require('../src/commands/config');
+const usersCmd      = require('../src/commands/users');
+const deployCmd     = require('../src/commands/deploy');
+const blueprintsCmd = require('../src/commands/blueprints');
+const apiKeysCmd    = require('../src/commands/api-keys');
+const loginCmd      = require('../src/commands/login');
+const generateCmd   = require('../src/commands/generate');
+const reviewCmd     = require('../src/commands/review');
+const docsCmd       = require('../src/commands/docs');
+const initCmd       = require('../src/commands/init');
+
+const program = new Command();
+
+program
+  .name('gabal')
+  .description('Gabaltech platform CLI — design, generate, deploy, and manage AWS infrastructure')
+  .version('0.1.0')
+  .addCommand(loginCmd)
+  .addCommand(configCmd)
+  .addCommand(usersCmd)
+  .addCommand(deployCmd)
+  .addCommand(blueprintsCmd)
+  .addCommand(apiKeysCmd)
+  .addCommand(generateCmd)
+  .addCommand(reviewCmd)
+  .addCommand(docsCmd)
+  .addCommand(initCmd);
+
+program.parseAsync(process.argv).catch(err => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});

package/bin/gabaltech.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+'use strict';
+
+const { Command } = require('commander');
+
+const configCmd     = require('../src/commands/config');
+const usersCmd      = require('../src/commands/users');
+const deployCmd     = require('../src/commands/deploy');
+const blueprintsCmd = require('../src/commands/blueprints');
+const apiKeysCmd    = require('../src/commands/api-keys');
+
+const program = new Command();
+
+program
+  .name('gabaltech')
+  .description('Gabaltech platform CLI')
+  .version('0.1.0')
+  .addCommand(configCmd)
+  .addCommand(usersCmd)
+  .addCommand(deployCmd)
+  .addCommand(blueprintsCmd)
+  .addCommand(apiKeysCmd);
+
+program.parseAsync(process.argv).catch(err => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@gabaltech/cli",
+  "version": "0.1.0",
+  "description": "Gabaltech platform CLI — design, generate, deploy, and manage AWS infrastructure",
+  "bin": {
+    "gabal": "./bin/gabal.js"
+  },
+  "type": "commonjs",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "jest --forceExit",
+    "lint": "eslint src/ bin/"
+  },
+  "dependencies": {
+    "@aws-sdk/client-cognito-identity-provider": "^3.0.0",
+    "chalk": "^4.1.2",
+    "cli-table3": "^0.6.5",
+    "commander": "^12.0.0",
+    "js-yaml": "^4.1.0"
+  },
+  "devDependencies": {
+    "jest": "^29.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://gitlab.com/gabaltech1/cli.git"
+  },
+  "license": "UNLICENSED",
+  "files": [
+    "bin/",
+    "src/"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/commands/api-keys.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const { Command } = require('commander');
+const idp = require('../idp-client');
+const { printTable } = require('../utils/table');
+
+const apiKeysCmd = new Command('api-keys').description('Manage IDP API keys');
+
+apiKeysCmd
+  .command('list')
+  .description('List all API keys (hashes not shown)')
+  .option('--json', 'Output raw JSON')
+  .action(async (opts) => {
+    const { keys } = await idp.listApiKeys();
+    if (opts.json) { console.log(JSON.stringify(keys, null, 2)); return; }
+    printTable(
+      ['ID', 'Name', 'Scopes', 'Created By', 'Last Used'],
+      keys.map(k => [
+        k.keyId.slice(0, 8),
+        k.name,
+        (k.scopes ?? []).join(', '),
+        k.createdBy,
+        k.lastUsed ? new Date(k.lastUsed).toLocaleString() : 'never',
+      ]),
+    );
+  });
+
+apiKeysCmd
+  .command('create <name>')
+  .description('Create a new API key — the key is shown once, save it immediately')
+  .option('--scope <scope>', 'Add scope (repeatable)', (v, acc) => [...acc, v], [])
+  .action(async (name, opts) => {
+    const scopes = opts.scope.length ? opts.scope : ['admin'];
+    const result = await idp.createApiKey(name, scopes);
+    console.log('\nAPI key created. Save this — it will not be shown again:\n');
+    console.log(`  ${result.key}\n`);
+    console.log(`  ID:     ${result.keyId}`);
+    console.log(`  Name:   ${result.name}`);
+    console.log(`  Scopes: ${result.scopes.join(', ')}`);
+    console.log('');
+    console.log(`Run to store locally: gabaltech config set api-key ${result.key}`);
+  });
+
+apiKeysCmd
+  .command('revoke <keyId>')
+  .description('Revoke an API key by ID')
+  .action(async (keyId) => {
+    await idp.revokeApiKey(keyId);
+    console.log(`Revoked: ${keyId}`);
+  });
+
+module.exports = apiKeysCmd;

package/src/commands/blueprints.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const { Command } = require('commander');
+const idp = require('../idp-client');
+const { printTable } = require('../utils/table');
+
+const blueprintsCmd = new Command('blueprints').description('Manage and provision service blueprints');
+
+blueprintsCmd
+  .command('list')
+  .description('List available blueprint catalogs')
+  .option('--json', 'Output raw JSON')
+  .action(async (opts) => {
+    const { catalogs } = await idp.listCatalogs();
+    if (opts.json) { console.log(JSON.stringify(catalogs, null, 2)); return; }
+    printTable(
+      ['ID', 'Name', 'Description'],
+      catalogs.map(c => [c.id, c.name, c.description ?? '']),
+    );
+  });
+
+blueprintsCmd
+  .command('provision <catalogId> <serviceName> <environment>')
+  .description('Provision a new service from a blueprint (e.g. dynamodb my-table dev)')
+  .option('--field <kv>', 'Field value in key=value format (repeatable)', (v, acc) => [...acc, v], [])
+  .option('--json', 'Output raw JSON')
+  .action(async (catalogId, serviceName, environment, opts) => {
+    const fields = Object.fromEntries(opts.field.map(kv => {
+      const idx = kv.indexOf('=');
+      return [kv.slice(0, idx), kv.slice(idx + 1)];
+    }));
+    const { deployment } = await idp.provision(catalogId, serviceName, environment, fields);
+    if (opts.json) { console.log(JSON.stringify(deployment, null, 2)); return; }
+    console.log(`Provisioned: ${deployment?.deploymentId ?? '?'} [${deployment?.status ?? '?'}]`);
+  });
+
+module.exports = blueprintsCmd;

package/src/commands/config.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const { Command } = require('commander');
+const cfg = require('../config');
+
+const configCmd = new Command('config')
+  .description('Manage CLI configuration (~/.gabaltech/config.json)');
+
+configCmd
+  .command('set <key> <value>')
+  .description('Set a config value')
+  .action((key, value) => {
+    cfg.set(key, value);
+    console.log(`Set ${key}`);
+  });
+
+configCmd
+  .command('get <key>')
+  .description('Get a config value')
+  .action((key) => {
+    const v = cfg.get(key);
+    if (v === undefined) { console.error(`Key not found: ${key}`); process.exit(1); }
+    console.log(v);
+  });
+
+configCmd
+  .command('unset <key>')
+  .description('Remove a config value')
+  .action((key) => {
+    cfg.unset(key);
+    console.log(`Unset ${key}`);
+  });
+
+configCmd
+  .command('list')
+  .description('Show all config values')
+  .action(() => {
+    const data = cfg.load();
+    if (!Object.keys(data).length) { console.log('No config set.'); return; }
+    for (const [k, v] of Object.entries(data)) {
+      const display = k === 'api-key' ? v.slice(0, 12) + '...' : v;
+      console.log(`${k}=${display}`);
+    }
+  });
+
+module.exports = configCmd;

package/src/commands/deploy.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const { Command } = require('commander');
+const idp = require('../idp-client');
+const { printTable } = require('../utils/table');
+
+const deployCmd = new Command('deploy').description('Trigger and list deployments');
+
+deployCmd
+  .command('trigger <service> <environment>')
+  .description('Trigger a deployment (e.g. website prod)')
+  .option('--version <tag>', 'Image tag / version', 'latest')
+  .option('--reason <reason>', 'Reason for deployment', 'CLI trigger')
+  .action(async (service, environment, opts) => {
+    const { deployment } = await idp.triggerDeploy(service, environment, opts.version, opts.reason);
+    console.log(`Deployment queued: ${deployment?.deploymentId ?? '?'} [${deployment?.status ?? '?'}]`);
+  });
+
+deployCmd
+  .command('list')
+  .description('List recent deployments')
+  .option('--service <service>', 'Filter by service')
+  .option('--env <env>', 'Filter by environment')
+  .option('--limit <n>', 'Max results', '20')
+  .option('--json', 'Output raw JSON')
+  .action(async (opts) => {
+    const { deployments } = await idp.listDeployments({
+      service:     opts.service,
+      environment: opts.env,
+      limit:       opts.limit,
+    });
+    if (opts.json) { console.log(JSON.stringify(deployments, null, 2)); return; }
+    printTable(
+      ['ID', 'Service', 'Env', 'Version', 'Status', 'By', 'At'],
+      deployments.map(d => [
+        (d.deploymentId ?? '').slice(0, 8),
+        d.service ?? '',
+        d.environment ?? '',
+        d.version ?? '',
+        d.status ?? '',
+        d.requestedBy ?? '',
+        d.requestedAt ? new Date(d.requestedAt).toLocaleString() : '',
+      ]),
+    );
+  });
+
+module.exports = deployCmd;

package/src/commands/docs.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const { Command } = require('commander');
+const fs = require('fs');
+const path = require('path');
+const idp = require('../idp-client');
+
+const docsCmd = new Command('docs').description('Generate architecture docs from a design');
+
+docsCmd
+  .option('--design <designId>', 'Design ID from the IDP')
+  .option('--output <dir>', 'Output directory', './gabaltech-docs')
+  .action(async (opts) => {
+    if (!opts.design) {
+      console.error('Error: --design <designId> is required');
+      process.exit(1);
+    }
+
+    const { docs } = await idp.generateDocs(opts.design);
+
+    const outDir = path.resolve(opts.output);
+    fs.mkdirSync(outDir, { recursive: true });
+    fs.writeFileSync(path.join(outDir, 'architecture.md'), docs.architecture ?? '', 'utf8');
+    fs.writeFileSync(path.join(outDir, 'runbook.md'),      docs.runbook      ?? '', 'utf8');
+
+    console.log(`Documentation generated → ${opts.output}/`);
+  });
+
+module.exports = docsCmd;

package/src/commands/generate.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const { Command } = require('commander');
+const fs = require('fs');
+const path = require('path');
+const idp = require('../idp-client');
+
+const generateCmd = new Command('generate').description('Generate Terraform from a design or prompt');
+
+generateCmd
+  .option('--design <designId>', 'Design ID from the IDP')
+  .option('--prompt <text>', 'Describe your architecture in plain text')
+  .option('--output <dir>', 'Output directory', './gabaltech-infra')
+  .action(async (opts) => {
+    if (!opts.design && !opts.prompt) {
+      console.error('Error: provide --design <id> or --prompt "<text>"');
+      process.exit(1);
+    }
+
+    let payload;
+    if (opts.design) {
+      const design = await idp.getDesign(opts.design);
+      payload = { design };
+    } else {
+      payload = { prompt: opts.prompt };
+    }
+
+    const { terraform } = await idp.generateTerraform(payload);
+
+    const outDir = path.resolve(opts.output);
+    fs.mkdirSync(outDir, { recursive: true });
+    fs.writeFileSync(path.join(outDir, 'main.tf'),      terraform.main      ?? '', 'utf8');
+    fs.writeFileSync(path.join(outDir, 'variables.tf'), terraform.variables ?? '', 'utf8');
+    fs.writeFileSync(path.join(outDir, 'outputs.tf'),   terraform.outputs   ?? '', 'utf8');
+
+    console.log(`Terraform generated → ${opts.output}/`);
+  });
+
+module.exports = generateCmd;

package/src/commands/init.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const { Command } = require('commander');
+const fs = require('fs');
+const path = require('path');
+const cfg = require('../config');
+
+const initCmd = new Command('init').description('Scaffold a new Gabaltech project');
+
+initCmd
+  .option('--name <project>', 'Project name', 'my-project')
+  .option('--type <type>', 'Project type: serverless|container|platform', 'container')
+  .action((opts) => {
+    const root = path.resolve(opts.name);
+    fs.mkdirSync(path.join(root, 'infra'), { recursive: true });
+    fs.mkdirSync(path.join(root, 'docs'),  { recursive: true });
+    fs.writeFileSync(path.join(root, 'infra', '.gitkeep'), '', 'utf8');
+    fs.writeFileSync(path.join(root, 'docs',  '.gitkeep'), '', 'utf8');
+    fs.writeFileSync(
+      path.join(root, 'gabaltech.json'),
+      JSON.stringify({ name: opts.name, type: opts.type, idpUrl: cfg.getIdpUrl() }, null, 2) + '\n',
+      'utf8',
+    );
+    console.log(`Project scaffolded → ./${opts.name}/`);
+  });
+
+module.exports = initCmd;

package/src/commands/login.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const { Command } = require('commander');
+const cfg = require('../config');
+
+const loginCmd = new Command('login').description('Authenticate with the Gabaltech IDP');
+
+loginCmd
+  .option('--token <api-key>', 'API key to save')
+  .option('--url <url>', 'IDP URL (default: https://idp.gabaltech.co.uk)')
+  .action((opts) => {
+    if (opts.url) {
+      cfg.set('idp-url', opts.url);
+    }
+    if (opts.token) {
+      cfg.set('api-key', opts.token);
+      console.log('Logged in. API key saved.');
+      return;
+    }
+    console.log('To authenticate:');
+    console.log('  1. Open https://idp.gabaltech.co.uk/admin/api-keys');
+    console.log('  2. Create a new API key with scope: cli');
+    console.log('  3. Run: gabal login --token <your-api-key>');
+  });
+
+module.exports = loginCmd;

package/src/commands/review.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const { Command } = require('commander');
+const fs = require('fs');
+const path = require('path');
+const idp = require('../idp-client');
+
+const SEVERITY_ORDER = { CRITICAL: 0, WARNING: 1, INFO: 2 };
+
+const reviewCmd = new Command('review').description('AI review of Terraform files');
+
+reviewCmd
+  .option('--file <path>', 'Single .tf file to review')
+  .option('--dir <path>', 'Directory of .tf files to review')
+  .action(async (opts) => {
+    if (!opts.file && !opts.dir) {
+      console.error('Error: provide --file <path> or --dir <path>');
+      process.exit(1);
+    }
+
+    let content;
+    if (opts.file) {
+      content = fs.readFileSync(path.resolve(opts.file), 'utf8');
+    } else {
+      const dir = path.resolve(opts.dir);
+      const files = fs.readdirSync(dir).filter(f => f.endsWith('.tf'));
+      if (!files.length) { console.error('No .tf files found in', dir); process.exit(1); }
+      content = files.map(f => fs.readFileSync(path.join(dir, f), 'utf8')).join('\n\n');
+    }
+
+    const { findings } = await idp.reviewTerraform(content);
+
+    if (!findings?.length) { console.log('No findings.'); return; }
+
+    findings
+      .slice()
+      .sort((a, b) => (SEVERITY_ORDER[a.severity] ?? 99) - (SEVERITY_ORDER[b.severity] ?? 99))
+      .forEach(f => console.log(`[${f.severity ?? 'INFO'}] ${f.message ?? f}`));
+  });
+
+module.exports = reviewCmd;

package/src/commands/users.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const { Command } = require('commander');
+const fs   = require('fs');
+const yaml = require('js-yaml');
+const idp  = require('../idp-client');
+const { printTable } = require('../utils/table');
+
+const usersCmd = new Command('users').description('Manage Cognito users via IDP API');
+
+usersCmd
+  .command('list')
+  .description('List all users')
+  .option('--json', 'Output raw JSON')
+  .action(async (opts) => {
+    const { users } = await idp.listUsers();
+    if (opts.json) { console.log(JSON.stringify(users, null, 2)); return; }
+    printTable(
+      ['Email', 'Name', 'Status', 'Enabled'],
+      users.map(u => [u.email, u.name || '', u.status, u.enabled ? 'yes' : 'no']),
+    );
+  });
+
+usersCmd
+  .command('invite <email>')
+  .description('Invite a new user')
+  .option('--name <name>', 'Display name')
+  .option('--admin', 'Make user an approver')
+  .action(async (email, opts) => {
+    const result = await idp.inviteUser(email, opts.name, !!opts.admin);
+    console.log(`Invited: ${result.user?.username ?? email}`);
+  });
+
+usersCmd
+  .command('delete <username>')
+  .description('Delete a user by username')
+  .action(async (username) => {
+    await idp.deleteUser(username);
+    console.log(`Deleted: ${username}`);
+  });
+
+usersCmd
+  .command('set-admin <username>')
+  .description('Grant or revoke admin (approver) role')
+  .option('--revoke', 'Remove admin role instead')
+  .action(async (username, opts) => {
+    const is_admin = !opts.revoke;
+    await idp.patchUser(username, { is_admin });
+    console.log(`${is_admin ? 'Granted' : 'Revoked'} admin for ${username}`);
+  });
+
+usersCmd
+  .command('sync')
+  .description('Sync users from a YAML or JSON file')
+  .requiredOption('--file <path>', 'Path to users file')
+  .option('--dry-run', 'Show what would happen without making changes')
+  .option('--json', 'Output raw JSON result')
+  .action(async (opts) => {
+    const raw  = fs.readFileSync(opts.file, 'utf8');
+    const data = opts.file.endsWith('.json') ? JSON.parse(raw) : yaml.load(raw);
+    const users = Array.isArray(data) ? data : data.users;
+
+    if (!users?.length) { console.error('No users found in file'); process.exit(1); }
+
+    if (opts.dryRun) {
+      console.log(`Dry run — would sync ${users.length} users:`);
+      for (const u of users) console.log(`  ${u.email}${u.is_admin ? ' [admin]' : ''}`);
+      return;
+    }
+
+    const result = await idp.syncUsers(users);
+
+    if (opts.json) { console.log(JSON.stringify(result, null, 2)); return; }
+    if (result.invited.length)  console.log(`Invited (${result.invited.length}):`,  result.invited.map(u => u.email).join(', '));
+    if (result.updated.length)  console.log(`Updated (${result.updated.length}):`,  result.updated.map(u => u.email).join(', '));
+    if (result.skipped.length)  console.log(`Skipped (${result.skipped.length}):`,  result.skipped.map(u => u.email).join(', '));
+    if (result.errors.length) {
+      console.error(`Errors (${result.errors.length}):`);
+      for (const e of result.errors) console.error(`  ${e.email}: ${e.error}`);
+      process.exitCode = 1;
+    }
+  });
+
+module.exports = usersCmd;

package/src/config.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+const CONFIG_DIR  = path.join(os.homedir(), '.gabaltech');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+function load() {
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function save(data) {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(data, null, 2), 'utf8');
+}
+
+function get(key) {
+  return load()[key];
+}
+
+function set(key, value) {
+  const cfg = load();
+  cfg[key] = value;
+  save(cfg);
+}
+
+function unset(key) {
+  const cfg = load();
+  delete cfg[key];
+  save(cfg);
+}
+
+function getIdpUrl() {
+  return process.env.GABALTECH_IDP_URL || get('idp-url') || 'https://idp.gabaltech.co.uk';
+}
+
+function getApiKey() {
+  return process.env.GABALTECH_API_KEY || get('api-key');
+}
+
+function getAwsProfile() {
+  return process.env.AWS_PROFILE || get('aws-profile') || 'gabaltech';
+}
+
+function getCognitoPoolId() {
+  return process.env.COGNITO_USER_POOL_ID || get('cognito-pool-id');
+}
+
+module.exports = { load, save, get, set, unset, getIdpUrl, getApiKey, getAwsProfile, getCognitoPoolId };

package/src/idp-client.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const cfg = require('./config');
+
+async function request(method, path, body) {
+  const apiKey = cfg.getApiKey();
+  if (!apiKey) throw new Error('No API key configured. Run: gabaltech config set api-key <key>');
+
+  const url     = `${cfg.getIdpUrl()}${path}`;
+  const headers = {
+    'Authorization': `Bearer ${apiKey}`,
+    'Content-Type':  'application/json',
+    'Accept':        'application/json',
+  };
+
+  const res = await fetch(url, {
+    method,
+    headers,
+    body: body ? JSON.stringify(body) : undefined,
+  });
+
+  const text = await res.text();
+  let data;
+  try { data = JSON.parse(text); } catch { data = { raw: text }; }
+
+  if (!res.ok) {
+    throw new Error(data.error || `HTTP ${res.status}: ${text.slice(0, 200)}`);
+  }
+  return data;
+}
+
+const idp = {
+  // Users
+  listUsers:   ()                         => request('GET',    '/api/admin/users'),
+  inviteUser:  (email, name, is_admin)    => request('POST',   '/api/admin/users/invite',  { email, name, is_admin }),
+  syncUsers:   (users)                    => request('POST',   '/api/admin/users/sync',    { users }),
+  deleteUser:  (username)                 => request('DELETE', `/api/admin/users/${encodeURIComponent(username)}`),
+  patchUser:   (username, patch)          => request('PATCH',  `/api/admin/users/${encodeURIComponent(username)}`, patch),
+
+  // API keys
+  listApiKeys:   ()                       => request('GET',    '/api/admin/api-keys'),
+  createApiKey:  (name, scopes)           => request('POST',   '/api/admin/api-keys', { name, scopes }),
+  revokeApiKey:  (keyId)                  => request('DELETE', `/api/admin/api-keys/${keyId}`),
+
+  // Deployments
+  listDeployments: (opts = {}) => {
+    const qs = new URLSearchParams(Object.entries(opts).filter(([, v]) => v)).toString();
+    return request('GET', `/api/deployments${qs ? '?' + qs : ''}`);
+  },
+  triggerDeploy: (service, environment, version, reason) =>
+    request('POST', '/api/deployments', { service, environment, version, reason }),
+
+  // Blueprints
+  listCatalogs:   ()                              => request('GET',  '/api/catalogs'),
+  provision:      (catalogId, serviceName, environment, fields) =>
+    request('POST', '/api/blueprints/provision', { catalogId, serviceName, environment, fields }),
+
+  // Auth
+  verifyApiKey: () => request('GET', '/api/auth/verify'),
+
+  // Designs + generation
+  getDesign:        (id)      => request('GET',  `/api/designs/${encodeURIComponent(id)}`),
+  generateTerraform: (payload) => request('POST', '/api/generate/terraform', payload),
+  reviewTerraform:  (content) => request('POST', '/api/review/terraform', { content }),
+  generateDocs:     (designId) => request('POST', '/api/generate/docs', { designId }),
+};
+
+module.exports = idp;

package/src/utils/table.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const Table = require('cli-table3');
+
+function printTable(headers, rows) {
+  const t = new Table({ head: headers, style: { head: ['cyan'] } });
+  for (const row of rows) t.push(row);
+  console.log(t.toString());
+}
+
+module.exports = { printTable };