gitforest 1.1.2 → 1.2.0

package/src/cli/commands/github.ts

@@ -0,0 +1,238 @@
+import type { ViewMode } from "../../types/index.ts";
+import type { CLIOptions } from "./list.ts";
+import { showStatus } from "./list.ts";
+import { scanAllDirectories, filterProjects } from "../../scanner/index.ts";
+import { defaultGitHubService } from "../../services/github.ts";
+import {
+  fetchUnifiedRepos,
+  filterByViewMode,
+  sortUnifiedRepos,
+  filterUnifiedRepos,
+  cloneGitHubRepo,
+  getUnifiedStats,
+} from "../../github/unified.ts";
+import { ensureAuthenticated } from "../../github/auth.ts";
+import {
+  formatUnifiedRepoList,
+  formatWarning,
+  formatError,
+  formatInfo,
+  formatScanning,
+  formatOperationItem,
+  formatOperationSummary,
+  formatUnifiedStatusJson,
+  formatUnifiedStatusDisplay,
+  formatCloneItem,
+} from "../formatters.ts";
+
+/**
+ * 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)}`);
+}

package/src/cli/commands/helpers.ts

@@ -0,0 +1,15 @@
+import type { GitforestConfig, Project } from "../../types/index.ts";
+import { scanAllDirectories, filterProjects } from "../../scanner/index.ts";
+import { formatScanning } from "../formatters.ts";
+
+/**
+ * Scan all directories and optionally filter results
+ */
+export async function scanAndFilter(config: GitforestConfig, filter?: string): Promise<Project[]> {
+  console.log(formatScanning());
+  const projects = await scanAllDirectories(config);
+  if (filter) {
+    return filterProjects(projects, filter);
+  }
+  return projects;
+}

package/src/cli/commands/list.ts

@@ -0,0 +1,76 @@
+import type { GitforestConfig } from "../../types/index.ts";
+import { scanAllDirectories, sortProjects, filterProjects } from "../../scanner/index.ts";
+import {
+  formatProjectList,
+  formatStatusSummary,
+  formatStatusSummaryJson,
+  formatDirtyRepos,
+  formatScanning,
+  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));
+}
+
+/**
+ * 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));
+}

package/src/cli/commands/setup.ts

@@ -0,0 +1,86 @@
+import type { CLIOptions } from "./list.ts";
+import { scanAllDirectories, filterProjects } from "../../scanner/index.ts";
+import { initGitInProject } from "../../git/operations.ts";
+import { defaultGitHubService } from "../../services/github.ts";
+import { ensureAuthenticated } from "../../github/auth.ts";
+import {
+  formatWarning,
+  formatError,
+  formatInfo,
+  formatScanning,
+  formatOperationItem,
+  formatOperationSummary,
+} from "../formatters.ts";
+
+/**
+ * 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}`));
+  }
+}