gitforest 0.1.0

package/src/index.tsx

@@ -0,0 +1,494 @@
+#!/usr/bin/env bun
+
+import { render } from "ink";
+import { App } from "./app.tsx";
+import { loadConfig, createDefaultConfig, findConfigPath } from "./config/loader.ts";
+import { initDb, closeDb } from "./db/index.ts";
+import {
+  listProjects,
+  showStatus,
+  pullAll,
+  pushAll,
+  fetchAll,
+  showDirty,
+  initNonGit,
+  createGitHubRepos,
+  archiveRepos,
+  listGitHubRepos,
+  showUnifiedStatus,
+  cloneGitHubRepos,
+  showGitHubAuth,
+  setupProjects,
+  loginGitHub,
+  logoutGitHub,
+  handleConfigCommand,
+} from "./cli/index.ts";
+import { clearCache, getCacheStats } from "./scanner/index.ts";
+import type { ViewMode, GitforestConfig } from "./types/index.ts";
+
+const HELP_TEXT = `
+gitforest - Git Repository Manager
+
+Usage:
+  gitforest                    Start the interactive TUI
+  gitforest <command> [options]
+
+Commands:
+  list                     List all local projects
+  status                   Show status summary
+  dirty                    Show dirty repositories
+  pull                     Pull all repositories
+  push                     Push repositories with unpushed commits
+  fetch                    Fetch all remotes
+  init                     Initialize git in non-git projects
+  setup                    Setup: init git + create GitHub repo + push
+  create-repos             Create GitHub repos for projects without remotes
+  archive <repos...>       Archive GitHub repositories
+
+GitHub Commands:
+  login                    Login to GitHub (opens browser)
+  logout                   Logout from GitHub
+  auth                     Check GitHub authentication status
+  github                   List repos on GitHub not cloned locally
+  github --local           List local repos only
+  github --combined        List all repos (local + GitHub)
+  unified-status           Show unified status (local + GitHub)
+  clone [repos...]         Clone GitHub repos not yet local
+
+Cache Commands:
+  cache status             Show cache statistics
+  cache clear              Clear the project cache
+
+Options:
+  --init                   Create default config file
+  --help, -h               Show this help message
+  --json                   Output as JSON (for list, status, dirty)
+  --verbose, -v            Verbose output
+  --filter, -f <text>      Filter projects by name/path
+  --public                 Create public repos (default: private)
+  --local                  Show local repos only (github command)
+  --combined               Show all repos (github command)
+  --target, -t <dir>       Target directory for clone
+
+Environment:
+  GITHUB_TOKEN             GitHub personal access token for API access
+                           (Optional - run 'gitforest login' for automatic auth)
+
+Config file locations (in order of priority):
+  ./gitforest.config.yaml
+  ~/.config/gitforest/config.yaml
+  ~/.gitforest.yaml
+
+TUI Keyboard shortcuts:
+  j/k or arrows   Navigate
+  space           Toggle selection
+  a               Select all / deselect all
+  p               Push selected
+  P               Pull all repos
+  f               Fetch all remotes
+  i               Init git in selected
+  c               Create GitHub repo
+  C               Setup (init + create + push)
+  A               Archive GitHub repo
+  /               Filter by text
+  0               Show all projects
+  1               Show dirty projects
+  2               Show unpushed commits
+  3               Show no-remote projects
+  s               Cycle sort
+  v               Cycle view (local/github/combined)
+  r               Refresh
+  ?               Help
+  q               Quit
+
+Examples:
+  gitforest                           # Start TUI
+  gitforest list                      # List all local projects
+  gitforest list --json               # List as JSON
+  gitforest status                    # Show local status summary
+  gitforest unified-status            # Show status with GitHub repos
+  gitforest github                    # List GitHub repos not cloned
+  gitforest github --combined         # List all repos
+  gitforest clone                     # Clone all uncloned GitHub repos
+  gitforest clone my-repo             # Clone specific repo
+  gitforest clone -f python           # Clone repos matching filter
+  gitforest dirty                     # Show dirty repos
+  gitforest pull                      # Pull all repos
+  gitforest push                      # Push repos with unpushed commits
+  gitforest fetch                     # Fetch all remotes
+  gitforest list -f myproject         # Filter by name
+  gitforest init                      # Init git in non-git projects
+  gitforest setup                     # Setup all eligible projects (private)
+  gitforest setup --public            # Setup with public repos
+  gitforest setup -f myproject        # Setup filtered projects
+  gitforest create-repos              # Create private GitHub repos
+  gitforest create-repos --public     # Create public GitHub repos
+  gitforest archive my-repo           # Archive a GitHub repo
+  gitforest auth                      # Check GitHub auth status
+`;
+
+let isShuttingDown = false;
+
+async function gracefulShutdown(signal: string): Promise<void> {
+  if (isShuttingDown) return;
+  isShuttingDown = true;
+
+
+
+  try {
+    closeDb();
+  } catch (error) {
+    console.error('Error during shutdown:', error);
+  }
+
+  process.exit(0);
+}
+
+// Register signal handlers
+process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+process.on('uncaughtException', (error) => {
+  console.error('Uncaught Exception:', error);
+  gracefulShutdown('uncaughtException');
+});
+process.on('unhandledRejection', (reason) => {
+  console.error('Unhandled Rejection:', reason);
+  gracefulShutdown('unhandledRejection');
+});
+
+function parseArgs(args: string[]): {
+  command: string | null;
+  flags: Record<string, boolean | string>;
+  positional: string[];
+  errors: string[];
+} {
+  const flags: Record<string, boolean | string> = {};
+  const positional: string[] = [];
+  const errors: string[] = [];
+  let command: string | null = null;
+
+  // Known flags
+  const knownLongFlags = new Set([
+    'init', 'help', 'json', 'verbose', 'filter', 'target',
+    'public', 'local', 'combined', 'https', 'max-depth'
+  ]);
+  const flagsWithValues = new Set(['filter', 'target', 'max-depth']);
+
+
+  const shortFlagMap: Record<string, string> = {
+    'h': 'help',
+    'v': 'verbose',
+    'f': 'filter',
+    't': 'target',
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]!;
+
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+
+      // Check for unknown flags
+      if (!knownLongFlags.has(key)) {
+        errors.push(`Unknown flag: --${key}`);
+        continue;
+      }
+
+      const nextArg = args[i + 1];
+
+      if (flagsWithValues.has(key)) {
+        if (nextArg && !nextArg.startsWith("-")) {
+          flags[key] = nextArg;
+          i++;
+        } else {
+          errors.push(`Flag --${key} requires a value`);
+        }
+      } else {
+        flags[key] = true;
+      }
+    } else if (arg.startsWith("-") && arg.length === 2) {
+      const shortKey = arg.slice(1);
+      const longKey = shortFlagMap[shortKey];
+
+      if (!longKey) {
+        errors.push(`Unknown flag: -${shortKey}`);
+        continue;
+      }
+
+      const nextArg = args[i + 1];
+
+      if (flagsWithValues.has(longKey)) {
+        if (nextArg && !nextArg.startsWith("-")) {
+          flags[longKey] = nextArg;
+          i++;
+        } else {
+          errors.push(`Flag -${shortKey} requires a value`);
+        }
+      } else {
+        flags[longKey] = true;
+      }
+    } else if (!command) {
+      command = arg;
+    } else {
+      positional.push(arg);
+    }
+  }
+
+  return { command, flags, positional, errors };
+}
+
+/**
+ * Run the onboarding wizard for first-time users
+ */
+async function runOnboardingWizard(): Promise<void> {
+  const { OnboardingWizard } = await import("./components/onboarding/OnboardingWizard.tsx");
+  let completedConfig: GitforestConfig | null = null;
+  let cancelled = false;
+
+  const handleComplete = (config: GitforestConfig) => {
+    completedConfig = config;
+  };
+
+  const handleCancel = () => {
+    cancelled = true;
+  };
+
+  // Render onboarding wizard
+  const { waitUntilExit } = render(
+    <OnboardingWizard
+      onComplete={handleComplete}
+      onCancel={handleCancel}
+    />
+  );
+
+  await waitUntilExit();
+
+  if (cancelled) {
+    console.log("\nOnboarding cancelled. Run 'gitforest --init' to create a default config.");
+    process.exit(0);
+  }
+
+  if (completedConfig) {
+    // Start main TUI app
+    await initDb();
+    const { waitUntilExit: waitAppExit } = render(<App config={completedConfig} />);
+    await waitAppExit();
+    closeDb();
+  }
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const { command, flags, positional, errors } = parseArgs(args);
+
+  // Handle validation errors
+  if (errors.length > 0) {
+    for (const error of errors) {
+      console.error(`Error: ${error}`);
+    }
+    console.log("\nRun 'gitforest --help' for usage information.");
+    process.exit(1);
+  }
+
+  // Handle --init flag to create default config
+  if (flags["init"]) {
+    const existingConfig = findConfigPath();
+    if (existingConfig) {
+      console.log(`Config already exists at: ${existingConfig}`);
+      process.exit(1);
+    }
+
+    const configPath = await createDefaultConfig();
+    console.log(`Created default config at: ${configPath}`);
+    console.log("\nEdit the config to add your project directories, then run 'gitforest' again.");
+    process.exit(0);
+  }
+
+  // Handle --help flag (even when a command is provided)
+  if (flags["help"] || flags["h"]) {
+    console.log(HELP_TEXT);
+    process.exit(0);
+  }
+
+  // Check for first-time run (no config)
+  const configPath = findConfigPath();
+  const isTUIMode = !command;
+
+  if (!configPath && isTUIMode) {
+    // No config and TUI mode - run onboarding wizard
+    await runOnboardingWizard();
+    return; // runOnboardingWizard handles everything
+  }
+
+  try {
+    // Load configuration
+    const config = await loadConfig();
+    const filter = typeof flags["filter"] === "string" ? flags["filter"] : undefined;
+    const json = !!flags["json"];
+    const verbose = !!flags["verbose"];
+    const maxDepth = flags["max-depth"] ? parseInt(String(flags["max-depth"]), 10) : undefined;
+
+    // CLI commands
+    if (command) {
+      // Check for help flag again after command (e.g., "list --help")
+      if (flags["help"] || flags["h"]) {
+        console.log(HELP_TEXT);
+        process.exit(0);
+      }
+
+      const cliOptions = { config, filter, json, verbose, maxDepth };
+
+      switch (command) {
+        case "list":
+        case "ls":
+          await listProjects(cliOptions);
+          break;
+
+        case "status":
+        case "st":
+          await showStatus(cliOptions);
+          break;
+
+        case "dirty":
+          await showDirty(cliOptions);
+          break;
+
+        case "pull":
+          await pullAll(cliOptions);
+          break;
+
+        case "push":
+          await pushAll(cliOptions);
+          break;
+
+        case "fetch":
+          await fetchAll(cliOptions);
+          break;
+
+        case "init":
+          await initNonGit(cliOptions);
+          break;
+
+        case "setup":
+          await setupProjects({
+            ...cliOptions,
+            isPrivate: !flags["public"],
+          });
+          break;
+
+        case "create-repos":
+        case "create":
+          await createGitHubRepos({
+            ...cliOptions,
+            isPrivate: !flags["public"],
+          });
+          break;
+
+        case "archive":
+          if (positional.length === 0) {
+            console.error("Error: Please specify repositories to archive");
+            console.log("Usage: gitforest archive <repo1> [repo2] ...");
+            process.exit(1);
+          }
+          await archiveRepos({ ...cliOptions, repos: positional });
+          break;
+
+        // GitHub API commands
+        case "github":
+        case "gh": {
+          const view: ViewMode = flags["local"]
+            ? "local"
+            : flags["combined"]
+              ? "combined"
+              : "github";
+          await listGitHubRepos({ ...cliOptions, view });
+          break;
+        }
+
+        case "unified-status":
+        case "ustatus":
+          await showUnifiedStatus(cliOptions);
+          break;
+
+        case "clone": {
+          const targetDir = typeof flags["target"] === "string" ? flags["target"] : undefined;
+          await cloneGitHubRepos({
+            ...cliOptions,
+            repos: positional.length > 0 ? positional : undefined,
+            targetDir,
+            useHTTPS: !!flags["https"],
+          });
+          break;
+        }
+
+        case "auth":
+          await showGitHubAuth();
+          break;
+
+        case "login":
+          await loginGitHub();
+          break;
+
+        case "logout":
+          await logoutGitHub();
+          break;
+
+        case "cache":
+          if (positional[0] === "clear") {
+            await clearCache();
+            console.log("Cache cleared.");
+          } else if (positional[0] === "status" || positional.length === 0) {
+            const stats = await getCacheStats();
+            console.log("Cache Statistics:");
+            console.log(`  Projects cached: ${stats.projectCount}`);
+            if (stats.oldestScan) {
+              console.log(`  Oldest scan: ${stats.oldestScan.toLocaleString()}`);
+            }
+            if (stats.newestScan) {
+              console.log(`  Newest scan: ${stats.newestScan.toLocaleString()}`);
+            }
+          } else {
+            console.error(`Unknown cache subcommand: ${positional[0]}`);
+            console.log("Usage: gitforest cache [status|clear]");
+            process.exit(1);
+          }
+          break;
+
+        case "config":
+          if (positional.length === 0) {
+            console.error("Error: Missing config subcommand");
+            console.log("Usage: gitforest config add-dir <path>");
+            process.exit(1);
+          }
+          await handleConfigCommand(positional[0]!, positional.slice(1), cliOptions);
+          break;
+
+        default:
+          console.error(`Unknown command: ${command}`);
+          console.error("\nRun 'gitforest --help' for usage information.");
+          process.exit(1);
+      }
+
+      process.exit(0);
+    }
+
+    // TUI mode (no command specified)
+    await initDb();
+
+    const { waitUntilExit } = render(<App config={config} />);
+    await waitUntilExit();
+
+    closeDb();
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : error);
+
+    if (error instanceof Error && error.message.includes("No config file found")) {
+      console.log("\nRun 'gitforest' to start the onboarding wizard,");
+      console.log("or 'gitforest --init' to create a default config file.");
+    }
+
+    process.exit(1);
+  }
+}
+
+main();