@capraconsulting/cals-cli 3.14.0 → 3.15.0

package/README.md

@@ -13,52 +13,61 @@ It is recommended to use `npx` over global install to ensure you
 always run the latest version. If you install it globally remember
 to update it before running.
 
-## Build
+## Commands
 
-Build and verify:
+### Authentication
 
-```sh
-$ make  # or "make build"
+Set your GitHub token (will be stored in the OS keychain):
+
+```bash
+cals auth
 ```
 
-## Contributing
+### List repositories
 
-This project uses [semantic release](https://semantic-release.gitbook.io/semantic-release/)
-to automate releases and follows
-[Git commit guidelines](https://github.com/angular/angular/blob/master/CONTRIBUTING.md#commit)
-from the Angular project.
+```bash
+cals repos --org capralifecycle
+cals repos --org capralifecycle --compact
+cals repos --org capralifecycle --csv
+```
+
+### List repository groups
+
+```bash
+cals groups --org capralifecycle
+```
+
+### Generate clone commands
 
-Version numbers depend on the commit type and footers: https://github.com/semantic-release/commit-analyzer/blob/75c9c87c88772d7ded4ca9614852b42519e41931/lib/default-release-rules.js#L7-L12
+Generate clone commands (pipe to bash to execute):
 
-## Goals of CLI
+```bash
+cals clone --org capralifecycle --all | bash
+cals clone --org capralifecycle mygroup | bash
+```
 
-- Provide an uniform way of consistently doing repeatable CALS tasks
-- Provide simple guidelines to improve the experience for developers
-- A tool that everybody uses and gets ownership of
-- Automate repeatable CALS tasks as we go
+### Sync repositories
 
-## Ideas and future work
+Pull latest changes for all repositories in a directory managed by a `.cals.yaml` manifest:
 
-- Automate onboarding of people
-  - Granting access to various resources: AWS, GitHub, Confluence, JIRA, Slack, ...
-- Automate offboarding of people
-- Automate generation of new projects/resources
-  - Creating GitHub repos, giving permissions etc
-  - Slack channels
-  - AWS account and structure
-  - Checklist for manual processes
-- AWS infrastructure management, e.g. scripts such as https://github.com/capralifecycle/rvr-aws-infrastructure/blob/master/rvr/create-stack.sh
-  - `cals aws ...`
+```bash
+cals sync
+cals sync --clone  # Prompt to clone missing repos
+```
 
-### Snyk management
+## Build
 
-https://snyk.docs.apiary.io/reference/projects
+Build and verify:
 
-- [ ] Automatically set up project in Snyk
-- [x] Report of which repos are in Snyk and which is not
-- [ ] Detect active vs disabled projects in Snyk (no way through API now?)
-- [x] Report issues in Snyk grouped by our projects
+```sh
+$ make  # or "make build"
+```
 
 ## Contributing
 
-This project doesn't currently accept contributions. For inquiries, please contact the maintainers at [Slack](https://liflig.slack.com/archives/C02T4KTPYS2).
+This project uses [semantic release](https://semantic-release.gitbook.io/semantic-release/)
+to automate releases and follows
+[Git commit guidelines](https://github.com/angular/angular/blob/master/CONTRIBUTING.md#commit)
+from the Angular project.
+
+For inquiries, please contact the maintainers at [Slack](https://liflig.slack.com/archives/C02T4KTPYS2).

package/lib/cals-cli.mjs

@@ -3,23 +3,23 @@ import * as process from 'node:process';
 import process__default from 'node:process';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
+import keytar from 'keytar';
+import readline from 'node:readline';
+import chalk from 'chalk';
 import fs from 'node:fs';
 import path from 'node:path';
+import os from 'node:os';
+import cachedir from 'cachedir';
 import { Buffer } from 'node:buffer';
 import { performance } from 'node:perf_hooks';
 import { Octokit } from '@octokit/rest';
 import pLimit from 'p-limit';
-import keytar from 'keytar';
-import os from 'node:os';
-import cachedir from 'cachedir';
-import readline from 'node:readline';
-import chalk from 'chalk';
 import { findUp } from 'find-up';
 import yaml from 'js-yaml';
 import AJV from 'ajv';
 import { execa } from 'execa';
 
-var version = "3.14.0";
+var version = "3.15.0";
 var engines = {
 	node: ">=22.14.0"
 };
@@ -46,6 +46,239 @@ class GitHubTokenCliProvider {
     }
 }
 
+const CLEAR_WHOLE_LINE = 0;
+function clearLine(stdout) {
+    readline.clearLine(stdout, CLEAR_WHOLE_LINE);
+    readline.cursorTo(stdout, 0);
+}
+async function readInput(options) {
+    process__default.stdout.write(options.prompt);
+    // For silent mode, read character by character with raw mode to hide input
+    if (options.silent && process__default.stdin.isTTY) {
+        return new Promise((resolve, reject) => {
+            let input = "";
+            process__default.stdin.setRawMode(true);
+            process__default.stdin.resume();
+            process__default.stdin.setEncoding("utf8");
+            const timer = options.timeout
+                ? setTimeout(() => {
+                    cleanup();
+                    reject(new Error("Input timed out"));
+                }, options.timeout)
+                : null;
+            const cleanup = () => {
+                process__default.stdin.setRawMode(false);
+                process__default.stdin.pause();
+                process__default.stdin.removeListener("data", onData);
+                if (timer)
+                    clearTimeout(timer);
+            };
+            const onData = (char) => {
+                if (char === "\r" || char === "\n") {
+                    cleanup();
+                    process__default.stdout.write("\n");
+                    resolve(input);
+                }
+                else if (char === "\u0003") {
+                    // Ctrl+C
+                    cleanup();
+                    process__default.exit(1);
+                }
+                else if (char === "\u007F" || char === "\b") {
+                    // Backspace
+                    input = input.slice(0, -1);
+                }
+                else {
+                    input += char;
+                }
+            };
+            process__default.stdin.on("data", onData);
+        });
+    }
+    // Normal (non-silent) mode
+    const rl = readline.createInterface({
+        input: process__default.stdin,
+        output: process__default.stdout,
+    });
+    return new Promise((resolve, reject) => {
+        const timer = options.timeout
+            ? setTimeout(() => {
+                rl.close();
+                reject(new Error("Input timed out"));
+            }, options.timeout)
+            : null;
+        rl.question("", (answer) => {
+            if (timer)
+                clearTimeout(timer);
+            rl.close();
+            resolve(answer);
+        });
+    });
+}
+class Reporter {
+    stdout = process__default.stdout;
+    stderr = process__default.stderr;
+    format = chalk;
+    error(msg) {
+        clearLine(this.stderr);
+        this.stderr.write(`${this.format.red("error")} ${msg}\n`);
+    }
+    log(msg) {
+        clearLine(this.stdout);
+        this.stdout.write(`${msg}\n`);
+    }
+    warn(msg) {
+        clearLine(this.stderr);
+        this.stderr.write(`${this.format.yellow("warning")} ${msg}\n`);
+    }
+    info(msg) {
+        clearLine(this.stdout);
+        this.stdout.write(`${this.format.blue("info")} ${msg}\n`);
+    }
+}
+
+class CacheProvider {
+    constructor(config) {
+        this.config = config;
+    }
+    mustValidate = false;
+    config;
+    defaultCacheTime = 1800;
+    /**
+     * Retrieve cache if existent, ignoring the time.
+     *
+     * The caller is responsible for handling proper validation,
+     */
+    retrieveJson(cachekey) {
+        const cachefile = path.join(this.config.cacheDir, `${cachekey}.json`);
+        if (!fs.existsSync(cachefile)) {
+            return undefined;
+        }
+        const data = fs.readFileSync(cachefile, "utf-8");
+        return {
+            cacheTime: fs.statSync(cachefile).mtime.getTime(),
+            data: (data === "undefined" ? undefined : JSON.parse(data)),
+        };
+    }
+    /**
+     * Save data to cache.
+     */
+    storeJson(cachekey, data) {
+        const cachefile = path.join(this.config.cacheDir, `${cachekey}.json`);
+        if (!fs.existsSync(this.config.cacheDir)) {
+            fs.mkdirSync(this.config.cacheDir, { recursive: true });
+        }
+        fs.writeFileSync(cachefile, data === undefined ? "undefined" : JSON.stringify(data));
+    }
+    async json(cachekey, block, cachetime = this.defaultCacheTime) {
+        const cacheItem = this.mustValidate
+            ? undefined
+            : this.retrieveJson(cachekey);
+        const expire = new Date(Date.now() - cachetime * 1000).getTime();
+        if (cacheItem !== undefined && cacheItem.cacheTime > expire) {
+            return cacheItem.data;
+        }
+        const result = await block();
+        this.storeJson(cachekey, result);
+        return result;
+    }
+    /**
+     * Delete all cached data.
+     */
+    cleanup() {
+        fs.rmSync(this.config.cacheDir, { recursive: true, force: true });
+    }
+}
+
+class Config {
+    cwd = path.resolve(process__default.cwd());
+    configFile = path.join(os.homedir(), ".cals-config.json");
+    cacheDir = cachedir("cals-cli");
+    configCached = undefined;
+    get config() {
+        const existingConfig = this.configCached;
+        if (existingConfig !== undefined) {
+            return existingConfig;
+        }
+        const config = this.readConfig();
+        this.configCached = config;
+        return config;
+    }
+    readConfig() {
+        if (!fs.existsSync(this.configFile)) {
+            return {};
+        }
+        try {
+            return JSON.parse(fs.readFileSync(this.configFile, "utf-8"));
+        }
+        catch (e) {
+            console.error("Failed", e);
+            throw new Error("Failed to read config");
+        }
+    }
+    getConfig(key) {
+        return this.config[key];
+    }
+    requireConfig(key) {
+        const result = this.config[key];
+        if (result === undefined) {
+            throw Error(`Configuration for ${key} missing. Add manually to ${this.configFile}`);
+        }
+        return result;
+    }
+    updateConfig(key, value) {
+        const updatedConfig = {
+            ...this.readConfig(),
+            [key]: value, // undefined will remove
+        };
+        fs.writeFileSync(this.configFile, JSON.stringify(updatedConfig, null, "  "));
+        this.configCached = updatedConfig;
+    }
+}
+
+function createReporter() {
+    return new Reporter();
+}
+function createCacheProvider(config, argv) {
+    const cache = new CacheProvider(config);
+    if (argv.noCache === true) {
+        cache.mustValidate = true;
+    }
+    return cache;
+}
+function createConfig() {
+    return new Config();
+}
+
+async function authenticate({ reporter, token, tokenProvider, }) {
+    if (token === undefined) {
+        reporter.info("Need API token to talk to GitHub");
+        reporter.info("https://github.com/settings/tokens/new?scopes=repo:status,read:repo_hook");
+        const inputToken = await readInput({
+            prompt: "Enter GitHub token: ",
+            silent: true,
+        });
+        token = inputToken;
+    }
+    await tokenProvider.setToken(token);
+    reporter.info("Token saved to keychain");
+}
+const command$5 = {
+    command: "auth [token]",
+    describe: "Authenticate with GitHub",
+    builder: (yargs) => yargs.positional("token", {
+        describe: "GitHub token (prompted if not provided)",
+        type: "string",
+    }),
+    handler: async (argv) => {
+        await authenticate({
+            reporter: createReporter(),
+            token: argv.token,
+            tokenProvider: new GitHubTokenCliProvider(),
+        });
+    },
+};
+
 class GitHubService {
     octokit;
     cache;
@@ -274,221 +507,45 @@ function includesTopic(repo, topic) {
     return repo.repositoryTopics.edges.some((it) => it.node.topic.name === topic);
 }
 
-class CacheProvider {
-    constructor(config) {
-        this.config = config;
-    }
-    mustValidate = false;
-    config;
-    defaultCacheTime = 1800;
-    /**
-     * Retrieve cache if existent, ignoring the time.
-     *
-     * The caller is responsible for handling proper validation,
-     */
-    retrieveJson(cachekey) {
-        const cachefile = path.join(this.config.cacheDir, `${cachekey}.json`);
-        if (!fs.existsSync(cachefile)) {
-            return undefined;
-        }
-        const data = fs.readFileSync(cachefile, "utf-8");
-        return {
-            cacheTime: fs.statSync(cachefile).mtime.getTime(),
-            data: (data === "undefined" ? undefined : JSON.parse(data)),
-        };
-    }
-    /**
-     * Save data to cache.
-     */
-    storeJson(cachekey, data) {
-        const cachefile = path.join(this.config.cacheDir, `${cachekey}.json`);
-        if (!fs.existsSync(this.config.cacheDir)) {
-            fs.mkdirSync(this.config.cacheDir, { recursive: true });
-        }
-        fs.writeFileSync(cachefile, data === undefined ? "undefined" : JSON.stringify(data));
-    }
-    async json(cachekey, block, cachetime = this.defaultCacheTime) {
-        const cacheItem = this.mustValidate
-            ? undefined
-            : this.retrieveJson(cachekey);
-        const expire = new Date(Date.now() - cachetime * 1000).getTime();
-        if (cacheItem !== undefined && cacheItem.cacheTime > expire) {
-            return cacheItem.data;
-        }
-        const result = await block();
-        this.storeJson(cachekey, result);
-        return result;
-    }
-    /**
-     * Delete all cached data.
-     */
-    cleanup() {
-        fs.rmSync(this.config.cacheDir, { recursive: true, force: true });
-    }
-}
-
-class Config {
-    cwd = path.resolve(process__default.cwd());
-    configFile = path.join(os.homedir(), ".cals-config.json");
-    cacheDir = cachedir("cals-cli");
-    configCached = undefined;
-    get config() {
-        const existingConfig = this.configCached;
-        if (existingConfig !== undefined) {
-            return existingConfig;
-        }
-        const config = this.readConfig();
-        this.configCached = config;
-        return config;
-    }
-    readConfig() {
-        if (!fs.existsSync(this.configFile)) {
-            return {};
-        }
-        try {
-            return JSON.parse(fs.readFileSync(this.configFile, "utf-8"));
-        }
-        catch (e) {
-            console.error("Failed", e);
-            throw new Error("Failed to read config");
-        }
-    }
-    getConfig(key) {
-        return this.config[key];
-    }
-    requireConfig(key) {
-        const result = this.config[key];
-        if (result === undefined) {
-            throw Error(`Configuration for ${key} missing. Add manually to ${this.configFile}`);
-        }
-        return result;
-    }
-    updateConfig(key, value) {
-        const updatedConfig = {
-            ...this.readConfig(),
-            [key]: value, // undefined will remove
-        };
-        fs.writeFileSync(this.configFile, JSON.stringify(updatedConfig, null, "  "));
-        this.configCached = updatedConfig;
-    }
-}
-
-const CLEAR_WHOLE_LINE = 0;
-function clearLine(stdout) {
-    readline.clearLine(stdout, CLEAR_WHOLE_LINE);
-    readline.cursorTo(stdout, 0);
-}
-async function readInput(options) {
-    const rl = readline.createInterface({
-        input: process__default.stdin,
-        output: process__default.stdout,
-    });
-    if (options.silent) {
-        rl._writeToOutput = () => { };
-    }
-    return new Promise((resolve, reject) => {
-        const timer = options.timeout
-            ? setTimeout(() => {
-                rl.close();
-                reject(new Error("Input timed out"));
-            }, options.timeout)
-            : null;
-        rl.question(options.prompt, (answer) => {
-            if (timer)
-                clearTimeout(timer);
-            rl.close();
-            if (options.silent) {
-                process__default.stdout.write("\n");
-            }
-            resolve(answer);
-        });
-    });
-}
-class Reporter {
-    stdout = process__default.stdout;
-    stderr = process__default.stderr;
-    format = chalk;
-    error(msg) {
-        clearLine(this.stderr);
-        this.stderr.write(`${this.format.red("error")} ${msg}\n`);
-    }
-    log(msg) {
-        clearLine(this.stdout);
-        this.stdout.write(`${msg}\n`);
-    }
-    warn(msg) {
-        clearLine(this.stderr);
-        this.stderr.write(`${this.format.yellow("warning")} ${msg}\n`);
-    }
-    info(msg) {
-        clearLine(this.stdout);
-        this.stdout.write(`${this.format.blue("info")} ${msg}\n`);
-    }
-}
-
-function createReporter() {
-    return new Reporter();
-}
-function createCacheProvider(config, argv) {
-    const cache = new CacheProvider(config);
-    if (argv.validateCache === true) {
-        cache.mustValidate = true;
-    }
-    return cache;
-}
-function createConfig() {
-    return new Config();
-}
-
-async function generateCloneCommands({ reporter, config, github, org, ...opt }) {
-    if (!opt.listGroups && !opt.all && opt.group === undefined) {
+async function generateCloneCommands({ config, github, org, ...opt }) {
+    if (!opt.all && opt.group === undefined) {
         yargs(hideBin(process__default.argv)).showHelp();
         return;
     }
     const repos = await github.getOrgRepoList({ org });
     const groups = getGroupedRepos(repos);
-    if (opt.listGroups) {
-        groups.forEach((it) => {
-            reporter.log(it.name);
-        });
-        return;
-    }
-    groups.forEach((group) => {
+    for (const group of groups) {
         if (opt.group !== undefined && opt.group !== group.name) {
-            return;
+            continue;
         }
         group.items
             .filter((it) => opt.includeArchived || !it.isArchived)
             .filter((it) => opt.name === undefined || it.name.includes(opt.name))
             .filter((it) => opt.topic === undefined || includesTopic(it, opt.topic))
-            .filter((it) => !opt.excludeExisting ||
-            !fs.existsSync(path.resolve(config.cwd, it.name)))
+            .filter((it) => !opt.skipCloned || !fs.existsSync(path.resolve(config.cwd, it.name)))
             .forEach((repo) => {
             // The output of this is used to pipe into e.g. bash.
-            // We cannot use reporter.log as it adds additional characters.
             process__default.stdout.write(`[ ! -e "${repo.name}" ] && git clone ${repo.sshUrl}\n`);
         });
-    });
+    }
 }
 const command$4 = {
-    command: "generate-clone-commands",
-    describe: "Generate shell commands to clone GitHub repos for an organization",
+    command: "clone [group]",
+    describe: "Generate git clone commands (pipe to bash to execute)",
     builder: (yargs) => yargs
         .positional("group", {
-        describe: "Group to generate commands for",
+        describe: "Clone only repos in this group",
+        type: "string",
     })
         .options("org", {
-        demandOption: true,
-        describe: "Specify GitHub organization",
+        alias: "o",
+        default: "capralifecycle",
+        requiresArg: true,
+        describe: "GitHub organization",
         type: "string",
     })
         .option("all", {
-        describe: "Use all groups",
-        type: "boolean",
-    })
-        .option("list-groups", {
-        alias: "l",
-        describe: "List available groups",
+        describe: "Clone all repos",
         type: "boolean",
     })
         .option("include-archived", {
@@ -499,37 +556,61 @@ const command$4 = {
         .option("name", {
         describe: "Filter to include the specified name",
         type: "string",
+        requiresArg: true,
     })
         .option("topic", {
         alias: "t",
         describe: "Filter by specific topic",
         type: "string",
+        requiresArg: true,
     })
-        .option("exclude-existing", {
-        alias: "x",
-        describe: "Exclude if existing in working directory",
+        .option("skip-cloned", {
+        alias: "s",
+        describe: "Skip repos already cloned in working directory",
         type: "boolean",
     }),
     handler: async (argv) => {
         const config = createConfig();
         return generateCloneCommands({
-            reporter: createReporter(),
             config,
             github: await createGitHubService({
                 cache: createCacheProvider(config, argv),
             }),
             all: !!argv.all,
-            listGroups: !!argv["list-groups"],
             includeArchived: !!argv["include-archived"],
             name: argv.name,
             topic: argv.topic,
-            excludeExisting: !!argv["exclude-existing"],
+            skipCloned: !!argv["skip-cloned"],
             group: argv.group,
             org: argv.org,
         });
     },
 };
 
+const command$3 = {
+    command: "groups",
+    describe: "List available repository groups in a GitHub organization",
+    builder: (yargs) => yargs.options("org", {
+        alias: "o",
+        default: "capralifecycle",
+        requiresArg: true,
+        describe: "GitHub organization",
+        type: "string",
+    }),
+    handler: async (argv) => {
+        const config = createConfig();
+        const reporter = createReporter();
+        const github = await createGitHubService({
+            cache: createCacheProvider(config, argv),
+        });
+        const repos = await github.getOrgRepoList({ org: argv.org });
+        const groups = getGroupedRepos(repos);
+        for (const group of groups) {
+            reporter.log(group.name);
+        }
+    },
+};
+
 function getReposMissingGroup(repos) {
     return repos.filter((it) => getGroup(it) === null);
 }
@@ -612,13 +693,15 @@ async function listRepos({ reporter, github, includeArchived, name = undefined,
         });
     }
 }
-const command$3 = {
-    command: "list-repos",
-    describe: "List Git repos for a GitHub organization",
+const command$2 = {
+    command: "repos",
+    describe: "List repositories in a GitHub organization",
     builder: (yargs) => yargs
         .options("org", {
-        required: true,
-        describe: "Specify GitHub organization",
+        alias: "o",
+        default: "capralifecycle",
+        requiresArg: true,
+        describe: "GitHub organization",
         type: "string",
     })
         .option("include-archived", {
@@ -638,11 +721,13 @@ const command$3 = {
         .option("name", {
         describe: "Filter to include the specified name",
         type: "string",
+        requiresArg: true,
     })
         .option("topic", {
         alias: "t",
         describe: "Filter by specific topic",
         type: "string",
+        requiresArg: true,
     }),
     handler: async (argv) => {
         const config = createConfig();
@@ -661,34 +746,6 @@ const command$3 = {
     },
 };
 
-async function setToken({ reporter, token, tokenProvider, }) {
-    if (token === undefined) {
-        reporter.info("Need API token to talk to GitHub");
-        reporter.info("https://github.com/settings/tokens/new?scopes=repo:status,read:repo_hook");
-        const inputToken = await readInput({
-            prompt: "Enter new GitHub API token: ",
-            silent: true,
-        });
-        token = inputToken;
-    }
-    await tokenProvider.setToken(token);
-    reporter.info("Token saved");
-}
-const command$2 = {
-    command: "set-token",
-    describe: "Set GitHub token for API calls",
-    builder: (yargs) => yargs.positional("token", {
-        describe: "Token. If not provided it will be requested as input. Can be generated at https://github.com/settings/tokens/new?scopes=repo:status,read:repo_hook",
-    }),
-    handler: async (argv) => {
-        await setToken({
-            reporter: createReporter(),
-            token: argv.token,
-            tokenProvider: new GitHubTokenCliProvider(),
-        });
-    },
-};
-
 var type = "object";
 var properties = {
 	projects: {
@@ -1200,7 +1257,7 @@ async function askMoveConfirm() {
             return false;
     }
 }
-async function sync({ reporter, github, cals, rootdir, askClone, askMove, }) {
+async function sync({ reporter, github, cals, rootdir, clone, move, }) {
     const { expectedRepos, definitionRepo } = await getExpectedRepos(reporter, github, cals, rootdir);
     const unknownDirs = [];
     const foundRepos = [];
@@ -1260,8 +1317,8 @@ async function sync({ reporter, github, cals, rootdir, askClone, askMove, }) {
         for (const it of movedRepos) {
             reporter.info(`  ${it.actualRelpath} -> ${getRelpath(it)}`);
         }
-        if (!askMove) {
-            reporter.info("To move these repos on disk add --ask-move option");
+        if (!move) {
+            reporter.info("To move these repos on disk add --move option");
         }
         else {
             const shouldMove = await askMoveConfirm();
@@ -1293,8 +1350,8 @@ async function sync({ reporter, github, cals, rootdir, askClone, askMove, }) {
         for (const it of missingRepos) {
             reporter.info(`  ${it.id}`);
         }
-        if (!askClone) {
-            reporter.info("To clone these repos add --ask-clone option for dialog");
+        if (!clone) {
+            reporter.info("To clone these repos add --clone option");
         }
         else {
             reporter.info("You must already have working credentials for GitHub set up for clone to work");
@@ -1342,16 +1399,17 @@ const command$1 = {
     command: "sync",
     describe: "Sync repositories for working directory",
     builder: (yargs) => yargs
-        .option("ask-clone", {
+        .option("clone", {
         alias: "c",
-        describe: "Ask to clone new missing repos",
+        describe: "Prompt to clone missing repos",
         type: "boolean",
     })
-        .option("ask-move", {
-        describe: "Ask to actual move renamed repos",
+        .option("move", {
+        alias: "m",
+        describe: "Prompt to move renamed repos",
         type: "boolean",
     })
-        .usage(`cals github sync
+        .usage(`cals sync
 
 Synchronize all checked out GitHub repositories within the working directory
 grouped by the project in the resource definition file. The command can also
@@ -1400,39 +1458,42 @@ will be stored there.`),
             github,
             cals,
             rootdir: dir,
-            askClone: !!argv["ask-clone"],
-            askMove: !!argv["ask-move"],
+            clone: !!argv.clone,
+            move: !!argv.move,
         });
     },
 };
 
 const command = {
-    command: "github",
-    describe: "Integration with GitHub",
-    builder: (yargs) => yargs
-        .command(command$4)
-        .command(command$3)
-        .command(command$2)
-        .command(command$1)
-        .demandCommand()
-        .usage(`cals github
-
-Notes:
-  Before doing anything against GitHub you need to configure a token
-  used for authentication. The following command will ask for a token
-  and provide a link to generate one:
-  $ cals github set-token
-
-  Quick clone all repos:
-  $ cals github generate-clone-commands --org capralifecycle --all -x | bash
-
-  And for a specific project:
-  $ cals github generate-clone-commands --org capralifecycle -x buildtools | bash
-
-  Some responses are cached for some time. Use the --validate-cache
-  option to avoid stale cache.`),
-    handler: () => {
-        yargs(hideBin(process__default.argv)).showHelp();
+    command: "topics",
+    describe: "List customer topics in a GitHub organization",
+    builder: (yargs) => yargs.options("org", {
+        alias: "o",
+        default: "capralifecycle",
+        requiresArg: true,
+        describe: "GitHub organization",
+        type: "string",
+    }),
+    handler: async (argv) => {
+        const config = createConfig();
+        const reporter = createReporter();
+        const github = await createGitHubService({
+            cache: createCacheProvider(config, argv),
+        });
+        const repos = await github.getOrgRepoList({ org: argv.org });
+        const topics = new Set();
+        for (const repo of repos) {
+            for (const edge of repo.repositoryTopics.edges) {
+                const name = edge.node.topic.name;
+                if (name.startsWith("customer-")) {
+                    topics.add(name);
+                }
+            }
+        }
+        const sorted = [...topics].sort((a, b) => a.localeCompare(b));
+        for (const topic of sorted) {
+            reporter.log(topic);
+        }
     },
 };
 
@@ -1459,17 +1520,35 @@ async function main() {
         process__default.exit(1);
     }
     await yargs(hideBin(process__default.argv))
-        .usage(`cals-cli v${version} (build: ${"2026-01-30T14:13:10.419Z"})`)
+        .usage(`cals v${version} (build: ${"2026-01-30T15:20:39.822Z"})
+
+A CLI for managing GitHub repositories.
+
+Before using, authenticate with: cals auth`)
         .scriptName("cals")
         .locale("en")
+        .strict()
+        .strictCommands()
+        .strictOptions()
         .help("help")
+        .command(command$5)
+        .command(command$4)
+        .command(command$3)
+        .command(command$2)
+        .command(command$1)
         .command(command)
         .version(version)
         .demandCommand()
-        .option("validate-cache", {
-        describe: "Only read from cache if validated against server",
+        .option("no-cache", {
+        describe: "Bypass cache and fetch fresh data",
         type: "boolean",
     })
+        .example("cals auth", "Set GitHub token")
+        .example("cals repos", "List repositories")
+        .example("cals groups", "List repository groups")
+        .example("cals topics", "List customer topics")
+        .example("cals clone --all | bash", "Clone all repos")
+        .example("cals sync", "Pull latest changes")
         .parse();
 }
 

package/lib/cals-cli.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"cals-cli.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"cals-cli.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/cli/commands/{github/generate-clone-commands.d.ts → repos.d.ts}

@@ -1,3 +1,3 @@
-import { type CommandModule } from "yargs";
+import type { CommandModule } from "yargs";
 declare const command: CommandModule;
 export default command;

package/lib/cli/commands/{github/sync.d.ts → sync.d.ts}

@@ -1,5 +1,5 @@
 import type { CommandModule } from "yargs";
-import type { DefinitionRepo } from "../../../definition/types";
+import type { DefinitionRepo } from "../../definition/types";
 interface Alias {
     group: string;
     name: string;

package/lib/cli/commands/topics.d.ts

@@ -0,0 +1,3 @@
+import type { CommandModule } from "yargs";
+declare const command: CommandModule;
+export default command;

package/lib/index.es.js

@@ -9,7 +9,7 @@ import { Octokit } from '@octokit/rest';
 import pLimit from 'p-limit';
 import keytar from 'keytar';
 
-var version = "3.14.0";
+var version = "3.15.0";
 
 function uniq(array) {
     return Array.from(new Set(array));

package/lib/index.js

@@ -9,7 +9,7 @@ import { Octokit } from '@octokit/rest';
 import pLimit from 'p-limit';
 import keytar from 'keytar';
 
-var version = "3.14.0";
+var version = "3.15.0";
 
 function uniq(array) {
     return Array.from(new Set(array));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capraconsulting/cals-cli",
-  "version": "3.14.0",
+  "version": "3.15.0",
   "description": "CLI for repeatable tasks in CALS",
   "type": "module",
   "license": "Apache-2.0",