gitforest 0.1.0

package/src/scanner/index.ts

@@ -0,0 +1,424 @@
+import { existsSync } from "fs";
+import { readdir, stat } from "fs/promises";
+import { join, basename } from "path";
+import { createHash } from "crypto";
+import type { Project, ProjectType, GitforestConfig, GitStatus, SubmoduleInfo } from "../types/index.ts";
+import type { GitService } from "../services/git.ts";
+import { bunGitService } from "../services/git.ts";
+import { getGitStatus } from "../git/status.ts";
+import { detectProjectMarker } from "./markers.ts";
+import { getSubmoduleInfo, findSubmodules } from "./submodules.ts";
+import { initDb, schema, clearCache as clearDbCache } from "../db/index.ts";
+import { SCANNER } from "../constants.ts";
+
+/**
+ * Get the most recent file modification time in a directory (non-recursive, top-level only)
+ */
+async function getLatestModificationTime(dirPath: string): Promise<Date | null> {
+  try {
+    const entries = await readdir(dirPath);
+    let latestTime: Date | null = null;
+    
+    for (const entry of entries) {
+      // Skip hidden files and common non-source directories
+      if (entry.startsWith('.') || entry === 'node_modules' || entry === 'dist' || entry === 'build') {
+        continue;
+      }
+      
+      try {
+        const entryPath = join(dirPath, entry);
+        const entryStat = await stat(entryPath);
+        const mtime = entryStat.mtime;
+        
+        if (!latestTime || mtime > latestTime) {
+          latestTime = mtime;
+        }
+      } catch {
+        // Skip files we can't stat
+      }
+    }
+    
+    return latestTime;
+  } catch {
+    return null;
+  }
+}
+
+// Re-export from utils to maintain backward compatibility
+export { sortProjects, filterProjects } from "../utils/project-utils.ts";
+
+/**
+ * Generate a unique ID for a project path
+ */
+function generateProjectId(path: string): string {
+  return createHash("md5").update(path).digest("hex").slice(0, SCANNER.PROJECT_ID_LENGTH);
+}
+
+/**
+ * Check if a directory should be ignored
+ */
+function shouldIgnore(name: string, ignorePatterns: string[], includeHidden: boolean): boolean {
+  // Always ignore these
+  if (name === "." || name === "..") return true;
+
+  // Ignore hidden directories unless configured
+  if (!includeHidden && name.startsWith(".")) return true;
+
+  // Check ignore patterns
+  return ignorePatterns.includes(name);
+}
+
+/**
+ * Scan a single directory for projects
+ */
+async function scanDirectory(
+  dirPath: string,
+  config: GitforestConfig,
+  depth: number,
+  maxDepth: number,
+  foundProjects: Project[],
+  processedPaths: Set<string>,
+  gitService: GitService
+): Promise<void> {
+  // Don't scan beyond max depth
+  if (depth > maxDepth) return;
+
+  // Skip if already processed
+  if (processedPaths.has(dirPath)) return;
+  processedPaths.add(dirPath);
+
+  // Check if this directory exists
+  if (!existsSync(dirPath)) return;
+
+  // Check if this is a git repository
+  const isGit = await gitService.isGitRepo(dirPath);
+
+  if (isGit) {
+    // This is a git repository - add it as a project
+    const project = await createProject(dirPath, "git");
+    foundProjects.push(project);
+
+    // Check for submodules if configured
+    if (config.display.showSubmodules) {
+      const submodulePaths = await findSubmodules(dirPath, gitService);
+      for (const subPath of submodulePaths) {
+        if (!processedPaths.has(subPath)) {
+          const subProject = await createProject(subPath, "git-submodule", undefined, gitService);
+          foundProjects.push(subProject);
+          processedPaths.add(subPath);
+        }
+      }
+    }
+
+    // Don't recurse into git repositories (except for submodules which we handle above)
+    return;
+  }
+
+  // Check if this is a project without git
+  const marker = await detectProjectMarker(dirPath);
+  if (marker) {
+    // Only add non-git projects if configured to show them
+    if (config.display.showNonGitProjects) {
+      const project = await createProject(dirPath, "non-git", marker, gitService);
+      foundProjects.push(project);
+    }
+    // Don't recurse into non-git projects (even if not showing them)
+    return;
+  }
+
+  // This is just a directory - scan children
+  try {
+    const entries = await readdir(dirPath);
+
+    for (const entry of entries) {
+      if (shouldIgnore(entry, config.scan.ignore, config.scan.includeHidden)) {
+        continue;
+      }
+
+      const entryPath = join(dirPath, entry);
+
+      try {
+        const entryStat = await stat(entryPath);
+        if (entryStat.isDirectory()) {
+          await scanDirectory(
+            entryPath,
+            config,
+            depth + 1,
+            maxDepth,
+            foundProjects,
+            processedPaths,
+            gitService
+          );
+        }
+      } catch {
+        // Skip entries we can't stat
+      }
+    }
+  } catch {
+    // Skip directories we can't read
+  }
+}
+
+/**
+ * Create a Project object from a path
+ */
+async function createProject(
+  path: string,
+  type: ProjectType,
+  marker?: string | null,
+  gitService: GitService = bunGitService
+): Promise<Project> {
+  const id = generateProjectId(path);
+  const name = basename(path);
+
+  // Get project marker if not provided and not a git repo
+  const projectMarker = marker ?? (type === "non-git" ? await detectProjectMarker(path) : null);
+
+  // Get git status if this is a git project
+  let status = null;
+  if (type === "git" || type === "git-submodule") {
+    try {
+      status = await getGitStatus(path, gitService);
+    } catch {
+      // Status unavailable
+    }
+  }
+
+  // Get submodule info if applicable
+  let submodule = null;
+  if (type === "git-submodule") {
+    submodule = await getSubmoduleInfo(path, gitService);
+  }
+
+  // Get last modified time for non-git projects (or git projects without commits)
+  let lastModified: Date | null = null;
+  if (type === "non-git" || (status && !status.hasCommits)) {
+    lastModified = await getLatestModificationTime(path);
+  }
+
+  return {
+    id,
+    name,
+    path,
+    type,
+    projectMarker,
+    status,
+    submodule,
+    lastScanned: new Date(),
+    lastModified,
+  };
+}
+
+/**
+ * Scan all configured directories for projects
+ * 
+ * Recursively scans directories looking for git repositories, submodules,
+ * and non-git projects (identified by marker files like package.json).
+ * 
+ * @param config - The gitforest configuration object containing directories to scan
+ * @param options - Options for scanning
+ * @param options.onProgress - Optional callback for progress updates
+ * @param options.gitService - Git service implementation (defaults to bunGitService)
+ * @returns Promise resolving to array of discovered projects
+ * 
+ * @example
+ * ```typescript
+ * const projects = await scanAllDirectories(config, { 
+ *   onProgress: (scanned, found) => {
+ *     console.log(`Scanned ${scanned} dirs, found ${found} projects`);
+ *   }
+ * });
+ * ```
+ */
+export async function scanAllDirectories(
+  config: GitforestConfig,
+  options: {
+    onProgress?: (scanned: number, found: number) => void;
+    gitService?: GitService;
+  } = {}
+): Promise<Project[]> {
+  const { onProgress, gitService = bunGitService } = options;
+  const foundProjects: Project[] = [];
+  const processedPaths = new Set<string>();
+
+  for (const dirConfig of config.directories) {
+    await scanDirectory(
+      dirConfig.path,
+      config,
+      0,
+      dirConfig.maxDepth,
+      foundProjects,
+      processedPaths,
+      gitService
+    );
+
+    onProgress?.(processedPaths.size, foundProjects.length);
+  }
+
+  return foundProjects;
+}
+
+/**
+ * Convert a database row to a Project object
+ */
+function dbRowToProject(row: typeof schema.projects.$inferSelect): Project {
+  return {
+    id: row.id,
+    name: row.name,
+    path: row.path,
+    type: row.type as ProjectType,
+    projectMarker: row.projectMarker,
+    status: row.statusJson ? JSON.parse(row.statusJson) as GitStatus : null,
+    submodule: row.submoduleJson ? JSON.parse(row.submoduleJson) as SubmoduleInfo : null,
+    lastScanned: row.lastScanned ?? new Date(),
+    lastModified: (row as { lastModified?: Date }).lastModified ?? null,
+  };
+}
+
+/**
+ * Convert a Project to database row format
+ */
+function projectToDbRow(project: Project) {
+  return {
+    id: project.id,
+    name: project.name,
+    path: project.path,
+    type: project.type,
+    projectMarker: project.projectMarker,
+    statusJson: project.status ? JSON.stringify(project.status) : null,
+    submoduleJson: project.submodule ? JSON.stringify(project.submodule) : null,
+    lastScanned: project.lastScanned,
+    lastModified: project.lastModified,
+  };
+}
+
+/**
+ * Save projects to the cache database
+ */
+async function saveToCache(projects: Project[]): Promise<void> {
+  const db = await initDb();
+
+  for (const project of projects) {
+    const row = projectToDbRow(project);
+    await db
+      .insert(schema.projects)
+      .values(row)
+      .onConflictDoUpdate({
+        target: schema.projects.path,
+        set: row,
+      });
+  }
+}
+
+/**
+ * Load all projects from cache
+ */
+async function loadFromCache(): Promise<Project[]> {
+  const db = await initDb();
+  const rows = await db.select().from(schema.projects).all();
+  return rows.map(dbRowToProject);
+}
+
+/**
+ * Check if cache is fresh based on TTL
+ */
+function isCacheFresh(projects: Project[], ttlSeconds: number): boolean {
+  if (projects.length === 0) return false;
+
+  const now = Date.now();
+  const ttlMs = ttlSeconds * 1000;
+
+  // Cache is fresh if most recent scan is within TTL
+  const mostRecent = Math.max(...projects.map(p => p.lastScanned.getTime()));
+  return now - mostRecent < ttlMs;
+}
+
+/**
+ * Scan directories with caching support
+ * 
+ * Uses cached data if fresh (within TTL), otherwise performs full scan.
+ * Results are automatically cached for subsequent calls.
+ * 
+ * @param config - The gitforest configuration object
+ * @param options - Scanning options
+ * @param options.forceRefresh - Force a fresh scan even if cache is valid
+ * @param options.onProgress - Callback for scan progress updates
+ * @param options.gitService - Git service implementation (defaults to bunGitService)
+ * @returns Promise resolving to array of projects (cached or fresh)
+ * 
+ * @example
+ * ```typescript
+ * // Use cache if available
+ * const projects = await scanWithCache(config);
+ * 
+ * // Force fresh scan
+ * const freshProjects = await scanWithCache(config, { forceRefresh: true });
+ * ```
+ */
+export async function scanWithCache(
+  config: GitforestConfig,
+  options: {
+    forceRefresh?: boolean;
+    onProgress?: (scanned: number, found: number) => void;
+    gitService?: GitService;
+  } = {}
+): Promise<Project[]> {
+  const { forceRefresh = false, onProgress, gitService = bunGitService } = options;
+
+  // Try to load from cache first
+  if (!forceRefresh) {
+    try {
+      const cached = await loadFromCache();
+      if (isCacheFresh(cached, config.cache.ttlSeconds)) {
+        return cached;
+      }
+    } catch {
+      // Cache read failed, continue with fresh scan
+    }
+  }
+
+  // Perform full scan
+  const projects = await scanAllDirectories(config, { onProgress, gitService });
+
+  // Save to cache
+  try {
+    await saveToCache(projects);
+  } catch {
+    // Cache write failed, but we still have the projects
+  }
+
+  return projects;
+}
+
+/**
+ * Clear the project cache
+ */
+export async function clearCache(): Promise<void> {
+  await clearDbCache();
+}
+
+/**
+ * Get cache statistics
+ */
+export async function getCacheStats(): Promise<{
+  projectCount: number;
+  oldestScan: Date | null;
+  newestScan: Date | null;
+}> {
+  const db = await initDb();
+  const rows = await db.select().from(schema.projects).all();
+
+  if (rows.length === 0) {
+    return { projectCount: 0, oldestScan: null, newestScan: null };
+  }
+
+  const timestamps = rows
+    .map(r => r.lastScanned?.getTime() ?? 0)
+    .filter(t => t > 0);
+
+  return {
+    projectCount: rows.length,
+    oldestScan: timestamps.length > 0 ? new Date(Math.min(...timestamps)) : null,
+    newestScan: timestamps.length > 0 ? new Date(Math.max(...timestamps)) : null,
+  };
+}

package/src/scanner/markers.ts

@@ -0,0 +1,43 @@
+import { existsSync } from "fs";
+import { join } from "path";
+import { PROJECT_MARKERS } from "../types/index.ts";
+
+/**
+ * Detect the project type based on marker files
+ */
+export async function detectProjectMarker(path: string): Promise<string | null> {
+  for (const marker of Object.keys(PROJECT_MARKERS)) {
+    const markerPath = join(path, marker);
+    if (existsSync(markerPath)) {
+      return marker;
+    }
+  }
+  return null;
+}
+
+/**
+ * Get the human-readable project type
+ */
+export function getProjectTypeName(marker: string | null): string {
+  if (!marker) return "Unknown";
+  return PROJECT_MARKERS[marker] ?? "Unknown";
+}
+
+/**
+ * Check if a directory is likely a project (has marker files or is a git repo)
+ */
+export async function isLikelyProject(path: string): Promise<boolean> {
+  // Check for .git directory
+  if (existsSync(join(path, ".git"))) {
+    return true;
+  }
+
+  // Check for project markers
+  for (const marker of Object.keys(PROJECT_MARKERS)) {
+    if (existsSync(join(path, marker))) {
+      return true;
+    }
+  }
+
+  return false;
+}

package/src/scanner/submodules.ts

@@ -0,0 +1,61 @@
+import { existsSync } from "fs";
+import { join, relative } from "path";
+import type { SubmoduleInfo } from "../types/index.ts";
+import type { GitService } from "../services/git.ts";
+import { bunGitService } from "../services/git.ts";
+
+/**
+ * Get submodule information for a path
+ */
+export async function getSubmoduleInfo(
+  path: string,
+  gitService: GitService = bunGitService
+): Promise<SubmoduleInfo | null> {
+  const isSub = await gitService.isSubmodule(path);
+  if (!isSub) return null;
+
+  const parentPath = await gitService.getSubmoduleParent(path);
+  if (!parentPath) return null;
+
+  // Get configured commit from parent's submodule list
+  const submodules = await gitService.listSubmodules(parentPath);
+  const relativePath = relative(parentPath, path);
+
+  const subInfo = submodules.find((s) => s.path === relativePath);
+
+  return {
+    parentPath,
+    relativePath,
+    configuredCommit: subInfo?.commit ?? "",
+    currentCommit: subInfo?.commit ?? "",
+    isInitialized: subInfo?.status !== "-",
+  };
+}
+
+/**
+ * Find all submodules in a git repository
+ */
+export async function findSubmodules(
+  repoPath: string,
+  gitService: GitService = bunGitService
+): Promise<string[]> {
+  // Check if .gitmodules exists
+  if (!existsSync(join(repoPath, ".gitmodules"))) {
+    return [];
+  }
+
+  const submodules = await gitService.listSubmodules(repoPath);
+  return submodules.map((s) => join(repoPath, s.path));
+}
+
+/**
+ * Check if a path is a submodule of another repository
+ */
+export async function isSubmoduleOf(
+  path: string,
+  parentPath: string,
+  gitService: GitService = bunGitService
+): Promise<boolean> {
+  const submodules = await findSubmodules(parentPath, gitService);
+  return submodules.includes(path);
+}