@cardstack/boxel-cli 0.3.2-unstable.57 → 0.3.2-unstable.58

package/bundled-types/host-app/commands/listing-generate-example.ts

@@ -1,92 +0,0 @@
-import { service } from '@ember/service';
-
-import { resolveAdoptsFrom } from '@cardstack/runtime-common/code-ref';
-import { realmURL } from '@cardstack/runtime-common/constants';
-
-import type { CardDef } from 'https://cardstack.com/base/card-api';
-import type * as BaseCommandModule from 'https://cardstack.com/base/command';
-
-import HostBaseCommand from '../lib/host-base-command';
-
-import { GenerateExampleCardsOneShotCommand } from './generate-example-cards';
-import GetDefaultWritableRealmCommand from './get-default-writable-realm';
-
-import type NetworkService from '../services/network';
-
-export default class ListingGenerateExampleCommand extends HostBaseCommand<
-  typeof BaseCommandModule.GenerateListingExampleInput,
-  typeof BaseCommandModule.CreateInstanceResult
-> {
-  @service declare private network: NetworkService;
-
-  static actionVerb = 'Generate Example';
-  description = 'Generate a new example card for the listing and link it.';
-
-  requireInputFields = ['listing', 'referenceExample'];
-
-  async getInputType() {
-    const commandModule = await this.loadCommandModule();
-    const { GenerateListingExampleInput } = commandModule;
-    return GenerateListingExampleInput;
-  }
-
-  protected async run(
-    input: BaseCommandModule.GenerateListingExampleInput,
-  ): Promise<BaseCommandModule.CreateInstanceResult> {
-    const listing = input.listing as CardDef | undefined;
-    if (!listing || !listing.id) {
-      throw new Error('Listing card is required and must have an id');
-    }
-
-    const referenceExample = input.referenceExample as CardDef | undefined;
-    if (!referenceExample) {
-      throw new Error('Listing must include a reference example');
-    }
-
-    const codeRef = resolveAdoptsFrom(
-      referenceExample,
-      this.network.virtualNetwork,
-    );
-    if (!codeRef) {
-      throw new Error(
-        'Unable to resolve card definition from reference example',
-      );
-    }
-
-    const { realmIdentifier: defaultWritableRealmPath } =
-      await new GetDefaultWritableRealmCommand(this.commandContext).execute();
-    const targetRealm =
-      input.realm ||
-      (referenceExample as any)[realmURL]?.href ||
-      listing[realmURL]?.href ||
-      defaultWritableRealmPath ||
-      undefined;
-
-    const generator = new GenerateExampleCardsOneShotCommand(
-      this.commandContext,
-    );
-
-    const result = await generator.execute({
-      codeRef,
-      realm: targetRealm,
-      count: 1,
-      exampleCard: referenceExample,
-    });
-    const createdExample = result.createdCard as CardDef | undefined;
-    if (!createdExample) {
-      throw new Error('Failed to create example card for listing');
-    }
-
-    this.linkListingExample(listing, createdExample);
-    return result;
-  }
-
-  private linkListingExample(listing: CardDef, exampleCard: CardDef) {
-    // TODO: autoSave should take over persisting this relationship; for now we only update the local instance.
-    const currentExamples = Array.isArray((listing as any).examples)
-      ? [...((listing as any).examples as CardDef[])]
-      : [];
-    currentExamples.push(exampleCard);
-    (listing as any).examples = currentExamples;
-  }
-}

package/bundled-types/host-app/commands/listing-install.ts

@@ -1,241 +0,0 @@
-import { service } from '@ember/service';
-
-import {
-  type ResolvedCodeRef,
-  join,
-  planModuleInstall,
-  planInstanceInstall,
-  PlanBuilder,
-  extractRelationshipIds,
-  type Relationship,
-  type RealmResourceIdentifier,
-} from '@cardstack/runtime-common';
-import { logger } from '@cardstack/runtime-common';
-import type {
-  ListingPathResolver,
-  ModuleResource,
-  LooseCardResource,
-} from '@cardstack/runtime-common';
-import type { Listing } from '@cardstack/runtime-common';
-import type { CopyInstanceMeta } from '@cardstack/runtime-common/catalog';
-import type { CopyModuleMeta } from '@cardstack/runtime-common/catalog';
-
-import type { CardDef } from 'https://cardstack.com/base/card-api';
-import type * as BaseCommandModule from 'https://cardstack.com/base/command';
-
-import HostBaseCommand from '../lib/host-base-command';
-
-import ExecuteAtomicOperationsCommand from './execute-atomic-operations';
-import FetchCardJsonCommand from './fetch-card-json';
-import GetCardCommand from './get-card';
-import ReadSourceCommand from './read-source';
-import SerializeCardCommand from './serialize-card';
-import ValidateRealmCommand from './validate-realm';
-
-import type NetworkService from '../services/network';
-
-const log = logger('catalog:install');
-
-export default class ListingInstallCommand extends HostBaseCommand<
-  typeof BaseCommandModule.ListingInstallInput,
-  typeof BaseCommandModule.ListingInstallResult
-> {
-  @service declare private network: NetworkService;
-
-  description =
-    'Install catalog listing with bringing them to code mode, and then remixing them via AI';
-
-  async getInputType() {
-    let commandModule = await this.loadCommandModule();
-    const { ListingInstallInput } = commandModule;
-    return ListingInstallInput;
-  }
-
-  requireInputFields = ['realm', 'listing'];
-
-  protected async run(
-    input: BaseCommandModule.ListingInstallInput,
-  ): Promise<BaseCommandModule.ListingInstallResult> {
-    let { realm, listing: listingInput } = input;
-
-    let { realmIdentifier } = await new ValidateRealmCommand(
-      this.commandContext,
-    ).execute({ realmIdentifier: realm });
-
-    // this is intentionally to type because base command cannot interpret Listing type from catalog
-    const listing = listingInput as Listing;
-
-    let examplesToInstall = listing.examples;
-    if (listing.examples?.length) {
-      examplesToInstall = await this.expandInstances(listing.examples);
-    }
-
-    // side-effects
-    let exampleCardId: string | undefined;
-    let selectedCodeRef: ResolvedCodeRef | undefined;
-    let skillCardId: string | undefined;
-
-    const builder = new PlanBuilder(
-      realmIdentifier,
-      listing,
-      this.network.virtualNetwork,
-    );
-
-    let vn = this.network.virtualNetwork;
-    builder
-      .addIf(listing.specs?.length > 0, (resolver: ListingPathResolver) => {
-        let r = planModuleInstall(listing.specs, resolver, vn);
-        selectedCodeRef = r.modulesCopy[0].targetCodeRef;
-        return r;
-      })
-      .addIf(examplesToInstall?.length > 0, (resolver: ListingPathResolver) => {
-        let r = planInstanceInstall(examplesToInstall, resolver, vn);
-        let firstInstance = r.instancesCopy[0];
-        exampleCardId = join(realmIdentifier, firstInstance.lid);
-        selectedCodeRef = firstInstance.targetCodeRef;
-        return r;
-      })
-      .addIf(listing.skills?.length > 0, (resolver: ListingPathResolver) => {
-        let r = planInstanceInstall(listing.skills, resolver, vn);
-        skillCardId = join(realmIdentifier, r.instancesCopy[0].lid);
-        return r;
-      });
-
-    const plan = builder.build();
-
-    let sourceOperations = await Promise.all(
-      plan.modulesToInstall.map(async (moduleMeta: CopyModuleMeta) => {
-        let { sourceModule, targetModule } = moduleMeta;
-        let { content } = await new ReadSourceCommand(
-          this.commandContext,
-        ).execute({ path: sourceModule });
-        let moduleResource: ModuleResource = {
-          type: 'source',
-          attributes: { content },
-          meta: {},
-        };
-        let href = targetModule + '.gts';
-        return { op: 'add' as const, href, data: moduleResource };
-      }),
-    );
-
-    let instanceOperations = await Promise.all(
-      plan.instancesCopy.map(async (copyInstanceMeta: CopyInstanceMeta) => {
-        let { sourceCard } = copyInstanceMeta;
-        let { document: doc } = await new FetchCardJsonCommand(
-          this.commandContext,
-        ).execute({ cardIdentifier: sourceCard.id });
-        if (!doc || !('data' in doc)) {
-          throw new Error('We are only expecting single documents returned');
-        }
-        delete (doc as any).data.id;
-        delete (doc as any).included;
-        let cardResource: LooseCardResource = (doc as any)
-          .data as LooseCardResource;
-        let href = join(realmIdentifier, copyInstanceMeta.lid) + '.json';
-        return { op: 'add' as const, href, data: cardResource };
-      }),
-    );
-
-    const operations = [...sourceOperations, ...instanceOperations];
-
-    let atomicResults;
-    try {
-      ({ results: atomicResults } = await new ExecuteAtomicOperationsCommand(
-        this.commandContext,
-      ).execute({ realmIdentifier, operations }));
-    } catch (e: any) {
-      if (
-        typeof e?.message === 'string' &&
-        e.message.includes('filter refers to a nonexistent type')
-      ) {
-        throw new Error(
-          'Please click "Update Specs" on the listing and make sure all specs are linked.',
-        );
-      }
-      throw e;
-    }
-
-    let writtenFiles = (atomicResults as Array<Record<string, any>>)
-      .map((r) => r.data?.id)
-      .filter(Boolean);
-    log.debug('=== Final Results ===');
-    log.debug(JSON.stringify(writtenFiles, null, 2));
-
-    let commandModule = await this.loadCommandModule();
-    const { ListingInstallResult } = commandModule;
-    return new ListingInstallResult({
-      selectedCodeRef,
-      exampleCardId,
-      skillCardId,
-    });
-  }
-
-  // Walk relationships by fetching linked cards and enqueueing their ids.
-  private async expandInstances(instances: CardDef[]): Promise<CardDef[]> {
-    let instancesById = new Map<RealmResourceIdentifier, CardDef>();
-    let visited = new Set<RealmResourceIdentifier>();
-    let queue: RealmResourceIdentifier[] = instances
-      .map((instance) => instance.id)
-      .filter((id): id is RealmResourceIdentifier => typeof id === 'string');
-
-    // - Queue of ids to traverse; visited prevents duplicate relationship ids.
-    // - Each loop extracts relationship ids and enqueues them, so we descend
-    //   through the relationship graph breadth-first.
-    while (queue.length > 0) {
-      let id = queue.shift();
-      if (!id || visited.has(id)) {
-        continue;
-      }
-      visited.add(id);
-
-      let instance = (await new GetCardCommand(this.commandContext).execute({
-        cardId: id,
-      })) as CardDef;
-      instancesById.set(instance.id ?? id, instance);
-
-      let { json: serialized } = await new SerializeCardCommand(
-        this.commandContext,
-      ).execute({ cardId: id });
-      let baseUrl: string = (serialized as any)?.data?.id ?? id;
-      let relationships: Record<string, Relationship | Relationship[]> =
-        (serialized as any)?.data?.relationships ?? {};
-
-      let entries = Object.entries(relationships);
-      log.debug(`Relationships for ${id}:`);
-      if (entries.length === 0) {
-        log.debug('[]');
-        continue;
-      }
-      let summary = entries.map(([field, rel]) => {
-        let rels = Array.isArray(rel) ? rel : [rel];
-        return {
-          field,
-          relationships: rels.map((relationship) => ({
-            links: relationship.links ?? null,
-            data: relationship.data ?? null,
-          })),
-        };
-      });
-      log.debug(JSON.stringify(summary, null, 2));
-
-      for (let rel of Object.values(relationships)) {
-        let rels = Array.isArray(rel) ? rel : [rel];
-        for (let relationship of rels) {
-          let relatedIds = extractRelationshipIds(
-            relationship,
-            baseUrl,
-            this.network.virtualNetwork,
-          );
-          for (let relatedId of relatedIds) {
-            if (!visited.has(relatedId)) {
-              queue.push(relatedId);
-            }
-          }
-        }
-      }
-    }
-
-    return [...instancesById.values()];
-  }
-}

package/bundled-types/host-app/commands/listing-remix.ts

@@ -1,149 +0,0 @@
-import {
-  isResolvedCodeRef,
-  type ResolvedCodeRef,
-} from '@cardstack/runtime-common';
-import type { Listing } from '@cardstack/runtime-common';
-import { DEFAULT_CODING_LLM } from '@cardstack/runtime-common/matrix-constants';
-
-import type * as BaseCommandModule from 'https://cardstack.com/base/command';
-
-import HostBaseCommand from '../lib/host-base-command';
-
-import { skillCardURL, devSkillId, envSkillId } from '../lib/utils';
-
-import UseAiAssistantCommand from './ai-assistant';
-import ListingInstallCommand from './listing-install';
-import PersistModuleInspectorViewCommand from './persist-module-inspector-view';
-import SwitchSubmodeCommand from './switch-submode';
-import UpdateCodePathWithSelectionCommand from './update-code-path-with-selection';
-import UpdatePlaygroundSelectionCommand from './update-playground-selection';
-import ValidateRealmCommand from './validate-realm';
-
-export default class RemixCommand extends HostBaseCommand<
-  typeof BaseCommandModule.ListingInstallInput
-> {
-  static actionVerb = 'Remix';
-
-  description =
-    'Install catalog listing with bringing them to code mode, and then remixing them via AI';
-
-  async getInputType() {
-    let commandModule = await this.loadCommandModule();
-    const { ListingInstallInput } = commandModule;
-    return ListingInstallInput;
-  }
-
-  requireInputFields = ['realm', 'listing'];
-
-  private isThemeListing(listing: Listing): boolean {
-    return listing?.constructor?.name === 'ThemeListing';
-  }
-
-  private async navigateView(options: {
-    listing: Listing;
-    selectedCodeRef?: ResolvedCodeRef;
-    exampleCardId?: string;
-    skillCardId?: string;
-  }) {
-    const { listing, selectedCodeRef, exampleCardId, skillCardId } = options;
-
-    if (this.isThemeListing(listing)) {
-      if (exampleCardId) {
-        await new SwitchSubmodeCommand(this.commandContext).execute({
-          submode: 'code',
-          codePath: `${exampleCardId}.json`,
-        });
-      }
-      return;
-    }
-
-    if (selectedCodeRef && isResolvedCodeRef(selectedCodeRef)) {
-      const codePath = selectedCodeRef.module;
-
-      if (exampleCardId) {
-        const moduleId = [selectedCodeRef.module, selectedCodeRef.name].join(
-          '/',
-        );
-        await new UpdatePlaygroundSelectionCommand(this.commandContext).execute(
-          {
-            moduleId: moduleId,
-            cardId: exampleCardId,
-            format: 'isolated',
-            fieldIndex: undefined,
-          },
-        );
-
-        await new PersistModuleInspectorViewCommand(
-          this.commandContext,
-        ).execute({
-          codePath: codePath + '.gts',
-          moduleInspectorView: 'preview',
-        });
-      }
-
-      await new UpdateCodePathWithSelectionCommand(this.commandContext).execute(
-        {
-          codeRef: selectedCodeRef,
-          localName: selectedCodeRef.name,
-          fieldName: undefined,
-        },
-      );
-      await new SwitchSubmodeCommand(this.commandContext).execute({
-        submode: 'code',
-        codePath: selectedCodeRef.module,
-      });
-    } else if ('skills' in listing) {
-      // A listing can have more than one skill
-      // The most optimum way for remixing is still to display only the first instance
-      if (skillCardId) {
-        await new SwitchSubmodeCommand(this.commandContext).execute({
-          submode: 'code',
-          codePath: skillCardId,
-        });
-      }
-    }
-  }
-
-  protected async run(
-    input: BaseCommandModule.ListingInstallInput,
-  ): Promise<undefined> {
-    let { realm, listing: listingInput } = input;
-    let { realmIdentifier } = await new ValidateRealmCommand(
-      this.commandContext,
-    ).execute({ realmIdentifier: realm });
-
-    // this is intentionally to type because base command cannot interpret Listing type from catalog
-    const listing = listingInput as Listing;
-
-    const { selectedCodeRef, exampleCardId, skillCardId } =
-      await new ListingInstallCommand(this.commandContext).execute({
-        realm: realmIdentifier,
-        listing,
-      });
-    await this.navigateView({
-      listing,
-      selectedCodeRef,
-      exampleCardId,
-      skillCardId,
-    });
-
-    let prompt =
-      'Remix done! Please suggest two example prompts on how to edit this card.';
-
-    const skillCardIds = [
-      devSkillId,
-      envSkillId,
-      skillCardURL('source-code-editing'),
-      skillCardURL('catalog-listing'),
-    ];
-    await new UseAiAssistantCommand(this.commandContext).execute({
-      roomId: 'new',
-      prompt,
-      openRoom: true,
-      roomName: `Remixing ${listing.name ?? 'Listing'}  `,
-      attachedCards: [listing],
-      skillCardIds,
-      llmModel: DEFAULT_CODING_LLM,
-    });
-  }
-}

package/bundled-types/host-app/commands/listing-update-specs.ts

@@ -1,116 +0,0 @@
-import { isCardInstance, SupportedMimeType } from '@cardstack/runtime-common';
-
-import { realmURL as realmURLSymbol } from '@cardstack/runtime-common';
-
-import type * as BaseCommandModule from 'https://cardstack.com/base/command';
-import type { Spec } from 'https://cardstack.com/base/spec';
-
-import HostBaseCommand from '../lib/host-base-command';
-
-import AuthedFetchCommand from './authed-fetch';
-import CreateSpecCommand from './create-specs';
-import SanitizeModuleListCommand from './sanitize-module-list';
-
-export default class ListingUpdateSpecsCommand extends HostBaseCommand<
-  typeof BaseCommandModule.ListingUpdateSpecsInput,
-  typeof BaseCommandModule.ListingUpdateSpecsResult
-> {
-  static actionVerb = 'Update';
-  description = 'Update listing specs based on example dependencies';
-  requireInputFields = ['listing'];
-
-  async getInputType() {
-    const commandModule = await this.loadCommandModule();
-    let { ListingUpdateSpecsInput } = commandModule;
-    return ListingUpdateSpecsInput;
-  }
-
-  private async sanitizeDeps(deps: string[]): Promise<string[]> {
-    const { moduleIdentifiers } = await new SanitizeModuleListCommand(
-      this.commandContext,
-    ).execute({ moduleIdentifiers: deps });
-    return moduleIdentifiers;
-  }
-
-  protected async run(
-    input: BaseCommandModule.ListingUpdateSpecsInput,
-  ): Promise<BaseCommandModule.ListingUpdateSpecsResult> {
-    const listing = input.listing;
-    if (!listing) {
-      throw new Error('listing is required');
-    }
-    if (!isCardInstance(listing)) {
-      throw new Error('listing must be a valid card instance');
-    }
-
-    const targetRealm = (listing as any)?.[realmURLSymbol]?.href;
-
-    if (!targetRealm) {
-      throw new Error('targetRealm is required to update specs');
-    }
-
-    const exampleId = (listing as any).examples?.[0]?.id;
-    if (!exampleId) {
-      throw new Error('No example found in listing to derive specs from');
-    }
-
-    const { ok, body: jsonApiResponse } = await new AuthedFetchCommand(
-      this.commandContext,
-    ).execute({
-      url: `${targetRealm}_dependencies?url=${encodeURIComponent(exampleId)}`,
-      acceptHeader: SupportedMimeType.JSONAPI,
-    });
-    if (!ok) {
-      throw new Error('Failed to fetch dependencies for listing');
-    }
-
-    // Extract dependencies from all entries in the JSONAPI response
-    const deps: string[] = [];
-    const responseData = (
-      jsonApiResponse as {
-        data?: Array<{ attributes?: { dependencies?: string[] } }>;
-      }
-    ).data;
-    if (responseData && Array.isArray(responseData)) {
-      for (const entry of responseData) {
-        if (
-          entry.attributes?.dependencies &&
-          Array.isArray(entry.attributes.dependencies)
-        ) {
-          deps.push(...entry.attributes.dependencies);
-        }
-      }
-    }
-
-    const sanitizedDeps = await this.sanitizeDeps(deps);
-    const commandModule = await this.loadCommandModule();
-    if (!sanitizedDeps.length) {
-      (listing as any).specs = [];
-      return new commandModule.ListingUpdateSpecsResult({
-        listing,
-        specs: [],
-      });
-    }
-
-    const createSpecCommand = new CreateSpecCommand(this.commandContext);
-    const specResults = await Promise.all(
-      sanitizedDeps.map((dep) =>
-        createSpecCommand
-          .execute({ module: dep, targetRealm, autoGenerateReadme: true })
-          .catch((e) => {
-            console.warn('Failed to create spec(s) for', dep, e);
-            return undefined;
-          }),
-      ),
-    );
-
-    const specs: Spec[] = [];
-    for (const res of specResults) {
-      if (res?.specs) {
-        specs.push(...res.specs);
-      }
-    }
-    (listing as any).specs = specs;
-    return new commandModule.ListingUpdateSpecsResult({ listing, specs });
-  }
-}

package/bundled-types/host-app/commands/listing-use.ts

@@ -1,108 +0,0 @@
-import { service } from '@ember/service';
-
-import {
-  codeRefWithAbsoluteIdentifier,
-  isResolvedCodeRef,
-  loadCardDef,
-  generateInstallFolderName,
-  rri,
-} from '@cardstack/runtime-common';
-
-import type { Listing } from '@cardstack/runtime-common';
-
-import type * as CardAPI from 'https://cardstack.com/base/card-api';
-import type * as BaseCommandModule from 'https://cardstack.com/base/command';
-
-import type { Skill } from 'https://cardstack.com/base/skill';
-
-import HostBaseCommand from '../lib/host-base-command';
-
-import CopyCardToRealmCommand from './copy-card';
-import SaveCardCommand from './save-card';
-import ValidateRealmCommand from './validate-realm';
-
-import type NetworkService from '../services/network';
-
-export default class ListingUseCommand extends HostBaseCommand<
-  typeof BaseCommandModule.ListingInstallInput
-> {
-  @service declare private network: NetworkService;
-
-  description = 'Catalog listing use command';
-
-  async getInputType() {
-    let commandModule = await this.loadCommandModule();
-    const { ListingInstallInput } = commandModule;
-    return ListingInstallInput;
-  }
-
-  requireInputFields = ['realm', 'listing'];
-
-  protected async run(
-    input: BaseCommandModule.ListingInstallInput,
-  ): Promise<undefined> {
-    let { realm, listing: listingInput } = input;
-
-    const listing = listingInput as Listing;
-
-    let { realmIdentifier } = await new ValidateRealmCommand(
-      this.commandContext,
-    ).execute({ realmIdentifier: realm });
-
-    const specsToCopy = listing.specs ?? [];
-    const specsWithoutFields = specsToCopy.filter(
-      (spec) => spec.specType !== 'field',
-    );
-
-    const localDir = generateInstallFolderName(listing.name);
-
-    for (const spec of specsWithoutFields) {
-      if (spec.isComponent) {
-        return;
-      }
-      let ref = codeRefWithAbsoluteIdentifier(
-        spec.ref,
-        rri(spec.id),
-        undefined,
-        this.network.virtualNetwork,
-      );
-      if (!isResolvedCodeRef(ref)) {
-        throw new Error('ref is not a resolved code ref');
-      }
-      let Klass = await loadCardDef(ref, {
-        loader: this.loaderService.loader,
-      });
-      let card = new Klass({}) as CardAPI.CardDef;
-      await new SaveCardCommand(this.commandContext).execute({
-        card,
-        realm: realmIdentifier,
-        localDir,
-      });
-    }
-
-    if (listing.examples) {
-      const sourceCards = (listing.examples as CardAPI.CardDef[]).map(
-        (example) => example,
-      );
-      for (const card of sourceCards) {
-        await new CopyCardToRealmCommand(this.commandContext).execute({
-          sourceCard: card,
-          targetRealm: realmIdentifier,
-          localDir,
-        });
-      }
-    }
-
-    if ('skills' in listing && Array.isArray(listing.skills)) {
-      await Promise.all(
-        listing.skills.map((skill: Skill) =>
-          new CopyCardToRealmCommand(this.commandContext).execute({
-            sourceCard: skill,
-            targetRealm: realmIdentifier,
-            localDir,
-          }),
-        ),
-      );
-    }
-  }
-}