@suffolklitlab/alkiln 5.13.3-feat-random → 5.13.3-feat-random-2

package/.github/workflows/github_server.yml

@@ -159,7 +159,9 @@ jobs:
           INSTALL_METHOD: "server"
           #### Developer note: You can probably leave the rest out
           #### To learn more, see https://assemblyline.suffolklitlab.org/docs/alkiln/writing/#optional-inputs
-          ALKILN_TAG_EXPRESSION: "${{ env.ALKILN_TAG_EXPRESSION }}"
+          #ALKILN_TAG_EXPRESSION: "${{ env.ALKILN_TAG_EXPRESSION }}"
+          # Temp debugging GitHub multi-folder problem
+          ALKILN_TAG_EXPRESSION: "@rp1"
           ALKILN_VERSION: random
 
       #### Developer note: Example of making an issue when tests fail

package/.github/workflows/playground.yml

@@ -80,6 +80,8 @@ jobs:
           # Internal: docassemble changes sometimes break @a11y tests. That is
           # a da problem, not ours. We will trigger these tests manually when we
           # want to check up on this.
-          ALKILN_TAG_EXPRESSION: "${{ env.ALKILN_TAG_EXPRESSION }}"
+          #ALKILN_TAG_EXPRESSION: "${{ env.ALKILN_TAG_EXPRESSION }}"
+          # Temp debugging GitHub multi-folder problem
+          ALKILN_TAG_EXPRESSION: "@rp1"
           #### Developer note: You can probably leave this out
           ALKILN_VERSION: random

package/.github/workflows/unit_tests.yml

@@ -27,7 +27,7 @@ jobs:
       - run: npm run unit
       # Artifacts
       - name: upload unit tests artifacts folder
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         # This will upload even if a previous step has failed
         if: ${{ always() }}
         with:

package/_alkiln_meta/shift_logs.js

@@ -0,0 +1,75 @@
+const fs = require('fs');
+const path = require('path');
+
+function shift_logs(folderPath, startNum, endNum) {
+    // Validate inputs
+    if (!folderPath || typeof folderPath !== 'string') {
+        throw new Error('Invalid folder path provided');
+    }
+    if (!startNum || !endNum || isNaN(startNum) || isNaN(endNum)) {
+        throw new Error('Invalid number range provided');
+    }
+
+    // Process directory recursively
+    function processDirectory(dirPath) {
+        // Read all files in the folder
+        const files = fs.readdirSync(dirPath);
+        
+        files.forEach(file => {
+            const some_path = path.join(dirPath, file);
+            const stats = fs.statSync(some_path);
+
+            if (stats.isDirectory()) {
+                // Recursively process subdirectories
+                processDirectory(some_path);
+            } else if (stats.isFile()) {
+                // Only process supported file paths
+                if ( some_path.startsWith(`.`) || some_path.startsWith(`alkiln`) || some_path.startsWith(`_`)) {
+                    console.log(`not editing`, some_path);
+                    return;
+                }
+                if (some_path.match(/(node_modules)|(_alkiln)|(package)|(shrinkwrap)|(runtime)|(alkiln\-)$/)) {
+                    console.log(`not editing`, some_path);
+                    return;
+                }
+
+                let content = fs.readFileSync(some_path, 'utf8');
+                
+                // Create regex pattern for ALK followed by digits
+                const pattern = /\bALK0(\d+)\b/g;
+                
+                // Process matches and adjust numbers
+                content = content.replace(pattern, (match, numStr) => {
+                    console.log(`match in ${ some_path }:`, JSON.stringify(match) );
+                    
+                    const num = parseInt(numStr);
+                    // Only modify numbers within our target range
+                    if (num >= startNum && num <= endNum) {
+                        console.log(`Changing match: previous content:`);
+                        console.log( content );
+                        return `ALK0${num + 1}`;
+                    }
+                    return match;
+                });
+
+                // Write back the modified content
+                fs.writeFileSync(some_path, content);
+                console.log(`Processed file: ${file}`);
+            }
+        });
+    }
+
+    processDirectory(folderPath)
+}
+
+// Example usage
+try {
+    shift_logs(`.`, 236, 276);  //'./your_folder', 123, 456);
+    console.log('Sequence fixing completed');
+} catch (error) {
+    console.error('Error:', error.message);
+}
+
+
+function check_types({ folderPath, startNum, endNum }) {
+}

package/action.yml

@@ -106,10 +106,10 @@ runs:
       run: |
         log="💡 ALK0024 INFO: Confirm environment variables"
         echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
-        vars_log='\nALKiln version is $ALKILN_VERSION\nRepo is "$REPO_URL"\nBranch ref is "$BRANCH_PATH"\nCustom MAX_SECONDS_FOR_SETUP is "$MAX_SECONDS_FOR_SETUP"\nCustom SERVER_RELOAD_TIMEOUT_SECONDS is "$SERVER_RELOAD_TIMEOUT_SECONDS"\nCustom MAX_RANDOM_TESTS_PER_SCENARIO is "$MAX_RANDOM_TESTS_PER_SCENARIO"\n'
+        vars_log='\nALKiln version is ${{ env.ALKILN_VERSION }}\nRepo is "${{ env.REPO_URL }}"\nBranch ref is "${{ env.BRANCH_PATH }}"\nCustom MAX_SECONDS_FOR_SETUP is "${{ env.MAX_SECONDS_FOR_SETUP }}"\nCustom SERVER_RELOAD_TIMEOUT_SECONDS is "${{ env.SERVER_RELOAD_TIMEOUT_SECONDS }}"\nCustom MAX_RANDOM_TESTS_PER_SCENARIO is "${{ env.MAX_RANDOM_TESTS_PER_SCENARIO }}"\n'
         echo -e "$vars_log" >> "${{ env.DEBUG_PATH }}" && echo -e "$vars_log"
 
-    # Install ALKiln into GitHub workflow
+    # Install ALKiln during GitHub workflow
     - name: "💡 ALK0025 INFO: Set up node"
       uses: actions/setup-node@v4
       with:
@@ -122,19 +122,17 @@ runs:
         npm install -g "@suffolklitlab/alkiln@$ALKILN_VERSION"
 
     # Files prep
-
     - shell: bash
       env:
         ARTIFACT_FOLDER: ${{ env.ARTIFACT_FOLDER }}
       run: |
-        log="💡 ALK0273 INFO: Prepare repository test files"
+        log="💡 ALK0275 INFO: Prepare repository test files"
         echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
         alkiln-artifacts --path="${{ env.ARTIFACT_FOLDER }}"
         alkiln-validate
         alkiln-generate
 
     # Install package on playground
-
     # Don't rely on the environment's version of python
     - uses: actions/setup-python@v5
       if: ${{ inputs.INSTALL_METHOD == 'playground' }}
@@ -156,15 +154,15 @@ runs:
         long_log="\n\n―――\n🤕 ALK0028 ERROR: Unable to create a Project on your server's testing account or pull your package into it. Check the messages above this line.\n\n"
         echo -e "$long_log" >> "${{ env.DEBUG_PATH }}" && echo -e "$long_log"
 
-    # Server installations - find folders and save session vars
-    - name: "💡 ALK0029 INFO: Install the GitHub package onto the server"
+    # Server installation
+    - name: "💡 ALK0029 INFO: Try to install the GitHub package onto the GitHub sandbox server"
       if: ${{ inputs.INSTALL_METHOD == 'server' }}
       shell: bash
       run: |
         log="💡 ALK0029 INFO: Install the GitHub package onto the server"
         echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
         alkiln-server-install
-    - name: "🤕 ALK0030 ERROR: Unable to install the package"
+    - name: "🤕 ALK0030 ERROR: Unable to install the package on the GitHub sandbox server"
       if: ${{ inputs.INSTALL_METHOD == 'server' && failure() }}
       shell: bash
       run: |

package/action_for_github_server/action.yml

@@ -51,36 +51,28 @@ runs:
         run: |
           log="💡 ALK0018 INFO: Get path names with date and time"
           timestamp="$(date +'%Y-%m-%d at %Hh%Mm%Ss' -u)"
+          # Where to get the contents for the artifact
           debug_dir="/tmp"
-          debug_path="$debug_dir/alkiln_docker_logs-${timestamp}UTC.txt"
+          debug_logs_path="$debug_dir/alkiln_docker_logs-${timestamp}UTC.txt"
+          # Where to put the artifact
           artifact_folder="alkiln_github_server-${timestamp}UTC"
+          echo "debug_logs_path: $debug_logs_path"
+          echo "artifact_folder: $artifact_folder"
 
           mkdir -p "$debug_dir"
           mkdir -p "$artifact_folder"
-          echo -e "$log" >> "$debug_path"
+          echo -e "$log" >> "$debug_logs_path"
 
-          echo "DEBUG_PATH=$debug_path" >> $GITHUB_ENV
+          echo "DEBUG_LOGS_PATH=$debug_logs_path" >> $GITHUB_ENV
           echo "GITHUB_SERVER_ARTIFACT_NAME=$artifact_folder" >> $GITHUB_ENV
 
-      - shell: bash
-        env:
-          GITHUB_SERVER_ARTIFACT_NAME: ${{ env.GITHUB_SERVER_ARTIFACT_NAME }}
-        run: |
-          log="💡 ALK0276 INFO: Prepare repository test files"
-          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
-          alkiln-artifacts --path="${{ env.GITHUB_SERVER_ARTIFACT_NAME }}"
-          alkiln-validate
-          alkiln-generate
-
-          # These run twice. As before, this creates 2 artifact folders.
-
       - shell: bash
         env:
           MAX_SECONDS_FOR_DOCKER: ${{ inputs.MAX_SECONDS_FOR_DOCKER }}
           DOCASSEMBLECLI_VERSION: ${{ inputs.DOCASSEMBLECLI_VERSION }}
         run: |
           log="💡 ALK0001 INFO: Set environment variables"
-          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
+          echo -e "\n$log" >> "${{ env.DEBUG_LOGS_PATH }}"
 
           echo "MAX_SECONDS_FOR_DOCKER=$MAX_SECONDS_FOR_DOCKER" >> $GITHUB_ENV
           echo "DOCASSEMBLECLI_VERSION=$DOCASSEMBLECLI_VERSION" >> $GITHUB_ENV
@@ -93,7 +85,7 @@ runs:
         shell: bash
         run: |
           log="💡 ALK0002 INFO: Create GitHub step output variables"
-          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
+          echo -e "\n$log" >> "${{ env.DEBUG_LOGS_PATH }}"
           echo "DOCASSEMBLE_DEVELOPER_API_KEY=$DA_ADMIN_API_KEY" >> "$GITHUB_OUTPUT"
           echo "DA_ADMIN_EMAIL=$DA_ADMIN_EMAIL" >> "$GITHUB_OUTPUT"
           echo "DA_ADMIN_PASSWORD=$DA_ADMIN_PASSWORD" >> "$GITHUB_OUTPUT"
@@ -104,19 +96,19 @@ runs:
         shell: bash
         run: |
           log="💡 ALK0003 INFO: Get config"
-          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
+          echo -e "\n$log" >> "${{ env.DEBUG_LOGS_PATH }}"
 
           mkdir /tmp/config
           # Worth making this silent by defining a variable with > /dev/null...?
           if [ -n "$CONFIG" ]
           then
             log2="💡 ALK0004 INFO: The developer did provide a custom docassemble config file as an input into this action."
-            echo -e "\n$log2" >> "${{ env.DEBUG_PATH }}" echo "$log2"
+            echo -e "\n$log2" >> "${{ env.DEBUG_LOGS_PATH }}" echo "$log2"
             echo "$CONFIG" > /tmp/config/myconfig.yml
             echo "CONFIG_ARGS=--env DA_CONFIG=/tmp/config/myconfig.yml --volume /tmp/config:/tmp/config " >> $GITHUB_ENV
           else
             log3="💡 ALK0005 INFO: The developer did NOT provide a custom docassemble config file as an input into this action. Docassemble will use its default config."
-            echo -e "\n$log3" >> "${{ env.DEBUG_PATH }}" echo "$log3"
+            echo -e "\n$log3" >> "${{ env.DEBUG_LOGS_PATH }}" echo "$log3"
             echo "CONFIG_ARGS=" >> $GITHUB_ENV
           fi
 
@@ -132,13 +124,13 @@ runs:
         shell: bash
         run: |
           log="💡 ALK0006 INFO: Determine docker logs visibility"
-          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
+          echo -e "\n$log" >> "${{ env.DEBUG_LOGS_PATH }}"
           if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
             echo "OUTPUT_DOCKER=$SHOW_DOCKER_OUTPUT" >> $GITHUB_ENV
-            echo -e "\n$SHOW_DOCKER_OUTPUT" >> "${{ env.DEBUG_PATH }}"
+            echo -e "\n$SHOW_DOCKER_OUTPUT" >> "${{ env.DEBUG_LOGS_PATH }}"
           else
             echo "OUTPUT_DOCKER=false" >> $GITHUB_ENV
-            echo -e "\nfalse" >> "${{ env.DEBUG_PATH }}"
+            echo -e "\nfalse" >> "${{ env.DEBUG_LOGS_PATH }}"
           fi
 
       # Messages about output
@@ -148,14 +140,14 @@ runs:
         run: |
           # 💡 ALK0007 INFO: ALKiln will now hide docker output
           log="===\n💡 ALK0007 INFO: ALKiln will now hide docker output to avoid possibly showing details about your config. If you want to get output to see more of what is going on, use \"with:\" and set the input \"SHOW_DOCKER_OUTPUT\" to \"true\". This output will only be visible to those who can already see the action output, like people with admin or write permissions.\n==="
-          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}" && echo -e "$log"
+          echo -e "\n$log" >> "${{ env.DEBUG_LOGS_PATH }}" && echo -e "$log"
       - name: "💡 ALK0008 INFO: ALKiln will show docker output"
         if: ${{ env.OUTPUT_DOCKER == 'true' }}
         shell: bash
         run: |
           # 💡 ALK0008 INFO: ALKiln will show docker output
           log="===\n💡 ALK0008 INFO: ALKiln will show docker output. ALKiln cannot control this output. If you want to prevent output, use \"with:\" and set the input \"SHOW_DOCKER_OUTPUT\" to \"false\". This output will only be visible to those who can already see the action output, like people with admin or write permissions.\n==="
-          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}" && echo -e "$log"
+          echo -e "\n$log" >> "${{ env.DEBUG_LOGS_PATH }}" && echo -e "$log"
 
       # TODO: Reduce these to 1 block by putting ` > /dev/null 2>&1` into an env var
       # No docker output
@@ -166,7 +158,7 @@ runs:
         shell: bash
         run: |
           log="💡 ALK0009 INFO: Download and start docker silently"
-          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
+          echo -e "\n$log" >> "${{ env.DEBUG_LOGS_PATH }}"
           docker pull jhpyle/docassemble > /dev/null 2>&1
           docker run --name docassemble_container \
                      --env DA_ADMIN_EMAIL="$DA_ADMIN_EMAIL" \
@@ -183,7 +175,7 @@ runs:
         shell: bash
         run: |
           log="💡 ALK0010 INFO: Download and start docker"
-          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
+          echo -e "\n$log" >> "${{ env.DEBUG_LOGS_PATH }}"
           docker pull jhpyle/docassemble
           docker run --name docassemble_container \
                      --env DA_ADMIN_EMAIL="$DA_ADMIN_EMAIL" \
@@ -201,13 +193,13 @@ runs:
         run: |
           # 💡 ALK0011 INFO: The following messages are not docker output
           log="💡 ALK0011 INFO: The following messages are NOT docker output, just ALKiln waiting for the server to start"
-          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}" && echo -e "$log"
+          echo -e "\n$log" >> "${{ env.DEBUG_LOGS_PATH }}" && echo -e "$log"
 
       - name: "💡 ALK0012 INFO: Waiting for server to start"
         shell: bash
         run: |
           log="💡 ALK0012 INFO: Waiting for server to start"
-          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
+          echo -e "\n$log" >> "${{ env.DEBUG_LOGS_PATH }}"
 
           # Reset the SECONDS variable
           SECONDS=0
@@ -217,27 +209,27 @@ runs:
           response="start"
           while [[ $response != *"200"* ]]; do
             log2="💡 ALK0013 INFO: Time elapsed: $SECONDS seconds"
-            echo -e "\n$log2" >> "${{ env.DEBUG_PATH }}" && echo -e "$log2"
+            echo -e "\n$log2" >> "${{ env.DEBUG_LOGS_PATH }}" && echo -e "$log2"
 
             # Check if max seconds till loading has passed
             if [[ $SECONDS -ge $MAX_SECONDS_FOR_DOCKER ]]; then
               log3="🤕 ALK0014 ERROR: Timed out waiting for docker container to serve the site. If you want to give your docker container more timem to install, set the MAX_SECONDS_FOR_DOCKER input for this action."
-              echo -e "\n$log3" >> "${{ env.DEBUG_PATH }}" && echo -e "$log3"
+              echo -e "\n$log3" >> "${{ env.DEBUG_LOGS_PATH }}" && echo -e "$log3"
               exit 1
             fi
 
             # Set the variable to a new string value in each iteration
             response=$(curl -o /dev/null -s -w "%{http_code}\n" http://localhost:80/health_check?ready=1)
             log4="💡 ALK0015 INFO: Response is $response"
-            echo -e "\n$log4" >> "${{ env.DEBUG_PATH }}" && echo -e "$log4"
+            echo -e "\n$log4" >> "${{ env.DEBUG_LOGS_PATH }}" && echo -e "$log4"
 
             # Check if the string includes the desired text
             if [[ $response == *"200"* ]]; then
               log5="💡 ALK0016 SUCCESS: Success! The docker container is ready!"
-              echo -e "\n$log5" >> "${{ env.DEBUG_PATH }}" && echo -e "$log5"
+              echo -e "\n$log5" >> "${{ env.DEBUG_LOGS_PATH }}" && echo -e "$log5"
             else
               log6="💡 ALK0017 INFO: The docker container is not ready yet. Will check again in 30 seconds."
-              echo -e "\n$log6" >> "${{ env.DEBUG_PATH }}" && echo -e "$log6"
+              echo -e "\n$log6" >> "${{ env.DEBUG_LOGS_PATH }}" && echo -e "$log6"
               sleep 30
             fi
 
@@ -272,23 +264,23 @@ runs:
         shell: bash
         run: |
           log="💡 ALK0019 INFO: Create docker artifact data"
-          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}"
-          echo "$(docker output docassemble_container)" >> "${{ env.DEBUG_PATH }}"
+          echo -e "\n$log" >> "${{ env.DEBUG_LOGS_PATH }}"
+          echo "$(docker output docassemble_container)" >> "${{ env.DEBUG_LOGS_PATH }}"
       - name: "💡 ALK0020 INFO: Upload artifacts folder"
         if: ${{ always() && env.OUTPUT_DOCKER == 'true' }}
         uses: actions/upload-artifact@v4
         with:
           name: ${{ env.GITHUB_SERVER_ARTIFACT_NAME }}
-          path: ${{ env.DEBUG_PATH }}
+          path: ${{ env.DEBUG_LOGS_PATH }}
 
       - shell: bash
         if: ${{ success() }}
         run: |
           log="💡 ALK0021 SUCCESS: ALKiln created the docker container and started the server!"
-          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}" && echo -e "$log"
+          echo -e "\n$log" >> "${{ env.DEBUG_LOGS_PATH }}" && echo -e "$log"
 
       - shell: bash
         if: ${{ failure() }}
         run: |
           log="🤕 ALK0022 ERROR: Something went wrong. See above for more details."
-          echo -e "\n$log" >> "${{ env.DEBUG_PATH }}" && echo -e "$log"
+          echo -e "\n$log" >> "${{ env.DEBUG_LOGS_PATH }}" && echo -e "$log"

package/lib/docassemble/setup.js

@@ -1,7 +1,5 @@
 #!/usr/bin/env node
 
-// rename? install_authors_docassemble_interview_package_on_server
-
 const child_process = require(`child_process`);
 
 const Log = require(`../utils/Log`);
@@ -56,7 +54,7 @@ const setup = async () => {
       + `dainstall this package on your server. See above for more details.`;
     log.throw({ code: `ALK0047`, context,
       before: `☝️ ☝️ ☝️  Error data ☝️ ☝️ ☝️\n`,
-      error: `Error while installing project` },
+      error: new Error(`Error while installing project on your docassemble server`) },
       install_err_msg
     );
   }

package/lib/run_cucumber.js

@@ -10,34 +10,29 @@ const Log = require('./utils/Log');
 const session_vars = require('./utils/session_vars');
 const set_sources_paths = require(`./utils/set_sources_paths`);
 
-// TODO: Remove after merging Log class
-const files = require('./utils/files');
-
 const SUMMARY_FILENAME = `cucumber-report.txt`;
 
 
-function build_config( cli_args ) {
+function build_config() {
   /** Use the command line arguments to build the cucumberjs config object.
    * 
    * @param {string?} - Arguments passed to the command line.
    * 
    * @returns {object} - cucumberjs config object
    * */
-  // ========== TODO: Abstract after merging Log class PR
   // Turn all the paths to the sources folders into paths to the feature files
   let sources_paths = session_vars.get_sources_paths();
   let feature_paths = [];
 
   // Get all the paths for the right feature files (for cucumber to use)
   for ( let sources_path of sources_paths ) {
-    // Ignore feature files that we parsed ourselves
     let glob = fast_glob.sync(
       `${ sources_path }/**/*.feature`,
+      // Ignore "generator" feature files that we used to generate actual tests
       { ignore: [`${ sources_path }/${ globals.generators_prefix }*.feature`] }
     );
     feature_paths.push( ...glob );
   }
-  // ========== Ends TODO: Abstract
 
   const config = {
     publishQuiet: true,
@@ -47,6 +42,7 @@ function build_config( cli_args ) {
     retry: 1,
   }
 
+  const cli_args = require(`minimist`)( process.argv.slice(2) );
   // Normalize tag expressions, if there are any
   // Joining and splitting handles both tags surrounded with `""` or those without `""`
   let tags = cli_args[`_`].join(` `).split(` `);
@@ -84,29 +80,11 @@ async function main() {
     environment
   );
 
-  // ========== TODO: Abstract after merging Log class PR
-  let artifacts_path = files.make_artifacts_folder();
-  session_vars.save_artifacts_path_name( artifacts_path );
-
-  // We'll use the user info to construct the possible paths to /sources
-  let id = session_vars.get_user_id();
-  // `project` is the name in the server docassemble "Project" page
-  let project = session_vars.get_user_project_name();
-
-  // process.argv is a list of strings of commands and args.
-  // If using `npm run cucumber` (as opposed to the bin commands),
-  // use `--` before `--sources=./foo`
-  const argv = require(`minimist`)( process.argv.slice(2), {
-    default: {
-      sources: [
-        `./docassemble/*/data/sources`,  // In GitHub folder
-        `/usr/share/docassemble/files/playgroundsources/${id}/${project}/*.feature`, // From playground without S3
-        `/tmp/playgroundsources/${id}/${project}/*.feature` // From playground with S3
-      ],
-    }
-  });
-
-  // ========== Ends TODO: Abstract
+  // TODO: These are not used as far as I can tell. Delete them
+  // // We'll use the user info to construct the possible paths to /sources
+  // let id = session_vars.get_user_id();
+  // // `project` is the name in the server docassemble "Project" page
+  // let project = session_vars.get_user_project_name();
   
   const { runConfiguration } = await cucumber_api.loadConfiguration({
     provided: build_config( argv ),
@@ -133,9 +111,9 @@ async function main() {
 
   /** Write to files.
    *
-   * Note: Don't add to the purely report-focused files. Those are files where
-   *    authors can focus on the info we give them, which they often miss in
-   *    the GitHub action.
+   * Note: Avoid adding to the purely report-focused files. Those are files
+   *    where authors can focus on the info we give them, which they often miss
+   *    in the GitHub action.
    */
 
   if ( success ) {
@@ -153,29 +131,12 @@ async function main() {
   const exitCode = success ? 0 : 50;
   process.exitCode = exitCode;
 
-  /** TODO:
-   * randomly generated test file cleanup
-   * 1. Generate files into the sources folder
-   * 2. copy the randomly generated files into the artifacts folder
-   * 3. MVP: delete the randomly generated files from the sources folder
-   * 4. post MVP: let the author keep the randomly generated tests in the
-   *    sources folder and make a PR with them
-   * */
-
-  /**
-   * Loop through sources folders
-   *   If there are generated files in the generated files folder(s)
-   *     delete that folder from the sources folders where we found them
-   * */
-
-  // This is hardcoded information from `provide_config` above.
-  // This code isn't used for anything other than detecting and removing color codes.
   let summary_file_name = SUMMARY_FILENAME;
   fs.readFile(summary_file_name, 'utf8', (read_error, text) => {
     if ( read_error ) {
       // Something else will probably show an error that's more relevant
       log.warn({ code: `ALK0056`, context: `post_run error`, },
-        `Failed to read cucumber report`, read_error
+        `Failed to read the report of the 3rd party library, cucumberjs. There may be more information above or below.`, read_error
       );
       return;
     }
@@ -210,7 +171,13 @@ async function main() {
         try {
           fs.readFileSync(`${ log.path }/${ log.unexpected_filename }`);  // Does it have contents?
           fs.appendFileSync(`${ log.path }/${ log.unexpected_filename }`, `\n\n\n\n\n` );
-        } catch ( ignore_err ) { /* Missing unexpected file is ok */ }
+        } catch ( ignore_err ) {
+          /* Missing "unexpected results" file is ok */
+        }
+
+        // TODO: Is this meant to write to the debug file or is this debug info
+        // really supposed to be in the "unexpected results" file? Or are these
+        // comments old?
 
         // Add the heading for debug content
         fs.appendFileSync( `${ log.path }/${ log.unexpected_filename }`,
@@ -224,7 +191,7 @@ async function main() {
 
     } catch ( writing_cucumber_error ) {
       let code = `ALK0182`;
-      let context = `post_run error`
+      let context = `post_run`
       let msg = `Something probably went wrong earlier. See warnings and errors above. Skipped writing to ${ log.path }/${ log.debug_log_filename }.`;
       try {
         log.warn({ code, context, }, msg, writing_cucumber_error );