Function collectFeatureFiles

src/lib/fetch.ts:415–514

* Collect files from feature directories

(params: {
  client: GitHubClient;
  owner: string;
  repo: string;
  basePath: string;
  ref: string;
  enabledFeatures: Feature[];
  semaphore: Semaphore;
  logger: Logger;
})

 * Collect files from feature directories
 */
async function collectFeatureFiles(params: {
  client: GitHubClient;
  owner: string;
  repo: string;
  basePath: string;
  ref: string;
  enabledFeatures: Feature[];
  semaphore: Semaphore;
  logger: Logger;
}): Promise<Array<{ remotePath: string; relativePath: string; size: number }>> {
  const { client, owner, repo, basePath, ref, enabledFeatures, semaphore, logger } = params;

  // Cache directory listing results to avoid duplicate API calls
  // File-based features (ignore, mcp, hooks) all list the same basePath directory
  const dirCache = new Map<string, Promise<GitHubFileEntry[]>>();

  async function getCachedDirectory(path: string): Promise<GitHubFileEntry[]> {
    let promise = dirCache.get(path);
    if (promise === undefined) {
      promise = withSemaphore(semaphore, () => client.listDirectory(owner, repo, path, ref));
      dirCache.set(path, promise);
    }
    return promise;
  }

  const tasks = enabledFeatures.flatMap((feature) =>
    FEATURE_PATHS[feature].map((featurePath) => ({ feature, featurePath })),
  );

  const results = await Promise.all(
    tasks.map(async ({ featurePath }) => {
      const fullPath =
        basePath === "." || basePath === "" ? featurePath : posix.join(basePath, featurePath);
      const collected: Array<{ remotePath: string; relativePath: string; size: number }> = [];

      try {
        // Check if it's a file (mcp.json, .aiignore, hooks.json)
        if (featurePath.includes(".")) {
          // Try to get the file directly
          try {
            const entries = await getCachedDirectory(
              basePath === "." || basePath === "" ? "." : basePath,
            );
            const fileEntry = entries.find((e) => e.name === featurePath && e.type === "file");
            if (fileEntry) {
              collected.push({
                remotePath: fileEntry.path,
                relativePath: featurePath,
                size: fileEntry.size,
              });
            }
          } catch (error) {
            // Only skip 404 errors (file not found), re-throw other errors
            if (isNotFoundError(error)) {
              logger.debug(`File not found: ${fullPath}`);
            } else {
              throw error;
            }