Function listProjectDescriptors

src/index.ts:357–411

()

}

function listProjectDescriptors(): ProjectDescriptor[] {
  const rootPaths = new Map<string, string>();
  for (const rootPath of getKnownRootPaths()) {
    rootPaths.set(normalizeRootKey(rootPath), rootPath);
  }
  for (const [projectKey, rootPath] of discoveredProjectPaths.entries()) {
    rootPaths.set(projectKey, rootPath);
  }
  for (const project of getAllProjects()) {
    rootPaths.set(normalizeRootKey(project.rootPath), project.rootPath);
  }

  const descriptors = Array.from(rootPaths.values())
    .map((rootPath) => buildProjectDescriptor(rootPath))
    .sort((a, b) => {
      if (a.active !== b.active) return a.active ? -1 : 1;
      if (a.source !== b.source) {
        const weight: Record<ProjectDescriptor['source'], number> = {
          root: 0,
          subdirectory: 1,
          ad_hoc: 2
        };
        return weight[a.source] - weight[b.source];
      }
      return a.label.localeCompare(b.label);
    });

  const duplicates = new Set<string>();
  const counts = new Map<string, number>();
  for (const descriptor of descriptors) {
    counts.set(descriptor.label, (counts.get(descriptor.label) ?? 0) + 1);
  }
  for (const [label, count] of counts.entries()) {
    if (count > 1) {
      duplicates.add(label);
    }
  }

  return descriptors.map((descriptor) => {
    if (!duplicates.has(descriptor.label)) {
      return descriptor;
    }

    const containingRoot = getContainingKnownRoot(descriptor.rootPath);
    const rootHint =
      (containingRoot && getKnownRootLabel(containingRoot)) ||
      (containingRoot && path.basename(containingRoot)) ||
      path.basename(descriptor.rootPath);

    return {
      ...descriptor,
      label: `${descriptor.label} (${rootHint})`
    };
  });
}

function getActiveProjectDescriptor(): ProjectDescriptor | undefined {
  if (!activeProjectKey) return undefined;