Function initialSync

src/lib/utils.ts:278–487

(
  store: Store,
  fileSystem: FileSystem,
  storeId: string,
  repoRoot: string,
  dryRun?: boolean,
  onProgress?: (info: InitialSyncProgress) => void,
  config?: MgrepConfig,
)

}

export async function initialSync(
  store: Store,
  fileSystem: FileSystem,
  storeId: string,
  repoRoot: string,
  dryRun?: boolean,
  onProgress?: (info: InitialSyncProgress) => void,
  config?: MgrepConfig,
): Promise<InitialSyncResult> {
  const storeMetadata = await listStoreFileMetadata(store, storeId, repoRoot);
  const allFiles = Array.from(fileSystem.getFiles(repoRoot));
  const repoFiles = allFiles.filter(
    (filePath) => !fileSystem.isIgnored(filePath, repoRoot),
  );

  const repoFileSet = new Set(repoFiles);

  const filesToDelete = Array.from(storeMetadata.keys()).filter(
    (filePath) => isSubpath(repoRoot, filePath) && !repoFileSet.has(filePath),
  );

  // Check files that potentially need uploading (new or modified)
  const filesToPotentiallyUpload = repoFiles.filter((filePath) => {
    if (config && exceedsMaxFileSize(filePath, config.maxFileSize)) {
      return false;
    }
    const stored = storeMetadata.get(filePath);
    // If not in store, it needs uploading
    if (!stored) {
      return true;
    }
    // If no mtime stored, we need to check (conservative)
    if (!stored.mtime) {
      return true;
    }
    // Check mtime to see if file might have changed
    try {
      const stat = fs.statSync(filePath);
      return stat.mtimeMs > stored.mtime;
    } catch {
      return true;
    }
  });

  const filesToSync = filesToPotentiallyUpload.length + filesToDelete.length;
  if (config && filesToSync > config.maxFileCount) {
    throw new MaxFileCountExceededError(filesToSync, config.maxFileCount);
  }

  const total = repoFiles.length + filesToDelete.length;
  let processed = 0;
  let uploaded = 0;
  let deleted = 0;
  let errors = 0;
  let quotaExceeded = false;
  let quotaErrorMessage = "";

  const concurrency = 100;