@cardstack/boxel-cli 0.2.0-unstable.448 → 0.3.0-unstable.13

package/bundled-types/host-app/commands/patch-code.ts

@@ -0,0 +1,243 @@
+import { service } from '@ember/service';
+
+import { hasExecutableExtension, rri } from '@cardstack/runtime-common';
+
+import type * as BaseCommandModule from 'https://cardstack.com/base/command';
+
+import HostBaseCommand from '../lib/host-base-command';
+import { parseSearchReplace } from '../lib/search-replace-block-parsing';
+import { isReady } from '../resources/file';
+
+import { findNonConflictingFilename } from '../utils/file-name';
+
+import ApplySearchReplaceBlockCommand from './apply-search-replace-block';
+import LintAndFixCommand from './lint-and-fix';
+
+import type CardService from '../services/card-service';
+import type CommandService from '../services/command-service';
+import type MonacoService from '../services/monaco-service';
+import type OperatorModeStateService from '../services/operator-mode-state-service';
+import type RealmService from '../services/realm';
+
+interface FileInfo {
+  exists: boolean;
+  hasContent: boolean;
+  content: string;
+}
+
+export default class PatchCodeCommand extends HostBaseCommand<
+  typeof BaseCommandModule.PatchCodeInput,
+  typeof BaseCommandModule.PatchCodeCommandResult
+> {
+  @service declare private cardService: CardService;
+  @service declare private realm: RealmService;
+  @service declare private monacoService: MonacoService;
+  @service declare private operatorModeStateService: OperatorModeStateService;
+  @service declare private commandService: CommandService;
+
+  description = `Apply code changes to file and then apply lint fixes`;
+  static actionVerb = 'Apply';
+
+  async getInputType() {
+    let commandModule = await this.loadCommandModule();
+    const { PatchCodeInput } = commandModule;
+    return PatchCodeInput;
+  }
+
+  requireInputFields = ['fileIdentifier', 'codeBlocks'];
+
+  protected async run(
+    input: BaseCommandModule.PatchCodeInput,
+  ): Promise<BaseCommandModule.PatchCodeCommandResult> {
+    let { fileIdentifier: fileUrl, codeBlocks, roomId } = input;
+
+    let fileInfo = await this.getFileInfo(fileUrl);
+    let hasEmptySearchPortion = this.hasEmptySearchPortion(codeBlocks);
+    let sourceContent = hasEmptySearchPortion ? '' : fileInfo.content;
+    let { patchedCode, results } = await this.applyCodeBlocks(
+      sourceContent,
+      codeBlocks,
+    );
+    let finalFileIdentifier = fileUrl;
+    let lintIssues: string[] = [];
+    if (results.some((r) => r.status === 'applied')) {
+      if (patchedCode.trim() !== '' && this.isLintableFile(fileUrl)) {
+        let lintResult = await this.lintAndFix(fileUrl, patchedCode);
+        patchedCode = lintResult.output;
+        lintIssues = lintResult.lintIssues ?? [];
+      }
+
+      finalFileIdentifier = await this.determineFinalFileUrl(
+        fileUrl,
+        fileInfo,
+        hasEmptySearchPortion,
+      );
+
+      let clientRequestId = this.commandService.trackAiAssistantCardRequest({
+        action: 'patch-code',
+        roomId,
+        fileUrl: finalFileIdentifier,
+      });
+
+      let savedThroughOpenFile = await this.trySaveThroughOpenFile(
+        finalFileIdentifier,
+        patchedCode,
+        clientRequestId,
+      );
+      if (!savedThroughOpenFile) {
+        this.cardService
+          .saveSource(new URL(finalFileIdentifier), patchedCode, 'bot-patch', {
+            resetLoader: hasExecutableExtension(finalFileIdentifier),
+            clientRequestId,
+          })
+          .catch((error: unknown) => {
+            console.error('PatchCodeCommand: failed to save source', error);
+          });
+      }
+    }
+
+    let commandModule = await this.loadCommandModule();
+    const { PatchCodeCommandResult, PatchCodeResultField } = commandModule;
+
+    return new PatchCodeCommandResult({
+      patchedContent: patchedCode,
+      finalFileIdentifier,
+      lintIssues,
+      results: results.map((result) => {
+        return new PatchCodeResultField({
+          status: result.status,
+          failureReason: result.failureReason,
+        });
+      }),
+    });
+  }
+
+  private async trySaveThroughOpenFile(
+    targetFileUrl: string,
+    content: string,
+    clientRequestId?: string,
+  ): Promise<boolean> {
+    try {
+      let openFileResource = this.operatorModeStateService.openFile?.current;
+      if (!isReady(openFileResource)) {
+        return false;
+      }
+      let normalizedOpenUrl = new URL(openFileResource.url).href;
+      let normalizedTarget = new URL(targetFileUrl).href;
+      if (normalizedOpenUrl !== normalizedTarget) {
+        return false;
+      }
+      void openFileResource
+        .write(content, {
+          flushLoader: hasExecutableExtension(targetFileUrl),
+          saveType: 'bot-patch',
+          clientRequestId,
+        })
+        .catch((error: unknown) => {
+          console.error(
+            'PatchCodeCommand: failed to write through FileResource',
+            error,
+          );
+        });
+      return true;
+    } catch (error) {
+      console.error(
+        'PatchCodeCommand: unable to save through FileResource',
+        error,
+      );
+      return false;
+    }
+  }
+
+  private async getFileInfo(fileUrl: string): Promise<FileInfo> {
+    let getSourceResult = await this.cardService.getSource(rri(fileUrl));
+    let exists = getSourceResult.status !== 404;
+    let content = exists ? getSourceResult.content : '';
+    let hasContent = exists && content.trim() !== '';
+
+    return { exists, hasContent, content };
+  }
+
+  private hasEmptySearchPortion(codeBlocks: string[]): boolean {
+    if (codeBlocks.length !== 1) {
+      return false;
+    }
+
+    let searchReplaceBlock = codeBlocks[0];
+    let { searchContent } = parseSearchReplace(searchReplaceBlock);
+    return searchContent.trim() === '';
+  }
+
+  private async applyCodeBlocks(
+    initialContent: string,
+    codeBlocks: string[],
+  ): Promise<{
+    patchedCode: string;
+    results: { status: 'applied' | 'failed'; failureReason?: string }[];
+  }> {
+    let applyCommand = new ApplySearchReplaceBlockCommand(this.commandContext);
+    let content = initialContent;
+    let results: { status: 'applied' | 'failed'; failureReason?: string }[] =
+      [];
+    for (let codeBlock of codeBlocks) {
+      try {
+        let { resultContent } = await applyCommand.execute({
+          fileContent: content,
+          codeBlock: codeBlock,
+        });
+        content = resultContent;
+        results.push({ status: 'applied' });
+      } catch (error) {
+        results.push({
+          status: 'failed',
+          failureReason: error instanceof Error ? error.message : String(error),
+        });
+        continue;
+      }
+    }
+
+    return { patchedCode: content, results };
+  }
+
+  private async lintAndFix(
+    fileUrl: string,
+    content: string,
+  ): Promise<BaseCommandModule.LintAndFixResult> {
+    let lintCommand = new LintAndFixCommand(this.commandContext);
+    let realmURL = this.realm.url(fileUrl);
+    let filename = new URL(fileUrl).pathname.split('/').pop() || 'input.gts';
+
+    return await lintCommand.execute({
+      realm: realmURL,
+      fileContent: content,
+      filename: filename,
+    });
+  }
+
+  private isLintableFile(fileUrl: string): boolean {
+    try {
+      return /\.(gts|ts)$/.test(new URL(fileUrl).pathname);
+    } catch {
+      return /\.(gts|ts)$/.test(fileUrl);
+    }
+  }
+
+  private async determineFinalFileUrl(
+    originalUrl: string,
+    fileInfo: FileInfo,
+    hasEmptySearchPortion: boolean,
+  ): Promise<string> {
+    if (!hasEmptySearchPortion || !fileInfo.exists || !fileInfo.hasContent) {
+      return originalUrl;
+    }
+
+    return await findNonConflictingFilename(originalUrl, (candidateUrl) =>
+      this.fileExists(candidateUrl),
+    );
+  }
+
+  private async fileExists(fileUrl: string): Promise<boolean> {
+    let getSourceResult = await this.cardService.getSource(rri(fileUrl));
+    return getSourceResult.status !== 404;
+  }
+}

package/bundled-types/host-app/commands/patch-fields.ts

@@ -0,0 +1,304 @@
+import { service } from '@ember/service';
+
+import type { CommandContext } from '@cardstack/runtime-common';
+import {
+  generateJsonSchemaForCardType,
+  basicMappings,
+} from '@cardstack/runtime-common/helpers/ai';
+import { Loader } from '@cardstack/runtime-common/loader';
+
+import type { CardDef } from 'https://cardstack.com/base/card-api';
+import type * as BaseCommandModule from 'https://cardstack.com/base/command';
+
+import { FieldPathParser } from '../lib/field-path-parser';
+import HostBaseCommand from '../lib/host-base-command';
+
+import type { ValidateFieldPathResult } from '../lib/field-path-parser';
+
+import type CardService from '../services/card-service';
+import type StoreService from '../services/store';
+
+interface Configuration {
+  cardType: typeof CardDef;
+}
+
+export default class PatchFieldsCommand extends HostBaseCommand<
+  typeof BaseCommandModule.PatchFieldsInput,
+  typeof BaseCommandModule.PatchFieldsOutput
+> {
+  @service declare private store: StoreService;
+  @service declare private cardService: CardService;
+
+  description = `Update specific fields of a card instance. Supports nested field paths using dot notation (e.g., "address.state") and array indices (e.g., "tags[0]"). Multiple fields can be updated in a single operation. Uses partial success model - valid field updates will be applied even if some fields fail validation.`;
+
+  static actionVerb = 'Update Fields';
+  requireInputFields = ['cardId', 'fieldUpdates'];
+
+  constructor(
+    commandContext: CommandContext,
+    private readonly configuration?: Configuration,
+  ) {
+    super(commandContext);
+  }
+
+  async getInputType() {
+    let commandModule = await this.loadCommandModule();
+    const { PatchFieldsInput } = commandModule;
+    return PatchFieldsInput;
+  }
+
+  // Core implementation methods
+  private parseFieldPath(fieldPath: string): string[] {
+    return FieldPathParser.parseFieldPath(fieldPath);
+  }
+
+  private applyFieldUpdate(
+    dataNode: {
+      attributes: Record<string, any>;
+      relationships: Record<string, any>;
+    },
+    fieldPath: string[],
+    value: any,
+    isRelationship: boolean,
+  ): void {
+    // For attributes, use the helper to set the value in attributes
+    FieldPathParser.applyFieldUpdate(
+      dataNode,
+      fieldPath,
+      value,
+      isRelationship,
+    );
+  }
+
+  private async validatedFieldPath(
+    fieldPath: string[],
+    cardType: typeof CardDef,
+  ): Promise<ValidateFieldPathResult> {
+    // Load card-api dynamically to get getFields function
+    const cardApi = await this.loaderService.loader.import<
+      typeof import('https://cardstack.com/base/card-api')
+    >('https://cardstack.com/base/card-api');
+
+    return FieldPathParser.validatedFieldPath(
+      fieldPath,
+      cardType,
+      cardApi.getFields,
+    );
+  }
+
+  protected async run(
+    input: BaseCommandModule.PatchFieldsInput,
+  ): Promise<BaseCommandModule.PatchFieldsOutput> {
+    if (!input.cardId || !input.fieldUpdates) {
+      throw new Error(
+        "PatchFieldsCommand can't run because it doesn't have all the required fields",
+      );
+    }
+
+    // Initialize result tracking
+    const updatedFields: string[] = [];
+    const errors: Record<string, string> = {};
+
+    try {
+      // Get the current card instance to merge with our updates
+      const currentCard = await this.store.get(input.cardId);
+      if (
+        !currentCard ||
+        typeof currentCard !== 'object' ||
+        'status' in currentCard
+      ) {
+        throw new Error(`Card not found: ${input.cardId}`);
+      }
+
+      // Serialize the current card to get its current attributes structure
+      const currentDoc = await this.cardService.serializeCard(currentCard);
+
+      // Start with a deep copy of the data node (attributes and relationships)
+      const workingData = JSON.parse(JSON.stringify(currentDoc.data));
+
+      let cardType = currentCard.constructor as typeof CardDef;
+
+      // Apply each field update, collecting successes and failures
+      const successfulUpdates: string[] = [];
+      const fieldErrors: Record<string, string> = {};
+
+      for (const [fieldPath, value] of Object.entries(input.fieldUpdates)) {
+        try {
+          // Parse the field path
+          const parsedPath = this.parseFieldPath(fieldPath);
+          // Validate the field path exists on the card type
+          let validatedFieldPath = await this.validatedFieldPath(
+            parsedPath,
+            cardType,
+          );
+          if (!validatedFieldPath.isValid) {
+            throw new Error(
+              `Invalid field path: ${fieldPath}. ${validatedFieldPath.reason}`,
+            );
+          }
+          // Apply the update to the correct place
+          this.applyFieldUpdate(
+            workingData,
+            parsedPath,
+            value,
+            validatedFieldPath.fieldType === 'linksTo' ||
+              validatedFieldPath.fieldType === 'linksToMany',
+          );
+
+          // Track successful update
+          successfulUpdates.push(fieldPath);
+        } catch (error: any) {
+          // Track error but continue processing other fields
+          fieldErrors[fieldPath] = error.message || 'Update failed';
+        }
+      }
+
+      // Only apply changes if at least some fields were updated successfully
+      if (successfulUpdates.length > 0) {
+        // Apply the updated data node (attributes and relationships)
+        const result = await this.store.patch(
+          input.cardId,
+          {
+            attributes: workingData.attributes,
+            relationships: workingData.relationships,
+          },
+          { doNotWaitForPersist: true },
+        );
+
+        if (result && 'errors' in result) {
+          // Store operation failed - mark all attempted updates as failed
+          successfulUpdates.forEach((fieldPath) => {
+            fieldErrors[fieldPath] = (result as any).errors
+              .map((e: any) => e.detail || e.title)
+              .join(', ');
+          });
+          updatedFields.push(...[]); // Clear successful updates
+        } else {
+          // Store operation succeeded - record successful updates
+          updatedFields.push(...successfulUpdates);
+        }
+      }
+
+      // Merge field errors into main errors object
+      Object.assign(errors, fieldErrors);
+
+      // Create and return the output
+      let commandModule = await this.loadCommandModule();
+      const { PatchFieldsOutput } = commandModule;
+
+      return new PatchFieldsOutput({
+        success: updatedFields.length > 0,
+        updatedFields,
+        errors,
+      });
+    } catch (error: any) {
+      console.log('PatchFieldsCommand: Caught error:', error.message);
+      // If the whole operation fails, mark all fields as failed
+      Object.keys(input.fieldUpdates).forEach((fieldPath) => {
+        errors[fieldPath] = error.message || 'Update failed';
+      });
+
+      let commandModule = await this.loadCommandModule();
+      const { PatchFieldsOutput } = commandModule;
+
+      return new PatchFieldsOutput({
+        success: false,
+        updatedFields,
+        errors,
+      });
+    }
+  }
+
+  async getInputJsonSchema(): Promise<any> {
+    // If we have a cardType configured, generate a detailed schema based on that card type
+    let configuredCardType = this.configuration?.cardType;
+    let loaderForSchema =
+      (configuredCardType && Loader.getLoaderFor(configuredCardType)) ??
+      this.loaderService.loader;
+
+    if (configuredCardType) {
+      const cardApi = await loaderForSchema.import<
+        typeof import('https://cardstack.com/base/card-api')
+      >('https://cardstack.com/base/card-api');
+      const cardFields = cardApi.getFields(configuredCardType, {
+        usedLinksToFieldsOnly: false,
+      });
+      let loaderFromFirstField = Object.values(cardFields)
+        .map((field) => Loader.getLoaderFor(field.card))
+        .find(Boolean);
+      const mappings = await basicMappings(
+        loaderFromFirstField ?? loaderForSchema,
+      );
+      const cardTypeSchema = generateJsonSchemaForCardType(
+        configuredCardType,
+        cardApi,
+        mappings,
+      );
+
+      // Create field updates schema based on the card type's attributes
+      const fieldUpdatesProperties: Record<string, any> = {};
+
+      // Add all attributes from the card schema as potential field updates
+      if (
+        cardTypeSchema.attributes &&
+        'properties' in cardTypeSchema.attributes &&
+        cardTypeSchema.attributes.properties
+      ) {
+        for (const [fieldName, fieldSchema] of Object.entries(
+          cardTypeSchema.attributes.properties,
+        )) {
+          // Skip card info and internal fields
+          if (!['id', 'cardInfo'].includes(fieldName)) {
+            fieldUpdatesProperties[fieldName] = fieldSchema;
+          }
+        }
+      }
+
+      return {
+        attributes: {
+          type: 'object',
+          properties: {
+            cardId: {
+              type: 'string',
+              description: 'The ID of the card to update',
+            },
+            fieldUpdates: {
+              type: 'object',
+              properties: fieldUpdatesProperties,
+              additionalProperties: true, // Allow nested field paths like "address.street"
+              description: 'Object containing field paths and their new values',
+            },
+          },
+          required: ['cardId', 'fieldUpdates'],
+        },
+        relationships: {
+          type: 'object',
+          properties: {},
+        },
+      };
+    }
+
+    // Fallback to basic schema if no card type is configured
+    return {
+      attributes: {
+        type: 'object',
+        properties: {
+          cardId: {
+            type: 'string',
+            description: 'The ID of the card to update',
+          },
+          fieldUpdates: {
+            type: 'object',
+            additionalProperties: true, // Allow any field updates for now
+            description: 'Object containing field paths and their new values',
+          },
+        },
+        required: ['cardId', 'fieldUpdates'],
+      },
+      relationships: {
+        type: 'object',
+        properties: {},
+      },
+    };
+  }
+}

package/bundled-types/host-app/commands/patch-theme.ts

@@ -0,0 +1,52 @@
+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 UseAiAssistantCommand from './ai-assistant';
+
+export default class PatchThemeCommand extends HostBaseCommand<
+  typeof BaseCommandModule.PatchThemeInput,
+  typeof BaseCommandModule.SendAiAssistantMessageResult
+> {
+  description =
+    'Open the AI assistant to suggest improvements to a theme card and generate a patch.';
+
+  static actionVerb = 'Patch Theme';
+
+  requireInputFields = ['cardId'];
+
+  async getInputType() {
+    let commandModule = await this.loadCommandModule();
+    const { PatchThemeInput } = commandModule;
+    return PatchThemeInput;
+  }
+
+  protected async run(
+    input: BaseCommandModule.PatchThemeInput,
+  ): Promise<BaseCommandModule.SendAiAssistantMessageResult> {
+    if (!input.cardId) {
+      throw new Error('patch-theme command requires a cardId');
+    }
+    let prompt = [
+      'Ask me for possible improvements to modify this theme card (e.g., change font, adjust backgrounds, tweak palettes, spacing, shadows).',
+      'Then propose changes and outline the patches you would apply to the theme JSON or CSS variables.',
+    ].join('\n');
+
+    let linkedSkill = input.skillCard as Skill | undefined;
+    let linkedSkillId =
+      linkedSkill && typeof linkedSkill.id === 'string'
+        ? linkedSkill.id
+        : undefined;
+
+    let useAssistant = new UseAiAssistantCommand(this.commandContext);
+    return await useAssistant.execute({
+      roomId: 'new',
+      openRoom: true,
+      llmModel: 'anthropic/claude-3.5-sonnet',
+      prompt,
+      skillCardIds: linkedSkillId ? [linkedSkillId] : undefined,
+      attachedCardIds: [input.cardId],
+    });
+  }
+}

package/bundled-types/host-app/commands/persist-module-inspector-view.ts

@@ -0,0 +1,41 @@
+import { service } from '@ember/service';
+
+import type * as BaseCommandModule from 'https://cardstack.com/base/command';
+
+import HostBaseCommand from '../lib/host-base-command';
+
+import type OperatorModeStateService from '../services/operator-mode-state-service';
+
+export default class PersistModuleInspectorViewCommand extends HostBaseCommand<
+  typeof BaseCommandModule.PersistModuleInspectorViewInput,
+  undefined
+> {
+  @service declare private operatorModeStateService: OperatorModeStateService;
+
+  description = 'Persist the module inspector view selection to local storage';
+
+  async getInputType() {
+    let commandModule = await this.loadCommandModule();
+    const { PersistModuleInspectorViewInput } = commandModule;
+    return PersistModuleInspectorViewInput;
+  }
+
+  requireInputFields = ['codePath', 'moduleInspectorView'];
+
+  protected async run(
+    input: BaseCommandModule.PersistModuleInspectorViewInput,
+  ): Promise<undefined> {
+    let view = input.moduleInspectorView;
+    let allowedViews: Set<string> = new Set(['schema', 'spec', 'preview']);
+    if (!allowedViews.has(view)) {
+      throw new Error(
+        `Invalid moduleInspectorView "${view}". Must be one of: schema, spec, preview`,
+      );
+    }
+    this.operatorModeStateService.persistModuleInspectorView(
+      input.codePath,
+      view as 'schema' | 'spec' | 'preview',
+    );
+    return undefined;
+  }
+}