github-archiver 1.0.2 → 1.0.5

package/src/services/archiver.ts

@@ -1,192 +0,0 @@
-import PQueue from "p-queue";
-import type {
-  ArchiveOptions,
-  ArchiveResult,
-  RepositoryIdentifier,
-} from "../types";
-import { ErrorCode } from "../types";
-import { isArchiveError } from "../utils/errors";
-import { getLogger } from "../utils/logger";
-import type { GitHubService } from "./github";
-
-const logger = getLogger();
-
-export class Archiver {
-  private readonly queue: PQueue;
-  private results: ArchiveResult[] = [];
-  private readonly gitHubService: GitHubService;
-  private completed = 0;
-  private failed = 0;
-  private readonly startTime = 0;
-
-  constructor(gitHubService: GitHubService, options: ArchiveOptions) {
-    this.gitHubService = gitHubService;
-    this.queue = new PQueue({
-      concurrency: options.concurrency,
-      timeout: options.timeout * 1000,
-      interval: 1000,
-      intervalCap: options.concurrency,
-    });
-
-    logger.info("Archiver initialized", {
-      concurrency: options.concurrency,
-      timeout: options.timeout,
-      dryRun: options.dryRun,
-    });
-  }
-
-  async archiveRepositories(
-    repos: RepositoryIdentifier[],
-    options: ArchiveOptions
-  ): Promise<ArchiveResult[]> {
-    this.results = [];
-    this.completed = 0;
-    this.failed = 0;
-
-    logger.info(`Starting to archive ${repos.length} repositories`, {
-      dryRun: options.dryRun,
-    });
-
-    const tasks = repos.map((repo) =>
-      this.queue.add(() => this.archiveRepository(repo, options))
-    );
-
-    await Promise.all(tasks);
-
-    return this.results;
-  }
-
-  private async archiveRepository(
-    repo: RepositoryIdentifier,
-    options: ArchiveOptions
-  ): Promise<void> {
-    const startTime = Date.now();
-
-    try {
-      if (options.dryRun) {
-        logger.info(`[DRY-RUN] Would archive ${repo.owner}/${repo.repo}`);
-        const result: ArchiveResult = {
-          owner: repo.owner,
-          repo: repo.repo,
-          success: true,
-          archived: false,
-          duration: Date.now() - startTime,
-          message: "[DRY-RUN] Validation successful",
-        };
-        this.results.push(result);
-        this.completed++;
-        return;
-      }
-
-      const validation = await this.gitHubService.validateRepository(
-        repo.owner,
-        repo.repo
-      );
-
-      if (!validation.exists) {
-        logger.warn(`Repository not found: ${repo.owner}/${repo.repo}`);
-        const result: ArchiveResult = {
-          owner: repo.owner,
-          repo: repo.repo,
-          success: false,
-          archived: false,
-          error: "Repository not found",
-          duration: Date.now() - startTime,
-          message: "Repository does not exist on GitHub",
-        };
-        this.results.push(result);
-        this.failed++;
-        return;
-      }
-
-      if (validation.isArchived) {
-        logger.info(`Repository already archived: ${repo.owner}/${repo.repo}`);
-        const result: ArchiveResult = {
-          owner: repo.owner,
-          repo: repo.repo,
-          success: true,
-          archived: false,
-          duration: Date.now() - startTime,
-          message: "Repository is already archived",
-        };
-        this.results.push(result);
-        this.completed++;
-        return;
-      }
-
-      console.log(`📦 Archiving ${repo.owner}/${repo.repo}...`);
-      await this.gitHubService.archiveRepository(repo.owner, repo.repo);
-
-      const result: ArchiveResult = {
-        owner: repo.owner,
-        repo: repo.repo,
-        success: true,
-        archived: true,
-        duration: Date.now() - startTime,
-        message: "Repository archived successfully",
-      };
-      this.results.push(result);
-      this.completed++;
-      logger.info(`✓ Archived ${repo.owner}/${repo.repo}`, {
-        duration: result.duration,
-      });
-    } catch (error) {
-      if (isArchiveError(error) && error.code === ErrorCode.ALREADY_ARCHIVED) {
-        logger.info(`Repository already archived: ${repo.owner}/${repo.repo}`);
-        const result: ArchiveResult = {
-          owner: repo.owner,
-          repo: repo.repo,
-          success: true,
-          archived: false,
-          duration: Date.now() - startTime,
-          message: "Repository is already archived",
-        };
-        this.results.push(result);
-        this.completed++;
-        return;
-      }
-
-      const errorMessage =
-        error instanceof Error ? error.message : String(error);
-      logger.error(
-        `✗ Failed to archive ${repo.owner}/${repo.repo}: ${errorMessage}`
-      );
-
-      const result: ArchiveResult = {
-        owner: repo.owner,
-        repo: repo.repo,
-        success: false,
-        archived: false,
-        error: errorMessage,
-        duration: Date.now() - startTime,
-        message: `Error: ${errorMessage}`,
-      };
-      this.results.push(result);
-      this.failed++;
-    }
-  }
-
-  getProgress(): { completed: number; failed: number; total: number } {
-    return {
-      completed: this.completed,
-      failed: this.failed,
-      total: this.results.length,
-    };
-  }
-
-  getSummary(): {
-    successful: number;
-    failed: number;
-    skipped: number;
-    totalDuration: number;
-  } {
-    const successful = this.results.filter(
-      (r) => r.success && r.archived
-    ).length;
-    const failed = this.results.filter((r) => !r.success).length;
-    const skipped = this.results.filter((r) => r.success && !r.archived).length;
-    const totalDuration = Date.now() - this.startTime;
-
-    return { successful, failed, skipped, totalDuration };
-  }
-}

package/src/services/auth-manager.ts

@@ -1,79 +0,0 @@
-import { Octokit } from "octokit";
-import { PATHS } from "../constants/paths";
-import type { Config, StoredCredentials } from "../types";
-import { ConfigManager } from "../utils/config";
-import { createAuthError } from "../utils/errors";
-
-export class AuthManager {
-  private readonly configManager: ConfigManager;
-
-  constructor(configDir: string = PATHS.APP_DIR) {
-    this.configManager = new ConfigManager(configDir);
-  }
-
-  async saveToken(token: string): Promise<void> {
-    if (!token || typeof token !== "string") {
-      throw createAuthError("Invalid token format");
-    }
-
-    const octokit = new Octokit({ auth: token });
-
-    try {
-      const { data } = await octokit.rest.users.getAuthenticated();
-
-      const credentials: StoredCredentials = {
-        token,
-        savedAt: new Date().toISOString(),
-        githubUser: data.login,
-      };
-
-      await this.configManager.saveConfig(credentials);
-    } catch (error) {
-      throw createAuthError(
-        `Failed to validate token: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-
-  async getToken(): Promise<string | undefined> {
-    if (process.env.GH_TOKEN) {
-      return process.env.GH_TOKEN;
-    }
-
-    const credentials = await this.configManager.getStoredCredentials();
-    return credentials?.token;
-  }
-
-  async removeToken(): Promise<void> {
-    await this.configManager.removeStoredCredentials();
-  }
-
-  async validateToken(
-    token: string
-  ): Promise<{ valid: boolean; user?: string }> {
-    try {
-      const octokit = new Octokit({ auth: token });
-      const { data } = await octokit.rest.users.getAuthenticated();
-      return {
-        valid: true,
-        user: data.login,
-      };
-    } catch (_error) {
-      return {
-        valid: false,
-      };
-    }
-  }
-
-  getStoredCredentials(): Promise<StoredCredentials | null> {
-    return this.configManager.getStoredCredentials();
-  }
-
-  ensureConfigDir(): Promise<void> {
-    return this.configManager.ensureConfigDir();
-  }
-
-  loadConfig(): Promise<Config> {
-    return this.configManager.loadConfig();
-  }
-}

package/src/services/github.ts

@@ -1,211 +0,0 @@
-import { Octokit } from "octokit";
-import { MAX_RETRIES, RETRY_DELAY_MS } from "../constants/defaults";
-import type { RateLimitInfo } from "../types";
-import {
-  createAlreadyArchivedError,
-  createNetworkError,
-  createPermissionError,
-  createRateLimitError,
-  createRepoNotFoundError,
-} from "../utils/errors";
-import { getLogger } from "../utils/logger";
-
-const logger = getLogger();
-
-interface OctokitError {
-  status: number;
-  response?: {
-    data?: {
-      message: string;
-    };
-  };
-  message: string;
-}
-
-export class GitHubService {
-  private readonly octokit: Octokit;
-
-  constructor(token: string) {
-    this.octokit = new Octokit({ auth: token });
-  }
-
-  async archiveRepository(owner: string, repo: string): Promise<void> {
-    const startTime = Date.now();
-    logger.debug(`Attempting to archive ${owner}/${repo}`);
-
-    await this.retryWithBackoff(async () => {
-      try {
-        await this.octokit.rest.repos.update({
-          owner,
-          repo,
-          archived: true,
-        });
-        const duration = Date.now() - startTime;
-        logger.info(`Successfully archived ${owner}/${repo} in ${duration}ms`);
-      } catch (error) {
-        this.handleArchiveError(error, owner, repo);
-      }
-    });
-  }
-
-  private handleArchiveError(
-    error: unknown,
-    owner: string,
-    repo: string
-  ): never {
-    const err = this.parseOctokitError(error);
-    logger.error(`Failed to archive ${owner}/${repo}: ${err.message}`, {
-      status: err.status,
-      code: err.code,
-    });
-
-    if (err.status === 404) {
-      throw createRepoNotFoundError(owner, repo);
-    }
-
-    if (err.status === 403 || err.message.includes("permission")) {
-      throw createPermissionError(owner, repo);
-    }
-
-    if (err.status === 422 && err.message.includes("archived")) {
-      throw createAlreadyArchivedError(owner, repo);
-    }
-
-    if (err.message.includes("API rate limit")) {
-      throw createRateLimitError();
-    }
-
-    if (
-      err.message.includes("ECONNREFUSED") ||
-      err.message.includes("ETIMEDOUT") ||
-      err.message.includes("EHOSTUNREACH") ||
-      err.message.includes("socket hang up")
-    ) {
-      throw createNetworkError(err.message);
-    }
-
-    throw error;
-  }
-
-  private parseOctokitError(error: unknown): {
-    message: string;
-    status: number;
-    code: string | undefined;
-  } {
-    const message = error instanceof Error ? error.message : String(error);
-    const err = error as unknown as OctokitError;
-    return {
-      message,
-      status: err?.status || 0,
-      code: err?.response?.data?.message,
-    };
-  }
-
-  async validateRepository(
-    owner: string,
-    repo: string
-  ): Promise<{ exists: boolean; isArchived: boolean }> {
-    try {
-      logger.debug(`Validating repository ${owner}/${repo}`);
-      const { data } = await this.octokit.rest.repos.get({
-        owner,
-        repo,
-      });
-
-      const result = {
-        exists: true,
-        isArchived: data.archived,
-      };
-      logger.debug(`Repository ${owner}/${repo} validated`, result);
-      return result;
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("404")) {
-        logger.debug(`Repository ${owner}/${repo} does not exist`);
-        return {
-          exists: false,
-          isArchived: false,
-        };
-      }
-
-      logger.error(`Error validating ${owner}/${repo}:`, error);
-      throw error;
-    }
-  }
-
-  async getRateLimitStatus(): Promise<RateLimitInfo> {
-    try {
-      logger.debug("Fetching rate limit status");
-      const { data } = await this.octokit.rest.rateLimit.get();
-
-      const info: RateLimitInfo = {
-        remaining: data.rate.remaining,
-        reset: new Date(data.rate.reset * 1000),
-        limit: data.rate.limit,
-      };
-
-      logger.debug("Rate limit status retrieved", {
-        remaining: info.remaining,
-        limit: info.limit,
-        resetAt: info.reset.toISOString(),
-      });
-
-      return info;
-    } catch (error) {
-      logger.error("Failed to fetch rate limit status:", error);
-      throw error;
-    }
-  }
-
-  async validateAuth(): Promise<string> {
-    try {
-      logger.debug("Validating authentication");
-      const { data } = await this.octokit.rest.users.getAuthenticated();
-      logger.info(`Authenticated as user: ${data.login}`);
-      return data.login;
-    } catch (error) {
-      logger.error("Authentication validation failed:", error);
-      throw createNetworkError(
-        error instanceof Error ? error.message : "Authentication failed"
-      );
-    }
-  }
-
-  private async retryWithBackoff<T>(
-    fn: () => Promise<T>,
-    maxRetries: number = MAX_RETRIES
-  ): Promise<T> {
-    let lastError: Error | undefined;
-
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-      try {
-        return await fn();
-      } catch (error) {
-        lastError = error as Error;
-
-        const message = lastError.message.toLowerCase();
-        const isRetryable =
-          message.includes("rate limit") ||
-          message.includes("timeout") ||
-          message.includes("econnrefused") ||
-          message.includes("etimedout") ||
-          message.includes("ehostunreach") ||
-          message.includes("socket hang up");
-
-        if (!isRetryable || attempt === maxRetries - 1) {
-          throw error;
-        }
-
-        const delay = RETRY_DELAY_MS * 2 ** attempt;
-        logger.warn(
-          `Retry attempt ${attempt + 1}/${maxRetries} after ${delay}ms`,
-          {
-            error: message,
-          }
-        );
-        await new Promise((resolve) => setTimeout(resolve, delay));
-      }
-    }
-
-    throw lastError || new Error("Unknown error during retry");
-  }
-}

package/src/types/config.ts

@@ -1,24 +0,0 @@
-export interface Config {
-  token?: string;
-  concurrency: number;
-  timeout: number;
-  logLevel: "debug" | "info" | "warn" | "error";
-  logDir: string;
-  configDir: string;
-}
-
-export interface StoredCredentials {
-  token: string;
-  savedAt: string;
-  githubUser?: string;
-}
-
-export interface CommandOptions {
-  file?: string;
-  stdin?: boolean;
-  dryRun: boolean;
-  concurrency: string;
-  timeout: string;
-  verbose: boolean;
-  force: boolean;
-}

package/src/types/error.ts

@@ -1,35 +0,0 @@
-export const ErrorCode = {
-  INVALID_AUTH: "INVALID_AUTH",
-  REPO_NOT_FOUND: "REPO_NOT_FOUND",
-  ALREADY_ARCHIVED: "ALREADY_ARCHIVED",
-  PERMISSION_DENIED: "PERMISSION_DENIED",
-  RATE_LIMITED: "RATE_LIMITED",
-  NETWORK_ERROR: "NETWORK_ERROR",
-  INVALID_URL: "INVALID_URL",
-  PARSE_ERROR: "PARSE_ERROR",
-  EDITOR_ERROR: "EDITOR_ERROR",
-  CONFIG_ERROR: "CONFIG_ERROR",
-  FILE_ERROR: "FILE_ERROR",
-} as const;
-
-export type ErrorCode = (typeof ErrorCode)[keyof typeof ErrorCode];
-
-export class ArchiveError extends Error {
-  code: ErrorCode;
-  statusCode?: number;
-  retryable: boolean;
-
-  constructor(
-    code: ErrorCode,
-    message: string,
-    statusCode?: number,
-    retryable = false
-  ) {
-    super(message);
-    this.name = "ArchiveError";
-    this.code = code;
-    this.statusCode = statusCode;
-    this.retryable = retryable;
-    Object.setPrototypeOf(this, ArchiveError.prototype);
-  }
-}

package/src/types/github.ts

@@ -1,34 +0,0 @@
-export interface RepositoryIdentifier {
-  owner: string;
-  repo: string;
-  url: string;
-}
-
-export interface ArchiveResult {
-  owner: string;
-  repo: string;
-  success: boolean;
-  archived: boolean;
-  error?: Error | string;
-  duration: number;
-  message: string;
-}
-
-export interface ArchiveOptions {
-  dryRun: boolean;
-  concurrency: number;
-  timeout: number;
-  force: boolean;
-  verbose: boolean;
-}
-
-export interface RateLimitInfo {
-  remaining: number;
-  reset: Date;
-  limit: number;
-}
-
-export interface GitHubError extends Error {
-  status: number;
-  code: string;
-}

package/src/types/index.ts

@@ -1,4 +0,0 @@
-// biome-ignore lint/performance/noBarrelFile: needed for exports
-export * from "./config";
-export * from "./error";
-export * from "./github";

package/src/utils/colors.ts

@@ -1,79 +0,0 @@
-const RESET = "\x1b[0m";
-const BRIGHT = "\x1b[1m";
-const DIM = "\x1b[2m";
-const RED = "\x1b[31m";
-const GREEN = "\x1b[32m";
-const YELLOW = "\x1b[33m";
-const CYAN = "\x1b[36m";
-
-function success(text: string): string {
-  return `${GREEN}${text}${RESET}`;
-}
-
-function error(text: string): string {
-  return `${RED}${text}${RESET}`;
-}
-
-function warning(text: string): string {
-  return `${YELLOW}${text}${RESET}`;
-}
-
-function info(text: string): string {
-  return `${CYAN}${text}${RESET}`;
-}
-
-function dim(text: string): string {
-  return `${DIM}${text}${RESET}`;
-}
-
-function bold(text: string): string {
-  return `${BRIGHT}${text}${RESET}`;
-}
-
-function successBold(text: string): string {
-  return `${GREEN}${BRIGHT}${text}${RESET}`;
-}
-
-function errorBold(text: string): string {
-  return `${RED}${BRIGHT}${text}${RESET}`;
-}
-
-function warningBold(text: string): string {
-  return `${YELLOW}${BRIGHT}${text}${RESET}`;
-}
-
-function table(rows: string[]): string {
-  return rows.map((row) => `${DIM}│${RESET} ${row}`).join("\n");
-}
-
-function formatStatus(
-  status: "success" | "error" | "warning" | "info"
-): string {
-  const icons = {
-    success: "✅",
-    error: "❌",
-    warning: "⚠️ ",
-    info: "ℹ️ ",
-  };
-  const colors = {
-    success,
-    error,
-    warning,
-    info,
-  };
-  return colors[status](icons[status]);
-}
-
-export const Colors = {
-  success,
-  error,
-  warning,
-  info,
-  dim,
-  bold,
-  successBold,
-  errorBold,
-  warningBold,
-  table,
-  formatStatus,
-};