gitforest 0.1.0

package/src/cli/index.ts

@@ -0,0 +1,583 @@
+import type { GitforestConfig, ViewMode } from "../types/index.ts";
+import { scanAllDirectories, sortProjects, filterProjects } from "../scanner/index.ts";
+import { initGitInProject } from "../git/operations.ts";
+import { batchPull, batchPush, batchFetch } from "../operations/batch.ts";
+import { defaultGitHubService } from "../services/github.ts";
+import {
+  fetchUnifiedRepos,
+  filterByViewMode,
+  sortUnifiedRepos,
+  filterUnifiedRepos,
+  cloneGitHubRepo,
+  getUnifiedStats,
+} from "../github/unified.ts";
+import {
+  login,
+  logout,
+  getAuthStatus,
+  ensureAuthenticated,
+  isGhInstalled,
+} from "../github/auth.ts";
+import {
+  formatProjectList,
+  formatStatusSummary,
+  formatStatusSummaryJson,
+  formatBatchResult,
+  formatProgress,
+  formatDirtyRepos,
+  formatUnifiedRepoList,
+  formatAuthSuccess,
+  formatNoToken,
+  formatScanning,
+  formatWarning,
+  formatError,
+  formatInfo,
+  formatOperationItem,
+  formatOperationSummary,
+  formatUnifiedStatusJson,
+  formatUnifiedStatusDisplay,
+  formatCloneItem,
+  calculateStatusSummary,
+} from "./formatters.ts";
+
+/**
+ * CLI command handlers for non-TUI usage
+ */
+
+export interface CLIOptions {
+  config: GitforestConfig;
+  filter?: string;
+  json?: boolean;
+  verbose?: boolean;
+  maxDepth?: number;
+}
+
+/**
+ * List all projects
+ */
+export async function listProjects(options: CLIOptions): Promise<void> {
+  const { config, filter, json, verbose } = options;
+
+  console.log(formatScanning());
+  const projects = await scanAllDirectories(config);
+  let result = sortProjects(projects, config.display.sortBy, config.display.sortDirection);
+
+  if (filter) {
+    result = filterProjects(result, filter);
+  }
+
+  console.log(formatProjectList(result, { json, verbose }));
+}
+
+/**
+ * Show status summary
+ */
+export async function showStatus(options: CLIOptions): Promise<void> {
+  const { config, filter, json } = options;
+
+  console.log(formatScanning());
+  const projects = await scanAllDirectories(config);
+  let result = sortProjects(projects, "status", "desc");
+
+  if (filter) {
+    result = filterProjects(result, filter);
+  }
+
+  const summary = calculateStatusSummary(result);
+
+  if (json) {
+    console.log(formatStatusSummaryJson(summary));
+    return;
+  }
+
+  console.log(formatStatusSummary(summary));
+}
+
+/**
+ * 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"));
+}
+
+/**
+ * Show dirty repositories
+ */
+export async function showDirty(options: CLIOptions): Promise<void> {
+  const { config, json } = options;
+
+  console.log(formatScanning());
+  const projects = await scanAllDirectories(config);
+  const dirty = projects.filter((p) => p.status?.isDirty);
+
+  console.log(formatDirtyRepos(dirty, json));
+}
+
+/**
+ * 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)}`);
+}
+
+/**
+ * Create GitHub repos for projects without remotes
+ */
+export async function createGitHubRepos(options: CLIOptions & { isPrivate?: boolean }): Promise<void> {
+  const { config, filter, isPrivate = true } = options;
+
+  // Check GitHub auth - auto-login if not set
+  const token = await ensureAuthenticated();
+  if (!token) {
+    console.log(formatError("GitHub authentication required."));
+    console.log(formatInfo("Run 'gitforest login' to authenticate."));
+    process.exit(1);
+  }
+
+  console.log(formatScanning());
+  const projects = await scanAllDirectories(config);
+  let noRemoteProjects = projects.filter((p) => p.type === "git" && !p.status?.hasRemote);
+
+  if (filter) {
+    noRemoteProjects = filterProjects(noRemoteProjects, filter);
+  }
+
+  if (noRemoteProjects.length === 0) {
+    console.log(formatWarning("No projects without remotes found."));
+    return;
+  }
+
+  console.log(formatInfo(`\nCreating ${isPrivate ? "private" : "public"} repos for ${noRemoteProjects.length} projects...\n`));
+
+  let success = 0;
+  for (const project of noRemoteProjects) {
+    const result = await defaultGitHubService.createRepo({
+      name: project.name,
+      isPrivate,
+      localPath: project.path,
+    });
+
+    console.log(formatOperationItem(project.name, result.success, result.error));
+    if (result.success) success++;
+  }
+
+  console.log(`\n${formatOperationSummary("Created", success, noRemoteProjects.length)}`);
+}
+
+/**
+ * Archive GitHub repositories
+ */
+export async function archiveRepos(options: CLIOptions & { repos: string[] }): Promise<void> {
+  const { repos } = options;
+
+  // Check GitHub auth - auto-login if not set
+  const token = await ensureAuthenticated();
+  if (!token) {
+    console.log(formatError("GitHub authentication required."));
+    console.log(formatInfo("Run 'gitforest login' to authenticate."));
+    process.exit(1);
+  }
+
+  console.log(formatInfo(`\nArchiving ${repos.length} repositories...\n`));
+
+  let success = 0;
+  for (const repo of repos) {
+    const result = await defaultGitHubService.archiveRepo(repo);
+    console.log(formatOperationItem(repo, result.success, result.error));
+    if (result.success) success++;
+  }
+
+  console.log(`\n${formatOperationSummary("Archived", success, repos.length)}`);
+}
+
+/**
+ * List GitHub repositories (not cloned locally)
+ */
+export async function listGitHubRepos(options: CLIOptions & { view?: ViewMode }): Promise<void> {
+  const { config, filter, json, verbose, view = "github" } = options;
+
+  // Check for GitHub token - auto-login if not set
+  const token = await ensureAuthenticated();
+  if (!token) {
+    console.log(formatError("GitHub authentication required."));
+    console.log(formatInfo("Run 'gitforest login' to authenticate."));
+    process.exit(1);
+  }
+
+  console.log(formatScanning("Scanning local directories..."));
+  const localProjects = await scanAllDirectories(config);
+
+  console.log(formatScanning("Fetching GitHub repositories..."));
+  const { unified, error } = await fetchUnifiedRepos(localProjects);
+
+  if (error) {
+    console.log(formatWarning(error));
+  }
+
+  // Apply view filter
+  let result = filterByViewMode(unified, view);
+
+  // Apply text filter
+  if (filter) {
+    result = filterUnifiedRepos(result, filter);
+  }
+
+  // Sort
+  result = sortUnifiedRepos(result, config.display.sortBy, config.display.sortDirection);
+
+  const stats = getUnifiedStats(unified);
+  console.log(formatUnifiedRepoList(result, stats, view, { json, verbose }));
+}
+
+/**
+ * Show unified status (local + GitHub)
+ */
+export async function showUnifiedStatus(options: CLIOptions): Promise<void> {
+  const { config, json } = options;
+
+  if (!defaultGitHubService.hasToken()) {
+    console.log(formatWarning("GITHUB_TOKEN not set - showing local status only"));
+    await showStatus(options);
+    return;
+  }
+
+  console.log(formatScanning("Scanning local directories..."));
+  const localProjects = await scanAllDirectories(config);
+
+  console.log(formatScanning("Fetching GitHub repositories..."));
+  const { unified, error } = await fetchUnifiedRepos(localProjects);
+
+  if (error) {
+    console.log(formatWarning(error));
+  }
+
+  const stats = getUnifiedStats(unified);
+  const statusData = {
+    stats,
+    githubOnly: unified.filter((r) => r.source === "github"),
+    localOnly: unified.filter((r) => r.source === "local"),
+    dirty: unified.filter((r) => r.local?.status?.isDirty),
+    unpushed: unified.filter((r) => r.local?.status?.isAhead),
+    unpulled: unified.filter((r) => r.local?.status?.isBehind),
+  };
+
+  if (json) {
+    console.log(formatUnifiedStatusJson(statusData));
+    return;
+  }
+
+  console.log(formatUnifiedStatusDisplay(statusData));
+}
+
+/**
+ * Clone GitHub repositories that aren't local
+ */
+export async function cloneGitHubRepos(options: CLIOptions & {
+  repos?: string[];
+  targetDir?: string;
+  useHTTPS?: boolean;
+}): Promise<void> {
+  const { config, filter, repos: specificRepos, targetDir, useHTTPS = false } = options;
+
+  // Check GitHub auth - auto-login if not set
+  const token = await ensureAuthenticated();
+  if (!token) {
+    console.log(formatError("GitHub authentication required."));
+    console.log(formatInfo("Run 'gitforest login' to authenticate."));
+    process.exit(1);
+  }
+
+  // Determine target directory
+  const cloneDir = targetDir ?? config.directories[0]?.path ?? process.cwd();
+
+  console.log(formatScanning("Scanning local directories..."));
+  const localProjects = await scanAllDirectories(config);
+
+  console.log(formatScanning("Fetching GitHub repositories..."));
+  const { unified, error } = await fetchUnifiedRepos(localProjects);
+
+  if (error) {
+    console.log(formatWarning(error));
+  }
+
+  // Get repos to clone
+  let toClone = unified.filter((r) => r.source === "github");
+
+  // Filter by specific repos if provided
+  if (specificRepos && specificRepos.length > 0) {
+    toClone = toClone.filter((r) =>
+      specificRepos.some((name) =>
+        r.name.toLowerCase() === name.toLowerCase() ||
+        r.github?.fullName.toLowerCase() === name.toLowerCase()
+      )
+    );
+  } else if (filter) {
+    toClone = filterUnifiedRepos(toClone, filter);
+  }
+
+  if (toClone.length === 0) {
+    console.log(formatWarning("No repositories to clone."));
+    return;
+  }
+
+  console.log(formatInfo(`\nCloning ${toClone.length} repositories to ${cloneDir}...\n`));
+
+  let success = 0;
+  for (const repo of toClone) {
+    const result = await cloneGitHubRepo(repo, cloneDir, !useHTTPS);
+    console.log(formatCloneItem(repo.github?.fullName, result.success, result.path, result.error));
+    if (result.success) success++;
+  }
+
+  console.log(`\n${formatOperationSummary("Cloned", success, toClone.length)}`);
+}
+
+/**
+ * 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."));
+}
+
+/**
+ * Setup projects: init git + create GitHub repo + push
+ * For non-git projects and git projects without remotes
+ */
+export async function setupProjects(options: CLIOptions & { isPrivate?: boolean }): Promise<void> {
+  const { config, filter, isPrivate = true } = options;
+
+  // Check GitHub auth - auto-login if not set
+  const token = await ensureAuthenticated();
+  if (!token) {
+    console.log(formatError("GitHub authentication required."));
+    console.log(formatInfo("Run 'gitforest login' to authenticate."));
+    process.exit(1);
+  }
+
+  console.log(formatScanning());
+  const projects = await scanAllDirectories(config);
+
+  // Find eligible projects: non-git OR git without remote
+  let eligibleProjects = projects.filter(
+    (p) => p.type === "non-git" || (p.type === "git" && !p.status?.hasRemote)
+  );
+
+  if (filter) {
+    eligibleProjects = filterProjects(eligibleProjects, filter);
+  }
+
+  if (eligibleProjects.length === 0) {
+    console.log(formatWarning("No projects need setup (all have remotes)."));
+    return;
+  }
+
+  const nonGitCount = eligibleProjects.filter((p) => p.type === "non-git").length;
+  const noRemoteCount = eligibleProjects.filter((p) => p.type === "git").length;
+
+  console.log(formatInfo(`\nSetting up ${eligibleProjects.length} projects:`));
+  if (nonGitCount > 0) console.log(formatInfo(`  - ${nonGitCount} non-git projects (will init)`));
+  if (noRemoteCount > 0) console.log(formatInfo(`  - ${noRemoteCount} git projects without remote`));
+  console.log(formatInfo(`  - Creating ${isPrivate ? "private" : "public"} repos\n`));
+
+  let initSuccess = 0;
+  let createSuccess = 0;
+
+  for (const project of eligibleProjects) {
+    // Step 1: Init git if needed
+    if (project.type === "non-git") {
+      const initResult = await initGitInProject(project.path);
+      if (initResult.success) {
+        initSuccess++;
+        console.log(formatOperationItem(`${project.name} (init)`, true));
+      } else {
+        console.log(formatOperationItem(`${project.name} (init)`, false, initResult.error));
+        continue; // Skip create if init failed
+      }
+    }
+
+    // Step 2: Create GitHub repo (this also adds remote and pushes)
+    const createResult = await defaultGitHubService.createRepo({
+      name: project.name,
+      isPrivate,
+      localPath: project.path,
+    });
+
+    console.log(formatOperationItem(`${project.name} (create + push)`, createResult.success, createResult.error));
+    if (createResult.success) createSuccess++;
+  }
+
+  console.log(`\n${formatOperationSummary("Set up", createSuccess, eligibleProjects.length)}`);
+  if (nonGitCount > 0) {
+    console.log(formatInfo(`  Git initialized: ${initSuccess}/${nonGitCount}`));
+  }
+}
+
+export * from "./config.ts";

package/src/components/CloneDialog.tsx

@@ -0,0 +1,137 @@
+import { Box, Text, useInput } from "ink";
+import type { UnifiedRepo, DirectoryConfig } from "../types/index.ts";
+
+export interface CloneDialogProps {
+  repos: UnifiedRepo[];
+  directories: DirectoryConfig[];
+  selectedDirIndex: number;
+  useSSH: boolean;
+  onConfirm: (targetDir: string, useSSH: boolean) => void;
+  onCancel: () => void;
+  onSelectDir: (index: number) => void;
+  onToggleSSH: () => void;
+}
+
+export function CloneDialog({
+  repos,
+  directories,
+  selectedDirIndex,
+  useSSH,
+  onConfirm,
+  onCancel,
+  onSelectDir,
+  onToggleSSH,
+}: CloneDialogProps) {
+  useInput((input, key) => {
+    if (key.escape || input === "n" || input === "N") {
+      onCancel();
+      return;
+    }
+
+    if (key.return || input === "y" || input === "Y") {
+      const targetDir = directories[selectedDirIndex]?.path;
+      if (targetDir) {
+        // Expand ~ to home directory
+        const expandedPath = targetDir.replace(/^~/, process.env.HOME || "");
+        onConfirm(expandedPath, useSSH);
+      }
+      return;
+    }
+
+    // Navigate directories
+    if (input === "j" || key.downArrow) {
+      const nextIndex = Math.min(selectedDirIndex + 1, directories.length - 1);
+      onSelectDir(nextIndex);
+      return;
+    }
+
+    if (input === "k" || key.upArrow) {
+      const prevIndex = Math.max(selectedDirIndex - 1, 0);
+      onSelectDir(prevIndex);
+      return;
+    }
+
+    // Toggle SSH/HTTPS
+    if (input === "p" || input === "P") {
+      onToggleSSH();
+      return;
+    }
+  });
+
+  const maxItems = 5;
+  const displayRepos = repos.slice(0, maxItems);
+  const remainingCount = repos.length - maxItems;
+
+  return (
+    <Box
+      flexDirection="column"
+      borderStyle="round"
+      borderColor="cyan"
+      paddingX={2}
+      paddingY={1}
+      width={60}
+    >
+      {/* Title */}
+      <Box marginBottom={1}>
+        <Text bold color="cyan">
+          Clone GitHub {repos.length === 1 ? "Repository" : `Repositories (${repos.length})`}
+        </Text>
+      </Box>
+
+      {/* Repos to clone */}
+      <Box flexDirection="column" marginBottom={1}>
+        <Text>Repositories to clone:</Text>
+        {displayRepos.map((repo) => (
+          <Text key={repo.id} color="magenta">
+            {"  ☁ "}
+            {repo.github?.fullName || repo.name}
+          </Text>
+        ))}
+        {remainingCount > 0 && (
+          <Text dimColor>{"  "}...and {remainingCount} more</Text>
+        )}
+      </Box>
+
+      {/* Target directory selection */}
+      <Box flexDirection="column" marginBottom={1}>
+        <Text>Target directory (j/k to select):</Text>
+        {directories.map((dir, index) => (
+          <Box key={dir.path} gap={1}>
+            <Text color={index === selectedDirIndex ? "cyan" : "gray"}>
+              {index === selectedDirIndex ? "●" : "○"}
+            </Text>
+            <Text color={index === selectedDirIndex ? "white" : "gray"}>
+              {dir.label || dir.path}
+            </Text>
+            <Text dimColor>({dir.path})</Text>
+          </Box>
+        ))}
+      </Box>
+
+      {/* Protocol selection */}
+      <Box marginBottom={1} gap={2}>
+        <Text>Protocol:</Text>
+        <Text color={useSSH ? "green" : "gray"}>
+          {useSSH ? "[●]" : "[ ]"} SSH
+        </Text>
+        <Text color={!useSSH ? "green" : "gray"}>
+          {!useSSH ? "[●]" : "[ ]"} HTTPS
+        </Text>
+        <Text dimColor>(p to toggle)</Text>
+      </Box>
+
+      {/* Actions */}
+      <Box gap={2}>
+        <Text dimColor>Press </Text>
+        <Text color="green" bold>
+          Enter/y
+        </Text>
+        <Text dimColor> to clone, </Text>
+        <Text color="red" bold>
+          Esc/n
+        </Text>
+        <Text dimColor> to cancel</Text>
+      </Box>
+    </Box>
+  );
+}