Lots

Author: Explosion-Scratch

briefing_support_dirs.md

@@ -0,0 +1,15 @@
+# Changes to Support Directory Removal
+
+-   **Interactive Removal**: Updated `completeAppUninstall` in `lib/system.js` to prompt the user before removing each support directory (prompts for `Application Support`, `Caches`, `Preferences`, etc.).
+-   **Confirmation Logic**: Uses the existing `confirm` utility. Defaults to "y".
+-   **Yes Flag Support**: `completeAppUninstall` now accepts a `yesFlag` argument. If `yesFlag` (from `--yes`) is true, these prompts are automatically confirmed.
+-   **Caller Update**: Updated `lib/updater.js` to pass the `yesFlag` from `performUninstall` down to `completeAppUninstall`.
+
+## Technical Details
+
+-   Modified `lib/system.js`:
+    -   Imported `confirm` from `./utils`.
+    -   Refactored `completeAppUninstall` loop for `supportDirs`.
+    -   Restored accidentally clobbered functions `findLaunchAgents` and `unloadLaunchAgent`.
+-   Modified `lib/updater.js`:
+    -   Updated call site for `completeAppUninstall`.

lib/config.js

@@ -80,7 +80,7 @@ const createInstallationRecord = (source, selected, metadata = {}) => {
       url: source.url,
       owner: source.owner,
       repo: source.repo,
-      originalArgs: source.originalArgs,
+      originalArgs: Array.isArray(source.originalArgs) ? source.originalArgs : [source.originalArgs],
     },
     selected: {
       name: selected.name,
@@ -95,6 +95,7 @@ const createInstallationRecord = (source, selected, metadata = {}) => {
       destinations: metadata.destinations || [],
       preferredMethod: metadata.preferredMethod || metadata.installMethod,
       selectedAssetPattern: metadata.selectedAssetPattern || null,
+      script: metadata.script || null,
     },
     version: metadata.version,
     commit: metadata.commit,

lib/installer-scripts.js

@@ -102,17 +102,19 @@ const getInstallerScriptConfig = (extension) => {
 
 /**
  * Score an installer script based on filename relevance to current platform
- * @param {string} filename - Full filename of the script
+ * @param {string} filePath - Path to the script (relative or absolute)
  * @param {string} extension - File extension
  * @returns {number} Score (higher is better match)
  */
-const scoreInstallerScript = (filename, extension) => {
+const scoreInstallerScript = (filePath, extension) => {
   if (!isInstallerScriptCompatible(extension)) return -1
 
   const config = INSTALLER_SCRIPT_CONFIG[extension.toLowerCase()]
   let score = config.priority
 
+  const filename = path.basename(filePath);
   const lowerFilename = filename.toLowerCase()
+  const lowerPath = filePath.toLowerCase()
   const platform = process.platform
 
   const platformNameMatches = {
@@ -139,6 +141,24 @@ const scoreInstallerScript = (filename, extension) => {
     }
   }
 
+  // Penalize completion scripts heavily
+  // Check directory path for 'completion' or 'completions'
+  const dirname = path.dirname(filePath).toLowerCase();
+  
+  if (
+    dirname.includes('completion') || 
+    dirname.includes('completions') ||
+    dirname.includes('examples') ||
+    dirname.includes('samples') ||
+    dirname.includes('test') ||
+    dirname.includes('t/') || // Common test directory
+    lowerFilename.includes('completion') ||
+    lowerFilename.startsWith('_') || // Common zsh completion prefix
+    lowerFilename.includes('.min.') // Minified files are rarely installers
+  ) {
+    return -1; // Exclude completely
+  }
+
   for (const pattern of config.patterns) {
     if (lowerFilename.includes(pattern)) {
       score += 3
@@ -164,7 +184,7 @@ const detectInstallerScripts = (files, basePath = '') => {
     if (!isInstallerScript(ext)) continue
     if (!isInstallerScriptCompatible(ext)) continue
 
-    const score = scoreInstallerScript(filename, ext)
+    const score = scoreInstallerScript(file, ext)
     if (score < 0) continue
 
     scripts.push({

lib/installer.js

@@ -377,7 +377,6 @@ const displayScriptList = (installScripts, log) => {
 
   log.log(`  ${continueOption}. Continue to regular installation`);
   log.log(`  ${exitOption}. Exit installation`);
-  log.log(`  e. Edit selected script before running`);
 };
 
 const handleSingleScript = async (script, log, yesFlag = false) => {
@@ -431,51 +430,54 @@ const handleMultipleScripts = async (installScripts, log, yesFlag = false) => {
     });
 
     const choice = await new Promise((resolve) => {
-      rli.question(`${colors.fg.yellow}Preview install script (1-${EXIT_OPTION}) or 'e' to edit:${colors.reset} `, (ans) => {
+      rli.question(`${colors.fg.yellow}Select install script (1-${EXIT_OPTION}):${colors.reset} `, (ans) => {
         rli.close();
         resolve(ans.trim().toLowerCase());
       });
     });
 
-    if (choice === 'e') {
-      const scriptChoice = await promptChoice(
-        `Which script would you like to edit? (1-${installScripts.length}): `,
-        installScripts.length,
-        yesFlag
-      );
-      const scriptToEdit = installScripts[scriptChoice - 1];
-      const editedScript = await editScriptInEditor(scriptToEdit);
-      displayScriptPreview(editedScript, log);
-
-      const shouldRun = await confirm(
-        "Run this edited install script (y) or choose a different one (n)?",
-        "y",
-        yesFlag
-      );
-
-      if (shouldRun) return editedScript;
-      // Continue loop if user chooses 'n'
-    } else {
-      const numericChoice = parseInt(choice);
-      if (numericChoice <= installScripts.length) {
-        const script = installScripts[numericChoice - 1];
-        displayScriptPreview(script, log);
+    const numericChoice = parseInt(choice);
 
-        const shouldRun = await confirm(
-          "Run this install script (y) or choose a different one (n)?",
-          "y",
-          yesFlag
-        );
+    if (isNaN(numericChoice)) {
+      console.log(`${colors.fg.red}Invalid choice. Please enter a number.${colors.reset}`);
+      continue;
+    }
 
-        if (shouldRun) return script;
-        // Continue loop if user chooses 'n'
-      } else if (numericChoice === CONTINUE_OPTION) {
-        return null; // Continue to regular installation
-      } else if (numericChoice === EXIT_OPTION) {
-        throw new Error("Installation aborted by user");
-      } else {
-        console.log(`${colors.fg.red}Invalid choice. Please try again.${colors.reset}`);
+    if (numericChoice === CONTINUE_OPTION) {
+      return null; // Continue to regular installation
+    } else if (numericChoice === EXIT_OPTION) {
+      throw new Error("Installation aborted by user");
+    } else if (numericChoice > 0 && numericChoice <= installScripts.length) {
+      let script = installScripts[numericChoice - 1];
+      displayScriptPreview(script, log);
+
+      let actionLoop = true;
+      while (actionLoop) {
+        const rliAction = readline.createInterface({
+          input: process.stdin,
+          output: process.stdout,
+        });
+
+        const action = await new Promise((resolve) => {
+          rliAction.question(`${colors.fg.yellow}Run (y), Edit (e), or Select Different (n)?${colors.reset} `, (ans) => {
+            rliAction.close();
+            resolve(ans.trim().toLowerCase());
+          });
+        });
+
+        if (action === 'y' || action === 'yes') {
+          return script;
+        } else if (action === 'n' || action === 'no') {
+          actionLoop = false;
+        } else if (action === 'e') {
+          script = await editScriptInEditor(script);
+          displayScriptPreview(script, log);
+        } else {
+            // Optional: Handle invalid input if needed, strictly asking for y/e/n
+        }
       }
+    } else {
+      console.log(`${colors.fg.red}Invalid choice. Please try again.${colors.reset}`);
     }
   }
 };
@@ -506,6 +508,7 @@ const handleGitHubSource = async (source, platformInfo, capabilities, log, yesFl
   const previousInstallation = getInstallation(source.repo);
   const preferredMethod = previousInstallation?.installation?.preferredMethod;
   const previousAssetPattern = previousInstallation?.installation?.selectedAssetPattern;
+  const storedScript = previousInstallation?.installation?.script;
 
   if (isUpdate && preferredMethod) {
     log.debug(`Previous installation used method: ${preferredMethod}`);
@@ -538,21 +541,36 @@ const handleGitHubSource = async (source, platformInfo, capabilities, log, yesFl
   }
 
   const selected = selectBestAsset(assets, platformInfo, capabilities);
-  const binaryScore = selected ? (selected.points || 10) : 0;
+  // Boost binary score significantly if we found a compatible binary
+  // This ensures we prioritize direct binary downloads over install scripts unless strict overrides exist
+  const binaryScore = selected ? (selected.points || 10) + 100 : 0;
 
   const skipScriptDetection = isUpdate && preferredMethod && 
     !["script", "installer_script"].includes(preferredMethod);
 
   let installScripts = [];
-  if (!skipScriptDetection) {
+  if (isUpdate && preferredMethod === "script" && storedScript) {
+    log.debug("Using stored install script from previous installation");
+    installScripts = [
+      {
+        code: storedScript,
+        source: "stored script",
+        score: 1000,
+      },
+    ];
+  } else if (!skipScriptDetection) {
     installScripts = await findInstallScripts(
       source.owner,
       source.repo,
       body,
     );
-    log.debug(`Found ${installScripts.length} platform-compatible install scripts`);
+    log.debug(
+      `Found ${installScripts.length} platform-compatible install scripts`,
+    );
   } else {
-    log.debug(`Skipping script detection - previous install used: ${preferredMethod}`);
+    log.debug(
+      `Skipping script detection - previous install used: ${preferredMethod}`,
+    );
   }
 
   const installerScript = assets.find((i) => i.name.includes("installer.sh"));
@@ -608,6 +626,7 @@ const handleGitHubSource = async (source, platformInfo, capabilities, log, yesFl
     const selectedScript = await selectInstallScript(installScripts, log, yesFlag);
 
     if (selectedScript) {
+      const processedCode = processInstallSnippetReplacements(selectedScript.code);
       executeInstallScript(selectedScript, log);
 
       const installRecord = createInstallationRecord(
@@ -617,6 +636,7 @@ const handleGitHubSource = async (source, platformInfo, capabilities, log, yesFl
           name: source.repo,
           installMethod: "script",
           preferredMethod: "script",
+          script: processedCode,
           version: tag,
           commit: commit,
           prerelease: prerelease,

lib/installers.js

@@ -312,6 +312,13 @@ const getBinaries = (dir) => {
   return [...new Set(binaries)]; // Remove duplicates
 };
 
+/**
+ * Prompt user to choose from multiple binaries found in a package
+ * @param {string[]} binaries - List of binary files found
+ * @param {string} packageName - Name of the package being installed
+ * @param {Object} logger - Logger instance
+ * @returns {Promise<string[]>} Selected binaries
+ */
 /**
  * Prompt user to choose from multiple binaries found in a package
  * @param {string[]} binaries - List of binary files found
@@ -329,34 +336,90 @@ const selectBinaries = async (
     return binaries;
   }
 
-  // Filter out obvious non-binaries for cleaner selection
-  const filteredBinaries = binaries.filter((f) => {
-    const filename = path.basename(f).toLowerCase();
-    return (
-      !filename.includes("readme") &&
-      !filename.includes("license") &&
-      !filename.includes("changelog") &&
-      !filename.includes("notice") &&
-      !filename.includes(".md") &&
-      !filename.includes(".txt") &&
-      !filename.includes(".1") && // man pages
-      !f.includes("doc/") &&
-      !f.includes("docs/") &&
-      !f.includes("man/")
-    );
+  // Helper to score binaries based on name and location
+  const scoreBinary = (binaryPath) => {
+    let score = 0;
+    const filename = path.basename(binaryPath).toLowerCase();
+    const dirname = path.dirname(binaryPath).toLowerCase();
+    const cleanPackageName = extractName({ name: packageName }).toLowerCase();
+
+    // High penalty for completion scripts
+    if (
+      dirname.includes("completion") || 
+      dirname.includes("completions") ||
+      filename.endsWith(".bash") ||
+      filename.endsWith(".zsh") ||
+      filename.endsWith(".fish") ||
+      filename.endsWith(".csh") ||
+      filename.endsWith("completion")
+    ) {
+      return -100;
+    }
+    
+    // Penalty for other non-primary scripts
+    if (filename.endsWith(".sh") || filename.endsWith(".bat") || filename.endsWith(".ps1")) {
+      score -= 20;
+    }
+
+    // Major Boost for exact match with package name
+    // e.g. "gum" matches "gum"
+    if (filename === cleanPackageName) {
+      score += 100;
+    }
+
+    // Boost for name containing package name (e.g. "gum-cli")
+    else if (filename.includes(cleanPackageName)) {
+      score += 50;
+    }
+    
+    // Penalize documentation/garbage
+    if (
+      filename.includes("readme") ||
+      filename.includes("license") ||
+      filename.includes("changelog") ||
+      filename.includes("notice") ||
+      filename.includes(".md") ||
+      filename.includes(".txt") ||
+      filename.includes(".1") || // man pages
+      binaryPath.includes("doc/") ||
+      binaryPath.includes("docs/") ||
+      binaryPath.includes("man/")
+    ) {
+      score -= 100;
+    }
+    
+
+
+    return score;
+  };
+
+  // Sort binaries by score
+  const sortedBinaries = [...binaries].sort((a, b) => {
+    const scoreA = scoreBinary(a);
+    const scoreB = scoreBinary(b);
+    return scoreB - scoreA;
   });
 
-  // If filtering leaves us with just one, use it
-  if (filteredBinaries.length === 1) {
-    if (logger) {
-      logger.log(`Auto-selected binary: ${filteredBinaries[0]}`);
+  // Filter out heavily penalized items if we have good candidates
+  let binariesToChoose = sortedBinaries;
+  const bestScore = scoreBinary(sortedBinaries[0]);
+  
+  if (bestScore > 0) {
+    // If we have a good candidate, strictly filter out negative scoring items (completions, docs)
+    // unless they are the only options
+    const goodBinaries = sortedBinaries.filter(b => scoreBinary(b) > -10);
+    if (goodBinaries.length > 0) {
+      binariesToChoose = goodBinaries;
     }
-    return filteredBinaries;
   }
 
-  // If filtering leaves none, fall back to original list
-  const binariesToChoose =
-    filteredBinaries.length > 0 ? filteredBinaries : binaries;
+  // If filtering leaves us with just one (or the top one is significantly better), use it
+  if (binariesToChoose.length === 1 || (binariesToChoose.length > 0 && scoreBinary(binariesToChoose[0]) > 50 && scoreBinary(binariesToChoose[1] || "") < 0)) {
+    if (logger) {
+      logger.log(`Auto-selected binary: ${binariesToChoose[0]}`);
+    }
+    return [binariesToChoose[0]];
+  }
 
   if (logger) {
     logger.log(