virtual-code-owners 6.2.0 → 7.0.1

package/README.md

@@ -1,82 +1,34 @@
 ## What?
 
-This takes a
+This generates your `CODEOWNERS` file (_patterns_ x _users_) from
 
-- VIRTUAL-CODEOWNERS.txt file with (virtual) teams
-- a `virtual-teams.yml` file which define the teams
+- a `VIRTUAL-CODEOWNERS.txt` (_patterns_ x _teams_)
+- a `virtual-teams.yml` (_teams_ x _users_)
 
-... and merges them into a CODEOWNERS with user names.
+... which makes it easier to keep `CODEOWNERS` in sync on multi-team mono repos.
+When those teams are not defined on GitHub level.
 
 ## Usage
 
 - Rename your `.github/CODEOWNERS` to `.github/VIRTUAL-CODEOWNERS.txt` and put team names in them.
-- Specify team names that don't (yet) exist on GitHub level in a `.github/virtual-teams.yml`
+- Define teams that don't (yet) exist on GitHub level in `.github/virtual-teams.yml`
 - Run this:
 
 ```
 npx virtual-code-owners
+# Wrote '.github/CODEOWNERS'
 ```
 
-or, if you want to be verbose
-
-```
-npx virtual-code-owners \
-  --virtualCodeOwners .github/VIRTUAL-CODEOWNERS.txt \
-  --virtualTeams      .github/virtual-teams.yml \
-  --codeOwners        .github/CODEOWNERS
-```
-
-## Why?
-
-Organizations sometimes have large mono repositories with loads of code owners.
-They or their bureaucracy haven't landed on actually using GitHub teams to clearly
-demarcate that. Teams in those organizations who want to have clear code ownership
-have the following choices:
-
-- Wrestle the bureaucracy.  
-  This is the recommended approach. It might take a while, though - and even
-  though there are good people on many levels in bureaucracies, it might
-  eventually not pan out because #reasons.
-- Maintain a CODEOWNERS file with code assigned to large lists of individuals.  
-  An option, but laborious to maintain, even for smaller projects; for example:
-
-```CODEOWNERS
-# catch-all to ensure there at least _is_ a code owner, even when
-# it's _everyone_
-
-* @cloud-heroes-all
-
-# admin & ci stuff => transversal
-
-.github/                @abraham-lincoln @benjamin-franklin @koos-koets @luke-the-lucky-ch @mary-the-merry-ch @naomi-the-namegiver-ch
-
-# generic stuff
-
-apps/framework/         @abraham-lincoln @benjamin-franklin @koos-koets @luke-the-lucky-ch @mary-the-merry-ch @naomi-the-namegiver-ch
-apps/ux-portal/         @abraham-lincoln @benjamin-franklin @charlotte-de-bourbon-ch @davy-davidson-ch @joe-dalton-ch @john-johnson-ch @koos-koets @luke-the-lucky-ch @mary-the-merry-ch @naomi-the-namegiver-ch
-libs/components/        @charlotte-de-bourbon-ch @davy-davidson-ch @joe-dalton-ch @john-johnson-ch @koos-koets
-
-# specific functionality
-
-libs/ubc-sales/         @abraham-ableton-ch @boris-bubbleblower-ch @charlotte-charleston-ch @dagny-taggert-ch @gregory-gregson-ch @jane-doe-ch @karl-marx-ch
-libs/ubc-after-sales/   @daisy-duck @donald-duck @john-doe-ch @pete-peterson-ch @william-the-fourth-ch
-libs/ubc-pre-sales/     @averel-dalton-ch @jean-claude-ch @john-galt-ch @valerie-valerton-ch
-libs/ubc-refund/        @abraham-ableton-ch @boris-bubbleblower-ch @charlotte-charleston-ch @dagny-taggert-ch @daisy-duck @donald-duck @gregory-gregson-ch @jane-doe-ch @john-doe-ch @karl-marx-ch @pete-peterson-ch @william-the-fourth-ch
-libs/ubc-baarden/       jan@example.com korneel@example.com pier@example.com tjorus@example.com
-```
-
-This is where `virtual-code-owners` comes in.
+- :sparkles:
 
 ## Formats
 
 ### VIRTUAL-CODEOWNERS.txt
 
-`VIRTUAL-CODEOWNERS.txt` is a regular, valid GitHub [CODEOWNERS](https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners) file.
-The only difference between VIRTUAL-CODEOWNERS.txt and a CODEOWNERS file is that
-the _teams_ the former uses might not exist yet, except in a `virtual-teams.yml`.
-This enables you to write a _much_ easier to maintain list of code owners.
+`VIRTUAL-CODEOWNERS.txt` sticks to the [CODEOWNERS](https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners) format,
+but adds the ability to include teams defined in `virtual-teams.yml`.
 
-For example the CODEOWNERS file above can then look like this:
+For example a CODEOWNERS file can look like this:
 
 ```CODEOWNERS
 #! comments that start with #! won't appear in the CODEOWNERS output
@@ -108,11 +60,14 @@ libs/ubc-refund/        @ch/sales @ch/after-sales
 libs/ubc-baarden/       @ch/mannen-met-baarden
 ```
 
+... where only the @cloud-heroes-all is a 'real' team on GitHub level. The other
+ones are defined in `virtual-teams.yml`.
+
 ### virtual-teams.yml
 
-A valid YAML file that contains a list of teams, with for each team its members.
-If a new team member joins, you can enter it here, run `npx virtual-code-owners`
-to update CODEOWNERS.
+A valid YAML file that contains a list of teams and their members.
+Update it whenever you have new team members and run `npx virtual-code-owners`
+to keep CODEOWNERS current.
 
 ```yaml
 # yaml-language-server: $schema=https://raw.githubusercontent.com/sverweij/virtual-code-owners/main/src/virtual-teams.schema.json
@@ -148,61 +103,58 @@ ch/transversal:
   - benjamin-franklin
   - koos-koets
   - abraham-lincoln
+ch/mannen-met-baarden:
+  - jan@example.com
+  - pier@example.com
+  - tjorus@example.com
+  - korneel@example.com
 ```
 
-## FAQ
-
-### Can I mix real and virtual teams in `VIRTUAL-CODEOWNERS.txt`?
+### CODEOWNERS
 
-Yes.
+Running `npx virtual-code-owners` will combine these into a CODEOWNERS file like this:
 
-It might be you already have a team or two defined, but just want to use
-_additional_ teams. In that case just don't specify the already-defined teams
-in `virtual-teams.yml` and _virtual-code-owners_ will leave them alone.
-
-### Can I still use usernames in `VIRTUAL-CODEOWNERS.txt`?
-
-Yes.
+```CODEOWNERS
+#
+# DO NOT EDIT - this file is generated and your edits will be overwritten
+#
+# To make changes:
+#
+#   - edit .github/VIRTUAL-CODEOWNERS.txt
+#   - and/ or add team members to .github/virtual-teams.yml
+#   - run 'npx virtual-code-owners' (or 'npx virtual-code-owners --emitLabeler' if you also
+#     want to generate a .github/labeler.yml)
+#
 
-Just make sure there's no name clashes between the username and a (virtual)
-team name and _virtual-code-owners_ will leave the real name alone.
+# catch-all to ensure there at least _is_ a code owner, even when
+# it's _everyone_
 
-### What validations does virtual-code-owners perform?
+* @cloud-heroes-all
 
-On the VIRTUAL-CODEOWNERS.txt file it performs is a little bit of validation:
+# admin & ci stuff => transversal
 
-- it will find invalid user/ team names (those that don't start with an `@` or
-  aren't an e-mail address)
-- it will find invalid 'rules'; which is the case when there is a file pattern on
-  the line, but no user or team names.
+.github/                @abraham-lincoln @benjamin-franklin @koos-koets @luke-the-lucky-ch @mary-the-merry-ch @naomi-the-namegiver-ch
 
-When it encounters any of these virtual-code-owners will emit a clear error message
-with the location of the error and exit with a non-zero code, to prevent the
-creation of a potentially invalid CODEOWNERS file.
+# generic stuff
 
-It _does not_ check whether the user or team names actually exist in the current
-project, though. Although nice, there's already tooling on the generated CODEOWNERS
-file that will check that for you.
+apps/framework/         @abraham-lincoln @benjamin-franklin @koos-koets @luke-the-lucky-ch @mary-the-merry-ch @naomi-the-namegiver-ch
+apps/ux-portal/         @abraham-lincoln @benjamin-franklin @charlotte-de-bourbon-ch @davy-davidson-ch @joe-dalton-ch @john-johnson-ch @koos-koets @luke-the-lucky-ch @mary-the-merry-ch @naomi-the-namegiver-ch
+libs/components/        @charlotte-de-bourbon-ch @davy-davidson-ch @joe-dalton-ch @john-johnson-ch @koos-koets
 
-### Any limitations I should know of?
+# specific functionality
 
-- ~~Currently only works for _user names_ to identify team members - not for e-mail
-  addresses.~~
-  Works with both user names and e-mail addresses
-- Although _virtual-code-owners_ performs basic validations on the CODEOWNER
-  format and tries to emit clear and actionable error messages about them, it
-  might not catch all of them - e.g. it doesn't check if the users in
-  virtual-teams.yml actually exist.
+libs/ubc-sales/         @abraham-ableton-ch @boris-bubbleblower-ch @charlotte-charleston-ch @dagny-taggert-ch @gregory-gregson-ch @jane-doe-ch @karl-marx-ch
+libs/ubc-after-sales/   @daisy-duck @donald-duck @john-doe-ch @pete-peterson-ch @william-the-fourth-ch
+libs/ubc-pre-sales/     @averel-dalton-ch @jean-claude-ch @john-galt-ch @valerie-valerton-ch
+libs/ubc-refund/        @abraham-ableton-ch @boris-bubbleblower-ch @charlotte-charleston-ch @dagny-taggert-ch @daisy-duck @donald-duck @gregory-gregson-ch @jane-doe-ch @john-doe-ch @karl-marx-ch @pete-peterson-ch @william-the-fourth-ch
+libs/ubc-baarden/       jan@example.com korneel@example.com pier@example.com tjorus@example.com
+```
 
-### Why the `.txt` extension?
+## FAQ
 
-Various editors assume an ALL_CAPS file name with `#` characters on various lines
-to be markdown, and will auto format them as such - making for either very ugly
-or in worst cases invalid CODEOWNERS files. Usually such autoformatting is not
-present on text files.
+### Any gotcha's?
 
-Apparently these editors know about CODEOWNERS, though so this auto formatting
-doesn't seem to be happening over there.
+It won't check whether the users or teams you entered exist.
 
 ### Do I have to run this each time I edit `VIRTUAL-CODEOWNERS.txt`?
 
@@ -220,14 +172,27 @@ like this:
 }
 ```
 
-### It'd be _pretty_ handy if I could see for which virtual teams a PR is. For instance with a bunch of :label: labels.
+### Can I mix real and virtual teams in `VIRTUAL-CODEOWNERS.txt`?
+
+Yes.
+
+It might be you already have a team or two defined, but just want to use
+_additional_ teams. In that case just don't specify the already-defined teams
+in `virtual-teams.yml` and _virtual-code-owners_ will leave them alone.
+
+### Can I still use usernames in `VIRTUAL-CODEOWNERS.txt`?
+
+Yes.
+
+Just make sure there's no name clashes between the username and a (virtual)
+team name and _virtual-code-owners_ will leave the real name alone.
+
+### Can I automatically label PR's for virtual teams?
 
-How do I go about that?
+Yep.
 
-You can use the [actions/labeler](https://github.com/actions/labeler) action for
-for this. Maintaining the configuration file (`.github/labeler.yml`) and keeping it
-sync with the virtual-teams and virtual code-owners files manually is a bit of
-a chore, though, so `virtual-code-owners` has an option to automate that.
+Use [actions/labeler](https://github.com/actions/labeler) and tickle
+`virtual-code-owners` to generate the labeler config file:
 
 ```sh
 npx virtual-code-owners --emitLabeler
@@ -237,12 +202,62 @@ npx virtual-code-owners --emitLabeler
 If you have an alternate file location for the `labeler.yml` you can specify that
 with virtual-code-owner's `--labelerLocation` parameter.
 
-### Can I just run virtual-code-owners to validate VIRTUAL-CODEOWNERS.txt & virtual-teams.yml?
+### What validations does virtual-code-owners perform?
+
+virtual-code-owners checks for basic CODEOWNERS format errors and invalid
+user/team names but doesn't verify their existence in the project.
+
+- valid user/team names start with an `@` or are an e-mail address
+- valid rules have a file pattern and at least one user/team name
+
+### I want to specify different locations for the files (e.g. because I'm using GitLab)
+
+Here you go:
+
+```
+npx virtual-code-owners \
+  --virtualCodeOwners .gitlab/VIRTUAL-CODEOWNERS.txt \
+  --virtualTeams      .gitlab/virtual-teams.yml \
+  --codeOwners        .gitlab/CODEOWNERS
+```
+
+### Can I just validate VIRTUAL-CODEOWNERS.txt & virtual-teams.yml without generating output?
 
 So _without_ generating any output?
 
-Yes. Use the `--dryRun` command line option:
+Sure thing. Use `--dryRun`:
 
 ```
 npx virtual-code-owners --dryRun
 ```
+
+### Why the `.txt` extension?
+
+It keeps editors and IDE's from messing up your formatting.
+
+Various editors assume an ALL_CAPS file name with `#` characters on various lines
+to be markdown, and will auto format them as such. This makes for either very ugly
+or in worst cases invalid CODEOWNERS files. Usually such autoformatting is not
+present on text files.
+
+Apparently these editors know about CODEOWNERS, though, so they don't mess with
+the formatting of _those_.
+
+### Why does this exist at all? Why not just use GitHub teams?
+
+You should _totally_ use GitHub teams! If you can.
+
+Organizations sometimes have large mono repositories with loads of code owners.
+They or their bureaucracy haven't landed on actually using GitHub teams to clearly
+demarcate that. Or you're working on a cross-functional team that doesn't follow
+the organization chart (and hence the GitHub teams). Teams in those organizations
+who want to have clear code ownership have the following choices:
+
+- Wrestle the bureaucracy.  
+  This is the recommended approach. It might take a while, though - and even
+  though there are good people on many levels in bureaucracies, it might
+  eventually not pan out because #reasons.
+- Maintain a CODEOWNERS file with code assigned to large lists of individuals.  
+  An option, but laborious to maintain, even for smaller projects
+
+This is where `virtual-code-owners` comes in.

package/dist/cli.js

@@ -1,3 +1,84 @@
-#!/usr/bin/env node
-import { cli } from "./main.js";
-cli();
+import { EOL } from "node:os";
+import { parseArgs } from "node:util";
+import { main } from "./main.js";
+import { VERSION } from "./version.js";
+const HELP_MESSAGE = `Usage: virtual-code-owners [options]
+
+Merges a VIRTUAL-CODEOWNERS.txt and a virtual-teams.yml into CODEOWNERS
+
+Options:
+  -V, --version                        output the version number
+  -v, --virtualCodeOwners [file-name]  A CODEOWNERS file with team names in them 
+                                       that are defined in a virtual teams file
+                                       (default: ".github/VIRTUAL-CODEOWNERS.txt")
+  -t, --virtualTeams [file-name]       A YAML file listing teams and their 
+                                       members
+                                       (default: ".github/virtual-teams.yml")
+  -c, --codeOwners [file-name]         The location of the CODEOWNERS file 
+                                       (default: ".github/CODEOWNERS")
+  -l, --emitLabeler                    Whether or not to emit a labeler.yml to be
+                                       used with actions/labeler
+                                       (default: false)
+  --labelerLocation [file-name]        The location of the labeler.yml file
+                                       (default: ".github/labeler.yml")
+  --dryRun                             Just validate inputs, don't generate
+                                       outputs (default: false)
+  -h, --help                           display help for command`;
+export function cli(pArguments = process.argv.slice(2), pOutStream = process.stdout, pErrorStream = process.stderr, pErrorExitCode = 1) {
+    try {
+        const lOptions = getOptions(pArguments);
+        if (lOptions.help) {
+            pOutStream.write(`${HELP_MESSAGE}${EOL}`);
+            return;
+        }
+        if (lOptions.version) {
+            pOutStream.write(`${VERSION}${EOL}`);
+            return;
+        }
+        main(lOptions, pErrorStream);
+    }
+    catch (pError) {
+        pErrorStream.write(`${EOL}ERROR: ${pError.message}${EOL}${EOL}`);
+        process.exitCode = pErrorExitCode;
+    }
+}
+function getOptions(pArguments) {
+    return parseArgs({
+        args: pArguments,
+        options: {
+            virtualCodeOwners: {
+                type: "string",
+                short: "v",
+                default: ".github/VIRTUAL-CODEOWNERS.txt",
+            },
+            virtualTeams: {
+                type: "string",
+                short: "t",
+                default: ".github/virtual-teams.yml",
+            },
+            codeOwners: {
+                type: "string",
+                short: "c",
+                default: ".github/CODEOWNERS",
+            },
+            emitLabeler: {
+                type: "boolean",
+                short: "l",
+                default: false,
+            },
+            labelerLocation: {
+                type: "string",
+                default: ".github/labeler.yml",
+            },
+            dryRun: {
+                type: "boolean",
+                default: false,
+            },
+            help: { type: "boolean", short: "h", default: false },
+            version: { type: "boolean", short: "V", default: false },
+        },
+        strict: true,
+        allowPositionals: true,
+        tokens: false,
+    }).values;
+}

package/dist/{generate-codeowners.js → codeowners/generate.js}

@@ -1,5 +1,5 @@
 import { EOL } from "node:os";
-import { isEmailIshUsername } from "./utensils.js";
+import { isEmailIshUsername } from "../utensils.js";
 const DEFAULT_WARNING = `#${EOL}` +
     `# DO NOT EDIT - this file is generated and your edits will be overwritten${EOL}` +
     `#${EOL}` +
@@ -36,7 +36,7 @@ function expandTeamToUserNames(pUser, pTeamMap) {
     return [pUser.raw];
 }
 function stringifyTeamMembers(pTeamMap, pTeamName) {
-    return pTeamMap[pTeamName].map(userNameToCodeOwner);
+    return (pTeamMap[pTeamName] ?? []).map(userNameToCodeOwner);
 }
 function userNameToCodeOwner(pUserName) {
     if (isEmailIshUsername(pUserName)) {

package/dist/main.js

@@ -1,92 +1,10 @@
 import { writeFileSync } from "node:fs";
 import { EOL } from "node:os";
-import { parseArgs } from "node:util";
-import generateCodeOwners from "./generate-codeowners.js";
-import generateLabelerYml from "./generate-labeler-yml.js";
-import readTeamMap from "./read-team-map.js";
-import readVirtualCodeOwners from "./read-virtual-code-owners.js";
-import { VERSION } from "./version.js";
-const HELP_MESSAGE = `Usage: virtual-code-owners [options]
-
-Merges a VIRTUAL-CODEOWNERS.txt and a virtual-teams.yml into CODEOWNERS
-
-Options:
-  -V, --version                        output the version number
-  -v, --virtualCodeOwners [file-name]  A CODEOWNERS file with team names in them 
-                                       that are defined in a virtual teams file
-                                       (default: ".github/VIRTUAL-CODEOWNERS.txt")
-  -t, --virtualTeams [file-name]       A YAML file listing teams and their 
-                                       members
-                                       (default: ".github/virtual-teams.yml")
-  -c, --codeOwners [file-name]         The location of the CODEOWNERS file 
-                                       (default: ".github/CODEOWNERS")
-  -l, --emitLabeler                    Whether or not to emit a labeler.yml to be
-                                       used with actions/labeler
-                                       (default: false)
-  --labelerLocation [file-name]        The location of the labeler.yml file
-                                       (default: ".github/labeler.yml")
-  --dryRun                             Just validate inputs, don't generate
-                                       outputs (default: false)
-  -h, --help                           display help for command`;
-export function cli(pArguments = process.argv.slice(2), pOutStream = process.stdout, pErrorStream = process.stderr, pErrorExitCode = 1) {
-    try {
-        const lOptions = getOptions(pArguments);
-        if (lOptions.help) {
-            pOutStream.write(`${HELP_MESSAGE}${EOL}`);
-            return;
-        }
-        if (lOptions.version) {
-            pOutStream.write(`${VERSION}${EOL}`);
-            return;
-        }
-        main(lOptions, pErrorStream);
-    }
-    catch (pError) {
-        pErrorStream.write(`${EOL}ERROR: ${pError.message}${EOL}${EOL}`);
-        process.exitCode = pErrorExitCode;
-    }
-}
-function getOptions(pArguments) {
-    return parseArgs({
-        args: pArguments,
-        options: {
-            virtualCodeOwners: {
-                type: "string",
-                short: "v",
-                default: ".github/VIRTUAL-CODEOWNERS.txt",
-            },
-            virtualTeams: {
-                type: "string",
-                short: "t",
-                default: ".github/virtual-teams.yml",
-            },
-            codeOwners: {
-                type: "string",
-                short: "c",
-                default: ".github/CODEOWNERS",
-            },
-            emitLabeler: {
-                type: "boolean",
-                short: "l",
-                default: false,
-            },
-            labelerLocation: {
-                type: "string",
-                default: ".github/labeler.yml",
-            },
-            dryRun: {
-                type: "boolean",
-                default: false,
-            },
-            help: { type: "boolean", short: "h", default: false },
-            version: { type: "boolean", short: "V", default: false },
-        },
-        strict: true,
-        allowPositionals: true,
-        tokens: false,
-    }).values;
-}
-function main(pOptions, pErrorStream) {
+import generateCodeOwners from "./codeowners/generate.js";
+import generateLabelerYml from "./labeler-yml/generate.js";
+import readTeamMap from "./team-map/read.js";
+import readVirtualCodeOwners from "./virtual-code-owners/read.js";
+export function main(pOptions, pErrorStream) {
     const lTeamMap = readTeamMap(pOptions.virtualTeams);
     const lVirtualCodeOwners = readVirtualCodeOwners(pOptions.virtualCodeOwners, lTeamMap);
     const lCodeOwnersContent = generateCodeOwners(lVirtualCodeOwners, lTeamMap);

package/dist/run-cli.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { cli } from "./cli.js";
+cli();

package/dist/{read-team-map.js → team-map/read.js}

@@ -2,7 +2,7 @@ import Ajv from "ajv";
 import { readFileSync } from "node:fs";
 import { EOL } from "node:os";
 import { parse as parseYaml } from "yaml";
-const TEAM_MAP_SCHEMA = JSON.parse(readFileSync(new URL("./virtual-teams.schema.json", import.meta.url), "utf-8"));
+import virtualTeamsSchema from "./virtual-teams.schema.js";
 export default function readTeamMap(pVirtualTeamsFileName) {
     const lVirtualTeamsAsAString = readFileSync(pVirtualTeamsFileName, {
         encoding: "utf-8",
@@ -16,7 +16,7 @@ function assertTeamMapValid(pTeamMap, pVirtualTeamsFileName) {
         allErrors: true,
         verbose: true,
     });
-    if (!ajv.validate(TEAM_MAP_SCHEMA, pTeamMap)) {
+    if (!ajv.validate(virtualTeamsSchema, pTeamMap)) {
         throw new Error(`This is not a valid virtual-teams.yml:${EOL}${formatAjvErrors(ajv.errors, pVirtualTeamsFileName)}.\n`);
     }
 }

package/dist/team-map/virtual-teams.schema.js

@@ -0,0 +1,15 @@
+export default {
+    $schema: "http://json-schema.org/draft-07/schema#",
+    title: "virtual teams schema for virtual-code-owners",
+    description: "a list of teams and their team members",
+    $id: "org.js.virtual-code-owners/7.0.0",
+    type: "object",
+    additionalProperties: {
+        type: "array",
+        items: {
+            type: "string",
+            description: "Username or e-mail address of a team member. (Don't prefix usernames with '@')",
+            pattern: "^[^@][^\\s]+$",
+        },
+    },
+};

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = "6.2.0";
+export const VERSION = "7.0.1";

package/dist/virtual-code-owners/anomalies.js

@@ -0,0 +1,31 @@
+export function getAnomalies(pVirtualCodeOwners) {
+    const weirdLines = pVirtualCodeOwners
+        .filter((pLine) => pLine.type === "unknown")
+        .map((pLine) => ({
+        ...pLine,
+        type: "invalid-line",
+    }));
+    const weirdUsers = pVirtualCodeOwners.flatMap((pLine) => {
+        if (pLine.type === "rule") {
+            return pLine.users
+                .filter((pUser) => pUser.type === "invalid")
+                .map((pUser) => ({
+                ...pUser,
+                line: pLine.line,
+                type: "invalid-user",
+            }));
+        }
+        return [];
+    });
+    return weirdLines.concat(weirdUsers).sort(orderAnomaly);
+}
+function orderAnomaly(pLeft, pRight) {
+    if (pLeft.line === pRight.line &&
+        pLeft.type === "invalid-user" &&
+        pRight.type === "invalid-user") {
+        return pLeft.userNumberWithinLine > pRight.userNumberWithinLine ? 1 : -1;
+    }
+    else {
+        return pLeft.line > pRight.line ? 1 : -1;
+    }
+}

package/dist/{parse-virtual-code-owners.js → virtual-code-owners/parse.js}

@@ -1,45 +1,14 @@
 import { EOL } from "node:os";
-import { isEmailIshUsername } from "./utensils.js";
+import { isEmailIshUsername } from "../utensils.js";
 export function parse(pVirtualCodeOwnersAsString, pTeamMap = {}) {
     return pVirtualCodeOwnersAsString
         .split(EOL)
         .map((pUntreatedLine, pLineNo) => parseLine(pUntreatedLine, pTeamMap, pLineNo + 1));
 }
-export function getAnomalies(pVirtualCodeOwners) {
-    const weirdLines = pVirtualCodeOwners
-        .filter((pLine) => pLine.type === "unknown")
-        .map((pLine) => ({
-        ...pLine,
-        type: "invalid-line",
-    }));
-    const weirdUsers = pVirtualCodeOwners.flatMap((pLine) => {
-        if (pLine.type === "rule") {
-            return pLine.users
-                .filter((pUser) => pUser.type === "invalid")
-                .map((pUser) => ({
-                ...pUser,
-                line: pLine.line,
-                type: "invalid-user",
-            }));
-        }
-        return [];
-    });
-    return weirdLines.concat(weirdUsers).sort(orderAnomaly);
-}
-function orderAnomaly(pLeft, pRight) {
-    if (pLeft.line === pRight.line &&
-        pLeft.type === "invalid-user" &&
-        pRight.type === "invalid-user") {
-        return pLeft.userNumberWithinLine > pRight.userNumberWithinLine ? 1 : -1;
-    }
-    else {
-        return pLeft.line > pRight.line ? 1 : -1;
-    }
-}
 function parseLine(pUntreatedLine, pTeamMap, pLineNo) {
     const lTrimmedLine = pUntreatedLine.trim();
     const lCommentSplitLine = lTrimmedLine.split(/\s*#/);
-    const lRule = lCommentSplitLine[0].match(/^(?<filesPattern>[^\s]+)(?<spaces>\s+)(?<userNames>.*)$/);
+    const lRule = lCommentSplitLine[0]?.match(/^(?<filesPattern>[^\s]+)(?<spaces>\s+)(?<userNames>.*)$/);
     if (lTrimmedLine.startsWith("#!")) {
         return { type: "ignorable-comment", line: pLineNo, raw: pUntreatedLine };
     }

package/dist/{read-virtual-code-owners.js → virtual-code-owners/read.js}

@@ -1,6 +1,7 @@
 import { readFileSync } from "node:fs";
 import { EOL } from "node:os";
-import { getAnomalies, parse as parseVirtualCodeOwners, } from "./parse-virtual-code-owners.js";
+import { getAnomalies } from "./anomalies.js";
+import { parse as parseVirtualCodeOwners } from "./parse.js";
 export default function readVirtualCodeOwners(pVirtualCodeOwnersFileName, pTeamMap) {
     const lVirtualCodeOwnersAsAString = readFileSync(pVirtualCodeOwnersFileName, {
         encoding: "utf-8",

package/dist/virtual-teams.schema.json

@@ -2,7 +2,7 @@
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "virtual teams schema for virtual-code-owners",
   "description": "a list of teams and their team members",
-  "$id": "org.js.virtual-code-owners/6.0.0",
+  "$id": "org.js.virtual-code-owners/7.0.0",
   "type": "object",
   "additionalProperties": {
     "type": "array",

package/package.json

@@ -1,60 +1,15 @@
 {
   "name": "virtual-code-owners",
-  "version": "6.2.0",
+  "version": "7.0.1",
   "description": "Makes your CODEOWNERS file liveable again",
   "type": "module",
-  "exports": {
-    "parse": [
-      {
-        "import": "./dist/parse-virtual-code-owners.js",
-        "types": "./types/parse-virtual-code-owners.d.ts"
-      },
-      "./dist/parse-virtual-code-owners.js"
-    ],
-    "generateCodeOwners": [
-      {
-        "import": "./dist/generate-codeowners.js",
-        "types": "./types/generate-codeowners.d.ts"
-      },
-      "./dist/generate-codeowners.js"
-    ],
-    "generateLabelerYml": [
-      {
-        "import": "./dist/generate-labeler-yml.js",
-        "types": "./types/generate-labeler-yml.d.ts"
-      },
-      "./dist/generate-labeler-yml.js"
-    ]
-  },
-  "main": "dist/main.js",
-  "types": "types/types.d.ts",
-  "bin": "dist/cli.js",
+  "bin": "dist/run-cli.js",
   "files": [
     "dist/",
-    "types/",
     "package.json",
     "README.md",
     "LICENSE"
   ],
-  "scripts": {
-    "build": "rm -rf dist && node --no-warnings --loader ts-node/esm tools/get-version.ts > src/version.ts && tsc && cp -f src/*.json dist/.",
-    "check": "npm run format && npm run build && npm run depcruise -- --no-progress && npm test",
-    "depcruise": "depcruise src tools",
-    "depcruise:graph": "depcruise src --include-only '^(src)' --output-type dot | dot -T svg | depcruise-wrap-stream-in-html > dependency-graph.html",
-    "depcruise:graph:dev": "depcruise src --prefix vscode://file/$(pwd)/ --output-type dot | dot -T svg | depcruise-wrap-stream-in-html | browser",
-    "depcruise:graph:diff:dev": "depcruise src --prefix vscode://file/$(pwd)/ --output-type dot --reaches \"$(watskeburt $SHA -T regex)\"| dot -T svg | depcruise-wrap-stream-in-html | browser",
-    "depcruise:graph:diff:mermaid": "depcruise src tools --output-type mermaid --output-to - --reaches \"$(watskeburt $SHA -T regex)\"",
-    "depcruise:html": "depcruise src tools --output-type err-html --output-to dependency-violation-report.html",
-    "format": "prettier --log-level warn --write \"**/*.{md,ts,json,yml}\"",
-    "prepare": "husky install",
-    "scm:stage": "git add .",
-    "test": "c8 node --no-warnings --loader 'ts-node/esm' --test-reporter ./tools/dot-with-summary.reporter.js --test src/*.test.ts",
-    "update-dependencies": "npm run upem:update && npm run upem:install && npm run check",
-    "upem-outdated": "npm outdated --json --long | upem --dry-run",
-    "upem:install": "npm install",
-    "upem:update": "npm outdated --json --long | upem | pbcopy && pbpaste",
-    "version": "npm run build && npm run scm:stage"
-  },
   "keywords": [
     "CODEOWNERS"
   ],
@@ -63,28 +18,16 @@
   "homepage": "https://github.com/sverweij/virtual-code-owners",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/sverweij/virtual-code-owners"
+    "url": "git+https://github.com/sverweij/virtual-code-owners.git"
   },
   "bugs": {
     "url": "https://github.com/sverweij/virtual-code-owners/issues"
   },
-  "devDependencies": {
-    "@types/node": "20.5.8",
-    "c8": "8.0.1",
-    "dependency-cruiser": "13.1.5",
-    "husky": "8.0.3",
-    "lint-staged": "14.0.1",
-    "prettier": "3.0.3",
-    "ts-node": "10.9.1",
-    "typescript": "5.2.2",
-    "upem": "8.0.0",
-    "watskeburt": "1.0.1"
-  },
   "dependencies": {
     "ajv": "8.12.0",
-    "yaml": "2.3.2"
+    "yaml": "2.3.3"
   },
   "engines": {
-    "node": "^16.19.0||^18.11.0||>=20.0.0"
+    "node": "^18.11.0||>=20.0.0"
   }
-}
+}

package/types/generate-codeowners.d.ts

@@ -1,6 +0,0 @@
-import type { ITeamMap, IVirtualCodeOwnersCST } from "./types.js";
-export default function generateCodeOwners(
-  pVirtualCodeOwners: IVirtualCodeOwnersCST,
-  pTeamMap: ITeamMap,
-  pGeneratedWarning?: string,
-): string;

package/types/generate-labeler-yml.d.ts

@@ -1,6 +0,0 @@
-import type { ITeamMap, IVirtualCodeOwnersCST } from "./types.js";
-export default function generateLabelerYml(
-  pCodeOwners: IVirtualCodeOwnersCST,
-  pTeamMap: ITeamMap,
-  pGeneratedWarning?: string,
-): string;

package/types/parse-virtual-code-owners.d.ts

@@ -1,18 +0,0 @@
-import type { IAnomaly, ITeamMap, IVirtualCodeOwnersCST } from "./types.js";
-/**
- * parses (virtual) codeowners as a string into a virtual codeowners CST
- * which can be used to do further  rocessing on (e.g. generate codeowners,
- * validate etc.)
- *
- * @param pVirtualCodeOwnersAsString CODEOWNERS or VIRTUAL-CODE-OWNERS.txt file  to parse
- * @param pTeamMap a virtual team map  ()
- * @returns a virtual code owners CST
- */
-export declare function parse(
-  pVirtualCodeOwnersAsString: string,
-  pTeamMap?: ITeamMap,
-): IVirtualCodeOwnersCST;
-
-export declare function getAnomalies(
-  pVirtualCodeOwners: IVirtualCodeOwnersCST,
-): IAnomaly[];

package/types/types.d.ts

@@ -1,45 +0,0 @@
-export interface ITeamMap {
-  [teamName: string]: string[];
-}
-
-export type IVirtualCodeOwnersCST = IVirtualCodeOwnerLine[];
-export type IVirtualCodeOwnerLine = IBoringCSTLine | IInterestingCSTLine;
-export interface IBoringCSTLine {
-  type: "comment" | "ignorable-comment" | "empty" | "unknown";
-  line: number;
-  raw: string;
-}
-export interface IInterestingCSTLine {
-  type: "rule";
-  line: number;
-  filesPattern: string;
-  spaces: string;
-  users: IUser[];
-  inlineComment: string;
-  raw: string;
-}
-export type UserType =
-  | "virtual-team-name"
-  | "e-mail-address"
-  | "other-user-or-team"
-  | "invalid";
-export type IUser = {
-  type: UserType;
-  userNumberWithinLine: number;
-  bareName: string;
-  raw: string;
-};
-
-export type IAnomaly = ILineAnomaly | IUserAnomaly;
-export interface ILineAnomaly {
-  type: "invalid-line";
-  line: number;
-  raw: string;
-}
-export interface IUserAnomaly {
-  type: "invalid-user";
-  line: number;
-  userNumberWithinLine: number;
-  bareName: string;
-  raw: string;
-}