gitforest 0.1.0

package/src/operations/batch.ts

@@ -0,0 +1,280 @@
+/**
+ * Batch operations orchestrator
+ * Uses service abstractions for testability
+ */
+
+import type { Project, BatchResult, OperationResult } from "../types/index.ts";
+import type { GitService } from "../services/git.ts";
+import { bunGitService } from "../services/git.ts";
+import { chunk } from "../utils/array.ts";
+import { processBatch } from "../utils/rate-limiter.ts";
+import { GIT } from "../constants.ts";
+
+export type ProgressCallback = (completed: number, total: number) => void;
+
+export interface BatchOptions {
+  concurrency?: number;
+  minDelay?: number;
+  onProgress?: ProgressCallback;
+  gitService?: GitService;
+}
+
+/**
+ * Filter projects that can be pulled (git with remote)
+ */
+function getPullableProjects(projects: Project[]): Project[] {
+  return projects.filter((p) => p.type === "git" && p.status?.hasRemote);
+}
+
+/**
+ * Filter projects that need pushing (git with remote and ahead)
+ */
+function getPushableProjects(projects: Project[]): Project[] {
+  return projects.filter(
+    (p) => p.type === "git" && p.status?.hasRemote && p.status?.isAhead
+  );
+}
+
+/**
+ * Filter projects that can be fetched (git with remote)
+ */
+function getFetchableProjects(projects: Project[]): Project[] {
+  return projects.filter((p) => p.type === "git" && p.status?.hasRemote);
+}
+
+/**
+ * Pull changes for multiple projects with rate limiting
+ * 
+ * Filters projects to only those that are git repos with remotes,
+ * then pulls changes in parallel with configurable concurrency.
+ * 
+ * @param projects - Array of projects to pull
+ * @param options - Batch operation options
+ * @param options.concurrency - Maximum concurrent operations (default: 5)
+ * @param options.onProgress - Progress callback (completed, total)
+ * @param options.gitService - Git service implementation (for testing)
+ * @returns Promise resolving to batch result with success/failure counts
+ * 
+ * @example
+ * ```typescript
+ * const result = await batchPull(projects, {
+ *   concurrency: 3,
+ *   onProgress: (done, total) => console.log(`${done}/${total}`)
+ * });
+ * console.log(`Pulled ${result.successful}/${result.total} repos`);
+ * ```
+ */
+export async function batchPull(
+  projects: Project[],
+  options: BatchOptions = {}
+): Promise<BatchResult> {
+  const { concurrency = GIT.DEFAULT_CONCURRENCY, minDelay = 0, onProgress, gitService = bunGitService } = options;
+  const start = Date.now();
+  const pullable = getPullableProjects(projects);
+
+  const batchResults = await processBatch(
+    pullable,
+    (p) => gitService.pull(p.path),
+    {
+      concurrency,
+      minDelay,
+      onProgress,
+    }
+  );
+
+  // Transform BatchItemResult<OperationResult>[] to OperationResult[]
+  const results: OperationResult[] = batchResults.map((batchResult, index) => {
+    if (batchResult.success) {
+      return batchResult.result!;
+    } else {
+      // Create a failed OperationResult for this project
+      const project = pullable[index]!;
+      return {
+        success: false,
+        projectPath: project.path,
+        operation: "pull",
+        error: batchResult.error?.message,
+        duration: 0,
+      };
+    }
+  });
+
+  const successful = results.filter((r) => r.success).length;
+
+  return {
+    total: pullable.length,
+    successful,
+    failed: pullable.length - successful,
+    results,
+    duration: Date.now() - start,
+  };
+}
+
+/**
+ * Push changes for multiple projects with rate limiting
+ * 
+ * Filters projects to only those that are git repos with remotes and have unpushed commits,
+ * then pushes changes in parallel with configurable concurrency.
+ * 
+ * @param projects - Array of projects to push
+ * @param options - Batch operation options
+ * @param options.concurrency - Maximum concurrent operations (default: 5)
+ * @param options.onProgress - Progress callback (completed, total)
+ * @param options.gitService - Git service implementation (for testing)
+ * @returns Promise resolving to batch result with success/failure counts
+ * 
+ * @example
+ * ```typescript
+ * const result = await batchPush(projects, {
+ *   concurrency: 2,
+ *   onProgress: (done, total) => console.log(`${done}/${total}`)
+ * });
+ * console.log(`Pushed ${result.successful}/${result.total} repos`);
+ * ```
+ */
+export async function batchPush(
+  projects: Project[],
+  options: BatchOptions = {}
+): Promise<BatchResult> {
+  const { concurrency = GIT.DEFAULT_CONCURRENCY, minDelay = 0, onProgress, gitService = bunGitService } = options;
+  const start = Date.now();
+  const pushable = getPushableProjects(projects);
+
+  const batchResults = await processBatch(
+    pushable,
+    (p) => gitService.push(p.path),
+    {
+      concurrency,
+      minDelay,
+      onProgress,
+    }
+  );
+
+  // Transform BatchItemResult<OperationResult>[] to OperationResult[]
+  const results: OperationResult[] = batchResults.map((batchResult, index) => {
+    if (batchResult.success) {
+      return batchResult.result!;
+    } else {
+      // Create a failed OperationResult for this project
+      const project = pushable[index]!;
+      return {
+        success: false,
+        projectPath: project.path,
+        operation: "push",
+        error: batchResult.error?.message,
+        duration: 0,
+      };
+    }
+  });
+
+  const successful = results.filter((r) => r.success).length;
+
+  return {
+    total: pushable.length,
+    successful,
+    failed: pushable.length - successful,
+    results,
+    duration: Date.now() - start,
+  };
+}
+
+/**
+ * Fetch all remotes for multiple projects with rate limiting
+ * 
+ * Filters projects to only those that are git repos with remotes,
+ * then fetches updates in parallel with configurable concurrency.
+ * 
+ * @param projects - Array of projects to fetch
+ * @param options - Batch operation options
+ * @param options.concurrency - Maximum concurrent operations (default: 5)
+ * @param options.onProgress - Progress callback (completed, total)
+ * @param options.gitService - Git service implementation (for testing)
+ * @returns Promise resolving to batch result with success/failure counts
+ * 
+ * @example
+ * ```typescript
+ * const result = await batchFetch(projects, {
+ *   concurrency: 4,
+ *   onProgress: (done, total) => console.log(`${done}/${total}`)
+ * });
+ * console.log(`Fetched ${result.successful}/${result.total} repos`);
+ * ```
+ */
+export async function batchFetch(
+  projects: Project[],
+  options: BatchOptions = {}
+): Promise<BatchResult> {
+  const { concurrency = GIT.DEFAULT_CONCURRENCY, minDelay = 0, onProgress, gitService = bunGitService } = options;
+  const start = Date.now();
+  const fetchable = getFetchableProjects(projects);
+
+  const batchResults = await processBatch(
+    fetchable,
+    (p) => gitService.fetchAll(p.path),
+    {
+      concurrency,
+      minDelay,
+      onProgress,
+    }
+  );
+
+  // Transform BatchItemResult<OperationResult>[] to OperationResult[]
+  const results: OperationResult[] = batchResults.map((batchResult, index) => {
+    if (batchResult.success) {
+      return batchResult.result!;
+    } else {
+      // Create a failed OperationResult for this project
+      const project = fetchable[index]!;
+      return {
+        success: false,
+        projectPath: project.path,
+        operation: "fetch",
+        error: batchResult.error?.message,
+        duration: 0,
+      };
+    }
+  });
+
+  const successful = results.filter((r) => r.success).length;
+
+  return {
+    total: fetchable.length,
+    successful,
+    failed: fetchable.length - successful,
+    results,
+    duration: Date.now() - start,
+  };
+}
+
+/**
+ * Refresh git status for multiple projects
+ */
+export async function batchRefreshStatus(
+  projects: Project[],
+  options: BatchOptions = {}
+): Promise<Map<string, Project>> {
+  const { concurrency = GIT.STATUS_REFRESH_CONCURRENCY, gitService = bunGitService } = options;
+  const gitProjects = projects.filter((p) => p.type !== "non-git");
+  const results = new Map<string, Project>();
+
+  const batches = chunk(gitProjects, concurrency);
+
+  for (const batch of batches) {
+    const updates = await Promise.all(
+      batch.map(async (p) => {
+        try {
+          const status = await gitService.getStatus(p.path);
+          return { ...p, status, lastScanned: new Date() };
+        } catch {
+          return p;
+        }
+      })
+    );
+
+    for (const p of updates) {
+      results.set(p.id, p);
+    }
+  }
+
+  return results;
+}

package/src/operations/commands.ts

@@ -0,0 +1,140 @@
+/**
+ * Custom command execution module
+ * 
+ * Executes user-configured commands in project directories
+ */
+
+import type { CommandConfig } from "../types/index.ts";
+
+export interface CommandResult {
+  success: boolean;
+  command: string;
+  projectPath: string;
+  output: string;
+  error?: string;
+  duration: number;
+}
+
+/**
+ * Execute a custom command in a project directory
+ */
+export async function executeCommand(
+  command: CommandConfig,
+  projectPath: string,
+  options: { background?: boolean } = {}
+): Promise<CommandResult> {
+  const startTime = Date.now();
+  const { background = command.background } = options;
+
+  try {
+    // Expand environment variables in the command
+    const expandedCommand = expandEnvVars(command.command, projectPath);
+
+    if (background) {
+      // Run in background - don't wait for completion
+      Bun.spawn(["sh", "-c", expandedCommand], {
+        cwd: projectPath,
+        stdout: "ignore",
+        stderr: "ignore",
+      });
+
+      return {
+        success: true,
+        command: command.name,
+        projectPath,
+        output: "Started in background",
+        duration: Date.now() - startTime,
+      };
+    }
+
+    // Run and wait for completion
+    const result = await Bun.$`sh -c ${expandedCommand}`.cwd(projectPath).quiet().nothrow();
+
+    const output = result.stdout.toString().trim();
+    const stderr = result.stderr.toString().trim();
+
+    if (result.exitCode !== 0) {
+      return {
+        success: false,
+        command: command.name,
+        projectPath,
+        output,
+        error: stderr || `Command exited with code ${result.exitCode}`,
+        duration: Date.now() - startTime,
+      };
+    }
+
+    return {
+      success: true,
+      command: command.name,
+      projectPath,
+      output,
+      duration: Date.now() - startTime,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      command: command.name,
+      projectPath,
+      output: "",
+      error: error instanceof Error ? error.message : String(error),
+      duration: Date.now() - startTime,
+    };
+  }
+}
+
+/**
+ * Expand environment variables in a command string
+ * Supports $VAR and ${VAR} syntax
+ * Special handling for $PWD which gets replaced with projectPath
+ */
+function expandEnvVars(command: string, projectPath: string): string {
+  return command.replace(/\$\{?(\w+)\}?/g, (match, varName) => {
+    // Special case: $PWD should be the project path, not the current process's PWD
+    if (varName === "PWD") {
+      return projectPath;
+    }
+    // For other env vars, use process.env or leave unchanged if not found
+    return process.env[varName] ?? match;
+  });
+}
+
+/**
+ * Find a command by its key from the config
+ */
+export function findCommandByKey(
+  commands: CommandConfig[],
+  key: string
+): CommandConfig | undefined {
+  if (!commands || !Array.isArray(commands)) {
+    return undefined;
+  }
+  return commands.find((cmd) => cmd.key === key);
+}
+
+/**
+ * Execute commands on multiple projects
+ */
+export async function batchExecuteCommand(
+  command: CommandConfig,
+  projectPaths: string[],
+  options: {
+    concurrency?: number;
+    onProgress?: (current: number, total: number) => void;
+  } = {}
+): Promise<CommandResult[]> {
+  const { concurrency = 5, onProgress } = options;
+  const results: CommandResult[] = [];
+  
+  // Process in batches
+  for (let i = 0; i < projectPaths.length; i += concurrency) {
+    const batch = projectPaths.slice(i, i + concurrency);
+    const batchResults = await Promise.all(
+      batch.map((path) => executeCommand(command, path))
+    );
+    results.push(...batchResults);
+    onProgress?.(Math.min(i + concurrency, projectPaths.length), projectPaths.length);
+  }
+
+  return results;
+}

package/src/operations/index.ts

@@ -0,0 +1,37 @@
+/**
+ * Operations module - orchestrators for git and batch operations
+ *
+ * This module provides both low-level operations (single project)
+ * and batch orchestrators (multiple projects with progress).
+ *
+ * For testability, batch operations accept an optional GitService
+ * that can be mocked in tests.
+ */
+
+// Re-export single-project operations from git module
+export {
+  initGitInProject,
+  pullProject,
+  pushProject,
+  fetchProject,
+  addRemoteToProject,
+  refreshProjectStatuses,
+} from "../git/operations.ts";
+
+// Export new service-based batch operations
+export {
+  batchPull,
+  batchPush,
+  batchFetch,
+  batchRefreshStatus,
+  type BatchOptions,
+  type ProgressCallback,
+} from "./batch.ts";
+
+// Export custom command operations
+export {
+  executeCommand,
+  findCommandByKey,
+  batchExecuteCommand,
+  type CommandResult,
+} from "./commands.ts";