forge-remote 0.1.1 → 0.1.3

package/src/project-scanner.js

@@ -1,9 +1,10 @@
-import { readdirSync, statSync, existsSync } from "fs";
+import { readdirSync, readFileSync, statSync, existsSync } from "fs";
 import { join, basename } from "path";
 import { homedir } from "os";
+import * as log from "./logger.js";
 
-// Directories to scan (one level deep) for projects.
-const SCAN_DIRS = [
+// Default directories to scan for projects.
+const DEFAULT_SCAN_DIRS = [
   join(homedir(), "Documents"),
   join(homedir(), "Projects"),
   join(homedir(), "Developer"),
@@ -15,6 +16,29 @@ const SCAN_DIRS = [
   join(homedir(), "Desktop"),
 ];
 
+// Maximum depth to recurse into each scan directory.
+const MAX_DEPTH = 4;
+
+// Directories to skip during recursive scanning.
+const SKIP_DIRS = new Set([
+  "node_modules",
+  ".git",
+  "__pycache__",
+  "target",
+  "build",
+  "dist",
+  ".next",
+  ".nuxt",
+  "vendor",
+  ".dart_tool",
+  ".pub-cache",
+  "Pods",
+  ".gradle",
+  "venv",
+  ".venv",
+  "env",
+]);
+
 // Files that indicate a directory is a project root.
 const PROJECT_MARKERS = [
   ".git",
@@ -29,8 +53,34 @@ const PROJECT_MARKERS = [
   "build.gradle",
   "Makefile",
   "CMakeLists.txt",
+  ".xcodeproj", // Xcode projects (check for any child matching)
+  "Podfile",
+  "composer.json",
+  "mix.exs",
+  "stack.yaml",
+  "dune-project",
 ];
 
+/**
+ * Load user-configured extra scan paths from ~/.forge-remote/config.json.
+ * The config can contain a "scanPaths" array of absolute directory paths.
+ */
+function loadExtraScanPaths() {
+  try {
+    const configPath = join(homedir(), ".forge-remote", "config.json");
+    if (!existsSync(configPath)) return [];
+    const config = JSON.parse(readFileSync(configPath, "utf-8"));
+    if (Array.isArray(config.scanPaths)) {
+      return config.scanPaths.filter(
+        (p) => typeof p === "string" && p.startsWith("/"),
+      );
+    }
+  } catch {
+    // Ignore config parse errors.
+  }
+  return [];
+}
+
 /**
  * Scan common directories for projects.
  * Returns an array of { path, name, lastOpened } objects.
@@ -39,64 +89,80 @@ export async function scanProjects() {
   const projects = [];
   const seen = new Set();
 
-  for (const scanDir of SCAN_DIRS) {
-    if (!existsSync(scanDir)) continue;
+  const extraPaths = loadExtraScanPaths();
+  const scanDirs = [...DEFAULT_SCAN_DIRS, ...extraPaths];
 
-    try {
-      const entries = readdirSync(scanDir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue;
-        if (entry.name.startsWith(".")) continue;
-
-        const dirPath = join(scanDir, entry.name);
-        if (seen.has(dirPath)) continue;
-
-        if (isProject(dirPath)) {
-          seen.add(dirPath);
-          const stat = statSync(dirPath);
-          projects.push({
-            path: dirPath,
-            name: basename(dirPath),
-            lastOpened: stat.mtime.toISOString(),
-          });
-        }
-
-        // Also scan one level deeper for nested project dirs
-        // (e.g. ~/Documents/IronForgeApps/Mobile/ForgeRemote).
-        try {
-          const subEntries = readdirSync(dirPath, { withFileTypes: true });
-          for (const sub of subEntries) {
-            if (!sub.isDirectory() || sub.name.startsWith(".")) continue;
-            const subPath = join(dirPath, sub.name);
-            if (seen.has(subPath)) continue;
-
-            if (isProject(subPath)) {
-              seen.add(subPath);
-              const stat = statSync(subPath);
-              projects.push({
-                path: subPath,
-                name: basename(subPath),
-                lastOpened: stat.mtime.toISOString(),
-              });
-            }
-          }
-        } catch {
-          // Skip subdirs we can't read.
-        }
-      }
-    } catch {
-      // Skip dirs we can't read.
-    }
+  log.info(`Scanning ${scanDirs.length} directories for projects...`);
+
+  for (const scanDir of scanDirs) {
+    if (!existsSync(scanDir)) continue;
+    scanRecursive(scanDir, 0, projects, seen);
   }
 
   // Sort by lastOpened descending.
   projects.sort((a, b) => b.lastOpened.localeCompare(a.lastOpened));
 
+  log.info(`Found ${projects.length} projects`);
   return projects;
 }
 
+/**
+ * Recursively scan a directory for projects up to MAX_DEPTH.
+ * When a project is found, it is added to the list and we do NOT recurse
+ * into it (a project root's subdirectories are not separate projects).
+ */
+function scanRecursive(dirPath, depth, projects, seen) {
+  if (depth > MAX_DEPTH) return;
+
+  let entries;
+  try {
+    entries = readdirSync(dirPath, { withFileTypes: true });
+  } catch {
+    return; // Permission denied or unreadable.
+  }
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const name = entry.name;
+    if (name.startsWith(".") && name !== ".git") continue;
+    if (SKIP_DIRS.has(name)) continue;
+
+    const fullPath = join(dirPath, name);
+    if (seen.has(fullPath)) continue;
+
+    if (isProject(fullPath)) {
+      seen.add(fullPath);
+      try {
+        const stat = statSync(fullPath);
+        projects.push({
+          path: fullPath,
+          name: basename(fullPath),
+          lastOpened: stat.mtime.toISOString(),
+        });
+      } catch {
+        // stat failed — skip.
+      }
+      // Don't recurse into project directories.
+      continue;
+    }
+
+    // Not a project — recurse deeper.
+    scanRecursive(fullPath, depth + 1, projects, seen);
+  }
+}
+
 function isProject(dirPath) {
   for (const marker of PROJECT_MARKERS) {
+    // For .xcodeproj, check if any child ends with .xcodeproj
+    if (marker === ".xcodeproj") {
+      try {
+        const children = readdirSync(dirPath);
+        if (children.some((c) => c.endsWith(".xcodeproj"))) return true;
+      } catch {
+        // ignore
+      }
+      continue;
+    }
     if (existsSync(join(dirPath, marker))) return true;
   }
   return false;