@bragduck/cli 1.0.0

package/dist/bin/bragduck.js

@@ -0,0 +1,2346 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/constants.ts
+import { config } from "dotenv";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname, join } from "path";
+var __filename, __dirname, APP_NAME, CONFIG_KEYS, DEFAULT_CONFIG, OAUTH_CONFIG, API_ENDPOINTS, ENCRYPTION_CONFIG, STORAGE_PATHS, HTTP_STATUS;
+var init_constants = __esm({
+  "src/constants.ts"() {
+    "use strict";
+    init_esm_shims();
+    __filename = fileURLToPath2(import.meta.url);
+    __dirname = dirname(__filename);
+    config({ path: join(__dirname, "..", "..", ".env") });
+    APP_NAME = "bragduck";
+    CONFIG_KEYS = {
+      API_BASE_URL: "apiBaseUrl",
+      DEFAULT_COMMIT_DAYS: "defaultCommitDays",
+      AUTO_VERSION_CHECK: "autoVersionCheck"
+    };
+    DEFAULT_CONFIG = {
+      apiBaseUrl: process.env.API_BASE_URL || "https://api.bragduck.com",
+      defaultCommitDays: 30,
+      autoVersionCheck: true
+    };
+    OAUTH_CONFIG = {
+      CLIENT_ID: "bragduck-cli",
+      CALLBACK_PATH: "/callback",
+      TIMEOUT_MS: 12e4,
+      // 2 minutes
+      MIN_PORT: 8e3,
+      MAX_PORT: 9e3
+    };
+    API_ENDPOINTS = {
+      AUTH: {
+        INITIATE: "/v1/auth/cli/initiate",
+        TOKEN: "/v1/auth/cli/token"
+      },
+      COMMITS: {
+        REFINE: "/v1/commits/refine"
+      },
+      BRAGS: {
+        CREATE: "/v1/brags",
+        LIST: "/v1/brags"
+      },
+      VERSION: "/v1/cli/version"
+    };
+    ENCRYPTION_CONFIG = {
+      ALGORITHM: "aes-256-gcm",
+      KEY_LENGTH: 32,
+      IV_LENGTH: 16,
+      AUTH_TAG_LENGTH: 16,
+      SALT_LENGTH: 32
+    };
+    STORAGE_PATHS = {
+      CREDENTIALS_DIR: ".bragduck",
+      CREDENTIALS_FILE: "credentials.enc",
+      CONFIG_FILE: "config.json"
+    };
+    HTTP_STATUS = {
+      OK: 200,
+      CREATED: 201,
+      BAD_REQUEST: 400,
+      UNAUTHORIZED: 401,
+      FORBIDDEN: 403,
+      NOT_FOUND: 404,
+      INTERNAL_SERVER_ERROR: 500
+    };
+  }
+});
+
+// src/services/storage.service.ts
+import Conf from "conf";
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+var StorageService, storageService;
+var init_storage_service = __esm({
+  "src/services/storage.service.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants();
+    StorageService = class {
+      config;
+      storageBackend;
+      credentialsDir;
+      credentialsFilePath;
+      constructor() {
+        this.config = new Conf({
+          projectName: APP_NAME,
+          defaults: DEFAULT_CONFIG
+        });
+        this.credentialsDir = join2(homedir(), STORAGE_PATHS.CREDENTIALS_DIR);
+        this.credentialsFilePath = join2(this.credentialsDir, STORAGE_PATHS.CREDENTIALS_FILE);
+        this.storageBackend = "file";
+        this.ensureCredentialsDir();
+      }
+      /**
+       * Ensure credentials directory exists
+       */
+      ensureCredentialsDir() {
+        if (!existsSync(this.credentialsDir)) {
+          mkdirSync(this.credentialsDir, { recursive: true, mode: 448 });
+        }
+      }
+      /**
+       * Encrypt data for file storage
+       */
+      encrypt(data, key) {
+        const iv = randomBytes(ENCRYPTION_CONFIG.IV_LENGTH);
+        const cipher = createCipheriv(ENCRYPTION_CONFIG.ALGORITHM, key, iv, {
+          authTagLength: ENCRYPTION_CONFIG.AUTH_TAG_LENGTH
+        });
+        let encrypted = cipher.update(data, "utf8", "hex");
+        encrypted += cipher.final("hex");
+        const authTag = cipher.getAuthTag();
+        return {
+          encrypted,
+          iv: iv.toString("hex"),
+          authTag: authTag.toString("hex"),
+          salt: ""
+          // Salt is stored separately
+        };
+      }
+      /**
+       * Decrypt data from file storage
+       */
+      decrypt(encryptedData, key) {
+        const decipher = createDecipheriv(
+          ENCRYPTION_CONFIG.ALGORITHM,
+          key,
+          Buffer.from(encryptedData.iv, "hex"),
+          {
+            authTagLength: ENCRYPTION_CONFIG.AUTH_TAG_LENGTH
+          }
+        );
+        decipher.setAuthTag(Buffer.from(encryptedData.authTag, "hex"));
+        let decrypted = decipher.update(encryptedData.encrypted, "hex", "utf8");
+        decrypted += decipher.final("utf8");
+        return decrypted;
+      }
+      /**
+       * Derive encryption key from machine-specific data
+       */
+      deriveEncryptionKey(salt) {
+        const password = `${APP_NAME}-${homedir()}-${process.platform}`;
+        return scryptSync(password, salt, ENCRYPTION_CONFIG.KEY_LENGTH);
+      }
+      /**
+       * Store credentials using encrypted file storage
+       */
+      async setCredentials(credentials) {
+        const data = JSON.stringify(credentials);
+        const salt = randomBytes(ENCRYPTION_CONFIG.SALT_LENGTH);
+        const key = this.deriveEncryptionKey(salt);
+        const encrypted = this.encrypt(data, key);
+        encrypted.salt = salt.toString("hex");
+        writeFileSync(this.credentialsFilePath, JSON.stringify(encrypted), {
+          mode: 384,
+          encoding: "utf8"
+        });
+      }
+      /**
+       * Retrieve credentials from encrypted file storage
+       */
+      async getCredentials() {
+        if (!existsSync(this.credentialsFilePath)) {
+          return null;
+        }
+        try {
+          const encryptedData = JSON.parse(
+            readFileSync(this.credentialsFilePath, "utf8")
+          );
+          const salt = Buffer.from(encryptedData.salt, "hex");
+          const key = this.deriveEncryptionKey(salt);
+          const decrypted = this.decrypt(encryptedData, key);
+          return JSON.parse(decrypted);
+        } catch (error) {
+          console.error("Failed to decrypt credentials:", error);
+          return null;
+        }
+      }
+      /**
+       * Delete credentials from file storage
+       */
+      async deleteCredentials() {
+        if (existsSync(this.credentialsFilePath)) {
+          try {
+            unlinkSync(this.credentialsFilePath);
+          } catch (error) {
+            console.error("Failed to delete credentials file:", error);
+          }
+        }
+      }
+      /**
+       * Check if user is authenticated
+       */
+      async isAuthenticated() {
+        const credentials = await this.getCredentials();
+        if (!credentials || !credentials.accessToken) {
+          return false;
+        }
+        if (credentials.expiresAt && credentials.expiresAt < Date.now()) {
+          return false;
+        }
+        return true;
+      }
+      /**
+       * Store user information
+       */
+      setUserInfo(userInfo) {
+        this.config.set("userInfo", userInfo);
+      }
+      /**
+       * Get user information
+       */
+      getUserInfo() {
+        return this.config.get("userInfo") || null;
+      }
+      /**
+       * Delete user information
+       */
+      deleteUserInfo() {
+        this.config.delete("userInfo");
+      }
+      /**
+       * Store OAuth state for CSRF protection
+       */
+      setOAuthState(state) {
+        this.config.set("oauthState", state);
+      }
+      /**
+       * Get OAuth state
+       */
+      getOAuthState() {
+        return this.config.get("oauthState") || null;
+      }
+      /**
+       * Delete OAuth state
+       */
+      deleteOAuthState() {
+        this.config.delete("oauthState");
+      }
+      /**
+       * Get configuration value
+       */
+      getConfig(key) {
+        return this.config.get(key);
+      }
+      /**
+       * Set configuration value
+       */
+      setConfig(key, value) {
+        this.config.set(key, value);
+      }
+      /**
+       * Get all configuration
+       */
+      getAllConfig() {
+        return this.config.store;
+      }
+      /**
+       * Reset configuration to defaults
+       */
+      resetConfig() {
+        this.config.clear();
+        Object.entries(DEFAULT_CONFIG).forEach(([key, value]) => {
+          this.config.set(key, value);
+        });
+      }
+      /**
+       * Get current storage backend
+       */
+      getStorageBackend() {
+        return this.storageBackend;
+      }
+      /**
+       * Clear all stored data (credentials + config)
+       */
+      async clearAll() {
+        await this.deleteCredentials();
+        this.deleteUserInfo();
+        this.deleteOAuthState();
+        this.resetConfig();
+      }
+    };
+    storageService = new StorageService();
+  }
+});
+
+// src/utils/errors.ts
+var BragduckError, AuthenticationError, GitError, ApiError, NetworkError, ValidationError, OAuthError, TokenExpiredError;
+var init_errors = __esm({
+  "src/utils/errors.ts"() {
+    "use strict";
+    init_esm_shims();
+    BragduckError = class extends Error {
+      constructor(message, code, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = "BragduckError";
+        Error.captureStackTrace(this, this.constructor);
+      }
+    };
+    AuthenticationError = class extends BragduckError {
+      constructor(message, details) {
+        super(message, "AUTH_ERROR", details);
+        this.name = "AuthenticationError";
+      }
+    };
+    GitError = class extends BragduckError {
+      constructor(message, details) {
+        super(message, "GIT_ERROR", details);
+        this.name = "GitError";
+      }
+    };
+    ApiError = class extends BragduckError {
+      constructor(message, statusCode, details) {
+        super(message, "API_ERROR", details);
+        this.statusCode = statusCode;
+        this.name = "ApiError";
+      }
+    };
+    NetworkError = class extends BragduckError {
+      constructor(message, details) {
+        super(message, "NETWORK_ERROR", details);
+        this.name = "NetworkError";
+      }
+    };
+    ValidationError = class extends BragduckError {
+      constructor(message, details) {
+        super(message, "VALIDATION_ERROR", details);
+        this.name = "ValidationError";
+      }
+    };
+    OAuthError = class extends AuthenticationError {
+      constructor(message, details) {
+        super(message, details);
+        this.name = "OAuthError";
+      }
+    };
+    TokenExpiredError = class extends AuthenticationError {
+      constructor(message = "Authentication token has expired") {
+        super(message);
+        this.name = "TokenExpiredError";
+        this.code = "TOKEN_EXPIRED";
+      }
+    };
+  }
+});
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var logger;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    init_esm_shims();
+    logger = {
+      /**
+       * Debug message (only shown when DEBUG env var is set)
+       */
+      debug: (message, ...args) => {
+        if (process.env.DEBUG) {
+          console.log(chalk.gray(`[DEBUG] ${message}`), ...args);
+        }
+      },
+      /**
+       * Info message
+       */
+      info: (message) => {
+        console.log(chalk.blue(`\u2139 ${message}`));
+      },
+      /**
+       * Success message
+       */
+      success: (message) => {
+        console.log(chalk.green(`\u2713 ${message}`));
+      },
+      /**
+       * Warning message
+       */
+      warning: (message) => {
+        console.warn(chalk.yellow(`\u26A0 ${message}`));
+      },
+      /**
+       * Error message
+       */
+      error: (message) => {
+        console.error(chalk.red(`\u2717 ${message}`));
+      },
+      /**
+       * Plain log without formatting
+       */
+      log: (message) => {
+        console.log(message);
+      }
+    };
+  }
+});
+
+// src/utils/oauth-server.ts
+import { createServer } from "http";
+import { parse } from "url";
+async function findAvailablePort() {
+  const { MIN_PORT, MAX_PORT } = OAUTH_CONFIG;
+  for (let port = MIN_PORT; port <= MAX_PORT; port++) {
+    try {
+      await new Promise((resolve, reject) => {
+        const testServer = createServer();
+        testServer.once("error", reject);
+        testServer.once("listening", () => {
+          testServer.close(() => resolve());
+        });
+        testServer.listen(port, "127.0.0.1");
+      });
+      return port;
+    } catch (error) {
+      continue;
+    }
+  }
+  throw new OAuthError(`No available ports found in range ${MIN_PORT}-${MAX_PORT}`);
+}
+async function startOAuthCallbackServer(expectedState) {
+  const port = await findAvailablePort();
+  const timeout = OAUTH_CONFIG.TIMEOUT_MS;
+  return new Promise((resolve, reject) => {
+    let server = null;
+    let timeoutId;
+    const cleanup = () => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      if (server) {
+        if (typeof server.closeAllConnections === "function") {
+          server.closeAllConnections();
+        }
+        server.close(() => {
+          logger.debug("OAuth server closed");
+        });
+        server.unref();
+      }
+    };
+    const handleRequest = (req, res) => {
+      const parsedUrl = parse(req.url || "", true);
+      logger.debug(`OAuth callback received: ${req.url}`);
+      if (parsedUrl.pathname === OAUTH_CONFIG.CALLBACK_PATH) {
+        const { code, state, error, error_description } = parsedUrl.query;
+        if (error) {
+          const errorMsg = error_description || error;
+          logger.debug(`OAuth error: ${errorMsg}`);
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(ERROR_HTML(String(errorMsg)));
+          cleanup();
+          reject(new OAuthError(`OAuth error: ${errorMsg}`));
+          return;
+        }
+        if (!code || !state) {
+          const errorMsg = "Missing code or state parameter";
+          logger.debug(errorMsg);
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(ERROR_HTML(errorMsg));
+          cleanup();
+          reject(new OAuthError(errorMsg));
+          return;
+        }
+        if (state !== expectedState) {
+          const errorMsg = "Invalid state parameter (possible CSRF attack)";
+          logger.debug(errorMsg);
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(ERROR_HTML(errorMsg));
+          cleanup();
+          reject(new OAuthError(errorMsg));
+          return;
+        }
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(SUCCESS_HTML);
+        setTimeout(() => {
+          cleanup();
+          resolve({
+            code: String(code),
+            state: String(state),
+            port
+          });
+        }, 100);
+        return;
+      }
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("Not Found");
+    };
+    server = createServer(handleRequest);
+    server.on("error", (error) => {
+      logger.debug(`OAuth server error: ${error.message}`);
+      cleanup();
+      reject(new OAuthError(`OAuth server error: ${error.message}`));
+    });
+    server.listen(port, "127.0.0.1", () => {
+      logger.debug(`OAuth callback server listening on http://127.0.0.1:${port}${OAUTH_CONFIG.CALLBACK_PATH}`);
+    });
+    timeoutId = setTimeout(() => {
+      logger.debug("OAuth callback timeout");
+      cleanup();
+      reject(new OAuthError("Authentication timeout - no callback received within 2 minutes"));
+    }, timeout);
+  });
+}
+async function getCallbackUrl() {
+  const port = await findAvailablePort();
+  return `http://127.0.0.1:${port}${OAUTH_CONFIG.CALLBACK_PATH}`;
+}
+var SUCCESS_HTML, ERROR_HTML;
+var init_oauth_server = __esm({
+  "src/utils/oauth-server.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants();
+    init_errors();
+    init_logger();
+    SUCCESS_HTML = `
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Bragduck - Authentication Successful</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      min-height: 100vh;
+      margin: 0;
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+      color: white;
+    }
+    .container {
+      text-align: center;
+      padding: 2rem;
+      background: rgba(255, 255, 255, 0.1);
+      border-radius: 1rem;
+      backdrop-filter: blur(10px);
+      box-shadow: 0 8px 32px 0 rgba(31, 38, 135, 0.37);
+      max-width: 500px;
+    }
+    h1 {
+      font-size: 2.5rem;
+      margin: 0 0 1rem 0;
+    }
+    .checkmark {
+      font-size: 4rem;
+      animation: scale-in 0.3s ease-out;
+    }
+    p {
+      font-size: 1.2rem;
+      margin: 1rem 0;
+      opacity: 0.9;
+    }
+    @keyframes scale-in {
+      from { transform: scale(0); }
+      to { transform: scale(1); }
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="checkmark">\u2713</div>
+    <h1>Authentication Successful!</h1>
+    <p>You can now close this window and return to your terminal.</p>
+  </div>
+</body>
+</html>
+`;
+    ERROR_HTML = (error) => `
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Bragduck - Authentication Failed</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      min-height: 100vh;
+      margin: 0;
+      background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+      color: white;
+    }
+    .container {
+      text-align: center;
+      padding: 2rem;
+      background: rgba(255, 255, 255, 0.1);
+      border-radius: 1rem;
+      backdrop-filter: blur(10px);
+      box-shadow: 0 8px 32px 0 rgba(31, 38, 135, 0.37);
+      max-width: 500px;
+    }
+    h1 {
+      font-size: 2.5rem;
+      margin: 0 0 1rem 0;
+    }
+    .error-icon {
+      font-size: 4rem;
+    }
+    p {
+      font-size: 1.2rem;
+      margin: 1rem 0;
+      opacity: 0.9;
+    }
+    .error-details {
+      background: rgba(0, 0, 0, 0.2);
+      padding: 1rem;
+      border-radius: 0.5rem;
+      font-family: monospace;
+      font-size: 0.9rem;
+      margin-top: 1rem;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="error-icon">\u2717</div>
+    <h1>Authentication Failed</h1>
+    <p>Please return to your terminal and try again.</p>
+    <div class="error-details">${error}</div>
+  </div>
+</body>
+</html>
+`;
+  }
+});
+
+// src/utils/browser.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+async function openBrowser(url) {
+  const platform = process.platform;
+  let command;
+  switch (platform) {
+    case "darwin":
+      command = `open "${url}"`;
+      break;
+    case "win32":
+      command = `start "" "${url}"`;
+      break;
+    default:
+      command = `xdg-open "${url}"`;
+      break;
+  }
+  try {
+    logger.debug(`Opening browser with command: ${command}`);
+    await execAsync(command);
+    logger.debug("Browser opened successfully");
+  } catch (error) {
+    logger.debug(`Failed to open browser: ${error}`);
+    throw new Error(
+      `Failed to open browser automatically. Please open this URL manually:
+${url}`
+    );
+  }
+}
+var execAsync;
+var init_browser = __esm({
+  "src/utils/browser.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_logger();
+    execAsync = promisify(exec);
+  }
+});
+
+// src/services/auth.service.ts
+import { randomBytes as randomBytes2 } from "crypto";
+import { ofetch } from "ofetch";
+var AuthService, authService;
+var init_auth_service = __esm({
+  "src/services/auth.service.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants();
+    init_storage_service();
+    init_oauth_server();
+    init_browser();
+    init_errors();
+    init_logger();
+    AuthService = class {
+      apiBaseUrl;
+      constructor() {
+        this.apiBaseUrl = process.env.API_BASE_URL || storageService.getConfig("apiBaseUrl") || "https://api.bragduck.com";
+      }
+      /**
+       * Generate a random state string for CSRF protection
+       */
+      generateState() {
+        return randomBytes2(32).toString("hex");
+      }
+      /**
+       * Build the OAuth authorization URL
+       */
+      async buildAuthUrl(state, callbackUrl) {
+        const params = new URLSearchParams({
+          client_id: OAUTH_CONFIG.CLIENT_ID,
+          redirect_uri: callbackUrl,
+          state
+        });
+        return `${this.apiBaseUrl}${API_ENDPOINTS.AUTH.INITIATE}?${params.toString()}`;
+      }
+      /**
+       * Exchange authorization code for access token
+       */
+      async exchangeCodeForToken(code, callbackUrl) {
+        try {
+          logger.debug("Exchanging authorization code for token");
+          const response = await ofetch(
+            `${this.apiBaseUrl}${API_ENDPOINTS.AUTH.TOKEN}`,
+            {
+              method: "POST",
+              body: {
+                code,
+                redirect_uri: callbackUrl,
+                client_id: OAUTH_CONFIG.CLIENT_ID,
+                grant_type: "authorization_code"
+              },
+              headers: {
+                "Content-Type": "application/json"
+              }
+            }
+          );
+          logger.debug("Token exchange successful");
+          return response;
+        } catch (error) {
+          logger.debug(`Token exchange failed: ${error.message}`);
+          if (error.response) {
+            throw new AuthenticationError(
+              `Token exchange failed: ${error.response.statusText || "Unknown error"}`,
+              {
+                statusCode: error.response.status,
+                body: error.response._data
+              }
+            );
+          }
+          throw new NetworkError("Failed to connect to authentication server", {
+            originalError: error.message
+          });
+        }
+      }
+      /**
+       * Complete OAuth flow: start server, open browser, wait for callback, exchange token
+       */
+      async login() {
+        logger.debug("Starting OAuth login flow");
+        const state = this.generateState();
+        const callbackUrl = await getCallbackUrl();
+        storageService.setOAuthState({
+          state,
+          createdAt: Date.now()
+        });
+        logger.debug(`OAuth state: ${state}`);
+        logger.debug(`Callback URL: ${callbackUrl}`);
+        const authUrl = await this.buildAuthUrl(state, callbackUrl);
+        logger.debug(`Authorization URL: ${authUrl}`);
+        const serverPromise = startOAuthCallbackServer(state);
+        try {
+          await openBrowser(authUrl);
+        } catch (error) {
+          logger.warning("Could not open browser automatically");
+          logger.info(`Please open this URL in your browser:`);
+          logger.log(authUrl);
+        }
+        let callbackResult;
+        try {
+          callbackResult = await serverPromise;
+        } catch (error) {
+          storageService.deleteOAuthState();
+          throw error;
+        }
+        storageService.deleteOAuthState();
+        const tokenResponse = await this.exchangeCodeForToken(callbackResult.code, callbackUrl);
+        const expiresAt = tokenResponse.expires_in ? Date.now() + tokenResponse.expires_in * 1e3 : void 0;
+        const credentials = {
+          accessToken: tokenResponse.access_token,
+          refreshToken: tokenResponse.refresh_token,
+          expiresAt
+        };
+        await storageService.setCredentials(credentials);
+        if (tokenResponse.user) {
+          storageService.setUserInfo(tokenResponse.user);
+        }
+        logger.debug("Login successful");
+        return tokenResponse.user || { id: "unknown", email: "unknown", name: "Unknown User" };
+      }
+      /**
+       * Logout: clear all stored credentials and user info
+       */
+      async logout() {
+        logger.debug("Logging out");
+        await storageService.deleteCredentials();
+        storageService.deleteUserInfo();
+        storageService.deleteOAuthState();
+        logger.debug("Logout complete");
+      }
+      /**
+       * Check if user is authenticated
+       */
+      async isAuthenticated() {
+        return storageService.isAuthenticated();
+      }
+      /**
+       * Get current access token
+       */
+      async getAccessToken() {
+        const credentials = await storageService.getCredentials();
+        return credentials?.accessToken || null;
+      }
+      /**
+       * Get current user info
+       */
+      getUserInfo() {
+        return storageService.getUserInfo();
+      }
+      /**
+       * Refresh access token using refresh token
+       */
+      async refreshToken() {
+        logger.debug("Refreshing access token");
+        const credentials = await storageService.getCredentials();
+        if (!credentials?.refreshToken) {
+          throw new AuthenticationError("No refresh token available");
+        }
+        try {
+          const response = await ofetch(
+            `${this.apiBaseUrl}${API_ENDPOINTS.AUTH.TOKEN}`,
+            {
+              method: "POST",
+              body: {
+                refresh_token: credentials.refreshToken,
+                client_id: OAUTH_CONFIG.CLIENT_ID,
+                grant_type: "refresh_token"
+              },
+              headers: {
+                "Content-Type": "application/json"
+              }
+            }
+          );
+          const expiresAt = response.expires_in ? Date.now() + response.expires_in * 1e3 : void 0;
+          const newCredentials = {
+            accessToken: response.access_token,
+            refreshToken: response.refresh_token || credentials.refreshToken,
+            expiresAt
+          };
+          await storageService.setCredentials(newCredentials);
+          logger.debug("Token refresh successful");
+        } catch (error) {
+          logger.debug(`Token refresh failed: ${error.message}`);
+          await this.logout();
+          throw new AuthenticationError("Token refresh failed. Please log in again.");
+        }
+      }
+    };
+    authService = new AuthService();
+  }
+});
+
+// src/utils/version.ts
+var version_exports = {};
+__export(version_exports, {
+  checkForUpdates: () => checkForUpdates,
+  compareVersions: () => compareVersions,
+  formatVersion: () => formatVersion,
+  getCurrentVersion: () => getCurrentVersion,
+  version: () => version
+});
+import { readFileSync as readFileSync2 } from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { dirname as dirname2, join as join4 } from "path";
+import chalk4 from "chalk";
+import boxen3 from "boxen";
+function getCurrentVersion() {
+  try {
+    const packageJsonPath2 = join4(__dirname3, "../../package.json");
+    const packageJson2 = JSON.parse(readFileSync2(packageJsonPath2, "utf-8"));
+    return packageJson2.version;
+  } catch (error) {
+    logger.debug("Failed to read package.json version");
+    return "1.0.0";
+  }
+}
+function compareVersions(v1, v2) {
+  const parts1 = v1.split(".").map((p) => parseInt(p, 10));
+  const parts2 = v2.split(".").map((p) => parseInt(p, 10));
+  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+    const part1 = parts1[i] || 0;
+    const part2 = parts2[i] || 0;
+    if (part1 > part2) return 1;
+    if (part1 < part2) return -1;
+  }
+  return 0;
+}
+async function checkForUpdates(options = {}) {
+  const { silent = false, force = false } = options;
+  try {
+    if (!force) {
+      const autoVersionCheck = storageService.getConfig("autoVersionCheck");
+      if (!autoVersionCheck) {
+        logger.debug("Version check disabled in config");
+        return {
+          updateAvailable: false,
+          latestVersion: version,
+          currentVersion: version
+        };
+      }
+    }
+    logger.debug("Checking for CLI updates...");
+    const response = await apiService.checkVersion();
+    const latestVersion = response.latest_version;
+    const currentVersion = version;
+    logger.debug(`Current version: ${currentVersion}, Latest version: ${latestVersion}`);
+    const updateAvailable = compareVersions(latestVersion, currentVersion) > 0;
+    if (!silent && updateAvailable) {
+      displayUpdateNotification(currentVersion, latestVersion, response.critical_update);
+    }
+    return {
+      updateAvailable,
+      latestVersion,
+      currentVersion
+    };
+  } catch (error) {
+    logger.debug(`Version check failed: ${error.message}`);
+    return {
+      updateAvailable: false,
+      latestVersion: version,
+      currentVersion: version
+    };
+  }
+}
+function displayUpdateNotification(currentVersion, latestVersion, critical = false) {
+  const urgency = critical ? chalk4.red.bold("CRITICAL UPDATE") : chalk4.yellow.bold("Update Available");
+  const message = `${urgency}
+
+Current version: ${chalk4.dim(currentVersion)}
+Latest version:  ${chalk4.green(latestVersion)}
+
+Update with: ${chalk4.cyan("npm install -g @bragduck/cli@latest")}`;
+  console.log("");
+  console.log(
+    boxen3(message, {
+      padding: 1,
+      margin: { top: 0, right: 1, bottom: 0, left: 1 },
+      borderStyle: "round",
+      borderColor: critical ? "red" : "yellow"
+    })
+  );
+  console.log("");
+  if (critical) {
+    logger.warning("This is a critical update. Please update as soon as possible.");
+    console.log("");
+  }
+}
+function formatVersion(includePrefix = true) {
+  const prefix = includePrefix ? "v" : "";
+  return `${prefix}${version}`;
+}
+var __filename3, __dirname3, version;
+var init_version = __esm({
+  "src/utils/version.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_api_service();
+    init_storage_service();
+    init_logger();
+    __filename3 = fileURLToPath3(import.meta.url);
+    __dirname3 = dirname2(__filename3);
+    version = getCurrentVersion();
+  }
+});
+
+// src/services/api.service.ts
+import { ofetch as ofetch2 } from "ofetch";
+var ApiService, apiService;
+var init_api_service = __esm({
+  "src/services/api.service.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_storage_service();
+    init_auth_service();
+    init_constants();
+    init_errors();
+    init_logger();
+    ApiService = class {
+      baseURL;
+      client;
+      constructor() {
+        this.baseURL = process.env.API_BASE_URL || storageService.getConfig("apiBaseUrl");
+        this.client = ofetch2.create({
+          baseURL: this.baseURL,
+          // Request interceptor
+          onRequest: async ({ options }) => {
+            logger.debug(`API Request: ${options.method} ${options.baseURL}${options.url}`);
+            const token = await authService.getAccessToken();
+            if (token) {
+              options.headers = {
+                ...options.headers,
+                Authorization: `Bearer ${token}`
+              };
+            }
+            if (options.method && ["POST", "PUT", "PATCH"].includes(options.method)) {
+              options.headers = {
+                ...options.headers,
+                "Content-Type": "application/json"
+              };
+            }
+          },
+          // Response interceptor for success
+          onResponse: ({ response }) => {
+            logger.debug(`API Response: ${response.status} ${response.statusText}`);
+          },
+          // Response interceptor for errors
+          onResponseError: async ({ response, options }) => {
+            const status = response.status;
+            const url = `${options.baseURL}${options.url}`;
+            logger.debug(`API Error: ${status} ${response.statusText} - ${url}`);
+            if (status === HTTP_STATUS.UNAUTHORIZED) {
+              logger.debug("Token expired, attempting refresh");
+              try {
+                await authService.refreshToken();
+                logger.debug("Token refreshed, retrying request");
+                throw new Error("RETRY_WITH_NEW_TOKEN");
+              } catch (error) {
+                if (error.message === "RETRY_WITH_NEW_TOKEN") {
+                  throw error;
+                }
+                throw new TokenExpiredError('Your session has expired. Please run "bragduck init" to login again.');
+              }
+            }
+            let errorMessage = "An unexpected error occurred";
+            let errorDetails;
+            try {
+              const errorData = response._data;
+              if (errorData && errorData.message) {
+                errorMessage = errorData.message;
+                errorDetails = errorData.details;
+              }
+            } catch {
+              errorMessage = response.statusText || errorMessage;
+            }
+            throw new ApiError(errorMessage, status, errorDetails);
+          },
+          // Retry configuration
+          retry: 2,
+          retryDelay: 1e3,
+          retryStatusCodes: [408, 409, 425, 429, 500, 502, 503, 504],
+          // Timeout
+          timeout: 3e4
+          // 30 seconds
+        });
+      }
+      /**
+       * Make API request with retry for token refresh
+       */
+      async makeRequest(url, options = {}) {
+        try {
+          return await this.client(url, options);
+        } catch (error) {
+          if (error.message === "RETRY_WITH_NEW_TOKEN") {
+            logger.debug("Retrying request with refreshed token");
+            return await this.client(url, options);
+          }
+          if (error.name === "FetchError" || error.code === "ECONNREFUSED") {
+            throw new NetworkError("Failed to connect to Bragduck API", {
+              originalError: error.message,
+              baseURL: this.baseURL
+            });
+          }
+          throw error;
+        }
+      }
+      /**
+       * Refine commits using AI
+       */
+      async refineCommits(request) {
+        logger.debug(`Refining ${request.commits.length} commits`);
+        try {
+          const response = await this.makeRequest(
+            API_ENDPOINTS.COMMITS.REFINE,
+            {
+              method: "POST",
+              body: request
+            }
+          );
+          logger.debug(`Successfully refined ${response.refined_commits.length} commits`);
+          return response;
+        } catch (error) {
+          logger.debug("Failed to refine commits");
+          throw error;
+        }
+      }
+      /**
+       * Create brags from refined commits
+       */
+      async createBrags(request) {
+        logger.debug(`Creating ${request.brags.length} brags`);
+        try {
+          const response = await this.makeRequest(
+            API_ENDPOINTS.BRAGS.CREATE,
+            {
+              method: "POST",
+              body: request
+            }
+          );
+          logger.debug(`Successfully created ${response.created} brags`);
+          return response;
+        } catch (error) {
+          logger.debug("Failed to create brags");
+          throw error;
+        }
+      }
+      /**
+       * List existing brags
+       */
+      async listBrags(params = {}) {
+        const { limit = 50, offset = 0, tags, search } = params;
+        logger.debug(`Listing brags: limit=${limit}, offset=${offset}`);
+        try {
+          const queryParams = new URLSearchParams({
+            limit: limit.toString(),
+            offset: offset.toString()
+          });
+          if (search) {
+            queryParams.append("search", search);
+          }
+          if (tags && tags.length > 0) {
+            tags.forEach((tag) => queryParams.append("tags[]", tag));
+          }
+          const url = `${API_ENDPOINTS.BRAGS.LIST}?${queryParams.toString()}`;
+          const response = await this.makeRequest(url, {
+            method: "GET"
+          });
+          logger.debug(`Successfully fetched ${response.brags.length} brags (total: ${response.total})`);
+          return response;
+        } catch (error) {
+          logger.debug("Failed to list brags");
+          throw error;
+        }
+      }
+      /**
+       * Check for CLI updates
+       */
+      async checkVersion() {
+        logger.debug("Checking for CLI updates");
+        try {
+          const response = await this.makeRequest(
+            API_ENDPOINTS.VERSION,
+            {
+              method: "GET"
+            }
+          );
+          logger.debug(`Latest version: ${response.latest_version}`);
+          return response;
+        } catch (error) {
+          logger.debug("Failed to check version");
+          const { version: version2 } = await Promise.resolve().then(() => (init_version(), version_exports));
+          return {
+            latest_version: version2,
+            critical_update: false
+          };
+        }
+      }
+      /**
+       * Test API connectivity
+       */
+      async testConnection() {
+        try {
+          await this.checkVersion();
+          return true;
+        } catch (error) {
+          return false;
+        }
+      }
+      /**
+       * Update base URL
+       */
+      setBaseURL(url) {
+        this.baseURL = url;
+        storageService.setConfig("apiBaseUrl", url);
+        this.client = ofetch2.create({
+          baseURL: url
+        });
+      }
+      /**
+       * Get current base URL
+       */
+      getBaseURL() {
+        return this.baseURL;
+      }
+    };
+    apiService = new ApiService();
+  }
+});
+
+// src/cli.ts
+init_esm_shims();
+import { Command } from "commander";
+import { readFileSync as readFileSync3 } from "fs";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import { dirname as dirname3, join as join5 } from "path";
+
+// src/commands/init.ts
+init_esm_shims();
+init_auth_service();
+init_logger();
+import ora from "ora";
+import boxen from "boxen";
+import chalk2 from "chalk";
+async function initCommand() {
+  logger.log("");
+  logger.info("Starting authentication flow...");
+  logger.log("");
+  const isAuthenticated = await authService.isAuthenticated();
+  if (isAuthenticated) {
+    const userInfo = authService.getUserInfo();
+    if (userInfo) {
+      logger.log(
+        boxen(
+          `${chalk2.yellow("Already authenticated!")}
+
+${chalk2.gray("User:")} ${userInfo.name}
+${chalk2.gray("Email:")} ${userInfo.email}
+
+${chalk2.dim("Run")} ${chalk2.cyan("bragduck logout")} ${chalk2.dim("to sign out")}`,
+          {
+            padding: 1,
+            margin: 1,
+            borderStyle: "round",
+            borderColor: "yellow"
+          }
+        )
+      );
+      logger.log("");
+      setTimeout(() => {
+        process.exit(0);
+      }, 100);
+      return;
+    }
+  }
+  const spinner = ora("Opening browser for authentication...").start();
+  try {
+    spinner.text = "Waiting for authentication...";
+    const userInfo = await authService.login();
+    spinner.succeed("Authentication successful!");
+    logger.log("");
+    logger.log(
+      boxen(
+        `${chalk2.green.bold("\u2713 Successfully authenticated!")}
+
+${chalk2.gray("Welcome,")} ${chalk2.cyan(userInfo.name)}
+${chalk2.gray("Email:")} ${userInfo.email}
+
+${chalk2.dim("You can now use")} ${chalk2.cyan("bragduck scan")} ${chalk2.dim("to create brags!")}`,
+        {
+          padding: 1,
+          margin: 1,
+          borderStyle: "round",
+          borderColor: "green"
+        }
+      )
+    );
+    logger.log("");
+    setTimeout(() => {
+      process.exit(0);
+    }, 100);
+    return;
+  } catch (error) {
+    spinner.fail("Authentication failed");
+    logger.log("");
+    const err = error;
+    logger.log(
+      boxen(
+        `${chalk2.red.bold("\u2717 Authentication Failed")}
+
+${err.message}
+
+${chalk2.dim("Hint:")} ${getErrorHint(err)}`,
+        {
+          padding: 1,
+          margin: 1,
+          borderStyle: "round",
+          borderColor: "red"
+        }
+      )
+    );
+    process.exit(1);
+  }
+}
+function getErrorHint(error) {
+  if (error.name === "OAuthError") {
+    if (error.message.includes("timeout")) {
+      return "Try again and complete the authentication within 2 minutes";
+    }
+    if (error.message.includes("CSRF")) {
+      return "This might be a security issue. Try running the command again";
+    }
+    return "Check your internet connection and try again";
+  }
+  if (error.name === "NetworkError") {
+    return "Check your internet connection and firewall settings";
+  }
+  if (error.name === "AuthenticationError") {
+    return "Verify your credentials and try again";
+  }
+  return "Try running the command again or check the logs with DEBUG=* bragduck init";
+}
+
+// src/commands/logout.ts
+init_esm_shims();
+init_auth_service();
+init_logger();
+import { confirm } from "@inquirer/prompts";
+import boxen2 from "boxen";
+import chalk3 from "chalk";
+import ora2 from "ora";
+async function logoutCommand() {
+  const isAuthenticated = await authService.isAuthenticated();
+  if (!isAuthenticated) {
+    logger.log(
+      boxen2(`${chalk3.yellow("Not currently authenticated")}
+
+${chalk3.dim("Nothing to logout from")}`, {
+        padding: 1,
+        margin: 1,
+        borderStyle: "round",
+        borderColor: "yellow"
+      })
+    );
+    return;
+  }
+  const userInfo = authService.getUserInfo();
+  const userName = userInfo?.name || "Unknown User";
+  logger.log("");
+  const shouldLogout = await confirm({
+    message: `Are you sure you want to logout? (${chalk3.cyan(userName)})`,
+    default: false
+  });
+  if (!shouldLogout) {
+    logger.info("Logout cancelled");
+    return;
+  }
+  const spinner = ora2("Logging out...").start();
+  try {
+    await authService.logout();
+    spinner.succeed("Logged out successfully");
+    logger.log("");
+    logger.log(
+      boxen2(
+        `${chalk3.green.bold("\u2713 Logged out successfully")}
+
+${chalk3.dim("Your credentials have been cleared")}
+
+${chalk3.dim("Run")} ${chalk3.cyan("bragduck init")} ${chalk3.dim("to login again")}`,
+        {
+          padding: 1,
+          margin: 1,
+          borderStyle: "round",
+          borderColor: "green"
+        }
+      )
+    );
+  } catch (error) {
+    spinner.fail("Logout failed");
+    logger.error("Failed to logout. Please try again.");
+    process.exit(1);
+  }
+}
+
+// src/commands/scan.ts
+init_esm_shims();
+import boxen4 from "boxen";
+import chalk7 from "chalk";
+
+// src/services/git.service.ts
+init_esm_shims();
+import simpleGit from "simple-git";
+
+// src/utils/validators.ts
+init_esm_shims();
+init_errors();
+import { existsSync as existsSync2 } from "fs";
+import { join as join3 } from "path";
+function validateGitRepository(path2) {
+  const gitDir = join3(path2, ".git");
+  if (!existsSync2(gitDir)) {
+    throw new GitError(
+      "Not a git repository. Please run this command from within a git repository.",
+      {
+        path: path2,
+        hint: 'Run "git init" to initialize a git repository, or navigate to an existing one'
+      }
+    );
+  }
+}
+
+// src/services/git.service.ts
+init_errors();
+init_logger();
+var GitService = class {
+  git;
+  repoPath;
+  constructor(repoPath = process.cwd()) {
+    this.repoPath = repoPath;
+    this.git = simpleGit(repoPath);
+  }
+  /**
+   * Validate that the current directory is a git repository
+   */
+  async validateRepository() {
+    try {
+      validateGitRepository(this.repoPath);
+      const isRepo = await this.git.checkIsRepo();
+      if (!isRepo) {
+        throw new GitError("Not a valid git repository", {
+          path: this.repoPath
+        });
+      }
+    } catch (error) {
+      if (error instanceof GitError) {
+        throw error;
+      }
+      throw new GitError("Failed to validate git repository", {
+        originalError: error.message,
+        path: this.repoPath
+      });
+    }
+  }
+  /**
+   * Get repository information
+   */
+  async getRepositoryInfo() {
+    try {
+      await this.validateRepository();
+      const status = await this.git.status();
+      const remotes = await this.git.getRemotes(true);
+      const primaryRemote = remotes.find((r) => r.name === "origin");
+      return {
+        path: this.repoPath,
+        currentBranch: status.current || "unknown",
+        remoteUrl: primaryRemote?.refs?.fetch || primaryRemote?.refs?.push,
+        isClean: status.isClean()
+      };
+    } catch (error) {
+      if (error instanceof GitError) {
+        throw error;
+      }
+      throw new GitError("Failed to get repository information", {
+        originalError: error.message
+      });
+    }
+  }
+  /**
+   * Fetch recent commits
+   */
+  async getRecentCommits(options = {}) {
+    const { days = 30, limit, author, branch } = options;
+    try {
+      await this.validateRepository();
+      logger.debug(`Fetching commits from last ${days} days`);
+      const since = /* @__PURE__ */ new Date();
+      since.setDate(since.getDate() - days);
+      const logOptions = {
+        "--since": since.toISOString(),
+        "--no-merges": null
+      };
+      if (limit) {
+        logOptions.maxCount = limit;
+      }
+      if (author) {
+        logOptions["--author"] = author;
+      }
+      const log = await this.git.log(logOptions);
+      logger.debug(`Found ${log.all.length} commits`);
+      const commits = log.all.map((commit) => ({
+        sha: commit.hash,
+        message: commit.message,
+        author: commit.author_name,
+        authorEmail: commit.author_email,
+        date: commit.date
+      }));
+      return commits;
+    } catch (error) {
+      if (error instanceof GitError) {
+        throw error;
+      }
+      throw new GitError("Failed to fetch commits", {
+        originalError: error.message,
+        days
+      });
+    }
+  }
+  /**
+   * Get diff statistics for a specific commit
+   */
+  async getCommitStats(sha) {
+    try {
+      logger.debug(`Getting stats for commit ${sha}`);
+      const diffSummary = await this.git.diffSummary([`${sha}^`, sha]);
+      const stats = {
+        filesChanged: diffSummary.files.length,
+        insertions: diffSummary.insertions,
+        deletions: diffSummary.deletions
+      };
+      logger.debug(`Commit ${sha}: ${stats.filesChanged} files, +${stats.insertions} -${stats.deletions}`);
+      return stats;
+    } catch (error) {
+      if (error.message && error.message.includes("unknown revision")) {
+        logger.debug(`Commit ${sha} has no parent (first commit)`);
+        try {
+          const diffSummary = await this.git.diffSummary([sha]);
+          return {
+            filesChanged: diffSummary.files.length,
+            insertions: diffSummary.insertions,
+            deletions: diffSummary.deletions
+          };
+        } catch {
+          return {
+            filesChanged: 0,
+            insertions: 0,
+            deletions: 0
+          };
+        }
+      }
+      throw new GitError("Failed to get commit statistics", {
+        originalError: error.message,
+        sha
+      });
+    }
+  }
+  /**
+   * Get commits with their diff statistics
+   */
+  async getCommitsWithStats(options = {}) {
+    const commits = await this.getRecentCommits(options);
+    logger.debug(`Fetching diff stats for ${commits.length} commits`);
+    const commitsWithStats = await Promise.all(
+      commits.map(async (commit) => {
+        try {
+          const stats = await this.getCommitStats(commit.sha);
+          return {
+            ...commit,
+            diffStats: stats
+          };
+        } catch (error) {
+          logger.debug(`Failed to get stats for commit ${commit.sha}, continuing without stats`);
+          return commit;
+        }
+      })
+    );
+    return commitsWithStats;
+  }
+  /**
+   * Get the current git user email
+   */
+  async getCurrentUserEmail() {
+    try {
+      const email = await this.git.raw(["config", "user.email"]);
+      return email.trim() || null;
+    } catch (error) {
+      logger.debug("Failed to get git user email");
+      return null;
+    }
+  }
+  /**
+   * Get the current git user name
+   */
+  async getCurrentUserName() {
+    try {
+      const name = await this.git.raw(["config", "user.name"]);
+      return name.trim() || null;
+    } catch (error) {
+      logger.debug("Failed to get git user name");
+      return null;
+    }
+  }
+  /**
+   * Filter commits by current user
+   */
+  async getCommitsByCurrentUser(options = {}) {
+    const userEmail = await this.getCurrentUserEmail();
+    if (!userEmail) {
+      logger.warning("Could not determine git user email, returning all commits");
+      return this.getCommitsWithStats(options);
+    }
+    logger.debug(`Filtering commits by user: ${userEmail}`);
+    return this.getCommitsWithStats({
+      ...options,
+      author: userEmail
+    });
+  }
+};
+var gitService = new GitService();
+
+// src/commands/scan.ts
+init_api_service();
+init_auth_service();
+init_storage_service();
+init_logger();
+
+// src/ui/prompts.ts
+init_esm_shims();
+import { checkbox, confirm as confirm2, input, select } from "@inquirer/prompts";
+
+// src/ui/formatters.ts
+init_esm_shims();
+import chalk5 from "chalk";
+import Table from "cli-table3";
+function formatCommitChoice(commit) {
+  const sha = chalk5.yellow(commit.sha.substring(0, 7));
+  const message = commit.message.split("\n")[0];
+  const author = chalk5.gray(`by ${commit.author}`);
+  const date = chalk5.gray(new Date(commit.date).toLocaleDateString());
+  let stats = "";
+  if (commit.diffStats) {
+    const { filesChanged, insertions, deletions } = commit.diffStats;
+    stats = chalk5.gray(
+      ` [${filesChanged} files, ${chalk5.green(`+${insertions}`)} ${chalk5.red(`-${deletions}`)}]`
+    );
+  }
+  return `${sha} ${message}${stats}
+    ${author} \u2022 ${date}`;
+}
+function formatRefinedCommitsTable(commits) {
+  const table = new Table({
+    head: [
+      chalk5.cyan("SHA"),
+      chalk5.cyan("Original"),
+      chalk5.cyan("Refined Title"),
+      chalk5.cyan("Description"),
+      chalk5.cyan("Tags")
+    ],
+    colWidths: [10, 30, 30, 40, 20],
+    wordWrap: true,
+    style: {
+      head: [],
+      border: ["gray"]
+    }
+  });
+  commits.forEach((commit) => {
+    const sha = commit.sha.substring(0, 7);
+    const original = commit.original_message.split("\n")[0] || "";
+    const title = commit.refined_title;
+    const description = commit.refined_description.substring(0, 100) + "...";
+    const tags = (commit.suggested_tags || []).join(", ") || "none";
+    table.push([
+      chalk5.yellow(sha),
+      chalk5.gray(original),
+      chalk5.white(title),
+      chalk5.dim(description),
+      chalk5.blue(tags)
+    ]);
+  });
+  return table.toString();
+}
+function formatCommitStats(commits) {
+  const totalFiles = commits.reduce((sum, c) => sum + (c.diffStats?.filesChanged || 0), 0);
+  const totalInsertions = commits.reduce((sum, c) => sum + (c.diffStats?.insertions || 0), 0);
+  const totalDeletions = commits.reduce((sum, c) => sum + (c.diffStats?.deletions || 0), 0);
+  return chalk5.gray("Total changes: ") + chalk5.white(`${totalFiles} files`) + chalk5.gray(", ") + chalk5.green(`+${totalInsertions}`) + chalk5.gray(" ") + chalk5.red(`-${totalDeletions}`);
+}
+function formatSuccessMessage(count) {
+  const emoji = "\u{1F389}";
+  const title = chalk5.green.bold(`${emoji} Successfully created ${count} brag${count > 1 ? "s" : ""}!`);
+  const message = chalk5.white("\nYour achievements are now saved and ready to showcase.");
+  const hint = chalk5.dim("\nRun ") + chalk5.cyan("bragduck list") + chalk5.dim(" to see all your brags");
+  return `${title}${message}${hint}`;
+}
+function formatErrorMessage(message, hint) {
+  const title = chalk5.red.bold("\u2717 Error");
+  const error = chalk5.white(message);
+  const hintText = hint ? chalk5.dim("\n\nHint: ") + chalk5.cyan(hint) : "";
+  return `${title}
+
+${error}${hintText}`;
+}
+
+// src/ui/prompts.ts
+async function promptSelectCommits(commits) {
+  if (commits.length === 0) {
+    return [];
+  }
+  const choices = commits.map((commit) => ({
+    name: formatCommitChoice(commit),
+    value: commit.sha,
+    checked: false
+  }));
+  const selected = await checkbox({
+    message: "Select commits to brag about (use space to select, enter to confirm):",
+    choices,
+    pageSize: 10,
+    loop: false
+  });
+  return selected;
+}
+async function promptConfirm(message, defaultValue = true) {
+  return await confirm2({
+    message,
+    default: defaultValue
+  });
+}
+async function promptDaysToScan(defaultDays = 30) {
+  const choices = [
+    { name: "7 days", value: "7", description: "Last week" },
+    { name: "30 days (Recommended)", value: "30", description: "Last month" },
+    { name: "60 days", value: "60", description: "Last 2 months" },
+    { name: "90 days", value: "90", description: "Last 3 months" },
+    { name: "Custom", value: "custom", description: "Enter custom number of days" }
+  ];
+  const selected = await select({
+    message: "How many days back should we scan for commits?",
+    choices,
+    default: "30"
+  });
+  if (selected === "custom") {
+    const customDays = await input({
+      message: "Enter number of days:",
+      default: defaultDays.toString(),
+      validate: (value) => {
+        const num = parseInt(value, 10);
+        if (isNaN(num) || num <= 0) {
+          return "Please enter a valid positive number";
+        }
+        return true;
+      }
+    });
+    return parseInt(customDays, 10);
+  }
+  return parseInt(selected, 10);
+}
+
+// src/ui/spinners.ts
+init_esm_shims();
+import ora3 from "ora";
+import chalk6 from "chalk";
+function createSpinner(text) {
+  return ora3({
+    text,
+    color: "cyan",
+    spinner: "dots"
+  });
+}
+function fetchingCommitsSpinner(days) {
+  return createSpinner(`Fetching commits from the last ${days} days...`);
+}
+function refiningCommitsSpinner(count) {
+  return createSpinner(`Refining ${count} commit${count > 1 ? "s" : ""} with AI...`);
+}
+function creatingBragsSpinner(count) {
+  return createSpinner(`Creating ${count} brag${count > 1 ? "s" : ""}...`);
+}
+function fetchingBragsSpinner() {
+  return createSpinner("Fetching your brags...");
+}
+function succeedSpinner(spinner, text) {
+  if (text) {
+    spinner.succeed(chalk6.green(text));
+  } else {
+    spinner.succeed();
+  }
+}
+function failSpinner(spinner, text) {
+  if (text) {
+    spinner.fail(chalk6.red(text));
+  } else {
+    spinner.fail();
+  }
+}
+
+// src/commands/scan.ts
+async function scanCommand(options = {}) {
+  logger.log("");
+  try {
+    const isAuthenticated = await authService.isAuthenticated();
+    if (!isAuthenticated) {
+      logger.log(
+        boxen4(
+          `${chalk7.yellow.bold("\u26A0 Not authenticated")}
+
+Please run ${chalk7.cyan("bragduck init")} to login first.`,
+          {
+            padding: 1,
+            margin: 1,
+            borderStyle: "round",
+            borderColor: "yellow"
+          }
+        )
+      );
+      process.exit(1);
+    }
+    await gitService.validateRepository();
+    const repoInfo = await gitService.getRepositoryInfo();
+    logger.info(`Repository: ${chalk7.cyan(repoInfo.currentBranch)} branch`);
+    logger.log("");
+    let days = options.days;
+    if (!days) {
+      const defaultDays = storageService.getConfig("defaultCommitDays");
+      days = await promptDaysToScan(defaultDays);
+      logger.log("");
+    }
+    const spinner = fetchingCommitsSpinner(days);
+    spinner.start();
+    let commits;
+    if (options.all) {
+      commits = await gitService.getCommitsWithStats({ days });
+    } else {
+      commits = await gitService.getCommitsByCurrentUser({ days });
+    }
+    if (commits.length === 0) {
+      failSpinner(spinner, `No commits found in the last ${days} days`);
+      logger.log("");
+      logger.info("Try increasing the number of days or check your git configuration");
+      return;
+    }
+    succeedSpinner(spinner, `Found ${commits.length} commit${commits.length > 1 ? "s" : ""}`);
+    logger.log("");
+    logger.log(formatCommitStats(commits));
+    logger.log("");
+    const selectedShas = await promptSelectCommits(commits);
+    if (selectedShas.length === 0) {
+      logger.warning("No commits selected");
+      return;
+    }
+    const selectedCommits = commits.filter((c) => selectedShas.includes(c.sha));
+    logger.log("");
+    logger.success(`Selected ${selectedCommits.length} commit${selectedCommits.length > 1 ? "s" : ""}`);
+    logger.log("");
+    const refineSpinner = refiningCommitsSpinner(selectedCommits.length);
+    refineSpinner.start();
+    const refineRequest = {
+      commits: selectedCommits.map((c) => ({
+        sha: c.sha,
+        message: c.message,
+        author: c.author,
+        date: c.date,
+        diff_stats: c.diffStats ? {
+          filesChanged: c.diffStats.filesChanged,
+          insertions: c.diffStats.insertions,
+          deletions: c.diffStats.deletions
+        } : void 0
+      }))
+    };
+    const refineResponse = await apiService.refineCommits(refineRequest);
+    const refinedCommits = refineResponse.refined_commits;
+    succeedSpinner(refineSpinner, "Commits refined successfully");
+    logger.log("");
+    logger.info("Preview of refined brags:");
+    logger.log("");
+    logger.log(formatRefinedCommitsTable(refinedCommits));
+    logger.log("");
+    const shouldCreate = await promptConfirm("Create these brags?", true);
+    if (!shouldCreate) {
+      logger.warning("Cancelled");
+      return;
+    }
+    logger.log("");
+    const createSpinner2 = creatingBragsSpinner(refinedCommits.length);
+    createSpinner2.start();
+    const createRequest = {
+      brags: refinedCommits.map((refined) => {
+        const originalCommit = selectedCommits.find((c) => c.sha === refined.sha);
+        return {
+          commit_sha: refined.sha,
+          title: refined.refined_title,
+          description: refined.refined_description,
+          tags: refined.suggested_tags,
+          repository: repoInfo.remoteUrl,
+          date: originalCommit?.date || (/* @__PURE__ */ new Date()).toISOString()
+        };
+      })
+    };
+    const createResponse = await apiService.createBrags(createRequest);
+    succeedSpinner(createSpinner2, `Created ${createResponse.created} brags`);
+    logger.log("");
+    logger.log(
+      boxen4(formatSuccessMessage(createResponse.created), {
+        padding: 1,
+        margin: 1,
+        borderStyle: "round",
+        borderColor: "green"
+      })
+    );
+  } catch (error) {
+    const err = error;
+    logger.log("");
+    logger.log(
+      boxen4(formatErrorMessage(err.message, getErrorHint2(err)), {
+        padding: 1,
+        margin: 1,
+        borderStyle: "round",
+        borderColor: "red"
+      })
+    );
+    process.exit(1);
+  }
+}
+function getErrorHint2(error) {
+  if (error.name === "GitError") {
+    return "Make sure you are in a git repository with commits";
+  }
+  if (error.name === "TokenExpiredError" || error.name === "AuthenticationError") {
+    return 'Run "bragduck init" to login again';
+  }
+  if (error.name === "NetworkError") {
+    return "Check your internet connection and try again";
+  }
+  if (error.name === "ApiError") {
+    return "The server might be experiencing issues. Try again later";
+  }
+  return "Try running with DEBUG=* for more information";
+}
+
+// src/commands/list.ts
+init_esm_shims();
+init_api_service();
+init_auth_service();
+init_logger();
+import boxen5 from "boxen";
+import chalk8 from "chalk";
+import Table2 from "cli-table3";
+async function listCommand(options = {}) {
+  logger.log("");
+  try {
+    const isAuthenticated = await authService.isAuthenticated();
+    if (!isAuthenticated) {
+      logger.log(
+        boxen5(
+          `${chalk8.yellow.bold("\u26A0 Not authenticated")}
+
+Please run ${chalk8.cyan("bragduck init")} to login first.`,
+          {
+            padding: 1,
+            margin: 1,
+            borderStyle: "round",
+            borderColor: "yellow"
+          }
+        )
+      );
+      process.exit(1);
+    }
+    const limit = options.limit || 50;
+    const offset = options.offset || 0;
+    const tags = options.tags ? options.tags.split(",").map((t) => t.trim()) : void 0;
+    const search = options.search;
+    const spinner = fetchingBragsSpinner();
+    spinner.start();
+    const response = await apiService.listBrags({
+      limit,
+      offset,
+      tags,
+      search
+    });
+    if (response.brags.length === 0) {
+      failSpinner(spinner, "No brags found");
+      logger.log("");
+      if (search || tags) {
+        logger.info("Try adjusting your filters or run without filters to see all brags");
+      } else {
+        logger.info(`Run ${chalk8.cyan("bragduck scan")} to create your first brag!`);
+      }
+      return;
+    }
+    succeedSpinner(spinner, `Found ${response.total} brag${response.total > 1 ? "s" : ""}`);
+    logger.log("");
+    logger.log(formatBragsTable(response.brags));
+    logger.log("");
+    if (response.has_more) {
+      const nextOffset = offset + limit;
+      logger.info(
+        `Showing ${offset + 1}-${offset + response.brags.length} of ${response.total} total brags`
+      );
+      logger.info(
+        chalk8.dim(`Run `) + chalk8.cyan(`bragduck list --offset ${nextOffset}`) + chalk8.dim(` to see more`)
+      );
+      logger.log("");
+    } else if (offset > 0) {
+      logger.info(
+        `Showing ${offset + 1}-${offset + response.brags.length} of ${response.total} total brags`
+      );
+      logger.log("");
+    }
+    if (search || tags) {
+      const filterInfo = [];
+      if (search) filterInfo.push(`search: "${search}"`);
+      if (tags) filterInfo.push(`tags: ${tags.join(", ")}`);
+      logger.info(chalk8.dim(`Filters applied: ${filterInfo.join(", ")}`));
+      logger.log("");
+    }
+  } catch (error) {
+    const err = error;
+    logger.log("");
+    logger.log(
+      boxen5(formatErrorMessage(err.message, getErrorHint3(err)), {
+        padding: 1,
+        margin: 1,
+        borderStyle: "round",
+        borderColor: "red"
+      })
+    );
+    process.exit(1);
+  }
+}
+function formatBragsTable(brags) {
+  const table = new Table2({
+    head: [
+      chalk8.cyan("Date"),
+      chalk8.cyan("Title"),
+      chalk8.cyan("Description"),
+      chalk8.cyan("Tags"),
+      chalk8.cyan("Repository")
+    ],
+    colWidths: [12, 30, 40, 20, 30],
+    wordWrap: true,
+    style: {
+      head: [],
+      border: ["gray"]
+    }
+  });
+  brags.forEach((brag) => {
+    const date = new Date(brag.date).toLocaleDateString();
+    const title = brag.title;
+    const description = truncateText(brag.description, 100);
+    const tags = brag.tags.length > 0 ? brag.tags.join(", ") : chalk8.dim("none");
+    const repository = brag.repository ? truncateText(extractRepoName(brag.repository), 25) : chalk8.dim("none");
+    table.push([
+      chalk8.yellow(date),
+      chalk8.white(title),
+      chalk8.dim(description),
+      chalk8.blue(tags),
+      chalk8.gray(repository)
+    ]);
+  });
+  return table.toString();
+}
+function truncateText(text, maxLength) {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return text.substring(0, maxLength - 3) + "...";
+}
+function extractRepoName(url) {
+  try {
+    const match = url.match(/([^/]+\/[^/]+?)(\.git)?$/);
+    return match ? match[1] : url;
+  } catch {
+    return url;
+  }
+}
+function getErrorHint3(error) {
+  if (error.name === "TokenExpiredError" || error.name === "AuthenticationError") {
+    return 'Run "bragduck init" to login again';
+  }
+  if (error.name === "NetworkError") {
+    return "Check your internet connection and try again";
+  }
+  if (error.name === "ApiError") {
+    return "The server might be experiencing issues. Try again later";
+  }
+  return "Try running with DEBUG=* for more information";
+}
+
+// src/commands/config.ts
+init_esm_shims();
+init_storage_service();
+init_api_service();
+init_logger();
+init_constants();
+import boxen6 from "boxen";
+import chalk9 from "chalk";
+import Table3 from "cli-table3";
+init_errors();
+var VALID_CONFIG_KEYS = Object.values(CONFIG_KEYS);
+async function configCommand(subcommand, key, value) {
+  logger.log("");
+  try {
+    if (!subcommand) {
+      subcommand = "list";
+    }
+    switch (subcommand) {
+      case "list":
+        await handleListConfig();
+        break;
+      case "get":
+        if (!key) {
+          throw new ValidationError('Config key is required for "get" command');
+        }
+        await handleGetConfig(key);
+        break;
+      case "set":
+        if (!key || value === void 0) {
+          throw new ValidationError('Config key and value are required for "set" command');
+        }
+        await handleSetConfig(key, value);
+        break;
+      default:
+        throw new ValidationError(
+          `Invalid subcommand: "${subcommand}". Valid subcommands: list, get, set`
+        );
+    }
+  } catch (error) {
+    logger.log("");
+    logger.log(
+      boxen6(formatErrorMessage(error.message, getConfigHint(error)), {
+        padding: 1,
+        margin: 1,
+        borderStyle: "round",
+        borderColor: "red"
+      })
+    );
+    process.exit(1);
+  }
+}
+async function handleListConfig() {
+  const config2 = {
+    apiBaseUrl: storageService.getConfig("apiBaseUrl"),
+    defaultCommitDays: storageService.getConfig("defaultCommitDays"),
+    autoVersionCheck: storageService.getConfig("autoVersionCheck")
+  };
+  const table = new Table3({
+    head: [chalk9.cyan("Key"), chalk9.cyan("Value"), chalk9.cyan("Default")],
+    colWidths: [25, 40, 40],
+    wordWrap: true,
+    style: {
+      head: [],
+      border: ["gray"]
+    }
+  });
+  table.push([
+    chalk9.white("apiBaseUrl"),
+    chalk9.yellow(config2.apiBaseUrl),
+    chalk9.dim(DEFAULT_CONFIG.apiBaseUrl)
+  ]);
+  table.push([
+    chalk9.white("defaultCommitDays"),
+    chalk9.yellow(String(config2.defaultCommitDays)),
+    chalk9.dim(String(DEFAULT_CONFIG.defaultCommitDays))
+  ]);
+  table.push([
+    chalk9.white("autoVersionCheck"),
+    chalk9.yellow(String(config2.autoVersionCheck)),
+    chalk9.dim(String(DEFAULT_CONFIG.autoVersionCheck))
+  ]);
+  logger.info("Current configuration:");
+  logger.log("");
+  logger.log(table.toString());
+  logger.log("");
+  logger.info(chalk9.dim("To change a value: ") + chalk9.cyan("bragduck config set <key> <value>"));
+  logger.log("");
+}
+async function handleGetConfig(key) {
+  validateConfigKey(key);
+  const value = storageService.getConfig(key);
+  const defaultValue = DEFAULT_CONFIG[key];
+  logger.info(`Configuration for ${chalk9.cyan(key)}:`);
+  logger.log("");
+  logger.log(`  ${chalk9.white("Current:")} ${chalk9.yellow(String(value))}`);
+  logger.log(`  ${chalk9.white("Default:")} ${chalk9.dim(String(defaultValue))}`);
+  logger.log("");
+  if (value === defaultValue) {
+    logger.info(chalk9.dim("Using default value"));
+  } else {
+    logger.info(
+      chalk9.dim("Custom value set. Reset with: ") + chalk9.cyan(`bragduck config set ${key} ${defaultValue}`)
+    );
+  }
+  logger.log("");
+}
+async function handleSetConfig(key, value) {
+  validateConfigKey(key);
+  const typedValue = validateAndConvertValue(key, value);
+  storageService.setConfig(key, typedValue);
+  if (key === CONFIG_KEYS.API_BASE_URL) {
+    apiService.setBaseURL(typedValue);
+  }
+  logger.log(
+    boxen6(
+      `${chalk9.green.bold("\u2713 Configuration updated")}
+
+${chalk9.white(key)}: ${chalk9.yellow(String(typedValue))}`,
+      {
+        padding: 1,
+        margin: 1,
+        borderStyle: "round",
+        borderColor: "green"
+      }
+    )
+  );
+}
+function validateConfigKey(key) {
+  if (!VALID_CONFIG_KEYS.includes(key)) {
+    throw new ValidationError(
+      `Invalid config key: "${key}"
+
+Valid keys:
+${VALID_CONFIG_KEYS.map((k) => `  - ${k}`).join("\n")}`
+    );
+  }
+}
+function validateAndConvertValue(key, value) {
+  switch (key) {
+    case CONFIG_KEYS.API_BASE_URL:
+      if (!isValidUrl(value)) {
+        throw new ValidationError(
+          `Invalid URL format: "${value}"
+
+Example: https://api.bragduck.com`
+        );
+      }
+      return value;
+    case CONFIG_KEYS.DEFAULT_COMMIT_DAYS:
+      const days = parseInt(value, 10);
+      if (isNaN(days) || days < 1 || days > 365) {
+        throw new ValidationError(
+          `Invalid value for defaultCommitDays: "${value}"
+
+Must be a number between 1 and 365`
+        );
+      }
+      return days;
+    case CONFIG_KEYS.AUTO_VERSION_CHECK:
+      const lowerValue = value.toLowerCase();
+      if (lowerValue === "true" || lowerValue === "1" || lowerValue === "yes") {
+        return true;
+      } else if (lowerValue === "false" || lowerValue === "0" || lowerValue === "no") {
+        return false;
+      }
+      throw new ValidationError(
+        `Invalid value for autoVersionCheck: "${value}"
+
+Must be one of: true, false, yes, no, 1, 0`
+      );
+    default:
+      return value;
+  }
+}
+function isValidUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function getConfigHint(error) {
+  if (error.name === "ValidationError") {
+    return 'Run "bragduck config list" to see all available configuration keys';
+  }
+  return 'Run "bragduck config --help" for usage information';
+}
+
+// src/cli.ts
+init_version();
+init_logger();
+var __filename4 = fileURLToPath4(import.meta.url);
+var __dirname4 = dirname3(__filename4);
+var packageJsonPath = join5(__dirname4, "../../package.json");
+var packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
+var program = new Command();
+program.name("bragduck").description("CLI tool for managing developer achievements and brags").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("init").description("Authenticate with Bragduck").action(async () => {
+  try {
+    await initCommand();
+  } catch (error) {
+    console.error(error);
+    process.exit(1);
+  }
+});
+program.command("scan").description("Scan git commits and create brags").option("-d, --days <number>", "Number of days to scan", (val) => parseInt(val, 10)).option("-a, --all", "Include all commits (not just current user)").action(async (options) => {
+  try {
+    await scanCommand(options);
+  } catch (error) {
+    console.error(error);
+    process.exit(1);
+  }
+});
+program.command("list").description("List your existing brags").option("-l, --limit <number>", "Number of brags to display", (val) => parseInt(val, 10), 50).option("-o, --offset <number>", "Number of brags to skip", (val) => parseInt(val, 10), 0).option("-t, --tags <tags>", "Filter by tags (comma-separated)").option("-s, --search <query>", "Search brags by keyword").action(async (options) => {
+  try {
+    await listCommand(options);
+  } catch (error) {
+    console.error(error);
+    process.exit(1);
+  }
+});
+program.command("logout").description("Clear stored credentials").action(async () => {
+  try {
+    await logoutCommand();
+  } catch (error) {
+    console.error(error);
+    process.exit(1);
+  }
+});
+program.command("config [subcommand] [key] [value]").description("Manage CLI configuration (subcommands: list, get, set)").action(async (subcommand, key, value) => {
+  try {
+    await configCommand(subcommand, key, value);
+  } catch (error) {
+    console.error(error);
+    process.exit(1);
+  }
+});
+program.hook("preAction", async (_thisCommand) => {
+  const options = program.opts();
+  if (options.debug) {
+    process.env.DEBUG = "true";
+    logger.debug("Debug mode enabled");
+  }
+  const isVersionOrHelp = process.argv.includes("--version") || process.argv.includes("-v") || process.argv.includes("--help") || process.argv.includes("-h");
+  if (!options.skipVersionCheck && !isVersionOrHelp) {
+    try {
+      await checkForUpdates({ silent: false });
+    } catch (error) {
+      logger.debug("Version check failed, continuing...");
+    }
+  }
+});
+program.parse(process.argv);
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}
+//# sourceMappingURL=bragduck.js.map