@bstopp/git-who 0.1.0 → 0.2.0

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bstopp/git-who",
-    "version": "0.1.0",
+    "version": "0.2.0",
     "type": "module",
     "description": "Manage git profiles for per-project SSH account configuration.",
     "license": "Apache-2.0",

package/dist/src/cli.js

@@ -19,14 +19,18 @@ program
 program
     .command('show [name]')
     .description('Show the current git profile for this repo')
+    .option('--json', 'Print the result as JSON')
     .action(show);
 program
     .command('list')
     .description('List all available profiles')
+    .option('--json', 'Print the result as JSON')
     .action(list);
 program
     .command('use [name]')
     .description('Set the profile for this repo.')
+    .option('--json', 'Print the result as JSON, without prompting (a profile name is required)')
+    .option('--update-origin', 'Update the origin remote to match the profile, without asking')
     .action(use);
 program
     .command('add')
@@ -45,16 +49,19 @@ program
     .description('Clone a remote repo using a specific profile.')
     .action(clone);
 /**
- * Join an error's message with those of its `cause` chain, one per line, so wrapped failures show the real reason.
+ * The message of an error followed by those of its `cause` chain, so wrapped failures show the real reason.
  */
-function describeError(err) {
-    const lines = [];
+function errorMessages(err) {
+    const messages = [];
     let current = err;
     while (current instanceof Error) {
-        lines.push(lines.length === 0 ? current.message : `Caused by: ${current.message}`);
+        messages.push(current.message);
         current = current.cause;
     }
-    return lines.length > 0 ? lines.join('\n') : String(err);
+    return messages.length > 0 ? messages : [String(err)];
+}
+function describeError(err) {
+    return errorMessages(err).map((message, i) => i === 0 ? message : `Caused by: ${message}`).join('\n');
 }
 /**
  * Run the cli, printing any failure (with its cause chain) and setting a non-zero exit code. A cancelled prompt
@@ -69,7 +76,13 @@ export async function run(argv) {
             process.exitCode = SIGINT_EXIT_CODE;
             return;
         }
-        log.error(describeError(err));
+        if (argv.includes('--json')) {
+            const [error, ...causes] = errorMessages(err);
+            log.json({ error, causes });
+        }
+        else {
+            log.error(describeError(err));
+        }
         process.exitCode = 1;
     }
 }

package/dist/src/commands/list.js

@@ -2,9 +2,13 @@ import chalk from 'chalk';
 import { simpleGit } from 'simple-git';
 import log from "../utils/log.js";
 import { loadProfiles, getActiveProfileName } from "../utils/profiles.js";
-export default async function list() {
+export default async function list(options = {}) {
     const profiles = await loadProfiles();
     const activeName = await getActiveProfileName(simpleGit());
+    if (options.json) {
+        log.json(profiles.map((p) => ({ ...p, active: p.name === activeName })));
+        return;
+    }
     const lines = profiles.map((p) => {
         if (p.name === activeName) {
             return chalk.bold(`  - ${p.name} (${p.host})`);

package/dist/src/commands/show.js

@@ -128,14 +128,43 @@ async function resolveProfile(name, profiles) {
         return await resolveFromGit(profiles);
     }
 }
+/**
+ * The result as a plain object for `--json`. The warnings that are printed as text become fields, so nothing is lost
+ * from stdout. A mismatched field git has no value for is `null`, which JSON would otherwise drop from the object.
+ */
+function toJson(resolved, signingKeyStatus) {
+    const { profile, derived, mismatches } = resolved;
+    return {
+        profile,
+        derived,
+        signingKeyStatus,
+        mismatches: mismatches && Object.fromEntries(Object.entries(mismatches).map(([field, value]) => [field, value ?? null])),
+    };
+}
+/**
+ * The extras for `printProfile`, or `undefined` when there are none, so a plain profile is printed without them.
+ */
+function displayOptions(resolved, signingKeyStatus) {
+    let opts = undefined;
+    if (resolved.mismatches && Object.keys(resolved.mismatches).length > 0) {
+        opts ||= {};
+        opts.mismatches = resolved.mismatches;
+    }
+    if (signingKeyStatus) {
+        opts ||= {};
+        opts.signingKeyStatus = signingKeyStatus;
+    }
+    return opts;
+}
 /**
  * Print a profile, either the one given by name or the one resolved from the current repo. A profile resolved from the
- * repo is also checked against its git config, and any signing key is looked up to confirm it exists.
+ * repo is also checked against its git config, and any signing key is looked up to confirm it exists. With `json` the
+ * result is printed as JSON instead.
  *
  * @throws {Error} If no name is given outside a git repo, the named profile does not exist, or no profile can be
  * resolved from the repo. Errors from the ssh and gpg key lookups are not caught.
  */
-export default async function show(name) {
+export default async function show(name, options = {}) {
     const git = simpleGit();
     if (!name && !(await git.checkIsRepo())) {
         throw new Error('You must provide a profile name, or invoke the show command from a git repo.');
@@ -143,16 +172,11 @@ export default async function show(name) {
     const profiles = await loadProfiles();
     const resolved = await resolveProfile(name, profiles);
     const signingKeyStatus = await buildStatus(resolved);
-    let opts = undefined;
-    if (resolved.mismatches && Object.keys(resolved.mismatches).length > 0) {
-        opts ||= {};
-        opts.mismatches = resolved.mismatches;
-    }
-    if (signingKeyStatus) {
-        opts ||= {};
-        opts.signingKeyStatus = signingKeyStatus;
+    if (options.json) {
+        log.json(toJson(resolved, signingKeyStatus));
+        return;
     }
-    printProfile(resolved.profile, opts);
+    printProfile(resolved.profile, displayOptions(resolved, signingKeyStatus));
     if (resolved.derived) {
         log.warn(`Profile derived from git config — not explicitly set via gitwho.profile`);
     }

package/dist/src/commands/use.js

@@ -11,54 +11,74 @@ function extractRepoPath(url) {
     return parseSshUrl(url)?.path ?? url.match(HTTPS_URL_PATTERN)?.[1];
 }
 /**
- * Work out the origin remote url to set, if any. When the origin does not use the profile's ssh host, the user is asked
- * whether to rewrite it to `git@<host>:<path>`.
+ * Find where the origin remote differs from the url the profile's ssh host would give it, `git@<host>:<path>`.
  *
- * @returns The url to set, or `undefined` to leave the origin alone (no origin, already matching, or declined).
+ * @returns The current and expected urls, or `undefined` when there is no origin or it already matches.
  * @throws {Error} If the origin is neither an ssh nor an http(s) url, so its repo path cannot be determined.
  */
-async function resolveOriginUrl(git, profile) {
-    const { value: currentUrl } = await git.getConfig('remote.origin.url', 'local');
-    if (!currentUrl) {
+async function checkOrigin(git, profile) {
+    const { value: current } = await git.getConfig('remote.origin.url', 'local');
+    if (!current) {
         return undefined;
     }
-    const path = extractRepoPath(currentUrl);
+    const path = extractRepoPath(current);
     if (!path) {
-        throw new Error(`Unable to determine the repo path from origin remote '${currentUrl}'.`);
-    }
-    const desiredUrl = `git@${profile.host}:${path}`;
-    if (desiredUrl === currentUrl) {
-        return undefined;
+        throw new Error(`Unable to determine the repo path from origin remote '${current}'.`);
     }
+    const expected = `git@${profile.host}:${path}`;
+    return expected === current ? undefined : { current, expected };
+}
+function confirmOriginUpdate(profile, { current, expected }) {
     const { style } = makeTheme();
-    const updateOrigin = await confirm({
-        message: `Origin remote is ${style.highlight(currentUrl)}, but profile '${profile.name}' expects ${style.highlight(desiredUrl)}. Update origin to match?`,
+    return confirm({
+        message: `Origin remote is ${style.highlight(current)}, but profile '${profile.name}' expects ${style.highlight(expected)}. Update origin to match?`,
         default: true,
     });
-    return updateOrigin ? desiredUrl : undefined;
 }
 /**
- * Apply a profile to the current repo, either the one given by name or one picked from a prompt.
+ * Look a profile up by name without falling back to a prompt, for output that nobody is there to answer.
+ */
+function findProfile(profiles, name) {
+    if (!name) {
+        throw new Error('A profile name is required with --json.');
+    }
+    const profile = profiles.find((p) => p.name === name);
+    if (!profile) {
+        throw new Error(`Profile ${name} not found.`);
+    }
+    return profile;
+}
+/**
+ * Apply a profile to the current repo, either the one given by name or one picked from a prompt. A mismatched origin is
+ * rewritten when `updateOrigin` is set, otherwise the user is asked, except with `json`, which never prompts: it needs
+ * a name and leaves the origin alone unless `updateOrigin` is set.
  *
- * @throws {Error} If the current directory is not a git repo, the profile's signing key is missing or cannot be looked
- * up, the origin remote url cannot be parsed, or applying the profile fails. The signing key is checked first and its
- * failure is thrown as is, because nothing has been written by then. A failure to apply is wrapped with its `cause`,
- * since the git config may be left partly updated.
+ * @throws {Error} If the current directory is not a git repo, `json` has no name or the name is unknown, the profile's
+ * signing key is missing or cannot be looked up, the origin remote url cannot be parsed, or applying the profile fails.
+ * The signing key is checked first and its failure is thrown as is, because nothing has been written by then. A failure
+ * to apply is wrapped with its `cause`, since the git config may be left partly updated.
  */
-export default async function use(name) {
+export default async function use(name, options = {}) {
     const git = simpleGit();
     if (!await git.checkIsRepo()) {
         throw new Error('The current directory must have a git repository to use a profile.');
     }
     const profiles = await loadProfiles();
-    const profile = await selectProfile(profiles, name);
+    const profile = options.json ? findProfile(profiles, name) : await selectProfile(profiles, name);
     await verifySigningKey(profile);
-    const originUrl = await resolveOriginUrl(git, profile);
+    const origin = await checkOrigin(git, profile);
+    const updateOrigin = origin !== undefined
+        && (options.updateOrigin || (!options.json && await confirmOriginUpdate(profile, origin)));
     try {
-        await applyProfile(git, profile, originUrl);
+        await applyProfile(git, profile, updateOrigin ? origin.expected : undefined);
     }
     catch (error) {
         throw new Error(`Failed to apply profile '${profile.name}'. Git config may be partly updated; re-run to retry.`, { cause: error });
     }
-    log.info(`Now using profile '${chalk.bold(profile.name)}'.`);
+    if (options.json) {
+        log.json({ profile, originUpdated: updateOrigin, origin });
+    }
+    else {
+        log.info(`Now using profile '${chalk.bold(profile.name)}'.`);
+    }
 }

package/dist/src/utils/log.js

@@ -18,5 +18,11 @@ const log = {
     info(msg) {
         console.log(`\n${msg}\n`);
     },
+    /**
+     * Writes a value to stdout as indented JSON, with no blank lines or colors so the output can be parsed as is.
+     */
+    json(value) {
+        console.log(JSON.stringify(value, null, 2));
+    },
 };
 export default log;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bstopp/git-who",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "description": "Manage git profiles for per-project SSH account configuration.",
   "license": "Apache-2.0",