@bragduck/cli 2.24.2 → 2.27.0

package/dist/bin/bragduck.js

@@ -1689,13 +1689,13 @@ init_esm_shims();
 init_errors();
 import { existsSync as existsSync2 } from "fs";
 import { join as join4 } from "path";
-function validateGitRepository(path3) {
-  const gitDir = join4(path3, ".git");
+function validateGitRepository(path4) {
+  const gitDir = join4(path4, ".git");
   if (!existsSync2(gitDir)) {
     throw new GitError(
       "Not a git repository. Please run this command from within a git repository.",
       {
-        path: path3,
+        path: path4,
         hint: 'Run "git init" to initialize a git repository, or navigate to an existing one'
       }
     );
@@ -1912,11 +1912,11 @@ var GitHubService = class {
    * Unsets GITHUB_TOKEN and GH_TOKEN to prevent .envrc tokens from interfering
    * with gh CLI's own authentication
    */
-  async execGhCommand(command) {
+  async execGhCommand(command, cwd) {
     const env = { ...process.env };
     delete env.GITHUB_TOKEN;
     delete env.GH_TOKEN;
-    return execAsync2(command, { env });
+    return execAsync2(command, { env, cwd: cwd || process.cwd() });
   }
   /**
    * Check if GitHub CLI is installed and available
@@ -1977,12 +1977,14 @@ var GitHubService = class {
   /**
    * Validate that the current repository is hosted on GitHub
    */
-  async validateGitHubRepository() {
+  async validateGitHubRepository(repoPath) {
     try {
       await this.ensureGitHubCLI();
       await this.ensureAuthentication();
-      await gitService.validateRepository();
-      const { stdout } = await this.execGhCommand("command gh repo view --json url");
+      if (!repoPath) {
+        await gitService.validateRepository();
+      }
+      const { stdout } = await this.execGhCommand("command gh repo view --json url", repoPath);
       const data = JSON.parse(stdout);
       if (!data.url) {
         throw new GitHubError("This repository is not hosted on GitHub", {
@@ -2011,11 +2013,12 @@ var GitHubService = class {
   /**
    * Get GitHub repository information
    */
-  async getRepositoryInfo() {
+  async getRepositoryInfo(repoPath) {
     try {
       await this.ensureGitHubCLI();
       const { stdout } = await this.execGhCommand(
-        "command gh repo view --json owner,name,url,nameWithOwner"
+        "command gh repo view --json owner,name,url,nameWithOwner",
+        repoPath
       );
       const data = JSON.parse(stdout);
       return {
@@ -2037,9 +2040,9 @@ var GitHubService = class {
   /**
    * Get the current authenticated GitHub user
    */
-  async getCurrentGitHubUser() {
+  async getCurrentGitHubUser(repoPath) {
     try {
-      const { stdout } = await this.execGhCommand("command gh api user --jq .login");
+      const { stdout } = await this.execGhCommand("command gh api user --jq .login", repoPath);
       return stdout.trim() || null;
     } catch {
       logger.debug("Failed to get GitHub user");
@@ -2049,7 +2052,7 @@ var GitHubService = class {
   /**
    * Fetch merged PRs from GitHub
    */
-  async getMergedPRs(options = {}) {
+  async getMergedPRs(options = {}, repoPath) {
     const { days = 30, limit, author } = options;
     try {
       await this.ensureGitHubCLI();
@@ -2065,7 +2068,7 @@ var GitHubService = class {
       const limitArg = limit ? `--limit ${limit}` : "";
       const command = `command gh pr list --state merged --json ${this.PR_SEARCH_FIELDS} --search "${searchQuery}" ${limitArg}`;
       logger.debug(`Running: ${command}`);
-      const { stdout } = await this.execGhCommand(command);
+      const { stdout } = await this.execGhCommand(command, repoPath);
       const prs = JSON.parse(stdout);
       logger.debug(`Found ${prs.length} merged PRs`);
       return prs;
@@ -2082,17 +2085,20 @@ var GitHubService = class {
   /**
    * Get merged PRs by current user (PRs authored by the current user)
    */
-  async getPRsByCurrentUser(options = {}) {
-    const currentUser = await this.getCurrentGitHubUser();
+  async getPRsByCurrentUser(options = {}, repoPath) {
+    const currentUser = await this.getCurrentGitHubUser(repoPath);
     if (!currentUser) {
       logger.warning("Could not determine GitHub user, returning all PRs");
-      return this.getMergedPRs(options);
+      return this.getMergedPRs(options, repoPath);
     }
     logger.debug(`Filtering PRs by author: ${currentUser}`);
-    return this.getMergedPRs({
-      ...options,
-      author: currentUser
-    });
+    return this.getMergedPRs(
+      {
+        ...options,
+        author: currentUser
+      },
+      repoPath
+    );
   }
   /**
    * Transform a GitHub PR into a GitCommit structure
@@ -2659,11 +2665,10 @@ var SourceDetector = class {
   /**
    * Detect all possible sources from git remotes
    */
-  async detectSources(options = {}) {
+  async detectSources(options = {}, repoPath) {
     const detected = [];
     try {
-      const { stdout } = await execAsync3("git remote -v");
-      const remotes = this.parseRemotes(stdout);
+      const remotes = await this.parseRemotes(repoPath);
       for (const remote of remotes) {
         const source = this.parseRemoteUrl(remote.url);
         if (source) {
@@ -2728,7 +2733,16 @@ var SourceDetector = class {
   /**
    * Parse git remote -v output
    */
-  parseRemotes(output) {
+  async parseRemotes(repoPath) {
+    const { stdout } = await execAsync3("git remote -v", {
+      cwd: repoPath || process.cwd()
+    });
+    return this.parseRemotesOutput(stdout);
+  }
+  /**
+   * Parse git remote -v output string
+   */
+  parseRemotesOutput(output) {
     const lines = output.split("\n").filter(Boolean);
     const remotes = /* @__PURE__ */ new Map();
     for (const line of lines) {
@@ -2835,11 +2849,15 @@ init_esm_shims();
 init_esm_shims();
 var GitHubSyncAdapter = class {
   name = "github";
+  repoPath;
+  constructor(repoPath) {
+    this.repoPath = repoPath;
+  }
   async validate() {
-    await githubService.validateGitHubRepository();
+    await githubService.validateGitHubRepository(this.repoPath);
   }
   async getRepositoryInfo() {
-    const info = await githubService.getRepositoryInfo();
+    const info = await githubService.getRepositoryInfo(this.repoPath);
     return {
       owner: info.owner,
       name: info.name,
@@ -2848,31 +2866,54 @@ var GitHubSyncAdapter = class {
     };
   }
   async fetchWorkItems(options) {
-    let prs;
-    if (options.author) {
-      prs = await githubService.getMergedPRs({
-        days: options.days,
-        limit: options.limit,
-        author: options.author
-      });
+    const scanMode = options.scanMode || "prs";
+    if (scanMode === "commits") {
+      const gitSvc = new GitService(this.repoPath || process.cwd());
+      if (options.author) {
+        return gitSvc.getCommitsWithStats({
+          days: options.days,
+          limit: options.limit,
+          author: options.author
+        });
+      } else {
+        return gitSvc.getCommitsByCurrentUser({
+          days: options.days,
+          limit: options.limit
+        });
+      }
     } else {
-      prs = await githubService.getPRsByCurrentUser({
-        days: options.days,
-        limit: options.limit
-      });
+      let prs;
+      if (options.author) {
+        prs = await githubService.getMergedPRs(
+          {
+            days: options.days,
+            limit: options.limit,
+            author: options.author
+          },
+          this.repoPath
+        );
+      } else {
+        prs = await githubService.getPRsByCurrentUser(
+          {
+            days: options.days,
+            limit: options.limit
+          },
+          this.repoPath
+        );
+      }
+      return prs.map((pr) => githubService.transformPRToCommit(pr));
     }
-    return prs.map((pr) => githubService.transformPRToCommit(pr));
   }
   async isAuthenticated() {
     try {
-      await githubService.validateGitHubRepository();
+      await githubService.validateGitHubRepository(this.repoPath);
       return true;
     } catch {
       return false;
     }
   }
   async getCurrentUser() {
-    return githubService.getCurrentGitHubUser();
+    return githubService.getCurrentGitHubUser(this.repoPath);
   }
 };
 var githubSyncAdapter = new GitHubSyncAdapter();
@@ -3117,6 +3158,10 @@ var bitbucketService = new BitbucketService();
 // src/sync/bitbucket-adapter.ts
 var BitbucketSyncAdapter = class {
   name = "bitbucket";
+  repoPath;
+  constructor(repoPath) {
+    this.repoPath = repoPath;
+  }
   async validate() {
     await bitbucketService.validateBitbucketRepository();
   }
@@ -3130,20 +3175,37 @@ var BitbucketSyncAdapter = class {
     };
   }
   async fetchWorkItems(options) {
-    let prs;
-    if (options.author) {
-      prs = await bitbucketService.getMergedPRs({
-        days: options.days,
-        limit: options.limit,
-        author: options.author
-      });
+    const scanMode = options.scanMode || "prs";
+    if (scanMode === "commits") {
+      const gitSvc = new GitService(this.repoPath || process.cwd());
+      if (options.author) {
+        return gitSvc.getCommitsWithStats({
+          days: options.days,
+          limit: options.limit,
+          author: options.author
+        });
+      } else {
+        return gitSvc.getCommitsByCurrentUser({
+          days: options.days,
+          limit: options.limit
+        });
+      }
     } else {
-      prs = await bitbucketService.getPRsByCurrentUser({
-        days: options.days,
-        limit: options.limit
-      });
+      let prs;
+      if (options.author) {
+        prs = await bitbucketService.getMergedPRs({
+          days: options.days,
+          limit: options.limit,
+          author: options.author
+        });
+      } else {
+        prs = await bitbucketService.getPRsByCurrentUser({
+          days: options.days,
+          limit: options.limit
+        });
+      }
+      return prs.map((pr) => bitbucketService.transformPRToCommit(pr));
     }
-    return prs.map((pr) => bitbucketService.transformPRToCommit(pr));
   }
   async isAuthenticated() {
     try {
@@ -3157,7 +3219,7 @@ var BitbucketSyncAdapter = class {
     return bitbucketService.getCurrentGitHubUser();
   }
 };
-var bitbucketSyncAdapter = new BitbucketSyncAdapter();
+var bitbucketSyncAdapter = new BitbucketSyncAdapter(void 0);
 
 // src/sync/gitlab-adapter.ts
 init_esm_shims();
@@ -3410,6 +3472,10 @@ var gitlabService = new GitLabService();
 // src/sync/gitlab-adapter.ts
 var GitLabSyncAdapter = class {
   name = "gitlab";
+  repoPath;
+  constructor(repoPath) {
+    this.repoPath = repoPath;
+  }
   async validate() {
     await gitlabService.validateGitLabRepository();
   }
@@ -3423,20 +3489,37 @@ var GitLabSyncAdapter = class {
     };
   }
   async fetchWorkItems(options) {
-    let mrs;
-    if (options.author) {
-      mrs = await gitlabService.getMergedMRs({
-        days: options.days,
-        limit: options.limit,
-        author: options.author
-      });
+    const scanMode = options.scanMode || "prs";
+    if (scanMode === "commits") {
+      const gitSvc = new GitService(this.repoPath || process.cwd());
+      if (options.author) {
+        return gitSvc.getCommitsWithStats({
+          days: options.days,
+          limit: options.limit,
+          author: options.author
+        });
+      } else {
+        return gitSvc.getCommitsByCurrentUser({
+          days: options.days,
+          limit: options.limit
+        });
+      }
     } else {
-      mrs = await gitlabService.getMRsByCurrentUser({
-        days: options.days,
-        limit: options.limit
-      });
+      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));
     }
-    return mrs.map((mr) => gitlabService.transformMRToCommit(mr));
   }
   async isAuthenticated() {
     try {
@@ -3450,7 +3533,7 @@ var GitLabSyncAdapter = class {
     return gitlabService.getCurrentGitLabUser();
   }
 };
-var gitlabSyncAdapter = new GitLabSyncAdapter();
+var gitlabSyncAdapter = new GitLabSyncAdapter(void 0);
 
 // src/sync/jira-adapter.ts
 init_esm_shims();
@@ -4327,16 +4410,15 @@ var AdapterFactory = class {
   /**
    * Get adapter for a specific source type
    */
-  static getAdapter(source) {
+  static getAdapter(source, repoPath) {
     switch (source) {
       case "github":
-        return githubSyncAdapter;
+        return repoPath ? new GitHubSyncAdapter(repoPath) : githubSyncAdapter;
       case "bitbucket":
       case "atlassian":
-        return bitbucketSyncAdapter;
-      // Bitbucket Cloud and Server use same adapter
+        return repoPath ? new BitbucketSyncAdapter(repoPath) : bitbucketSyncAdapter;
       case "gitlab":
-        return gitlabSyncAdapter;
+        return repoPath ? new GitLabSyncAdapter(repoPath) : gitlabSyncAdapter;
       case "jira":
         return jiraSyncAdapter;
       case "confluence":
@@ -4641,6 +4723,35 @@ function formatErrorMessage(message, hint) {
 
 ${error}${hintText}`;
 }
+function formatMultiRepoSummary(result) {
+  const emoji = "\u{1F389}";
+  const title = colors.successBold(
+    `${emoji} Successfully synced ${result.results.length} repositor${result.results.length > 1 ? "ies" : "y"}!`
+  );
+  let repoSummaries = "";
+  for (const repoResult of result.results) {
+    const repoHeader = `
+
+${colors.highlight(repoResult.repoName)} (${colors.primary(repoResult.service)}): ${theme.count(repoResult.created)} brag${repoResult.created !== 1 ? "s" : ""} created`;
+    let bragsList = "";
+    if (repoResult.createdBrags && repoResult.createdBrags.length > 0) {
+      for (const brag of repoResult.createdBrags) {
+        const dateFormatted = formatDate(brag.date);
+        bragsList += `
+  ${colors.dim("\u2022")} ${colors.white(brag.title)} ${colors.dim(`(${dateFormatted})`)}`;
+      }
+    }
+    repoSummaries += repoHeader + bragsList;
+  }
+  const total = `
+
+${theme.secondary("Total: ")}${theme.count(result.totalCreated)} brag${result.totalCreated !== 1 ? "s" : ""} created across ${result.results.length} repositor${result.results.length > 1 ? "ies" : "y"}`;
+  const hint = theme.secondary("\n\nRun ") + theme.command("bragduck list") + theme.secondary(" to see all your brags");
+  const url = "https://bragduck.com/app/brags";
+  const clickableUrl = terminalLink(url, url, { fallback: () => colors.primary(url) });
+  const webUrl = theme.secondary("\n\nOr, check ") + clickableUrl + theme.secondary(" to see all your brags");
+  return `${title}${repoSummaries}${total}${hint}${webUrl}`;
+}
 
 // src/ui/prompts.ts
 async function promptSelectCommits(commits) {
@@ -4696,6 +4807,25 @@ async function promptDaysToScan(defaultDays = 30) {
   }
   return parseInt(selected, 10);
 }
+async function promptScanMode() {
+  const choices = [
+    {
+      name: "Pull Requests / Merge Requests (Recommended)",
+      value: "prs",
+      description: "Scan merged PRs/MRs"
+    },
+    {
+      name: "Direct Commits",
+      value: "commits",
+      description: "Scan git commits directly"
+    }
+  ];
+  return await select2({
+    message: "What would you like to scan?",
+    choices,
+    default: "prs"
+  });
+}
 async function promptSortOption() {
   const choices = [
     {
@@ -4928,6 +5058,441 @@ function failStepSpinner(spinner, currentStep, totalSteps, text) {
   spinner.fail(`${stepIndicator} ${colors.error(text)}`);
 }
 
+// src/utils/repo-scanner.ts
+init_esm_shims();
+import { promises as fs2 } from "fs";
+import path3 from "path";
+import { exec as exec6 } from "child_process";
+import { promisify as promisify6 } from "util";
+init_logger();
+var execAsync6 = promisify6(exec6);
+async function isGitRepository(dirPath) {
+  try {
+    const gitPath = path3.join(dirPath, ".git");
+    await fs2.access(gitPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function scanSubdirectories(basePath) {
+  try {
+    const entries = await fs2.readdir(basePath, { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => path3.join(basePath, entry.name));
+  } catch (error) {
+    logger.debug(`Error scanning subdirectories: ${error}`);
+    return [];
+  }
+}
+async function getRemoteUrl(repoPath) {
+  try {
+    const { stdout } = await execAsync6("command git remote -v", { cwd: repoPath });
+    const remotes = stdout.split("\n").filter(Boolean);
+    if (remotes.length === 0) {
+      return null;
+    }
+    const match = remotes[0]?.match(/^\S+\s+(\S+)\s+\(fetch\)$/);
+    return match && match[1] ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+async function discoverRepositories() {
+  const repositories = [];
+  const currentDir = process.cwd();
+  logger.debug(`Scanning for repositories in: ${currentDir}`);
+  if (await isGitRepository(currentDir)) {
+    logger.debug(`Current directory is a git repository`);
+    try {
+      const result = await sourceDetector.detectSources({}, currentDir);
+      const remoteUrl = await getRemoteUrl(currentDir);
+      if (result.detected.length > 0 && result.recommended && remoteUrl) {
+        const source = result.detected.find((s) => s.type === result.recommended);
+        if (source) {
+          repositories.push({
+            path: currentDir,
+            name: path3.basename(currentDir),
+            service: source.type,
+            remoteUrl
+          });
+          logger.debug(`Added repository: ${path3.basename(currentDir)} (${source.type})`);
+        }
+      }
+    } catch (error) {
+      logger.debug(`Error detecting sources for current directory: ${error}`);
+    }
+  } else {
+    logger.info("No repository found in current directory.");
+    logger.log("");
+    const subdirs = await scanSubdirectories(currentDir);
+    logger.info(
+      `Scanning ${subdirs.length} director${subdirs.length === 1 ? "y" : "ies"} for repositories...`
+    );
+    logger.log("");
+    logger.debug(`Subdirectories to scan: ${subdirs.map((d) => path3.basename(d)).join(", ")}`);
+    for (const subdir of subdirs) {
+      if (await isGitRepository(subdir)) {
+        try {
+          const result = await sourceDetector.detectSources({ allowInteractive: false }, subdir);
+          const remoteUrl = await getRemoteUrl(subdir);
+          if (result.detected.length > 0 && result.recommended && remoteUrl) {
+            const source = result.detected.find((s) => s.type === result.recommended);
+            if (source) {
+              repositories.push({
+                path: subdir,
+                name: path3.basename(subdir),
+                service: source.type,
+                remoteUrl
+              });
+              logger.debug(`Added repository: ${path3.basename(subdir)} (${source.type})`);
+            }
+          }
+        } catch (error) {
+          logger.debug(`Error detecting sources for ${subdir}: ${error}`);
+        }
+      }
+    }
+  }
+  logger.debug(`Found ${repositories.length} repositories`);
+  return repositories;
+}
+
+// src/sync/multi-repo-sync.ts
+init_esm_shims();
+init_api_service();
+init_auth_service();
+init_storage_service();
+init_logger();
+async function syncSingleRepository(repo, days, sortOption, scanMode, orgId, options) {
+  const TOTAL_STEPS = 5;
+  logger.debug(`Syncing repository: ${repo.name} at ${repo.path}`);
+  const adapter = AdapterFactory.getAdapter(repo.service, repo.path);
+  const repoSpinner = createStepSpinner(1, TOTAL_STEPS, "Validating repository");
+  repoSpinner.start();
+  const VALIDATION_TIMEOUT = 3e4;
+  let repoInfo;
+  try {
+    repoInfo = await Promise.race([
+      (async () => {
+        await adapter.validate();
+        return await adapter.getRepositoryInfo();
+      })(),
+      new Promise((_, reject) => {
+        setTimeout(
+          () => reject(new Error("Validation timeout after 30 seconds")),
+          VALIDATION_TIMEOUT
+        );
+      })
+    ]);
+    succeedStepSpinner(
+      repoSpinner,
+      1,
+      TOTAL_STEPS,
+      `Repository: ${theme.value(repoInfo.fullName)}`
+    );
+    logger.log("");
+  } catch (error) {
+    failStepSpinner(repoSpinner, 1, TOTAL_STEPS, "Validation failed");
+    throw error;
+  }
+  const fetchSpinner = createStepSpinner(
+    2,
+    TOTAL_STEPS,
+    `Fetching work items from the last ${days} days`
+  );
+  fetchSpinner.start();
+  const workItems = await adapter.fetchWorkItems({
+    days,
+    scanMode,
+    author: await adapter.getCurrentUser() || void 0
+  });
+  if (workItems.length === 0) {
+    failStepSpinner(fetchSpinner, 2, TOTAL_STEPS, `No work items found in the last ${days} days`);
+    logger.log("");
+    return { repoName: repo.name, service: repo.service, created: 0, skipped: 0 };
+  }
+  succeedStepSpinner(
+    fetchSpinner,
+    2,
+    TOTAL_STEPS,
+    `Found ${theme.count(workItems.length)} work item${workItems.length > 1 ? "s" : ""}`
+  );
+  logger.log("");
+  logger.log(formatCommitStats(workItems));
+  logger.log("");
+  const existingBrags = await apiService.listBrags({ limit: 100 });
+  logger.debug(`Fetched ${existingBrags.brags.length} existing brags`);
+  const existingUrls = new Set(existingBrags.brags.flatMap((b) => b.attachments || []));
+  logger.debug(`Existing URLs in attachments: ${existingUrls.size}`);
+  const duplicates = workItems.filter((c) => c.url && existingUrls.has(c.url));
+  const newWorkItems = workItems.filter((c) => !c.url || !existingUrls.has(c.url));
+  logger.debug(`Found ${duplicates.length} duplicates, ${newWorkItems.length} new items`);
+  if (duplicates.length > 0) {
+    logger.log("");
+    logger.info(
+      colors.dim(
+        `\u2139 ${duplicates.length} work item${duplicates.length > 1 ? "s" : ""} already exist in Bragduck (will be skipped)`
+      )
+    );
+    logger.log("");
+  }
+  if (newWorkItems.length === 0) {
+    logger.log("");
+    logger.info(theme.secondary("All work items already exist in Bragduck. Nothing to sync."));
+    logger.log("");
+    return { repoName: repo.name, service: repo.service, created: 0, skipped: duplicates.length };
+  }
+  let sortedCommits = [...newWorkItems];
+  if (sortOption === "date") {
+    sortedCommits.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
+  } else if (sortOption === "size") {
+    sortedCommits.sort((a, b) => {
+      const sizeA = (a.diffStats?.insertions || 0) + (a.diffStats?.deletions || 0);
+      const sizeB = (b.diffStats?.insertions || 0) + (b.diffStats?.deletions || 0);
+      return sizeB - sizeA;
+    });
+  } else if (sortOption === "files") {
+    sortedCommits.sort((a, b) => {
+      const filesA = a.diffStats?.filesChanged || 0;
+      const filesB = b.diffStats?.filesChanged || 0;
+      return filesB - filesA;
+    });
+  }
+  let selectedShas;
+  if (options.turbo) {
+    selectedShas = sortedCommits.map((c) => c.sha);
+    logger.debug(`Turbo mode: auto-selected all ${selectedShas.length} new items`);
+  } else {
+    selectedShas = await promptSelectCommits(sortedCommits);
+    if (selectedShas.length === 0) {
+      logger.log("");
+      logger.info(theme.secondary("No work items selected. Sync cancelled."));
+      logger.log("");
+      return { repoName: repo.name, service: repo.service, created: 0, skipped: duplicates.length };
+    }
+  }
+  const selectedCommits = sortedCommits.filter((c) => selectedShas.includes(c.sha));
+  logger.log(formatSelectionSummary(selectedCommits.length, selectedCommits));
+  logger.log("");
+  const refineSpinner = createStepSpinner(
+    3,
+    TOTAL_STEPS,
+    `Refining ${theme.count(selectedCommits.length)} work item${selectedCommits.length > 1 ? "s" : ""} with AI`
+  );
+  refineSpinner.start();
+  const refineRequest = {
+    brags: selectedCommits.map((c) => ({
+      text: c.message,
+      date: c.date,
+      title: c.message.split("\n")[0]
+    }))
+  };
+  const refineResponse = await apiService.refineBrags(refineRequest);
+  let refinedBrags = refineResponse.refined_brags;
+  succeedStepSpinner(refineSpinner, 3, TOTAL_STEPS, "Work items refined successfully");
+  logger.log("");
+  let acceptedBrags;
+  if (options.turbo) {
+    acceptedBrags = refinedBrags;
+    logger.debug(`Turbo mode: auto-accepted all ${acceptedBrags.length} refined brags`);
+    logger.log("");
+  } else {
+    logger.info("Preview of refined brags:");
+    logger.log("");
+    logger.log(formatRefinedCommitsTable(refinedBrags, selectedCommits));
+    logger.log("");
+    acceptedBrags = await promptReviewBrags(refinedBrags, selectedCommits);
+  }
+  if (acceptedBrags.length === 0) {
+    logger.log("");
+    logger.info(theme.secondary("No brags selected for creation. Sync cancelled."));
+    logger.log("");
+    return { repoName: repo.name, service: repo.service, created: 0, skipped: duplicates.length };
+  }
+  logger.log("");
+  const createSpinner2 = createStepSpinner(
+    4,
+    TOTAL_STEPS,
+    `Creating ${theme.count(acceptedBrags.length)} brag${acceptedBrags.length > 1 ? "s" : ""}`
+  );
+  createSpinner2.start();
+  const createRequest = {
+    brags: acceptedBrags.map((refined, index) => {
+      const originalCommit = selectedCommits[index];
+      const repoTag = repo.name;
+      const tagsWithRepo = refined.suggested_tags.includes(repoTag) ? refined.suggested_tags : [repoTag, ...refined.suggested_tags];
+      return {
+        commit_sha: originalCommit?.sha || `brag-${index}`,
+        title: refined.refined_title,
+        description: refined.refined_description,
+        tags: tagsWithRepo,
+        repository: repoInfo.url,
+        date: originalCommit?.date || (/* @__PURE__ */ new Date()).toISOString(),
+        commit_url: originalCommit?.url || "",
+        impact_score: refined.suggested_impactLevel,
+        impact_description: refined.impact_description,
+        attachments: originalCommit?.url ? [originalCommit.url] : [],
+        orgId: orgId || void 0,
+        // External fields for non-git sources
+        externalId: originalCommit?.externalId,
+        externalType: originalCommit?.externalType,
+        externalSource: originalCommit?.externalSource,
+        externalUrl: originalCommit?.externalUrl
+      };
+    })
+  };
+  const CREATE_TIMEOUT = 6e4;
+  logger.debug(`Sending ${acceptedBrags.length} brags to API for creation...`);
+  let createResponse;
+  try {
+    createResponse = await Promise.race([
+      apiService.createBrags(createRequest),
+      new Promise((_, reject) => {
+        setTimeout(
+          () => reject(new Error("Create brags timeout after 60 seconds")),
+          CREATE_TIMEOUT
+        );
+      })
+    ]);
+    logger.debug(`API response: ${createResponse.created} brags created`);
+    succeedStepSpinner(
+      createSpinner2,
+      4,
+      TOTAL_STEPS,
+      `Created ${theme.count(createResponse.created)} brag${createResponse.created > 1 ? "s" : ""}`
+    );
+    logger.log("");
+  } catch (error) {
+    failStepSpinner(createSpinner2, 4, TOTAL_STEPS, "Failed to create brags");
+    logger.log("");
+    throw error;
+  }
+  const createdBrags = createResponse.brags.map((brag, index) => ({
+    title: brag.title,
+    date: selectedCommits[index]?.date || (/* @__PURE__ */ new Date()).toISOString(),
+    source: repo.service
+  }));
+  return {
+    repoName: repo.name,
+    service: repo.service,
+    created: createResponse.created,
+    skipped: duplicates.length,
+    createdBrags
+  };
+}
+async function syncMultipleRepositories(repos, options) {
+  logger.debug(`Starting multi-repo sync for ${repos.length} repositories`);
+  let days = options.days;
+  if (!days && options.today) {
+    days = 1;
+    logger.debug("Using --today flag: scanning last 24 hours (1 day)");
+  }
+  if (!days && !options.turbo) {
+    const defaultDays = storageService.getConfig("defaultCommitDays") || 30;
+    days = await promptDaysToScan(defaultDays);
+    logger.log("");
+  }
+  if (!days && options.turbo) {
+    days = storageService.getConfig("defaultCommitDays") || 30;
+    logger.debug(`Turbo mode: using default ${days} days`);
+  }
+  if (!days) {
+    days = 30;
+  }
+  let scanMode = "prs";
+  if (!options.turbo) {
+    scanMode = await promptScanMode();
+    logger.log("");
+  } else {
+    logger.debug("Turbo mode: using default scan mode (prs)");
+  }
+  let sortOption = "date";
+  if (!options.turbo) {
+    sortOption = await promptSortOption();
+    logger.log("");
+  } else {
+    logger.debug("Turbo mode: using default sort option (date)");
+  }
+  const results = [];
+  for (let i = 0; i < repos.length; i++) {
+    const repo = repos[i];
+    if (!repo) continue;
+    const current = i + 1;
+    const total = repos.length;
+    logger.log("");
+    logger.log(colors.highlight(`\u2501\u2501\u2501 Syncing ${current}/${total}: ${repo.name} \u2501\u2501\u2501`));
+    logger.log("");
+    try {
+      let selectedOrgId = null;
+      if (!options.turbo) {
+        const userInfo = authService.getUserInfo();
+        if (userInfo?.id) {
+          try {
+            const orgsResponse = await apiService.listUserOrganisations(userInfo.id);
+            if (orgsResponse.items.length > 0) {
+              const defaultOrgId = storageService.getConfig("defaultCompany");
+              selectedOrgId = await promptSelectOrganisationWithDefault(
+                orgsResponse.items,
+                defaultOrgId
+              );
+              logger.log("");
+            }
+          } catch {
+            logger.debug("Failed to fetch organisations, skipping org selection");
+          }
+        }
+      }
+      const result = await syncSingleRepository(
+        repo,
+        days,
+        sortOption,
+        scanMode,
+        selectedOrgId,
+        options
+      );
+      results.push(result);
+      logger.log("");
+      logger.log(
+        theme.success(
+          `Completed ${repo.name}: ${result.created} created, ${result.skipped} skipped`
+        )
+      );
+    } catch (error) {
+      const err = error;
+      logger.log("");
+      logger.warning(`Failed to sync ${repo.name}: ${err.message}`);
+      results.push({
+        repoName: repo.name,
+        service: repo.service,
+        created: 0,
+        skipped: 0,
+        error: err.message
+      });
+    }
+  }
+  const totalCreated = results.reduce((sum, r) => sum + r.created, 0);
+  const totalSkipped = results.reduce((sum, r) => sum + r.skipped, 0);
+  logger.log("");
+  logger.log(colors.highlight("\u2501\u2501\u2501 Multi-Repository Sync Summary \u2501\u2501\u2501"));
+  logger.log("");
+  logger.log(`Total repositories: ${results.length}`);
+  logger.log(`Total brags created: ${totalCreated}`);
+  logger.log(`Total brags skipped: ${totalSkipped}`);
+  const failed = results.filter((r) => r.error);
+  if (failed.length > 0) {
+    logger.log("");
+    logger.log(colors.warning(`Failed repositories: ${failed.length}`));
+    for (const result of failed) {
+      logger.info(`  \u2022 ${result.repoName}: ${result.error}`);
+    }
+  }
+  return {
+    totalCreated,
+    totalSkipped,
+    results
+  };
+}
+
 // src/commands/sync.ts
 async function promptSelectService() {
   const nonGitServices = ["atlassian", "jira", "confluence"];
@@ -4945,7 +5510,7 @@ async function promptSelectService() {
   );
   const serviceChoices = [
     {
-      name: "Git Contributions (current dir)",
+      name: "Git Contributions (detect repositories)",
       value: "git",
       description: "Sync from your local repository (GitHub, GitLab, or Bitbucket)"
     }
@@ -5160,11 +5725,17 @@ async function syncSingleService(sourceType, options, TOTAL_STEPS, sharedDays, s
   const createRequest = {
     brags: acceptedBrags.map((refined, index) => {
       const originalCommit = selectedCommits[index];
+      const isGitSource = sourceType === "github" || sourceType === "gitlab" || sourceType === "bitbucket" || sourceType === "atlassian";
+      let tagsWithRepo = refined.suggested_tags;
+      if (isGitSource && repoInfo.name) {
+        const repoTag = repoInfo.name;
+        tagsWithRepo = refined.suggested_tags.includes(repoTag) ? refined.suggested_tags : [repoTag, ...refined.suggested_tags];
+      }
       return {
         commit_sha: originalCommit?.sha || `brag-${index}`,
         title: refined.refined_title,
         description: refined.refined_description,
-        tags: refined.suggested_tags,
+        tags: tagsWithRepo,
         repository: repoInfo.url,
         date: originalCommit?.date || (/* @__PURE__ */ new Date()).toISOString(),
         commit_url: originalCommit?.url || "",
@@ -5206,9 +5777,9 @@ async function syncSingleService(sourceType, options, TOTAL_STEPS, sharedDays, s
     logger.log("");
     throw error;
   }
-  const createdBrags = createResponse.brags.map((brag) => ({
+  const createdBrags = createResponse.brags.map((brag, index) => ({
     title: brag.title,
-    date: brag.date,
+    date: selectedCommits[index]?.date || (/* @__PURE__ */ new Date()).toISOString(),
     source: sourceType
   }));
   return { created: createResponse.created, skipped: duplicates.length, createdBrags };
@@ -5429,29 +6000,33 @@ async function syncCommand(options = {}) {
       const detectionSpinner = createStepSpinner(1, TOTAL_STEPS, "Preparing sync");
       detectionSpinner.start();
       if (selectedSource === "git") {
-        try {
-          const { detected } = await sourceDetector.detectSources();
-          const gitSource = detected.find(
-            (source) => ["github", "gitlab", "bitbucket", "atlassian"].includes(source.type)
-          );
-          if (!gitSource) {
-            failStepSpinner(detectionSpinner, 1, TOTAL_STEPS, "Not a git repository");
-            logger.log("");
-            logger.error("No git repository detected in current directory");
-            logger.log("");
-            logger.info("Navigate to a git repository or select a different service");
-            return;
-          }
-          sourceType = gitSource.type;
-          logger.debug(`Detected git service: ${sourceType}`);
-        } catch (error) {
-          logger.debug(`Git detection error: ${error}`);
-          failStepSpinner(detectionSpinner, 1, TOTAL_STEPS, "Failed to detect git service");
+        succeedStepSpinner(detectionSpinner, 1, TOTAL_STEPS, "Discovering repositories");
+        logger.log("");
+        const repos = await discoverRepositories();
+        if (repos.length === 0) {
+          logger.log("");
+          logger.error("\u26A0 No git repositories found");
           logger.log("");
-          logger.error("Could not detect git repository");
+          logger.info("Searched in:");
+          logger.info(`  \u2022 Current directory: ${process.cwd()}`);
+          logger.info(`  \u2022 Subdirectories (1 level): ${process.cwd()}/*`);
           logger.log("");
+          logger.info("Run from a directory containing git repositories.");
           return;
         }
+        logger.log("");
+        logger.info(`Found ${repos.length} repositor${repos.length > 1 ? "ies" : "y"}:`);
+        repos.forEach((r) => logger.info(`  \u2022 ${r.name} (${r.service})`));
+        logger.log("");
+        const result2 = await syncMultipleRepositories(repos, options);
+        if (result2.totalCreated > 0 || result2.totalSkipped > 0) {
+          logger.log("");
+          logger.log(boxen6(formatMultiRepoSummary(result2), boxStyles.success));
+        } else {
+          logger.log("");
+          logger.info("No brags created.");
+        }
+        process.exit(0);
       } else {
         sourceType = selectedSource;
       }
@@ -5822,11 +6397,13 @@ Please use ${chalk7.cyan("bragduck sync")} instead.
     const createRequest = {
       brags: acceptedBrags.map((refined, index) => {
         const originalCommit = newCommits[index];
+        const repoTag = repoInfo.name;
+        const tagsWithRepo = refined.suggested_tags.includes(repoTag) ? refined.suggested_tags : [repoTag, ...refined.suggested_tags];
         return {
           commit_sha: originalCommit?.sha || `brag-${index}`,
           title: refined.refined_title,
           description: refined.refined_description,
-          tags: refined.suggested_tags,
+          tags: tagsWithRepo,
           repository: repoInfo.url,
           date: originalCommit?.date || "",
           commit_url: originalCommit?.url || "",