github-archiver 1.0.2 → 1.0.5

package/src/utils/config.ts

@@ -1,95 +0,0 @@
-import { promises as fs } from "node:fs";
-import { join } from "node:path";
-import {
-  DEFAULT_CONCURRENCY,
-  DEFAULT_LOG_LEVEL,
-  DEFAULT_TIMEOUT,
-} from "../constants/defaults";
-import { PATHS } from "../constants/paths";
-import type { Config, StoredCredentials } from "../types";
-import { createConfigError, createFileError } from "./errors";
-
-export class ConfigManager {
-  private readonly configDir: string;
-  private readonly configFile: string;
-
-  constructor(configDir: string = PATHS.APP_DIR) {
-    this.configDir = configDir;
-    this.configFile = join(configDir, "config.json");
-  }
-
-  async loadConfig(): Promise<Config> {
-    try {
-      const token = process.env.GH_TOKEN;
-      const fileCredentials = await this.loadFileCredentials();
-
-      return {
-        token: token || fileCredentials?.token,
-        concurrency: DEFAULT_CONCURRENCY,
-        timeout: DEFAULT_TIMEOUT,
-        logLevel: DEFAULT_LOG_LEVEL,
-        logDir: join(this.configDir, "logs"),
-        configDir: this.configDir,
-      };
-    } catch (error) {
-      throw createConfigError(
-        `Failed to load configuration: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-
-  async saveConfig(credentials: StoredCredentials): Promise<void> {
-    try {
-      await this.ensureConfigDir();
-      await fs.writeFile(
-        this.configFile,
-        JSON.stringify(credentials, null, 2),
-        "utf-8"
-      );
-    } catch (error) {
-      throw createFileError(
-        `Failed to save configuration: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-
-  async ensureConfigDir(): Promise<void> {
-    try {
-      await fs.mkdir(this.configDir, { recursive: true });
-    } catch (error) {
-      throw createFileError(
-        `Failed to create config directory: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-
-  async getStoredCredentials(): Promise<StoredCredentials | null> {
-    try {
-      const data = await fs.readFile(this.configFile, "utf-8");
-      return JSON.parse(data) as StoredCredentials;
-    } catch {
-      return null;
-    }
-  }
-
-  async removeStoredCredentials(): Promise<void> {
-    try {
-      await fs.unlink(this.configFile);
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== "ENOENT") {
-        throw createFileError(
-          `Failed to remove stored credentials: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  }
-
-  private async loadFileCredentials(): Promise<StoredCredentials | null> {
-    try {
-      const data = await fs.readFile(this.configFile, "utf-8");
-      return JSON.parse(data) as StoredCredentials;
-    } catch {
-      return null;
-    }
-  }
-}

package/src/utils/errors.ts

@@ -1,93 +0,0 @@
-import { MESSAGES } from "../constants/messages";
-import { ArchiveError, ErrorCode } from "../types";
-
-export function isArchiveError(error: unknown): error is ArchiveError {
-  return error instanceof ArchiveError;
-}
-
-export function getErrorMessage(error: unknown): string {
-  if (isArchiveError(error)) {
-    return error.message;
-  }
-  if (error instanceof Error) {
-    return error.message;
-  }
-  return String(error);
-}
-
-export function createAuthError(
-  message: string,
-  statusCode?: number
-): ArchiveError {
-  return new ArchiveError(ErrorCode.INVALID_AUTH, message, statusCode, true);
-}
-
-export function createRepoNotFoundError(
-  owner: string,
-  repo: string
-): ArchiveError {
-  return new ArchiveError(
-    ErrorCode.REPO_NOT_FOUND,
-    `Repository ${owner}/${repo} not found`,
-    404,
-    false
-  );
-}
-
-export function createAlreadyArchivedError(
-  owner: string,
-  repo: string
-): ArchiveError {
-  return new ArchiveError(
-    ErrorCode.ALREADY_ARCHIVED,
-    `Repository ${owner}/${repo} is already archived`,
-    422,
-    false
-  );
-}
-
-export function createPermissionError(
-  owner: string,
-  repo: string
-): ArchiveError {
-  return new ArchiveError(
-    ErrorCode.PERMISSION_DENIED,
-    `Permission denied for ${owner}/${repo}. You must be the repository owner or have push access.`,
-    403,
-    false
-  );
-}
-
-export function createRateLimitError(): ArchiveError {
-  return new ArchiveError(
-    ErrorCode.RATE_LIMITED,
-    MESSAGES.RATE_LIMITED,
-    429,
-    true
-  );
-}
-
-export function createNetworkError(message?: string): ArchiveError {
-  return new ArchiveError(
-    ErrorCode.NETWORK_ERROR,
-    message || MESSAGES.NETWORK_ERROR,
-    undefined,
-    true
-  );
-}
-
-export function createInvalidUrlError(url: string): ArchiveError {
-  return new ArchiveError(ErrorCode.INVALID_URL, `Invalid GitHub URL: ${url}`);
-}
-
-export function createConfigError(message: string): ArchiveError {
-  return new ArchiveError(ErrorCode.CONFIG_ERROR, message);
-}
-
-export function createFileError(message: string): ArchiveError {
-  return new ArchiveError(ErrorCode.FILE_ERROR, message);
-}
-
-export function createEditorError(message: string): ArchiveError {
-  return new ArchiveError(ErrorCode.EDITOR_ERROR, message);
-}

package/src/utils/formatting.ts

@@ -1,65 +0,0 @@
-function formatDuration(ms: number): string {
-  if (ms < 1000) {
-    return `${ms}ms`;
-  }
-  if (ms < 60_000) {
-    return `${(ms / 1000).toFixed(1)}s`;
-  }
-  const minutes = Math.floor(ms / 60_000);
-  const seconds = ((ms % 60_000) / 1000).toFixed(0);
-  return `${minutes}m ${seconds}s`;
-}
-
-function formatBytes(bytes: number): string {
-  if (bytes === 0) {
-    return "0 B";
-  }
-  const k = 1024;
-  const sizes = ["B", "KB", "MB", "GB"];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return `${(bytes / k ** i).toFixed(2)} ${sizes[i]}`;
-}
-
-function formatPercent(value: number, total: number): string {
-  if (total === 0) {
-    return "0%";
-  }
-  return `${((value / total) * 100).toFixed(1)}%`;
-}
-
-function createProgressBar(
-  completed: number,
-  total: number,
-  width = 30
-): string {
-  if (total === 0) {
-    return "[ ]";
-  }
-  const filledWidth = Math.round((completed / total) * width);
-  const emptyWidth = width - filledWidth;
-  const filled = "=".repeat(filledWidth);
-  const empty = " ".repeat(emptyWidth);
-  const percentage = ((completed / total) * 100).toFixed(0);
-  return `[${filled}${empty}] ${percentage}%`;
-}
-
-function centerText(text: string, width: number): string {
-  const padding = Math.max(0, (width - text.length) / 2);
-  return " ".repeat(Math.floor(padding)) + text;
-}
-
-function truncate(text: string, maxLength: number): string {
-  if (text.length <= maxLength) {
-    return text;
-  }
-  return `${text.substring(0, maxLength - 3)}...`;
-}
-
-export const Formatting = {
-  formatDuration,
-  formatBytes,
-  formatPercent,
-  createProgressBar,
-  centerText,
-  truncate,
-};

package/src/utils/input-handler.ts

@@ -1,163 +0,0 @@
-import { promises as fs } from "node:fs";
-import { createInterface } from "node:readline";
-import type { RepositoryIdentifier } from "../types";
-import { getLogger } from "./logger";
-import { URLParser } from "./parser";
-
-const logger = getLogger();
-
-export class InputHandler {
-  getRepositoriesFromInteractive(): Promise<{
-    repos: RepositoryIdentifier[];
-    errors: Array<{ url: string; error: string; line: number }>;
-  }> {
-    logger.info("Starting interactive CLI input for repositories");
-
-    return new Promise((resolve) => {
-      const rl = createInterface({
-        input: process.stdin,
-        output: process.stdout,
-      });
-
-      console.log("");
-      console.log("📝 Enter repository URLs one at a time:");
-      console.log(
-        '   (Type "done" when finished, or leave empty and press Enter to skip)'
-      );
-      console.log("");
-
-      const urls: string[] = [];
-      let lineNumber = 1;
-
-      const promptNext = () => {
-        rl.question(`[${lineNumber}] > `, (input) => {
-          const trimmedInput = input.trim();
-
-          if (trimmedInput.toLowerCase() === "done") {
-            finishInput();
-            return;
-          }
-
-          if (trimmedInput === "") {
-            lineNumber++;
-            promptNext();
-            return;
-          }
-
-          urls.push(trimmedInput);
-          lineNumber++;
-          promptNext();
-        });
-      };
-
-      const finishInput = () => {
-        rl.close();
-        const result = URLParser.parseRepositoriesBatch(urls);
-
-        if (result.invalid.length > 0) {
-          logger.warn(`Found ${result.invalid.length} invalid repositories`, {
-            errors: result.invalid,
-          });
-        }
-
-        logger.info(`Parsed ${result.valid.length} valid repositories`);
-        resolve({
-          repos: result.valid,
-          errors: result.invalid,
-        });
-      };
-
-      rl.on("close", () => {
-        finishInput();
-      });
-
-      promptNext();
-    });
-  }
-
-  async getRepositoriesFromFile(filePath: string): Promise<{
-    repos: RepositoryIdentifier[];
-    errors: Array<{ url: string; error: string; line: number }>;
-  }> {
-    logger.info(`Reading repositories from file: ${filePath}`);
-
-    try {
-      const content = await fs.readFile(filePath, "utf-8");
-      const lines = content.split("\n");
-
-      const result = URLParser.parseRepositoriesBatch(lines);
-
-      if (result.invalid.length > 0) {
-        logger.warn(`Found ${result.invalid.length} invalid entries in file`, {
-          errors: result.invalid,
-        });
-      }
-
-      logger.info(`Parsed ${result.valid.length} valid repositories from file`);
-      return {
-        repos: result.valid,
-        errors: result.invalid,
-      };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      logger.error(`Failed to read file ${filePath}: ${message}`);
-      throw new Error(`Failed to read file: ${message}`);
-    }
-  }
-
-  getRepositoriesFromStdin(): Promise<{
-    repos: RepositoryIdentifier[];
-    errors: Array<{ url: string; error: string; line: number }>;
-  }> {
-    logger.info("Reading repositories from stdin");
-
-    return new Promise((resolve) => {
-      const lines: string[] = [];
-      const rl = createInterface({
-        input: process.stdin,
-        output: process.stdout,
-      });
-
-      rl.on("line", (line) => {
-        lines.push(line);
-      });
-
-      rl.on("close", () => {
-        const result = URLParser.parseRepositoriesBatch(lines);
-
-        if (result.invalid.length > 0) {
-          logger.warn(
-            `Found ${result.invalid.length} invalid entries from stdin`,
-            {
-              errors: result.invalid,
-            }
-          );
-        }
-
-        logger.info(
-          `Parsed ${result.valid.length} valid repositories from stdin`
-        );
-        resolve({
-          repos: result.valid,
-          errors: result.invalid,
-        });
-      });
-    });
-  }
-
-  promptForConfirmation(message: string): Promise<boolean> {
-    return new Promise((resolve) => {
-      const rl = createInterface({
-        input: process.stdin,
-        output: process.stdout,
-      });
-
-      rl.question(`${message} [y/N]: `, (answer) => {
-        rl.close();
-        const confirmed = answer.toLowerCase() === "y";
-        logger.info(`User confirmation: ${confirmed}`);
-        resolve(confirmed);
-      });
-    });
-  }
-}

package/src/utils/logger.ts

@@ -1,65 +0,0 @@
-import { promises as fs } from "node:fs";
-import winston from "winston";
-import { DEFAULT_LOG_LEVEL } from "../constants/defaults";
-import { PATHS } from "../constants/paths";
-import type { Config } from "../types";
-
-let loggerInstance: winston.Logger;
-
-export async function initializeLogger(logDir: string): Promise<void> {
-  try {
-    await fs.mkdir(logDir, { recursive: true });
-  } catch (error) {
-    console.error("Failed to create log directory:", error);
-  }
-}
-
-export function createLogger(config?: Partial<Config>): winston.Logger {
-  const level = config?.logLevel || DEFAULT_LOG_LEVEL;
-  const logDir = config?.logDir || PATHS.LOG_DIR;
-
-  return winston.createLogger({
-    level,
-    format: winston.format.combine(
-      winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
-      winston.format.errors({ stack: true }),
-      winston.format.json()
-    ),
-    defaultMeta: { service: "github-archiver" },
-    transports: [
-      new winston.transports.File({
-        filename: `${logDir}/errors.log`,
-        level: "error",
-      }),
-      new winston.transports.File({
-        filename: `${logDir}/combined.log`,
-      }),
-    ],
-  });
-}
-
-export function createConsoleLogger(): winston.Logger {
-  return winston.createLogger({
-    format: winston.format.combine(
-      winston.format.colorize(),
-      winston.format.printf(({ level, message, ...metadata }) => {
-        const meta = Object.keys(metadata).length
-          ? JSON.stringify(metadata)
-          : "";
-        return `${level}: ${message} ${meta}`;
-      })
-    ),
-    transports: [new winston.transports.Console()],
-  });
-}
-
-export function getLogger(): winston.Logger {
-  if (!loggerInstance) {
-    loggerInstance = createLogger();
-  }
-  return loggerInstance;
-}
-
-export function setLogger(logger: winston.Logger): void {
-  loggerInstance = logger;
-}

package/src/utils/parser.ts

@@ -1,125 +0,0 @@
-import type { RepositoryIdentifier } from "../types";
-import { ArchiveError, ErrorCode } from "../types";
-import { getLogger } from "./logger";
-
-const logger = getLogger();
-const NAME_REGEX = /^[a-zA-Z0-9]([a-zA-Z0-9._-]*[a-zA-Z0-9])?$/;
-
-const GITHUB_URL_PATTERNS: RegExp[] = [
-  // https://github.com/owner/repo or https://github.com/owner/repo.git
-  /^(?:https?:\/\/)?(?:www\.)?github\.com[/:]([\w.-]+)\/([\w.-]+?)(?:\.git)?(?:\/)?$/i,
-  // git@github.com:owner/repo.git or git@github.com:owner/repo
-  /^git@github\.com:([\w.-]+)\/([\w.-]+?)(?:\.git)?$/i,
-  // owner/repo (shorthand)
-  /^([\w.-]+)\/([\w.-]+)$/,
-];
-
-function parseRepositoryUrl(url: string): RepositoryIdentifier {
-  const trimmed = url.trim();
-
-  if (!trimmed) {
-    throw new ArchiveError(ErrorCode.INVALID_URL, "URL cannot be empty");
-  }
-
-  for (const pattern of GITHUB_URL_PATTERNS) {
-    const match = trimmed.match(pattern);
-    if (match) {
-      const owner = match[1];
-      const repo = match[2];
-
-      if (!(owner && repo)) {
-        throw new ArchiveError(
-          ErrorCode.INVALID_URL,
-          `Invalid GitHub URL format: ${url}`
-        );
-      }
-
-      if (!isValidName(owner)) {
-        throw new ArchiveError(
-          ErrorCode.INVALID_URL,
-          `Invalid owner name: ${owner}. Owner names must contain only alphanumeric characters, hyphens, or periods.`
-        );
-      }
-
-      if (!isValidName(repo)) {
-        throw new ArchiveError(
-          ErrorCode.INVALID_URL,
-          `Invalid repository name: ${repo}. Repository names must contain only alphanumeric characters, hyphens, underscores, or periods.`
-        );
-      }
-
-      const normalizedUrl = `https://github.com/${owner}/${repo}`;
-
-      logger.debug("Parsed repository URL", {
-        original: trimmed,
-        owner,
-        repo,
-        normalized: normalizedUrl,
-      });
-
-      return {
-        owner,
-        repo,
-        url: normalizedUrl,
-      };
-    }
-  }
-
-  throw new ArchiveError(ErrorCode.INVALID_URL, `Invalid GitHub URL: ${url}`);
-}
-
-function isValidName(name: string): boolean {
-  return NAME_REGEX.test(name);
-}
-
-function parseRepositoriesBatch(urls: string[]): {
-  valid: RepositoryIdentifier[];
-  invalid: Array<{ url: string; error: string; line: number }>;
-} {
-  const valid: RepositoryIdentifier[] = [];
-  const invalid: Array<{ url: string; error: string; line: number }> = [];
-
-  for (const [index, url] of urls.entries()) {
-    const lineNumber = index + 1;
-    const trimmed = url.trim();
-
-    if (!trimmed || trimmed.startsWith("#")) {
-      continue;
-    }
-
-    try {
-      const parsed = parseRepositoryUrl(trimmed);
-      valid.push(parsed);
-      logger.debug(`Line ${lineNumber}: Valid repository`, {
-        owner: parsed.owner,
-        repo: parsed.repo,
-      });
-    } catch (error) {
-      const errorMessage =
-        error instanceof Error ? error.message : String(error);
-      invalid.push({
-        url: trimmed,
-        error: errorMessage,
-        line: lineNumber,
-      });
-      logger.warn(`Line ${lineNumber}: Invalid repository`, {
-        url: trimmed,
-        error: errorMessage,
-      });
-    }
-  }
-
-  logger.info("Batch parsing complete", {
-    total: urls.length,
-    valid: valid.length,
-    invalid: invalid.length,
-    skipped: urls.length - valid.length - invalid.length,
-  });
-
-  return { valid, invalid };
-}
-
-export const URLParser = {
-  parseRepositoryUrl,
-  parseRepositoriesBatch,
-};

package/src/utils/progress.ts

@@ -1,87 +0,0 @@
-import { Formatting } from "./formatting";
-
-export interface ProgressUpdate {
-  completed: number;
-  failed: number;
-  total: number;
-  current?: {
-    owner: string;
-    repo: string;
-  };
-}
-
-export class ProgressDisplay {
-  private readonly startTime: number;
-  private lastUpdate = 0;
-  private readonly updateInterval = 500; // ms
-
-  constructor() {
-    this.startTime = Date.now();
-  }
-
-  shouldUpdate(): boolean {
-    const now = Date.now();
-    if (now - this.lastUpdate >= this.updateInterval) {
-      this.lastUpdate = now;
-      return true;
-    }
-    return false;
-  }
-
-  getProgressBar(progress: ProgressUpdate): string {
-    const { completed, total, current } = progress;
-    const percent = total > 0 ? (completed / total) * 100 : 0;
-    const bar = Formatting.createProgressBar(completed, total, 25);
-
-    let line = `${bar} ${completed}/${total} (${percent.toFixed(0)}%)`;
-
-    if (current) {
-      line += ` - ${current.owner}/${current.repo}`;
-    }
-
-    return line;
-  }
-
-  getSummaryBox(summary: {
-    successful: number;
-    failed: number;
-    skipped: number;
-    totalDuration: number;
-  }): string {
-    const { successful, failed, skipped, totalDuration } = summary;
-    const total = successful + failed + skipped;
-    const duration = Formatting.formatDuration(totalDuration);
-
-    const lines = [
-      "╔════════════════════════════════════╗",
-      "║       Archive Operation Summary    ║",
-      "╠════════════════════════════════════╣",
-      `║ ✅ Successful:  ${String(successful).padEnd(20)} ║`,
-      `║ ⚠️  Skipped:     ${String(skipped).padEnd(20)} ║`,
-      `║ ❌ Failed:      ${String(failed).padEnd(20)} ║`,
-      "╠════════════════════════════════════╣",
-      `║ Total:         ${String(total).padEnd(20)} ║`,
-      `║ Duration:      ${String(duration).padEnd(20)} ║`,
-      "╚════════════════════════════════════╝",
-    ];
-
-    return lines.join("\n");
-  }
-
-  getElapsedTime(): string {
-    const elapsed = Date.now() - this.startTime;
-    return Formatting.formatDuration(elapsed);
-  }
-
-  getEstimatedTimeRemaining(completed: number, total: number): string | null {
-    if (completed === 0) {
-      return null;
-    }
-
-    const elapsed = Date.now() - this.startTime;
-    const avgTime = elapsed / completed;
-    const remaining = (total - completed) * avgTime;
-
-    return remaining > 0 ? Formatting.formatDuration(remaining) : null;
-  }
-}