.gitignore (1)

104-106: Add a brief explanation of why these files are ignored.
Consider appending a quick comment describing the purpose of .sync-webgui-repo-* so that new contributors understand the rationale behind ignoring these script-related files.

web/scripts/sync-webgui-repo.js (6)

1-24: Centralize error handling for missing dependencies.
The script gracefully imports multiple modules (fs, path, etc.) but does not handle cases where dependencies might be missing or incorrectly installed. Adding a quick dependency check or a user-friendly warning if a module import fails could improve reliability.

---

26-78: Consider switching to asynchronous methods.
All file operations are synchronous (e.g., readFileSync, copyFileSync). While acceptable for a quick CLI tool, asynchronous methods could provide better scalability if the script grows in complexity or needs parallel processing.

---

80-117: Ensure cross-platform support for sound notifications.
The UI.playSound() method only checks known paths for macOS, Linux, and Windows. If users have custom system setups or different file paths, consider allowing them to configure sound commands or handle missing commands gracefully.

---

119-239: Validate file paths before usage.
The State and FileOps objects read from and write to JSON files. If paths are invalid or corrupted JSON is encountered, consider gracefully handling errors and prompting users to fix the files or reinitialize them.

---

241-508: Evaluate build errors for partial successes.
When building web components in handleWebComponentBuild(), the script treats the entire process as a single success/fail step. For complex builds, consider capturing partial successes or logging more granular build output to help diagnose smaller step failures.

---

610-630: Include automated tests.
The App.init() flow orchestrates user prompts and environment setup but lacks automated tests. Adding a few unit or integration tests (possibly mocking UI and file operations) would help ensure reliability for repeated usage.

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro (Legacy)

web/scripts/sync-webgui-repo.js (4)

154-194: Consider enhancing diff visualization.

The diff visualization works but could be improved for better clarity, especially for larger diffs.

Consider adding line numbers and limiting the context of diffs for very large files:

 showDiff(apiFile, webguiFile) {
   const content1 = fs.readFileSync(apiFile, 'utf8');
   const content2 = fs.readFileSync(webguiFile, 'utf8');

   const differences = diff.createPatch(
     path.basename(apiFile),
     content2,
     content1,
     'webgui version',
     'api version'
   );

   if (differences.split('\n').length > 5) {
     console.log('\nDiff for', chalk.cyan(path.basename(apiFile)));
     console.log(chalk.red('--- webgui:'), webguiFile);
     console.log(chalk.green('+++ api:  '), apiFile);

+    // Limit large diffs to improve readability
+    const diffLines = differences.split('\n').slice(5);
+    const maxLines = 50;
+    const showTruncationMessage = diffLines.length > maxLines;
+    const linesToShow = showTruncationMessage ? diffLines.slice(0, maxLines) : diffLines;
+
+    let lineCounter = 0;
     differences
       .split('\n')
       .slice(5)
+      .slice(0, maxLines)
       .forEach((line) => {
-        if (line.startsWith('+')) console.log(chalk.green(line));
-        else if (line.startsWith('-')) console.log(chalk.red(line));
-        else if (line.startsWith('@')) console.log(chalk.cyan(line));
-        else console.log(line);
+        lineCounter++;
+        const lineNum = `${lineCounter}`.padStart(4);
+        if (line.startsWith('+')) console.log(`${lineNum} ${chalk.green(line)}`);
+        else if (line.startsWith('-')) console.log(`${lineNum} ${chalk.red(line)}`);
+        else if (line.startsWith('@')) console.log(`${lineNum} ${chalk.cyan(line)}`);
+        else console.log(`${lineNum} ${line}`);
       });
+      
+    if (showTruncationMessage) {
+      console.log(chalk.yellow(`\n... (${diffLines.length - maxLines} more lines not shown)`));
+      console.log(chalk.yellow(`Total diff size: ${diffLines.length} lines\n`));
+    }
     return true;
   }
   return false;
 },

---

196-210: Enhance user experience in handleFileDiff with better prompts.

The prompt message "What should I do fam?" is informal, which may be fine for a personal tool but could be improved for better clarity.

Consider improving the prompt with more detailed options:

 async handleFileDiff(apiFile, webguiFile) {
   if (!this.showDiff(apiFile, webguiFile)) return 'identical';

   const answer = await UI.question(
-    'What should I do fam? (w=copy to webgui/a=copy to API/s=skip) '
+    'Action to take: (w=copy to webgui, a=copy to API, s=skip) '
   );
   switch (answer.toLowerCase()) {
     case 'w':
       return FileSystem.copyFile(apiFile, webguiFile) ? 'webgui' : 'error';
     case 'a':
       return FileSystem.copyFile(webguiFile, apiFile) ? 'api' : 'error';
     default:
       return 'skip';
   }
 },

---

212-239: Enhance directory traversal with more explicit filtering.

The traversal function has inline filtering logic that could be extracted to make the code more maintainable.

Consider refactoring to make the filtering logic more explicit:

 walkDirectory(currentPath, baseDir, projectFiles, gitignoreRules) {
   const files = fs.readdirSync(currentPath);

+  // Helper function to determine if a file should be skipped
+  const shouldSkipFile = (file, relativePath) => {
+    if (file.startsWith('.')) return true;
+    if (relativePath.includes('test') || relativePath.includes('tests')) return true;
+    if (CONSTANTS.IGNORE_PATTERNS.some((pattern) => pattern.test(file))) return true;
+    if (gitignoreRules?.ignores(relativePath)) return true;
+    return false;
+  };

   files.forEach((file) => {
-    if (file.startsWith('.')) return;
-
     const fullPath = path.join(currentPath, file);
     const relativePath = path.relative(baseDir, fullPath);

-    if (relativePath.includes('test') || relativePath.includes('tests')) return;
-    if (CONSTANTS.IGNORE_PATTERNS.some((pattern) => pattern.test(file))) return;
-    if (gitignoreRules?.ignores(relativePath)) return;
+    if (shouldSkipFile(file, relativePath)) return;

     const lstat = fs.lstatSync(fullPath);
     if (lstat.isSymbolicLink()) return;

     const stats = fs.statSync(fullPath);
     if (stats.isDirectory()) {
       this.walkDirectory(fullPath, baseDir, projectFiles, gitignoreRules);
     } else {
       if (!projectFiles.has(file)) {
         projectFiles.set(file, []);
       }
       projectFiles.get(file).push(fullPath);
     }
   });
 },

---

349-444: Improve error handling in findMissingPluginFiles function.

The function contains a nested walkDir function with verbose logging but could benefit from more robust error handling.

Consider adding try/catch blocks around file operations within the walkDir function:

 function walkDir(currentPath, baseDir) {
   if (!fs.existsSync(currentPath)) {
     UI.log(`Directory doesn't exist: ${currentPath}`, 'warning');
     return;
   }

   UI.log(`Checking directory: ${path.relative(apiProjectDir, currentPath)}`, 'info');

   fs.readdirSync(currentPath).forEach((file) => {
     if (file.startsWith('.')) {
       UI.log(`Skipping dot file/dir: ${file}`, 'skip');
       return;
     }

     const fullPath = path.join(currentPath, file);
     const relativePath = path.relative(apiPluginsPath, fullPath);

     if (CONSTANTS.IGNORE_PATTERNS.some((pattern) => pattern.test(file))) {
       UI.log(`Skipping ignored pattern: ${file}`, 'skip');
       return;
     }

     if (gitignore1?.ignores(relativePath)) {
       UI.log(`Skipping gitignored file: ${file}`, 'skip');
       return;
     }

+    try {
       const lstat = fs.lstatSync(fullPath);
       if (lstat.isSymbolicLink()) {
         UI.log(`Skipping symlink: ${file}`, 'skip');
         return;
       }

       const stats = fs.statSync(fullPath);
       if (stats.isDirectory()) {
         UI.log(`Found subdirectory: ${file}`, 'info');
         walkDir(fullPath, baseDir);
         return;
       }

       if (ignoredFiles.includes(file)) {
         UI.log(`Skipping manually ignored file: ${file}`, 'skip');
         return;
       }

       const webguiPath = path.join(webguiPluginsPath, relativePath);
       if (!fs.existsSync(webguiPath)) {
         UI.log(`Found new file: ${relativePath}`, 'new');
         missingFiles.set(relativePath, {
           source: fullPath,
           destinationPath: webguiPath,
           relativePath,
         });
       } else {
         UI.log(`File exists in both: ${relativePath}`, 'success');
       }
+    } catch (err) {
+      UI.log(`Error processing file ${file}: ${err.message}`, 'error');
+    }
   });
 }

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro (Legacy)

web/scripts/sync-webgui-repo.js (4)

1-8: Consider adding module documentation.

Adding a brief module header comment explaining the purpose of this script would help other developers understand its functionality at a glance.

+/**
+ * Synchronizes files between API and WebGUI repositories
+ * Supports finding new plugin files, handling diffs, and syncing web components
+ */
 const fs = require('fs');
 const path = require('path');
 const ignore = require('ignore');

---

165-194: Improve diff visualization with additional context.

The diff function could be enhanced by providing more context about what's being compared and adding color indicators for clarity.

 showDiff(apiFile, webguiFile) {
   const content1 = fs.readFileSync(apiFile, 'utf8');
   const content2 = fs.readFileSync(webguiFile, 'utf8');

+  // Add error handling for file reads
+  try {
     const differences = diff.createPatch(
       path.basename(apiFile),
       content2,
       content1,
       'webgui version',
       'api version'
     );

     if (differences.split('\n').length > 5) {
-      console.log('\nDiff for', chalk.cyan(path.basename(apiFile)));
+      console.log('\n' + chalk.bold(`Diff for ${path.basename(apiFile)}`));
       console.log(chalk.red('--- webgui:'), webguiFile);
       console.log(chalk.green('+++ api:  '), apiFile);

       differences
         .split('\n')
         .slice(5)
         .forEach((line) => {
-          if (line.startsWith('+')) console.log(chalk.green(line));
-          else if (line.startsWith('-')) console.log(chalk.red(line));
+          if (line.startsWith('+')) console.log(chalk.green(line) + ' ← API');
+          else if (line.startsWith('-')) console.log(chalk.red(line) + ' ← WebGUI');
           else if (line.startsWith('@')) console.log(chalk.cyan(line));
           else console.log(line);
         });
       return true;
     }
     return false;
+  } catch (err) {
+    UI.log(`Error comparing files: ${err.message}`, 'error');
+    return false;
+  }
 },

---

224-229: Optimize file stat operations.

You're calling both lstatSync and statSync on the same file, which is inefficient. Consider consolidating these operations.

- const lstat = fs.lstatSync(fullPath);
- if (lstat.isSymbolicLink()) return;
-
- const stats = fs.statSync(fullPath);
+ // Get file stats with the withFileTypes option to determine type
+ const stats = fs.statSync(fullPath, { throwIfNoEntry: false });
+ if (!stats) return;
+ 
+ // Use fs.lstatSync only when checking for symbolic links
+ if (stats.isSymbolicLink?.() || fs.lstatSync(fullPath).isSymbolicLink()) return;

---

610-624: Add validation for project paths.

The script doesn't verify if the paths provided by the user are valid repository roots. Add some basic validation to ensure they point to actual repositories.

 const App = {
   async init() {
     try {
       const paths = await Features.setupPaths();
+      
+      // Validate paths point to valid repositories
+      const validateRepo = (dir, name) => {
+        if (!fs.existsSync(dir)) {
+          throw new Error(`${name} directory doesn't exist: ${dir}`);
+        }
+        
+        // Check for common repository indicators
+        const hasGit = fs.existsSync(path.join(dir, '.git'));
+        const hasPackageJson = fs.existsSync(path.join(dir, 'package.json'));
+        
+        if (!hasGit && !hasPackageJson) {
+          UI.log(`Warning: ${name} directory might not be a valid repository.`, 'warning');
+          return UI.confirm(`Continue with this path anyway?`);
+        }
+        return true;
+      };
+      
+      // Validate both paths
+      const apiValid = await validateRepo(paths.apiProjectDir, 'API');
+      const webguiValid = await validateRepo(paths.webguiProjectDir, 'WebGUI');
+      
+      if (!apiValid || !webguiValid) {
+        throw new Error('Invalid repository paths. Please restart and provide valid paths.');
+      }
+      
       global.apiProjectDir = paths.apiProjectDir;
       global.webguiProjectDir = paths.webguiProjectDir;
       await Menu.show();

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro (Legacy)