gitforest 1.1.2 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitforest",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "description": "TUI for managing multiple Git repositories and GitHub integration",
   "module": "src/index.tsx",
   "type": "module",

package/src/app.tsx

@@ -1,9 +1,13 @@
 import React from "react";
+import { existsSync, statSync } from "fs";
+import { resolve } from "path";
+import { homedir } from "os";
 import { StoreProvider } from "./state/store.tsx";
 import { Layout } from "./components/Layout.tsx";
 import { useUnifiedRepos } from "./hooks/useUnifiedRepos.ts";
 import { useKeyBindings } from "./hooks/useKeyBindings.ts";
 import { useBackgroundFetch } from "./hooks/useBackgroundFetch.ts";
+import { saveConfig, findConfigPath } from "./config/loader.ts";
 import type { GitforestConfig, UnifiedRepo } from "./types/index.ts";
 
 interface AppContentProps {
@@ -18,6 +22,51 @@ function AppContent({ config }: AppContentProps) {
     await batchClone(repos, targetDir, useSSH);
   };
 
+  // Add directory handler for Layout
+  const handleAddDirectory = async (
+    rawPath: string,
+    maxDepth: number,
+    label: string,
+  ): Promise<{ success: boolean; error?: string }> => {
+    const expanded = rawPath.replace(/^~/, homedir());
+    const absPath = resolve(expanded);
+
+    if (!existsSync(absPath)) {
+      return { success: false, error: `Directory does not exist: ${absPath}` };
+    }
+
+    if (!statSync(absPath).isDirectory()) {
+      return { success: false, error: `Not a directory: ${absPath}` };
+    }
+
+    // Check for duplicates
+    const exists = config.directories.some((d) => {
+      const dPath = d.path.replace(/^~/, homedir());
+      return resolve(dPath) === absPath;
+    });
+
+    if (exists) {
+      return { success: false, error: "Directory already configured" };
+    }
+
+    // Add to the config object (mutation - stays in memory for this session)
+    const newDir: { path: string; maxDepth: number; label?: string } = {
+      path: absPath,
+      maxDepth,
+    };
+    if (label) newDir.label = label;
+    config.directories.push(newDir);
+
+    // Persist to disk
+    try {
+      const configPath = findConfigPath() ?? undefined;
+      await saveConfig(config, configPath);
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+  };
+
   // Set up keyboard bindings
   useKeyBindings({
     config,
@@ -27,7 +76,14 @@ function AppContent({ config }: AppContentProps) {
   // Set up background fetch
   useBackgroundFetch(config, loadUnifiedRepos);
 
-  return <Layout config={config} onRefresh={loadUnifiedRepos} onClone={handleClone} />;
+  return (
+    <Layout
+      config={config}
+      onRefresh={loadUnifiedRepos}
+      onClone={handleClone}
+      onAddDirectory={handleAddDirectory}
+    />
+  );
 }
 
 interface AppProps {

package/src/cli/commands/auth.ts

@@ -0,0 +1,75 @@
+import {
+  login,
+  logout,
+  getAuthStatus,
+  isGhInstalled,
+} from "../../github/auth.ts";
+import {
+  formatAuthSuccess,
+  formatNoToken,
+  formatError,
+  formatInfo,
+} from "../formatters.ts";
+
+/**
+ * Show GitHub authentication status
+ */
+export async function showGitHubAuth(): Promise<void> {
+  const status = await getAuthStatus();
+
+  if (!status.authenticated) {
+    console.log(formatNoToken());
+    console.log(formatInfo("\nRun 'gitforest login' to authenticate with GitHub."));
+    return;
+  }
+
+  console.log(formatAuthSuccess(status.user ?? "unknown", undefined));
+  console.log(formatInfo(`  Auth source: ${status.source === "env" ? "environment variable" : "gh CLI"}`));
+}
+
+/**
+ * Login to GitHub using gh CLI
+ */
+export async function loginGitHub(): Promise<void> {
+  // Check if gh is installed
+  const ghInstalled = await isGhInstalled();
+  if (!ghInstalled) {
+    console.log(formatError("GitHub CLI (gh) is not installed."));
+    console.log(formatInfo("Install it from: https://cli.github.com"));
+    console.log(formatInfo("\nOr set GITHUB_TOKEN environment variable manually."));
+    process.exit(1);
+  }
+
+  // Check if already authenticated
+  const status = await getAuthStatus();
+  if (status.authenticated) {
+    console.log(formatInfo(`Already logged in as ${status.user ?? "unknown"}`));
+    console.log(formatInfo("Run 'gitforest logout' first to login as a different user."));
+    return;
+  }
+
+  const result = await login();
+
+  if (result.success) {
+    console.log(`\n${formatAuthSuccess(result.user ?? "unknown", undefined)}`);
+    console.log(formatInfo("You can now use GitHub features."));
+  } else {
+    console.log(formatError(`Login failed: ${result.error}`));
+    process.exit(1);
+  }
+}
+
+/**
+ * Logout from GitHub
+ */
+export async function logoutGitHub(): Promise<void> {
+  const status = await getAuthStatus();
+
+  if (!status.authenticated) {
+    console.log(formatInfo("Not logged in."));
+    return;
+  }
+
+  await logout();
+  console.log(formatInfo("Logged out successfully."));
+}

package/src/cli/commands/batch.ts

@@ -0,0 +1,141 @@
+import type { CLIOptions } from "./list.ts";
+import { scanAndFilter } from "./helpers.ts";
+import { filterProjects } from "../../scanner/index.ts";
+import { initGitInProject } from "../../git/operations.ts";
+import { batchPull, batchPush, batchFetch } from "../../operations/batch.ts";
+import {
+  formatBatchResult,
+  formatProgress,
+  formatWarning,
+  formatInfo,
+  formatScanning,
+  formatOperationItem,
+  formatOperationSummary,
+} from "../formatters.ts";
+import { scanAllDirectories } from "../../scanner/index.ts";
+
+/**
+ * Pull all repositories
+ */
+export async function pullAll(options: CLIOptions): Promise<void> {
+  const { config, filter } = options;
+
+  console.log(formatScanning());
+  const projects = await scanAllDirectories(config);
+  let gitProjects = projects.filter((p) => p.type === "git" && p.status?.hasRemote);
+
+  if (filter) {
+    gitProjects = filterProjects(gitProjects, filter);
+  }
+
+  if (gitProjects.length === 0) {
+    console.log(formatWarning("No repositories to pull."));
+    return;
+  }
+
+  console.log(formatInfo(`\nPulling ${gitProjects.length} repositories...\n`));
+
+  const result = await batchPull(gitProjects, {
+    concurrency: config.scan.concurrency, onProgress: (completed, total) => {
+      process.stdout.write(formatProgress(completed, total));
+    }
+  });
+
+  console.log("\n");
+  console.log(formatBatchResult(result, "Pulled"));
+}
+
+/**
+ * Push repositories with unpushed commits
+ */
+export async function pushAll(options: CLIOptions): Promise<void> {
+  const { config, filter } = options;
+
+  console.log(formatScanning());
+  const projects = await scanAllDirectories(config);
+  let unpushedProjects = projects.filter(
+    (p) => p.type === "git" && p.status?.hasRemote && p.status?.isAhead
+  );
+
+  if (filter) {
+    unpushedProjects = filterProjects(unpushedProjects, filter);
+  }
+
+  if (unpushedProjects.length === 0) {
+    console.log(formatWarning("No repositories with unpushed commits."));
+    return;
+  }
+
+  console.log(formatInfo(`\nPushing ${unpushedProjects.length} repositories...\n`));
+
+  const result = await batchPush(unpushedProjects, {
+    concurrency: config.scan.concurrency, onProgress: (completed, total) => {
+      process.stdout.write(formatProgress(completed, total));
+    }
+  });
+
+  console.log("\n");
+  console.log(formatBatchResult(result, "Pushed"));
+}
+
+/**
+ * Fetch all repositories
+ */
+export async function fetchAll(options: CLIOptions): Promise<void> {
+  const { config, filter } = options;
+
+  console.log(formatScanning());
+  const projects = await scanAllDirectories(config);
+  let gitProjects = projects.filter((p) => p.type === "git" && p.status?.hasRemote);
+
+  if (filter) {
+    gitProjects = filterProjects(gitProjects, filter);
+  }
+
+  if (gitProjects.length === 0) {
+    console.log(formatWarning("No repositories to fetch."));
+    return;
+  }
+
+  console.log(formatInfo(`\nFetching ${gitProjects.length} repositories...\n`));
+
+  const result = await batchFetch(gitProjects, {
+    concurrency: config.scan.concurrency, onProgress: (completed, total) => {
+      process.stdout.write(formatProgress(completed, total));
+    }
+  });
+
+  console.log("\n");
+  console.log(formatBatchResult(result, "Fetched"));
+}
+
+/**
+ * Initialize git in non-git projects
+ */
+export async function initNonGit(options: CLIOptions): Promise<void> {
+  const { config, filter } = options;
+
+  console.log(formatScanning());
+  const projects = await scanAllDirectories(config);
+  let nonGitProjects = projects.filter((p) => p.type === "non-git");
+
+  if (filter) {
+    nonGitProjects = filterProjects(nonGitProjects, filter);
+  }
+
+  if (nonGitProjects.length === 0) {
+    console.log(formatWarning("No non-git projects found."));
+    return;
+  }
+
+  console.log(formatInfo(`\nInitializing git in ${nonGitProjects.length} projects...\n`));
+
+  let success = 0;
+  for (const project of nonGitProjects) {
+    const result = await initGitInProject(project.path);
+    console.log(formatOperationItem(project.name, result.success, result.error));
+    if (result.success) success++;
+  }
+
+  console.log(`\n${formatOperationSummary("Initialized", success, nonGitProjects.length)}`);
+}

package/src/cli/commands/dir.ts

@@ -0,0 +1,285 @@
+import { resolve } from "path";
+import { existsSync, statSync } from "fs";
+import { homedir } from "os";
+import { saveConfig, findConfigPath } from "../../config/loader.ts";
+import {
+  formatError,
+  formatInfo,
+  formatSuccess,
+  formatWarning,
+} from "../formatters.ts";
+import type { CLIOptions } from "./list.ts";
+import type { DirectoryConfig, GitforestConfig } from "../../types/index.ts";
+
+export interface DirOptions extends CLIOptions {
+  label?: string;
+  editor?: string;
+}
+
+/**
+ * Handle `gitforest dir <subcommand>` commands
+ */
+export async function handleDirCommand(
+  subcommand: string,
+  args: string[],
+  options: DirOptions
+): Promise<void> {
+  switch (subcommand) {
+    case "list":
+    case "ls":
+      listDirs(options);
+      break;
+    case "add":
+      await addDir(args, options);
+      break;
+    case "remove":
+    case "rm":
+      await removeDir(args, options);
+      break;
+    case "set":
+      await setDir(args, options);
+      break;
+    default:
+      console.error(formatError(`Unknown dir subcommand: ${subcommand}`));
+      console.log(formatInfo("Available commands: list, add, remove, set"));
+      console.log(formatInfo("\nUsage:"));
+      console.log(formatInfo("  gitforest dir list                       List configured directories"));
+      console.log(formatInfo("  gitforest dir add <path> [--max-depth N]  Add a directory"));
+      console.log(formatInfo("  gitforest dir remove <path>               Remove a directory"));
+      console.log(formatInfo("  gitforest dir set <path> [options]        Update directory settings"));
+      process.exit(1);
+  }
+}
+
+/**
+ * Resolve a user-provided path, expanding ~ and making absolute
+ */
+function resolveDirPath(rawPath: string): string {
+  const expanded = rawPath.replace(/^~/, homedir());
+  return resolve(expanded);
+}
+
+/**
+ * Find a directory in the config by resolved path
+ */
+function findDirIndex(config: GitforestConfig, absPath: string): number {
+  return config.directories.findIndex((d) => {
+    const dPath = d.path.replace(/^~/, homedir());
+    return resolve(dPath) === absPath;
+  });
+}
+
+/**
+ * Format a single directory entry for display
+ */
+function formatDirEntry(dir: DirectoryConfig, index: number): string {
+  const parts = [`  ${index + 1}. ${dir.path}`];
+  const meta: string[] = [];
+  meta.push(`depth: ${dir.maxDepth}`);
+  if (dir.label) meta.push(`label: ${dir.label}`);
+  if (dir.editor) meta.push(`editor: ${dir.editor}`);
+  if (meta.length > 0) {
+    parts.push(`     (${meta.join(", ")})`);
+  }
+  return parts.join("\n");
+}
+
+// ============================================================================
+// Subcommands
+// ============================================================================
+
+/**
+ * List all configured directories
+ */
+export function listDirs(options: CLIOptions): void {
+  const { config, json } = options;
+
+  if (json) {
+    console.log(JSON.stringify(config.directories, null, 2));
+    return;
+  }
+
+  if (config.directories.length === 0) {
+    console.log(formatWarning("No directories configured."));
+    console.log(formatInfo("Run 'gitforest dir add <path>' to add one."));
+    return;
+  }
+
+  console.log(formatInfo(`\nConfigured directories (${config.directories.length}):\n`));
+
+  for (let i = 0; i < config.directories.length; i++) {
+    const dir = config.directories[i]!;
+    console.log(formatDirEntry(dir, i));
+  }
+
+  const configPath = findConfigPath();
+  if (configPath) {
+    console.log(`\n  Config: ${configPath}`);
+  }
+}
+
+/**
+ * Add a directory to the config
+ */
+export async function addDir(args: string[], options: DirOptions): Promise<void> {
+  const { config } = options;
+
+  if (args.length === 0) {
+    console.error(formatError("Missing directory path"));
+    console.log(formatInfo("Usage: gitforest dir add <path> [--max-depth N] [--label TEXT]"));
+    process.exit(1);
+  }
+
+  const rawPath = args[0]!;
+  const absPath = resolveDirPath(rawPath);
+
+  // Validate path exists and is a directory
+  if (!existsSync(absPath)) {
+    console.error(formatError(`Directory does not exist: ${absPath}`));
+    process.exit(1);
+  }
+
+  if (!statSync(absPath).isDirectory()) {
+    console.error(formatError(`Not a directory: ${absPath}`));
+    process.exit(1);
+  }
+
+  // Check if directory is already in config
+  const existingIndex = findDirIndex(config, absPath);
+
+  if (existingIndex >= 0) {
+    console.log(formatWarning(`Directory already configured: ${absPath}`));
+    console.log(formatInfo("Use 'gitforest dir set' to update its settings."));
+    return;
+  }
+
+  const newDir: DirectoryConfig = {
+    path: absPath,
+    maxDepth: options.maxDepth ?? 2,
+  };
+  if (options.label) newDir.label = options.label;
+
+  config.directories.push(newDir);
+
+  await persistConfig(config);
+  console.log(formatSuccess(`Added directory: ${absPath} (max-depth: ${newDir.maxDepth})`));
+}
+
+/**
+ * Remove a directory from the config
+ */
+export async function removeDir(args: string[], options: DirOptions): Promise<void> {
+  const { config } = options;
+
+  if (args.length === 0) {
+    console.error(formatError("Missing directory path or index"));
+    console.log(formatInfo("Usage: gitforest dir remove <path|index>"));
+    console.log(formatInfo("  Use 'gitforest dir list' to see directories and their indices."));
+    process.exit(1);
+  }
+
+  const arg = args[0]!;
+
+  // Try to interpret as 1-based index
+  const indexNum = parseInt(arg, 10);
+  let removeIndex: number;
+
+  if (!isNaN(indexNum) && indexNum >= 1 && indexNum <= config.directories.length) {
+    removeIndex = indexNum - 1;
+  } else {
+    // Interpret as path
+    const absPath = resolveDirPath(arg);
+    removeIndex = findDirIndex(config, absPath);
+
+    if (removeIndex < 0) {
+      console.error(formatError(`Directory not found in config: ${absPath}`));
+      console.log(formatInfo("Run 'gitforest dir list' to see configured directories."));
+      process.exit(1);
+    }
+  }
+
+  // Prevent removing the last directory
+  if (config.directories.length === 1) {
+    console.error(formatError("Cannot remove the last directory. At least one directory is required."));
+    process.exit(1);
+  }
+
+  const removed = config.directories[removeIndex]!;
+  config.directories.splice(removeIndex, 1);
+
+  await persistConfig(config);
+  console.log(formatSuccess(`Removed directory: ${removed.path}`));
+}
+
+/**
+ * Update settings for an existing directory
+ */
+export async function setDir(args: string[], options: DirOptions): Promise<void> {
+  const { config } = options;
+
+  if (args.length === 0) {
+    console.error(formatError("Missing directory path or index"));
+    console.log(formatInfo("Usage: gitforest dir set <path|index> [--max-depth N] [--label TEXT] [--editor CMD]"));
+    process.exit(1);
+  }
+
+  const arg = args[0]!;
+
+  // Try to interpret as 1-based index
+  const indexNum = parseInt(arg, 10);
+  let dirIndex: number;
+
+  if (!isNaN(indexNum) && indexNum >= 1 && indexNum <= config.directories.length) {
+    dirIndex = indexNum - 1;
+  } else {
+    const absPath = resolveDirPath(arg);
+    dirIndex = findDirIndex(config, absPath);
+
+    if (dirIndex < 0) {
+      console.error(formatError(`Directory not found in config: ${absPath}`));
+      console.log(formatInfo("Run 'gitforest dir list' to see configured directories."));
+      process.exit(1);
+    }
+  }
+
+  const dir = config.directories[dirIndex]!;
+
+  let updated = false;
+
+  if (options.maxDepth !== undefined) {
+    dir.maxDepth = options.maxDepth;
+    updated = true;
+  }
+
+  if (options.label !== undefined) {
+    dir.label = options.label;
+    updated = true;
+  }
+
+  if (options.editor !== undefined) {
+    dir.editor = options.editor;
+    updated = true;
+  }
+
+  if (!updated) {
+    console.log(formatWarning("No options specified. Nothing to update."));
+    console.log(formatInfo("Options: --max-depth N, --label TEXT, --editor CMD"));
+    return;
+  }
+
+  await persistConfig(config);
+  console.log(formatSuccess(`Updated directory: ${dir.path}`));
+  console.log(formatDirEntry(dir, dirIndex));
+}
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+/**
+ * Save the config and print any errors
+ */
+async function persistConfig(config: GitforestConfig): Promise<void> {
+  const configPath = findConfigPath() ?? undefined;
+  await saveConfig(config, configPath);
+}