@bragduck/cli 2.5.0 → 2.6.0

package/dist/bin/bragduck.js

@@ -392,7 +392,7 @@ var init_storage_service = __esm({
 });
 
 // src/utils/errors.ts
-var BragduckError, AuthenticationError, GitError, ApiError, NetworkError, ValidationError, OAuthError, TokenExpiredError, GitHubError, BitbucketError;
+var BragduckError, AuthenticationError, GitError, ApiError, NetworkError, ValidationError, OAuthError, TokenExpiredError, GitHubError, BitbucketError, GitLabError;
 var init_errors = __esm({
   "src/utils/errors.ts"() {
     "use strict";
@@ -465,6 +465,12 @@ var init_errors = __esm({
         this.name = "BitbucketError";
       }
     };
+    GitLabError = class extends BragduckError {
+      constructor(message, details) {
+        super(message, "GITLAB_ERROR", details);
+        this.name = "GitLabError";
+      }
+    };
   }
 });
 
@@ -1613,9 +1619,11 @@ async function authCommand(subcommand) {
     await authStatus();
   } else if (subcommand === "bitbucket") {
     await authBitbucket();
+  } else if (subcommand === "gitlab") {
+    await authGitLab();
   } else {
     logger.error(`Unknown auth subcommand: ${subcommand}`);
-    logger.info("Available subcommands: login, status, bitbucket");
+    logger.info("Available subcommands: login, status, bitbucket, gitlab");
     process.exit(1);
   }
 }
@@ -1787,6 +1795,69 @@ User: ${user.display_name}
     process.exit(1);
   }
 }
+async function authGitLab() {
+  logger.log("");
+  logger.log(
+    boxen(
+      theme.info("GitLab Personal Access Token Authentication") + "\n\nCreate a Personal Access Token at:\n" + colors.highlight("https://gitlab.com/-/profile/personal_access_tokens") + "\n\nRequired scopes:\n  \u2022 api (full API access)\n  \u2022 read_api (read API)\n  \u2022 read_user (read user info)\n\n" + theme.warning("For self-hosted GitLab, check your instance docs"),
+      boxStyles.info
+    )
+  );
+  logger.log("");
+  try {
+    const instanceUrl = await input({
+      message: "GitLab instance URL (press Enter for gitlab.com):",
+      default: "https://gitlab.com"
+    });
+    const accessToken = await input({
+      message: "Personal Access Token:",
+      validate: (value) => value.length > 0 ? true : "Token cannot be empty"
+    });
+    const testUrl = `${instanceUrl.replace(/\/$/, "")}/api/v4/user`;
+    const response = await fetch(testUrl, {
+      headers: { "PRIVATE-TOKEN": accessToken }
+    });
+    if (!response.ok) {
+      logger.log("");
+      logger.log(
+        boxen(
+          theme.error("\u2717 Authentication Failed") + "\n\nInvalid instance URL or access token",
+          boxStyles.error
+        )
+      );
+      logger.log("");
+      process.exit(1);
+    }
+    const user = await response.json();
+    const credentials = {
+      accessToken,
+      instanceUrl: instanceUrl === "https://gitlab.com" ? void 0 : instanceUrl
+    };
+    await storageService.setServiceCredentials("gitlab", credentials);
+    logger.log("");
+    logger.log(
+      boxen(
+        theme.success("\u2713 Successfully authenticated with GitLab") + `
+
+Instance: ${instanceUrl}
+User: ${user.name} (@${user.username})`,
+        boxStyles.success
+      )
+    );
+    logger.log("");
+  } catch (error) {
+    const err = error;
+    logger.log("");
+    logger.log(
+      boxen(
+        theme.error("\u2717 Authentication Failed") + "\n\n" + (err.message || "Unknown error"),
+        boxStyles.error
+      )
+    );
+    logger.log("");
+    process.exit(1);
+  }
+}
 
 // src/commands/sync.ts
 init_esm_shims();
@@ -1911,6 +1982,8 @@ var SourceDetector = class {
         return true;
       } else if (type === "bitbucket" || type === "atlassian") {
         return await storageService.isServiceAuthenticated("bitbucket");
+      } else if (type === "gitlab") {
+        return await storageService.isServiceAuthenticated("gitlab");
       }
       return false;
     } catch {
@@ -2690,6 +2763,299 @@ var BitbucketSyncAdapter = class {
 };
 var bitbucketSyncAdapter = new BitbucketSyncAdapter();
 
+// src/sync/gitlab-adapter.ts
+init_esm_shims();
+
+// src/services/gitlab.service.ts
+init_esm_shims();
+init_errors();
+init_logger();
+init_storage_service();
+import { exec as exec5 } from "child_process";
+import { promisify as promisify5 } from "util";
+import { URLSearchParams as URLSearchParams3 } from "url";
+var execAsync5 = promisify5(exec5);
+var GitLabService = class {
+  DEFAULT_INSTANCE = "https://gitlab.com";
+  MAX_DESCRIPTION_LENGTH = 5e3;
+  /**
+   * Get stored GitLab credentials
+   */
+  async getCredentials() {
+    const creds = await storageService.getServiceCredentials("gitlab");
+    if (!creds || !creds.accessToken) {
+      throw new GitLabError("Not authenticated with GitLab", {
+        hint: "Run: bragduck auth gitlab"
+      });
+    }
+    if (creds.expiresAt && creds.expiresAt < Date.now()) {
+      throw new GitLabError("Access token has expired", {
+        hint: "Run: bragduck auth gitlab"
+      });
+    }
+    return {
+      accessToken: creds.accessToken,
+      instanceUrl: creds.instanceUrl || this.DEFAULT_INSTANCE
+    };
+  }
+  /**
+   * Make authenticated request to GitLab API
+   */
+  async request(endpoint) {
+    const { accessToken, instanceUrl } = await this.getCredentials();
+    const baseUrl = `${instanceUrl}/api/v4`;
+    const url = `${baseUrl}${endpoint}`;
+    logger.debug(`GitLab API: GET ${endpoint}`);
+    const response = await fetch(url, {
+      headers: {
+        "PRIVATE-TOKEN": accessToken,
+        Accept: "application/json"
+      }
+    });
+    if (!response.ok) {
+      const statusText = response.statusText;
+      const status = response.status;
+      if (status === 401) {
+        throw new GitLabError("Invalid or expired access token", {
+          hint: "Run: bragduck auth gitlab",
+          originalError: statusText
+        });
+      } else if (status === 403) {
+        throw new GitLabError("Insufficient token permissions", {
+          hint: "Token requires scopes: api, read_api, read_user",
+          originalError: statusText
+        });
+      } else if (status === 404) {
+        throw new GitLabError("Resource not found", {
+          hint: "Check repository URL and token permissions",
+          originalError: statusText
+        });
+      } else if (status === 429) {
+        throw new GitLabError("Rate limit exceeded", {
+          hint: "Wait a moment and try again",
+          originalError: statusText
+        });
+      }
+      throw new GitLabError(`API request failed: ${statusText}`, {
+        originalError: statusText
+      });
+    }
+    return response.json();
+  }
+  /**
+   * Extract namespace and project from git remote URL
+   */
+  parseRemoteUrl(url) {
+    const match = url.match(/[:/]([\w-]+)\/([\w-]+?)(?:\.git)?$/);
+    if (match && match[1] && match[2]) {
+      return {
+        namespace: match[1],
+        project: match[2]
+      };
+    }
+    return null;
+  }
+  /**
+   * Get project path from git remote
+   */
+  async getProjectFromGit() {
+    try {
+      const { stdout } = await execAsync5("git remote get-url origin");
+      const remoteUrl = stdout.trim();
+      const parsed = this.parseRemoteUrl(remoteUrl);
+      if (!parsed) {
+        throw new GitLabError("Could not parse GitLab project from remote URL", {
+          url: remoteUrl
+        });
+      }
+      return {
+        ...parsed,
+        projectPath: `${parsed.namespace}/${parsed.project}`
+      };
+    } catch (error) {
+      if (error instanceof GitLabError) {
+        throw error;
+      }
+      throw new GitError("Could not get git remote URL");
+    }
+  }
+  /**
+   * Validate that this is a GitLab repository and credentials work
+   */
+  async validateGitLabRepository() {
+    await gitService.validateRepository();
+    const { projectPath } = await this.getProjectFromGit();
+    const encodedPath = encodeURIComponent(projectPath);
+    try {
+      await this.request(`/projects/${encodedPath}`);
+    } catch (error) {
+      if (error instanceof GitLabError) {
+        throw error;
+      }
+      throw new GitLabError("Could not access GitLab project via API", {
+        hint: "Check that this is a GitLab repository and your token is valid",
+        originalError: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  /**
+   * Get repository information
+   */
+  async getRepositoryInfo() {
+    const { projectPath } = await this.getProjectFromGit();
+    const encodedPath = encodeURIComponent(projectPath);
+    const project = await this.request(`/projects/${encodedPath}`);
+    const [owner, name] = projectPath.split("/");
+    return {
+      owner: owner || "",
+      name: name || "",
+      fullName: project.path_with_namespace,
+      url: project.web_url
+    };
+  }
+  /**
+   * Fetch merged MRs with pagination
+   */
+  async getMergedMRs(options = {}) {
+    const { projectPath } = await this.getProjectFromGit();
+    const encodedPath = encodeURIComponent(projectPath);
+    const params = new URLSearchParams3({
+      state: "merged",
+      order_by: "updated_at",
+      sort: "desc",
+      per_page: "100"
+    });
+    if (options.days) {
+      const since = /* @__PURE__ */ new Date();
+      since.setDate(since.getDate() - options.days);
+      params.append("updated_after", since.toISOString());
+    }
+    if (options.author) {
+      params.append("author_username", options.author);
+    }
+    const allMRs = [];
+    let page = 1;
+    while (true) {
+      params.set("page", page.toString());
+      const endpoint = `/projects/${encodedPath}/merge_requests?${params}`;
+      const mrs = await this.request(endpoint);
+      allMRs.push(...mrs);
+      logger.debug(
+        `Fetched ${mrs.length} MRs (total: ${allMRs.length})${mrs.length === 100 ? ", fetching next page..." : ""}`
+      );
+      if (options.limit && allMRs.length >= options.limit) {
+        return allMRs.slice(0, options.limit);
+      }
+      if (mrs.length < 100) {
+        break;
+      }
+      page++;
+    }
+    return allMRs;
+  }
+  /**
+   * Get MRs by current user
+   */
+  async getMRsByCurrentUser(options = {}) {
+    const username = await this.getCurrentGitLabUser();
+    if (!username) {
+      throw new GitLabError("Could not get current user username");
+    }
+    return this.getMergedMRs({
+      ...options,
+      author: username
+    });
+  }
+  /**
+   * Get current authenticated user
+   */
+  async getCurrentGitLabUser() {
+    try {
+      const user = await this.request("/user");
+      return user.username;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Transform GitLab MR to GitCommit format
+   */
+  transformMRToCommit(mr) {
+    const message = this.formatMessage(mr.title, mr.description);
+    return {
+      sha: `mr-${mr.iid}`,
+      // Use iid (project-scoped)
+      message,
+      author: mr.author.username,
+      authorEmail: "",
+      // Not available in MR response
+      date: mr.created_at,
+      url: mr.web_url,
+      diffStats: {
+        filesChanged: mr.diff_stats?.file_count || 0,
+        insertions: mr.diff_stats?.additions || 0,
+        deletions: mr.diff_stats?.deletions || 0
+      }
+    };
+  }
+  /**
+   * Format MR message with title and description
+   */
+  formatMessage(title, description) {
+    if (!description) return title;
+    const truncated = description.substring(0, this.MAX_DESCRIPTION_LENGTH);
+    return `${title}
+
+${truncated}`;
+  }
+};
+var gitlabService = new GitLabService();
+
+// src/sync/gitlab-adapter.ts
+var GitLabSyncAdapter = class {
+  name = "gitlab";
+  async validate() {
+    await gitlabService.validateGitLabRepository();
+  }
+  async getRepositoryInfo() {
+    const info = await gitlabService.getRepositoryInfo();
+    return {
+      owner: info.owner,
+      name: info.name,
+      fullName: info.fullName,
+      url: info.url
+    };
+  }
+  async fetchWorkItems(options) {
+    let mrs;
+    if (options.author) {
+      mrs = await gitlabService.getMergedMRs({
+        days: options.days,
+        limit: options.limit,
+        author: options.author
+      });
+    } else {
+      mrs = await gitlabService.getMRsByCurrentUser({
+        days: options.days,
+        limit: options.limit
+      });
+    }
+    return mrs.map((mr) => gitlabService.transformMRToCommit(mr));
+  }
+  async isAuthenticated() {
+    try {
+      await gitlabService.validateGitLabRepository();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getCurrentUser() {
+    return gitlabService.getCurrentGitLabUser();
+  }
+};
+var gitlabSyncAdapter = new GitLabSyncAdapter();
+
 // src/sync/adapter-factory.ts
 var AdapterFactory = class {
   /**
@@ -2704,7 +3070,7 @@ var AdapterFactory = class {
         return bitbucketSyncAdapter;
       // Bitbucket Cloud and Server use same adapter
       case "gitlab":
-        throw new Error(`${source} adapter not yet implemented`);
+        return gitlabSyncAdapter;
       default:
         throw new Error(`Unknown source type: ${source}`);
     }
@@ -2713,7 +3079,7 @@ var AdapterFactory = class {
    * Check if adapter is available for source
    */
   static isSupported(source) {
-    return source === "github" || source === "bitbucket" || source === "atlassian";
+    return source === "github" || source === "bitbucket" || source === "atlassian" || source === "gitlab";
   }
 };
 
@@ -4158,7 +4524,7 @@ var packageJsonPath = join7(__dirname6, "../../package.json");
 var packageJson = JSON.parse(readFileSync5(packageJsonPath, "utf-8"));
 var program = new Command();
 program.name("bragduck").description("CLI tool for managing developer achievements and brags\nAliases: bd, duck, brag").version(packageJson.version, "-v, --version", "Display version number").helpOption("-h, --help", "Display help information").option("--skip-version-check", "Skip automatic version check on startup").option("--debug", "Enable debug mode (shows detailed logs)");
-program.command("auth [subcommand]").description("Manage authentication (subcommands: login, status, bitbucket)").action(async (subcommand) => {
+program.command("auth [subcommand]").description("Manage authentication (subcommands: login, status, bitbucket, gitlab)").action(async (subcommand) => {
   try {
     await authCommand(subcommand);
   } catch (error) {