@teambit/workspace 1.0.106 → 1.0.108

package/build-graph-from-fs.ts

@@ -0,0 +1,188 @@
+import mapSeries from 'p-map-series';
+import { Graph, Node, Edge } from '@teambit/graph.cleargraph';
+import { flatten } from 'lodash';
+import { Consumer } from '@teambit/legacy/dist/consumer';
+import { Component, ComponentID } from '@teambit/component';
+import { DependencyResolverMain } from '@teambit/dependency-resolver';
+import { ComponentIdList } from '@teambit/component-id';
+import { Lane } from '@teambit/legacy/dist/scope/models';
+import { ComponentNotFound, ScopeNotFound } from '@teambit/legacy/dist/scope/exceptions';
+import { ComponentNotFound as ComponentNotFoundInScope } from '@teambit/scope';
+import compact from 'lodash.compact';
+import { Logger } from '@teambit/logger';
+import { BitError } from '@teambit/bit-error';
+import { Workspace } from './workspace';
+
+export type ShouldLoadFunc = (id: ComponentID) => Promise<boolean>;
+
+export class GraphFromFsBuilder {
+  private graph = new Graph<Component, string>();
+  private completed: string[] = [];
+  private depth = 1;
+  private consumer: Consumer;
+  private importedIds: string[] = [];
+  private currentLane: Lane | null;
+  constructor(
+    private workspace: Workspace,
+    private logger: Logger,
+    private dependencyResolver: DependencyResolverMain,
+    private ignoreIds: string[] = [],
+    private shouldLoadItsDeps?: ShouldLoadFunc,
+    private shouldThrowOnMissingDep = true
+  ) {
+    this.consumer = this.workspace.consumer;
+  }
+
+  /**
+   * create a graph with all dependencies and flattened dependencies of the given components.
+   * the nodes are components and the edges has a label of the dependency type.
+   *
+   * the way how it is done is iterations by depths. each depth we gather all the dependencies of
+   * that depths, make sure all objects exist and then check their dependencies for the next depth.
+   * once there is no dependency left, we're on the last depth level and the graph is ready.
+   *
+   * for example, imagine the following graph:
+   * A1 -> A2 -> A3
+   * B1 -> B2 -> B3
+   * C1 -> C2 -> C3
+   *
+   * where the buildGraph is given [A1, B1, C1].
+   * first, it saves all these components as nodes in the graph. then, it finds the dependencies of
+   * the next level, in this case they're [A2, B2, C2]. it runs `importMany` in case some objects
+   * are missing. then, it loads them all (some from FS, some from the model) and sets the edges
+   * between the component and the dependencies.
+   * once done, it finds all their dependencies, which are [A3, B3, C3] and repeat the process
+   * above. since there are no more dependencies, the graph is completed.
+   * in this case, the total depth levels are 3.
+   *
+   * even with a huge project, there are not many depth levels. by iterating through depth levels
+   * we keep performance sane as the importMany doesn't run multiple time and therefore the round
+   * trips to the remotes are minimal.
+   *
+   * normally, one importMany of the seeders is enough as importMany knows to fetch all flattened.
+   * however, since this buildGraph is performed on the workspace, a dependency may be new or
+   * modified and as such, we don't know its flattened yet.
+   */
+  async buildGraph(ids: ComponentID[]): Promise<Graph<Component, string>> {
+    this.logger.debug(`GraphFromFsBuilder, buildGraph with ${ids.length} seeders`);
+    const start = Date.now();
+    const components = await this.loadManyComponents(ids);
+    this.currentLane = await this.workspace.consumer.getCurrentLaneObject();
+    await this.processManyComponents(components);
+    this.logger.debug(
+      `GraphFromFsBuilder, buildGraph with ${ids.length} seeders completed (${(Date.now() - start) / 1000} sec)`
+    );
+    return this.graph;
+  }
+
+  private async getAllDepsUnfiltered(component: Component): Promise<ComponentID[]> {
+    const deps = await this.dependencyResolver.getComponentDependencies(component);
+    const depsIds = deps.map((dep) => dep.componentId);
+
+    return depsIds.filter((depId) => !this.ignoreIds.includes(depId.toString()));
+  }
+
+  private async getAllDepsFiltered(component: Component): Promise<ComponentID[]> {
+    const depsWithoutIgnore = await this.getAllDepsUnfiltered(component);
+    const shouldLoadFunc = this.shouldLoadItsDeps;
+    if (!shouldLoadFunc) return depsWithoutIgnore;
+    const deps = await mapSeries(depsWithoutIgnore, async (depId) => {
+      const shouldLoad = await shouldLoadFunc(depId);
+      if (!shouldLoad) this.ignoreIds.push(depId.toString());
+      return shouldLoad ? depId : null;
+    });
+    return compact(deps);
+  }
+
+  private async processManyComponents(components: Component[]) {
+    this.logger.debug(`GraphFromFsBuilder.processManyComponents depth ${this.depth}, ${components.length} components`);
+    this.depth += 1;
+    await this.importObjects(components);
+    const allDependencies = await mapSeries(components, (component) => this.processOneComponent(component));
+    const allDependenciesFlattened = flatten(allDependencies);
+    if (allDependenciesFlattened.length) await this.processManyComponents(allDependenciesFlattened);
+  }
+
+  /**
+   * only for components from the workspace that can be modified to add/remove dependencies, we need to make sure that
+   * all their dependencies are imported.
+   * remember that `importMany` fetches all flattened dependencies. once a component from scope is imported, we know
+   * that all its flattened dependencies are there. no need to call importMany again for them.
+   */
+  private async importObjects(components: Component[]) {
+    const workspaceIds = await this.workspace.listIds();
+    const compOnWorkspaceOnly = components.filter((comp) => workspaceIds.find((id) => id.isEqual(comp.id)));
+    const allDeps = (await Promise.all(compOnWorkspaceOnly.map((c) => this.getAllDepsUnfiltered(c)))).flat();
+    const allDepsNotImported = allDeps.filter((d) => !this.importedIds.includes(d.toString()));
+    const exportedDeps = allDepsNotImported.map((id) => id).filter((dep) => this.workspace.isExported(dep));
+    const scopeComponentsImporter = this.consumer.scope.scopeImporter;
+    await scopeComponentsImporter.importMany({
+      ids: ComponentIdList.uniqFromArray(exportedDeps),
+      preferDependencyGraph: false,
+      throwForDependencyNotFound: this.shouldThrowOnMissingDep,
+      throwForSeederNotFound: this.shouldThrowOnMissingDep,
+      reFetchUnBuiltVersion: false,
+      lane: this.currentLane || undefined,
+      reason: 'for building a graph from the workspace',
+    });
+    allDepsNotImported.map((id) => this.importedIds.push(id.toString()));
+  }
+
+  private async processOneComponent(component: Component) {
+    const idStr = component.id.toString();
+    if (this.completed.includes(idStr)) return [];
+    const allIds = await this.getAllDepsFiltered(component);
+
+    const allDependenciesComps = await this.loadManyComponents(allIds, idStr);
+    const deps = await this.dependencyResolver.getComponentDependencies(component);
+    deps.forEach((dep) => {
+      const depId = dep.componentId;
+      if (this.ignoreIds.includes(depId.toString())) return;
+      if (!this.graph.hasNode(depId.toString())) {
+        if (this.shouldThrowOnMissingDep) {
+          throw new Error(`buildOneComponent: missing node of ${depId.toString()}`);
+        }
+        this.logger.warn(`ignoring missing ${depId.toString()}`);
+        return;
+      }
+      this.graph.setEdge(new Edge(idStr, depId.toString(), dep.lifecycle));
+    });
+
+    this.completed.push(idStr);
+    return allDependenciesComps;
+  }
+
+  private async loadManyComponents(componentsIds: ComponentID[], dependenciesOf?: string): Promise<Component[]> {
+    const components = await mapSeries(componentsIds, async (comp) => {
+      const idStr = comp.toString();
+      const fromGraph = this.graph.node(idStr)?.attr;
+      if (fromGraph) return fromGraph;
+      try {
+        const component = await this.workspace.get(comp);
+        this.graph.setNode(new Node(idStr, component));
+        return component;
+      } catch (err: any) {
+        if (
+          err instanceof ComponentNotFound ||
+          err instanceof ComponentNotFoundInScope ||
+          err instanceof ScopeNotFound
+        ) {
+          if (dependenciesOf && !this.shouldThrowOnMissingDep) {
+            this.logger.warn(
+              `component ${idStr}, dependency of ${dependenciesOf} was not found. continuing without it`
+            );
+            return null;
+          }
+          throw new BitError(
+            `error: component "${idStr}" was not found.\nthis component is a dependency of "${
+              dependenciesOf || '<none>'
+            }" and is needed as part of the graph generation`
+          );
+        }
+        if (dependenciesOf) this.logger.error(`failed loading dependencies of ${dependenciesOf}`);
+        throw err;
+      }
+    });
+    return compact(components);
+  }
+}

package/build-graph-ids-from-fs.ts

@@ -0,0 +1,216 @@
+import mapSeries from 'p-map-series';
+import { Graph, Node, Edge } from '@teambit/graph.cleargraph';
+import { flatten, partition } from 'lodash';
+import { Consumer } from '@teambit/legacy/dist/consumer';
+import { Component, ComponentID } from '@teambit/component';
+import ConsumerComponent from '@teambit/legacy/dist/consumer/component';
+import { ComponentIdList } from '@teambit/component-id';
+import { ComponentDependency, DependencyResolverMain } from '@teambit/dependency-resolver';
+import { CompIdGraph, DepEdgeType } from '@teambit/graph';
+import { ComponentNotFound, ScopeNotFound } from '@teambit/legacy/dist/scope/exceptions';
+import { ComponentNotFound as ComponentNotFoundInScope } from '@teambit/scope';
+import compact from 'lodash.compact';
+import { Logger } from '@teambit/logger';
+import { BitError } from '@teambit/bit-error';
+import { Workspace } from './workspace';
+
+export function lifecycleToDepType(compDep: ComponentDependency): DepEdgeType {
+  if (compDep.isExtension) return 'ext';
+  switch (compDep.lifecycle) {
+    case 'dev':
+      return 'dev';
+    case 'runtime':
+      return 'prod';
+    default:
+      throw new Error(`lifecycle ${compDep.lifecycle} is not support`);
+  }
+}
+
+export class GraphIdsFromFsBuilder {
+  private graph = new Graph<ComponentID, DepEdgeType>();
+  private completed: string[] = [];
+  private depth = 1;
+  private consumer: Consumer;
+  private loadedComponents: { [idStr: string]: Component } = {};
+  private importedIds: string[] = [];
+  private shouldThrowOnInvalidDeps = true; // for now it has the same value as shouldThrowOnMissingDep. change if needed
+  constructor(
+    private workspace: Workspace,
+    private logger: Logger,
+    private dependencyResolver: DependencyResolverMain,
+    private shouldThrowOnMissingDep = true
+  ) {
+    this.consumer = this.workspace.consumer;
+    this.shouldThrowOnInvalidDeps = this.shouldThrowOnMissingDep;
+  }
+
+  /**
+   * create a graph with all dependencies and flattened dependencies of the given components.
+   * the nodes are component-ids and the edges has a label of the dependency type.
+   * to get some info about this the graph build take a look into build-graph-from-fs.buildGraph() docs.
+   */
+  async buildGraph(ids: ComponentID[]): Promise<Graph<ComponentID, DepEdgeType>> {
+    this.logger.debug(`GraphIdsFromFsBuilder, buildGraph with ${ids.length} seeders`);
+    const start = Date.now();
+    const components = await this.loadManyComponents(ids);
+    await this.processManyComponents(components);
+    this.logger.debug(
+      `GraphIdsFromFsBuilder, buildGraph with ${ids.length} seeders completed (${(Date.now() - start) / 1000} sec)`
+    );
+    return this.graph;
+  }
+
+  private async processManyComponents(components: Component[]) {
+    this.logger.debug(
+      `GraphIdsFromFsBuilder.processManyComponents depth ${this.depth}, ${components.length} components`
+    );
+    this.depth += 1;
+    await this.importObjects(components);
+    const allDependencies = await mapSeries(components, (component) => this.processOneComponent(component));
+    const allDependenciesFlattened = flatten(allDependencies);
+    if (allDependenciesFlattened.length) await this.processManyComponents(allDependenciesFlattened);
+  }
+
+  /**
+   * only for components from the workspace that can be modified to add/remove dependencies, we need to make sure that
+   * all their dependencies are imported.
+   * once a component from scope is imported, we know that either we have its dependency graph or all flattened deps
+   */
+  private async importObjects(components: Component[]) {
+    const workspaceIds = await this.workspace.listIds();
+    const compOnWorkspaceOnly = components.filter((comp) => workspaceIds.find((id) => id.isEqual(comp.id)));
+    const notImported = compOnWorkspaceOnly.map((c) => c.id).filter((id) => !this.importedIds.includes(id.toString()));
+    const exportedDeps = notImported.filter((dep) => this.workspace.isExported(dep));
+    const scopeComponentsImporter = this.consumer.scope.scopeImporter;
+    await scopeComponentsImporter.importMany({
+      ids: ComponentIdList.uniqFromArray(exportedDeps),
+      throwForDependencyNotFound: this.shouldThrowOnMissingDep,
+      throwForSeederNotFound: this.shouldThrowOnMissingDep,
+      reFetchUnBuiltVersion: false,
+      lane: (await this.workspace.getCurrentLaneObject()) || undefined,
+      reason: 'for building graph-ids from the workspace',
+    });
+    notImported.map((id) => this.importedIds.push(id.toString()));
+  }
+
+  private async processOneComponent(component: Component) {
+    const idStr = component.id.toString();
+    if (this.completed.includes(idStr)) return [];
+    const graphFromScope = await this.workspace.getSavedGraphOfComponentIfExist(component);
+    if (graphFromScope?.edges.length) {
+      const isOnWorkspace = await this.workspace.hasId(component.id);
+      if (isOnWorkspace) {
+        const allDependenciesComps = await this.processCompFromWorkspaceWithGraph(graphFromScope, component);
+        this.completed.push(idStr);
+        return allDependenciesComps;
+      }
+      this.graph.merge([graphFromScope]);
+      this.completed.push(idStr);
+      return [];
+    }
+
+    const deps = await this.dependencyResolver.getComponentDependencies(component);
+    const allDepsIds = deps.map((d) => d.componentId);
+    const allDependenciesComps = await this.loadManyComponents(allDepsIds, idStr);
+
+    deps.forEach((dep) => this.addDepEdge(idStr, dep));
+    this.completed.push(idStr);
+
+    return allDependenciesComps;
+  }
+
+  /**
+   * this is tricky.
+   * the component is in the workspace so it can be modified. dependencies can be added/removed/updated/downgraded.
+   * we have the graph-dependencies from the last snap, so we prefer to use it whenever possible for performance reasons.
+   * if we can't use it, we have to recursively load dependencies components and get the data from there.
+   * to maximize the performance, we iterate the direct dependencies, if we find a dep with the same id in the graph,
+   * and that id is not in the workspace then ask the graph for all its successors. otherwise, if it's not there, or
+   * it's there but it's also in the workspace (which therefore can be modified), we recursively load the dep components
+   * and get its dependencies.
+   */
+  private async processCompFromWorkspaceWithGraph(
+    graphFromScope: CompIdGraph,
+    component: Component
+  ): Promise<Component[]> {
+    const deps = await this.dependencyResolver.getComponentDependencies(component);
+    const workspaceIds = await this.workspace.listIds();
+    const [depsInScopeGraph, depsNotInScopeGraph] = partition(
+      deps,
+      (dep) =>
+        graphFromScope.hasNode(dep.componentId.toString()) && !workspaceIds.find((id) => id.isEqual(dep.componentId))
+    );
+
+    const depsInScopeGraphIds = depsInScopeGraph.map((dep) => dep.componentId.toString());
+    const depsInScopeGraphIdsNotCompleted = depsInScopeGraphIds.filter((id) => !this.completed.includes(id));
+    if (depsInScopeGraphIdsNotCompleted.length) {
+      const subGraphs = graphFromScope.successorsSubgraph(depsInScopeGraphIdsNotCompleted);
+      this.graph.merge([subGraphs]);
+      this.completed.push(...depsInScopeGraphIdsNotCompleted);
+    }
+
+    const allDepsIds = depsNotInScopeGraph.map((d) => d.componentId);
+    const idStr = component.id.toString();
+    const allDependenciesComps = await this.loadManyComponents(allDepsIds, idStr);
+    deps.forEach((dep) => this.addDepEdge(idStr, dep));
+    return allDependenciesComps;
+  }
+
+  private addDepEdge(idStr: string, dep: ComponentDependency) {
+    const depId = dep.componentId;
+    if (!this.graph.hasNode(depId.toString())) {
+      if (this.shouldThrowOnMissingDep) {
+        throw new Error(`buildOneComponent: missing node of ${depId.toString()}`);
+      }
+      this.logger.warn(`ignoring missing ${depId.toString()}`);
+      return;
+    }
+    this.graph.setEdge(new Edge(idStr, depId.toString(), lifecycleToDepType(dep)));
+  }
+
+  private async loadManyComponents(componentsIds: ComponentID[], dependenciesOf?: string): Promise<Component[]> {
+    const components = await mapSeries(componentsIds, async (comp) => {
+      const idStr = comp.toString();
+      const fromCache = this.loadedComponents[idStr];
+      if (fromCache) return fromCache;
+      try {
+        const component = await this.workspace.get(comp);
+        this.loadedComponents[idStr] = component;
+        this.graph.setNode(new Node(idStr, component.id));
+        return component;
+      } catch (err: any) {
+        if (
+          err instanceof ComponentNotFound ||
+          err instanceof ComponentNotFoundInScope ||
+          err instanceof ScopeNotFound
+        ) {
+          if (dependenciesOf && !this.shouldThrowOnMissingDep) {
+            this.logger.warn(
+              `component ${idStr}, dependency of ${dependenciesOf} was not found. continuing without it`
+            );
+            return null;
+          }
+          throw new BitError(
+            `error: component "${idStr}" was not found.\nthis component is a dependency of "${
+              dependenciesOf || '<none>'
+            }" and is needed as part of the graph generation`
+          );
+        }
+        if (ConsumerComponent.isComponentInvalidByErrorType(err)) {
+          if (dependenciesOf && !this.shouldThrowOnInvalidDeps) {
+            this.logger.warn(`component ${idStr}, dependency of ${dependenciesOf} is invalid. continuing without it`);
+            return null;
+          }
+          throw new BitError(
+            `error: component "${idStr}" is invalid (${err.message}).\nthis component is a dependency of "${
+              dependenciesOf || '<none>'
+            }" and is needed as part of the graph generation`
+          );
+        }
+        if (dependenciesOf) this.logger.error(`failed loading dependencies of ${dependenciesOf}`);
+        throw err;
+      }
+    });
+    return compact(components);
+  }
+}

package/capsule.cmd.ts

@@ -0,0 +1,217 @@
+// eslint-disable-next-line max-classes-per-file
+import { Command, CommandOptions } from '@teambit/cli';
+import { CapsuleList, IsolateComponentsOptions, IsolatorMain } from '@teambit/isolator';
+import type { ScopeMain } from '@teambit/scope';
+import chalk from 'chalk';
+
+import { Workspace } from '.';
+
+type CreateOpts = {
+  baseDir?: string;
+  rootBaseDir?: string;
+  alwaysNew?: boolean;
+  seedersOnly?: boolean;
+  useHash?: boolean;
+  id: string;
+  installPackages?: boolean;
+};
+
+export class CapsuleCreateCmd implements Command {
+  name = 'create [component-id...]';
+  description = `create capsules for components`;
+  helpUrl = 'reference/build-pipeline/capsule';
+  group = 'capsules';
+  alias = '';
+  options = [
+    [
+      'b',
+      'base-dir <name>',
+      'set base dir of all capsules (hashed to create the base dir inside the root dir - host path by default)',
+    ],
+    ['r', 'root-base-dir <name>', 'set root base dir of all capsules (absolute path to use as root dir)'],
+    ['a', 'always-new', 'create new environment for capsule'],
+    ['s', 'seeders-only', 'create capsules for the seeders only (not for the entire graph)'],
+    ['i', 'id <name>', 'reuse capsule of certain name'],
+    ['', 'use-hash', 'whether to use hash function (of base dir) as capsules root dir name'],
+    ['j', 'json', 'json format'],
+    ['d', 'install-packages', 'install packages by the package-manager'],
+    ['p', 'package-manager <name>', 'npm, yarn or pnpm, default to npm'],
+  ] as CommandOptions;
+
+  constructor(private workspace: Workspace | undefined, private scope: ScopeMain, private isolator: IsolatorMain) {}
+
+  async create(
+    [componentIds = []]: [string[]],
+    { baseDir, rootBaseDir, alwaysNew = false, id, installPackages = false, seedersOnly = false, useHash }: CreateOpts
+  ): Promise<CapsuleList> {
+    // @todo: why it is not an array?
+    if (componentIds && !Array.isArray(componentIds)) componentIds = [componentIds];
+    let finalUseHash = useHash;
+    if (useHash === undefined) {
+      if (baseDir) {
+        finalUseHash = false;
+      } else {
+        finalUseHash = this.workspace
+          ? this.workspace?.shouldUseHashForCapsules()
+          : this.scope.shouldUseHashForCapsules();
+      }
+    }
+
+    const baseInstallOptions = { installPackages };
+    const additionalInstallOptions = this.workspace
+      ? {}
+      : {
+          copyPeerToRuntimeOnRoot: true,
+          useNesting: true,
+          copyPeerToRuntimeOnComponents: true,
+          installPeersFromEnvs: true,
+        };
+    const installOptions = { ...baseInstallOptions, ...additionalInstallOptions };
+
+    const capsuleOptions: IsolateComponentsOptions = {
+      baseDir,
+      rootBaseDir,
+      installOptions,
+      alwaysNew,
+      seedersOnly,
+      includeFromNestedHosts: true,
+      name: id,
+      useHash: finalUseHash,
+    };
+    const host = this.workspace || this.scope;
+    const ids = await host.resolveMultipleComponentIds(componentIds);
+    const network = await this.isolator.isolateComponents(ids, capsuleOptions);
+    const capsules = network.graphCapsules;
+    return capsules;
+  }
+
+  async report([componentIds]: [string[]], opts: CreateOpts) {
+    // @ts-ignore
+    const capsules = await this.create(componentIds, opts);
+    const capsuleOutput = capsules
+      .map((capsule) => `${chalk.bold(capsule.component.id.toString())} - ${capsule.path}`)
+      .join('\n');
+    const title = `${capsules.length} capsule(s) were created successfully`;
+    return `${chalk.green(title)}\n${capsuleOutput}`;
+  }
+
+  async json([componentIds]: [string[]], opts: CreateOpts) {
+    // @ts-ignore
+    const capsules = await this.create(componentIds, opts);
+    return capsules.map((c) => ({
+      id: c.component.id.toString(),
+      path: c.path,
+    }));
+  }
+}
+
+export class CapsuleListCmd implements Command {
+  name = 'list';
+  description = `list the capsules generated for this workspace`;
+  group = 'capsules';
+  alias = '';
+  options = [['j', 'json', 'json format']] as CommandOptions;
+
+  constructor(private isolator: IsolatorMain, private workspace: Workspace | undefined, private scope: ScopeMain) {}
+
+  async report() {
+    const { workspaceCapsulesRootDir, scopeAspectsCapsulesRootDir } = this.getCapsulesRootDirs();
+    const listWs = workspaceCapsulesRootDir ? await this.isolator.list(workspaceCapsulesRootDir) : undefined;
+    const listScope = await this.isolator.list(scopeAspectsCapsulesRootDir);
+
+    const hostPath = this.workspace ? this.workspace.path : this.scope.path;
+    const numOfWsCapsules = listWs ? listWs.capsules.length : listScope.capsules.length;
+    const hostType = this.workspace ? 'workspace' : 'scope';
+
+    const title = chalk.green(
+      `found ${chalk.cyan(numOfWsCapsules.toString())} capsule(s) for ${hostType}:  ${chalk.cyan(hostPath)}`
+    );
+    const wsLine = listWs
+      ? chalk.green(`workspace capsules root-dir:       ${chalk.cyan(workspaceCapsulesRootDir)}`)
+      : undefined;
+    const scopeLine = chalk.green(`scope's aspects capsules root-dir: ${chalk.cyan(scopeAspectsCapsulesRootDir)}`);
+    const suggestLine = chalk.green(`use --json to get the list of all capsules`);
+    const lines = [title, wsLine, scopeLine, suggestLine].filter((x) => x).join('\n');
+
+    // TODO: improve output
+    return lines;
+  }
+
+  async json() {
+    const rootDirs = this.getCapsulesRootDirs();
+    const listWs = rootDirs.workspaceCapsulesRootDir
+      ? await this.isolator.list(rootDirs.workspaceCapsulesRootDir)
+      : undefined;
+    const listScope = await this.isolator.list(rootDirs.scopeAspectsCapsulesRootDir);
+    const capsules = listWs ? listWs.capsules : [];
+    const scopeCapsules = listScope ? listScope.capsules : [];
+    return { ...rootDirs, capsules, scopeCapsules };
+  }
+
+  private getCapsulesRootDirs() {
+    return getCapsulesRootDirs(this.isolator, this.scope, this.workspace);
+  }
+}
+
+export class CapsuleDeleteCmd implements Command {
+  name = 'delete';
+  description = `delete capsules`;
+  extendedDescription = `with no args, only workspace's capsules are deleted`;
+  group = 'capsules';
+  alias = '';
+  options = [
+    ['', 'scope-aspects', 'delete scope-aspects capsules'],
+    ['a', 'all', 'delete all capsules for all workspaces and scopes'],
+  ] as CommandOptions;
+
+  constructor(private isolator: IsolatorMain, private scope: ScopeMain, private workspace?: Workspace) {}
+
+  async report(args: [], { all, scopeAspects }: { all: boolean; scopeAspects: boolean }) {
+    const capsuleBaseDirToDelete = (): string | undefined => {
+      if (all) return undefined;
+      if (scopeAspects) {
+        const { scopeAspectsCapsulesRootDir } = getCapsulesRootDirs(this.isolator, this.scope, this.workspace);
+        return scopeAspectsCapsulesRootDir;
+      }
+      return undefined;
+    };
+    const capsuleBaseDir = capsuleBaseDirToDelete();
+    const deletedDir = await this.isolator.deleteCapsules(capsuleBaseDir);
+    return chalk.green(`the following capsules dir has been deleted ${chalk.bold(deletedDir)}`);
+  }
+}
+
+export class CapsuleCmd implements Command {
+  name = 'capsule';
+  description = 'manage capsules';
+  extendedDescription = `a capsule is a directory containing the component code, isolated from the workspace.
+normally, capsules are created during the build process, the component files are copied and the packages are installed
+via the configured package-manager. the purpose is to compile/test them in isolation to make sure they will work for
+other users after publishing/exporting them.`;
+  alias = '';
+  group = 'capsules';
+  commands: Command[] = [];
+  options = [['j', 'json', 'json format']] as CommandOptions;
+
+  constructor(private isolator: IsolatorMain, private workspace: Workspace | undefined, private scope: ScopeMain) {}
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async report(args: [string]) {
+    return new CapsuleListCmd(this.isolator, this.workspace, this.scope).report();
+  }
+}
+
+function getCapsulesRootDirs(isolator, scope, workspace) {
+  const workspaceCapsulesRootDir = workspace
+    ? isolator.getCapsulesRootDir({
+        baseDir: workspace.getCapsulePath(),
+        useHash: workspace.shouldUseHashForCapsules(),
+      })
+    : undefined;
+  const scopeAspectsCapsulesRootDir = isolator.getCapsulesRootDir({
+    baseDir: scope.getAspectCapsulePath(),
+    useHash: scope.shouldUseHashForCapsules(),
+  });
+
+  return { workspaceCapsulesRootDir, scopeAspectsCapsulesRootDir };
+}

package/constants.ts

@@ -0,0 +1 @@
+export const EXT_NAME = 'teambit.workspace/workspace';