@cardstack/boxel-cli 0.2.0 → 0.3.0-unstable.58

package/bundled-types/host-app/commands/apply-markdown-edit.ts

@@ -0,0 +1,203 @@
+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 GetCardCommand from './get-card';
+import PatchFieldsCommand from './patch-fields';
+import SendRequestViaProxyCommand from './send-request-via-proxy';
+
+const escapeForTag = (value: string) =>
+  value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+
+// Command to apply markdown edits using relace/relace-apply-3 model
+export default class ApplyMarkdownEditCommand extends HostBaseCommand<
+  typeof BaseCommandModule.ApplyMarkdownEditInput,
+  undefined
+> {
+  static actionVerb = 'Apply Markdown Edit';
+  description =
+    'Apply a targeted edit to markdown content only (for example .md/.markdown text). This command is not for source code edits such as .gts/.ts/.js/.json files.';
+
+  async getInputType() {
+    let commandModule = await this.loadCommandModule();
+    const { ApplyMarkdownEditInput } = commandModule;
+    return ApplyMarkdownEditInput;
+  }
+
+  protected async run(
+    input: BaseCommandModule.ApplyMarkdownEditInput,
+  ): Promise<undefined> {
+    // Validate inputs
+    if (!input.cardId?.trim()) {
+      throw new Error('Card ID is required');
+    }
+    if (!input.fieldPath?.trim()) {
+      throw new Error('Field path is required');
+    }
+    if (!input.markdownDiff?.trim()) {
+      throw new Error('Markdown diff is required');
+    }
+    if (!input.instructions?.trim()) {
+      throw new Error('Instructions are required');
+    }
+
+    // Get the card
+    const getCard = new GetCardCommand(this.commandContext);
+    const card = await getCard.execute({ cardId: input.cardId });
+
+    if (!card) {
+      throw new Error(`Card not found: ${input.cardId}`);
+    }
+
+    // Get current markdown content from the field (supports dotted/array paths)
+    const pathParts = FieldPathParser.parseFieldPath(input.fieldPath);
+    let currentNode: any = card as any;
+    for (const part of pathParts) {
+      if (part.startsWith('[') && part.endsWith(']')) {
+        const indexStr = part.slice(1, -1);
+        if (indexStr === '' || indexStr === '-1') {
+          throw new Error(
+            `Field path "${input.fieldPath}" uses append syntax which is invalid when reading a value`,
+          );
+        }
+        const index = parseInt(indexStr, 10);
+        if (Number.isNaN(index)) {
+          throw new Error(
+            `Field path "${input.fieldPath}" contains an invalid array index`,
+          );
+        }
+        if (!Array.isArray(currentNode)) {
+          throw new Error(`Field path "${input.fieldPath}" not found on card`);
+        }
+        currentNode = currentNode[index];
+      } else {
+        currentNode = currentNode?.[part];
+      }
+
+      if (currentNode === undefined || currentNode === null) {
+        throw new Error(`Field path "${input.fieldPath}" not found on card`);
+      }
+    }
+
+    if (typeof currentNode !== 'string') {
+      throw new Error(`Field "${input.fieldPath}" is not a string field`);
+    }
+    const fullFieldContent = currentNode;
+
+    // Determine what content to send to the model
+    // If currentContent is provided, use it (focused edit mode)
+    // Otherwise, fall back to full field content (legacy mode)
+    const hasFocusedContent = Boolean(input.currentContent?.trim());
+    const contentForModel = hasFocusedContent
+      ? input.currentContent!
+      : fullFieldContent;
+
+    // Validate focused content exists in the field (if provided)
+    let focusedContentIndex = -1;
+    if (hasFocusedContent) {
+      focusedContentIndex = fullFieldContent.indexOf(contentForModel);
+      if (focusedContentIndex === -1) {
+        throw new Error(
+          `The provided currentContent was not found in the field. ` +
+            `Try selecting a larger or more unique portion of text. ` +
+            `Field content length: ${fullFieldContent.length}.`,
+        );
+      }
+      const secondOccurrenceIndex = fullFieldContent.indexOf(
+        contentForModel,
+        focusedContentIndex + contentForModel.length,
+      );
+      if (secondOccurrenceIndex !== -1) {
+        throw new Error(
+          `The provided currentContent matches multiple places in the field. ` +
+            `Provide a more specific selection to disambiguate the edit.`,
+        );
+      }
+    }
+
+    // Call OpenRouter's relace-apply-3 model to apply the diff
+    const requestBody = {
+      model: 'relace/relace-apply-3',
+      messages: [
+        {
+          role: 'user',
+          content: `<instruction>${escapeForTag(input.instructions)}</instruction>\n<code>${escapeForTag(
+            contentForModel,
+          )}</code>\n<update>${escapeForTag(input.markdownDiff)}</update>`,
+        },
+      ],
+    };
+
+    const response = await new SendRequestViaProxyCommand(
+      this.commandContext,
+    ).execute({
+      url: 'https://openrouter.ai/api/v1/chat/completions',
+      method: 'POST',
+      requestBody: JSON.stringify(requestBody),
+      headers: {
+        'Content-Type': 'application/json',
+        'HTTP-Referer': 'https://app.boxel.ai',
+        'X-Title': 'Boxel Markdown Editor',
+      },
+    });
+
+    if (!response.response.ok) {
+      throw new Error(
+        `OpenRouter request failed: ${response.response.statusText}`,
+      );
+    }
+
+    // Parse the response
+    let data;
+    try {
+      data = await response.response.json();
+    } catch (e: any) {
+      throw new Error(`Failed to parse OpenRouter response: ${e.message}`);
+    }
+
+    const newContent = data.choices?.[0]?.message?.content;
+    if (newContent === undefined || newContent === null) {
+      throw new Error('No content returned from OpenRouter');
+    }
+
+    // Compute final field content
+    // If we used focused mode, replace that section in the full content
+    // Otherwise, use the model's output directly
+    let finalContent: string;
+    if (hasFocusedContent) {
+      let replaceStart = focusedContentIndex;
+      let replaceEnd = focusedContentIndex + input.currentContent!.length;
+      // When deleting content, also drop a single trailing newline to avoid accumulating blank lines
+      if (newContent === '' && fullFieldContent[replaceEnd] === '\n') {
+        replaceEnd += 1;
+      }
+      const trailingContent = fullFieldContent.slice(replaceEnd);
+      // If the model already returned the full field (including the trailing content),
+      // avoid appending it a second time.
+      const prefix = fullFieldContent.slice(0, replaceStart);
+      // More robust check: ensure newContent starts with prefix and ends with trailingContent
+      if (
+        trailingContent &&
+        newContent.startsWith(prefix) &&
+        newContent.endsWith(trailingContent)
+      ) {
+        finalContent = newContent;
+      } else {
+        finalContent = prefix + newContent + trailingContent;
+      }
+    } else {
+      finalContent = newContent;
+    }
+
+    // Patch only the specific markdown field
+    await new PatchFieldsCommand(this.commandContext).execute({
+      cardId: input.cardId,
+      fieldUpdates: {
+        [input.fieldPath]: finalContent,
+      },
+    });
+
+    return undefined;
+  }
+}

package/bundled-types/host-app/commands/apply-search-replace-block.ts

@@ -0,0 +1,225 @@
+import {
+  REPLACE_MARKER,
+  SEARCH_MARKER,
+  SEPARATOR_MARKER,
+} from '@cardstack/runtime-common';
+
+import type * as BaseCommandModule from 'https://cardstack.com/base/command';
+
+import HostBaseCommand from '../lib/host-base-command';
+
+let standardErrorMessage =
+  'Unable to process the code patch due to invalid code coming from AI';
+export const APPLY_SEARCH_REPLACE_BLOCK_ERROR_MESSAGES = {
+  SEARCH_BLOCK_PARSE_ERROR: `${standardErrorMessage} (search block parse error)`,
+  REPLACE_BLOCK_PARSE_ERROR: `${standardErrorMessage} (replace block parse error)`,
+  SEARCH_PATTERN_NOT_FOUND: `${standardErrorMessage} (search pattern not found in the target source file)`,
+  EMPTY_SEARCH_PATTERN_ON_NONEMPTY_FILE: `${standardErrorMessage} (empty search pattern for non-empty file)`,
+} as const;
+
+export default class ApplySearchReplaceBlockCommand extends HostBaseCommand<
+  typeof BaseCommandModule.ApplySearchReplaceBlockInput,
+  typeof BaseCommandModule.ApplySearchReplaceBlockResult
+> {
+  description = `Apply search/replace blocks to file contents. The format is:
+╔═══ SEARCH ════╗
+[original code to find]
+╠═══════════════╣
+[new code to replace with]
+╚═══ REPLACE ═══╝
+`;
+  static actionVerb = 'Apply';
+
+  async getInputType() {
+    let commandModule = await this.loadCommandModule();
+    const { ApplySearchReplaceBlockInput } = commandModule;
+    return ApplySearchReplaceBlockInput;
+  }
+
+  requireInputFields = ['codeBlock', 'fileContent'];
+
+  protected async run(
+    input: BaseCommandModule.ApplySearchReplaceBlockInput,
+  ): Promise<BaseCommandModule.ApplySearchReplaceBlockResult> {
+    let commandModule = await this.loadCommandModule();
+    const { ApplySearchReplaceBlockResult } = commandModule;
+
+    // Parse the search and replace blocks from the provided code block
+    const { searchPattern, replacePattern } = this.parseCodeBlock(
+      input.codeBlock,
+    );
+
+    if (searchPattern == null) {
+      throw new Error(
+        APPLY_SEARCH_REPLACE_BLOCK_ERROR_MESSAGES.SEARCH_BLOCK_PARSE_ERROR,
+      );
+    } else if (replacePattern == null) {
+      throw new Error(
+        APPLY_SEARCH_REPLACE_BLOCK_ERROR_MESSAGES.REPLACE_BLOCK_PARSE_ERROR,
+      );
+    } else if (searchPattern === '' && input.fileContent.trim() !== '') {
+      throw new Error(
+        APPLY_SEARCH_REPLACE_BLOCK_ERROR_MESSAGES.EMPTY_SEARCH_PATTERN_ON_NONEMPTY_FILE,
+      );
+    }
+
+    // Apply the search/replace operation
+    const resultContent = this.applySearchReplace(
+      input.fileContent,
+      searchPattern,
+      replacePattern,
+    );
+    if (resultContent === input.fileContent && searchPattern !== '') {
+      throw new Error(
+        APPLY_SEARCH_REPLACE_BLOCK_ERROR_MESSAGES.SEARCH_PATTERN_NOT_FOUND,
+      );
+    }
+
+    return new ApplySearchReplaceBlockResult({
+      resultContent,
+    });
+  }
+
+  /**
+   * Parse the code block to extract search and replace patterns
+   */
+  private parseCodeBlock(codeBlock: string): {
+    searchPattern: string | null;
+    replacePattern: string | null;
+  } {
+    // Make sure the code block has all the required markers
+    if (
+      !codeBlock.includes(SEARCH_MARKER) ||
+      !codeBlock.includes(SEPARATOR_MARKER) ||
+      !codeBlock.includes(REPLACE_MARKER)
+    ) {
+      return { searchPattern: null, replacePattern: null };
+    }
+
+    // Extract the search and replace patterns
+    const searchStart = codeBlock.indexOf(SEARCH_MARKER) + SEARCH_MARKER.length;
+    const dividerPos = codeBlock.indexOf(SEPARATOR_MARKER);
+    const replaceStart = dividerPos + SEPARATOR_MARKER.length;
+    const replaceEnd = codeBlock.indexOf(REPLACE_MARKER);
+
+    if (searchStart >= dividerPos || replaceStart >= replaceEnd) {
+      return { searchPattern: null, replacePattern: null };
+    }
+
+    // Extract search pattern (trim for comparison) and replace pattern (preserve exactly)
+    const searchPattern = codeBlock.substring(searchStart, dividerPos).trim();
+    const replacePattern = codeBlock.substring(replaceStart, replaceEnd);
+    // remove leading newline from replace pattern
+    const replacePatternWithoutLeadingNewline = replacePattern.replace(
+      /^[\n\r]*/,
+      '',
+    );
+
+    return {
+      searchPattern,
+      replacePattern: replacePatternWithoutLeadingNewline.replace(/\n$/, ''),
+    };
+  }
+
+  /**
+   * Apply search and replace operation, handling whitespace variations
+   */
+  private applySearchReplace(
+    content: string,
+    searchPattern: string,
+    replacePattern: string,
+  ): string {
+    if (searchPattern === '') {
+      return replacePattern;
+    }
+    // Create a normalized search pattern for matching
+    // This helps with whitespace differences
+    const normalizedSearchLines = searchPattern
+      .split('\n')
+      .map((line) => line.trim());
+
+    // Split content into lines for line-by-line processing
+    const contentLines = content.split('\n');
+    const resultLines: string[] = [];
+
+    // Process content line by line
+    let i = 0;
+    while (i < contentLines.length) {
+      // Try to match the search pattern starting from current line
+      const matchResult = this.findMatch(
+        contentLines,
+        i,
+        normalizedSearchLines,
+      );
+
+      if (matchResult.matched) {
+        // We found a match
+        // Split the replacement text by lines and add each line exactly as is
+        const replaceLines = replacePattern.split('\n');
+        for (const line of replaceLines) {
+          resultLines.push(line);
+        }
+
+        // Skip the matched lines
+        i += matchResult.matchLength;
+        while (i < contentLines.length) {
+          resultLines.push(contentLines[i]);
+          i++;
+        }
+
+        // Case when replace pattern is empty (deleting code) - don't produce an uneccesary empty line at the beginning of the result
+        if (replacePattern === '' && resultLines[0] === '') {
+          return resultLines.slice(1).join('\n');
+        }
+        return resultLines.join('\n');
+      } else {
+        // No match, keep the original line
+        resultLines.push(contentLines[i]);
+        i++;
+      }
+    }
+
+    return resultLines.join('\n');
+  }
+
+  /**
+   * Find a match for the search pattern in content lines starting from startIndex
+   */
+  private findMatch(
+    contentLines: string[],
+    startIndex: number,
+    normalizedSearchLines: string[],
+  ): { matched: boolean; matchLength: number } {
+    // Make sure we have enough lines to match
+    if (startIndex + normalizedSearchLines.length > contentLines.length) {
+      return { matched: false, matchLength: 0 };
+    }
+
+    // Check if the pattern matches line by line
+    let searchLineIndex = 0;
+    let contentLineIndex = startIndex;
+    while (searchLineIndex < normalizedSearchLines.length) {
+      const contentLine = contentLines[contentLineIndex].trim();
+      const searchLine = normalizedSearchLines[searchLineIndex];
+
+      // Skip empty lines in the search pattern
+      // as long as there are still lines in the content
+      if (!searchLine && contentLine) {
+        searchLineIndex++;
+        continue;
+      }
+      // If the trimmed lines don't match, it's not a match
+      if (contentLine !== searchLine && searchLine !== '') {
+        return { matched: false, matchLength: 0 };
+      }
+      searchLineIndex++;
+      contentLineIndex++;
+    }
+
+    // All lines matched. The length of the match is the size of the match in
+    // the **content**, not the size of the search pattern.
+    // These are often the same, but are different when the search pattern contains
+    // empty lines that we skip over.
+    return { matched: true, matchLength: contentLineIndex - startIndex };
+  }
+}

package/bundled-types/host-app/commands/ask-ai.ts

@@ -0,0 +1,66 @@
+import { service } from '@ember/service';
+
+import type * as BaseCommandModule from 'https://cardstack.com/base/command';
+
+import HostBaseCommand from '../lib/host-base-command';
+
+import CreateAiAssistantRoomCommand from './create-ai-assistant-room';
+import OpenAiAssistantRoomCommand from './open-ai-assistant-room';
+import SendAiAssistantMessageCommand from './send-ai-assistant-message';
+
+import type MatrixService from '../services/matrix-service';
+import type OperatorModeStateService from '../services/operator-mode-state-service';
+
+export default class AskAiCommand extends HostBaseCommand<
+  typeof BaseCommandModule.AskAiInput,
+  typeof BaseCommandModule.AskAiOutput
+> {
+  @service declare private matrixService: MatrixService;
+  @service declare private operatorModeStateService: OperatorModeStateService;
+
+  static actionVerb = 'Ask';
+
+  async getInputType() {
+    let commandModule = await this.loadCommandModule();
+    const { AskAiInput } = commandModule;
+    return AskAiInput;
+  }
+
+  protected async run(
+    input: BaseCommandModule.AskAiInput,
+  ): Promise<BaseCommandModule.AskAiOutput> {
+    let createRoomCommand = new CreateAiAssistantRoomCommand(
+      this.commandContext,
+    );
+    let openRoomCommand = new OpenAiAssistantRoomCommand(this.commandContext);
+    let sendMessageCommand = new SendAiAssistantMessageCommand(
+      this.commandContext,
+    );
+
+    let [skills, openCards] = await Promise.all([
+      this.matrixService.loadDefaultSkills('code') || Promise.resolve([]),
+      this.operatorModeStateService.getOpenCards.perform() ||
+        Promise.resolve([]),
+    ]);
+    let { roomId } = await createRoomCommand.execute({
+      name: 'AI App Generator Assistant',
+      enabledSkills: skills,
+      llmMode: input.llmMode,
+    });
+    await sendMessageCommand.execute({
+      roomId,
+      prompt: input.prompt,
+      attachedCards: openCards,
+      openCardIds: openCards?.map((c: any) => c.id),
+      realmIdentifier: this.operatorModeStateService.realmURL,
+    });
+
+    await openRoomCommand.execute({ roomId });
+
+    let commandModule = await this.loadCommandModule();
+    return new commandModule.AskAiOutput({
+      response:
+        'AI assistant room created and opened successfully. You can now interact with the AI assistant.',
+    });
+  }
+}

package/bundled-types/host-app/commands/authed-fetch.ts

@@ -0,0 +1,53 @@
+import { service } from '@ember/service';
+
+import type * as BaseCommandModule from 'https://cardstack.com/base/command';
+
+import HostBaseCommand from '../lib/host-base-command';
+
+import type NetworkService from '../services/network';
+
+export default class AuthedFetchCommand extends HostBaseCommand<
+  typeof BaseCommandModule.AuthedFetchInput,
+  typeof BaseCommandModule.AuthedFetchResult
+> {
+  @service declare private network: NetworkService;
+
+  description = 'Perform an authenticated HTTP fetch';
+
+  async getInputType() {
+    let commandModule = await this.loadCommandModule();
+    const { AuthedFetchInput } = commandModule;
+    return AuthedFetchInput;
+  }
+
+  requireInputFields = ['url'];
+
+  protected async run(
+    input: BaseCommandModule.AuthedFetchInput,
+  ): Promise<BaseCommandModule.AuthedFetchResult> {
+    let commandModule = await this.loadCommandModule();
+    const { AuthedFetchResult } = commandModule;
+    const headers: Record<string, string> = {};
+    if (input.acceptHeader) {
+      headers['Accept'] = input.acceptHeader;
+    }
+    const response = await this.network.authedFetch(input.url, {
+      method: input.method ?? 'GET',
+      headers,
+    });
+    let body: Record<string, any> = {};
+    if (response.ok) {
+      let text = await response.text();
+      try {
+        body = JSON.parse(text);
+      } catch {
+        body = { rawText: text };
+      }
+    }
+    return new AuthedFetchResult({
+      ok: response.ok,
+      status: response.status,
+      body,
+    });
+  }
+}

package/bundled-types/host-app/commands/bot-requests/create-listing-pr-request.ts

@@ -0,0 +1,77 @@
+import { service } from '@ember/service';
+
+import { isCardInstance } from '@cardstack/runtime-common';
+
+import type * as BaseCommandModule from 'https://cardstack.com/base/command';
+
+import HostBaseCommand from '../../lib/host-base-command';
+
+import UseAiAssistantCommand from '../ai-assistant';
+
+import SendBotTriggerEventCommand from './send-bot-trigger-event';
+
+import type MatrixService from '../../services/matrix-service';
+import type StoreService from '../../services/store';
+import type { Listing } from '@cardstack/catalog/catalog-app/listing/listing';
+
+export default class CreateListingPRRequestCommand extends HostBaseCommand<
+  typeof BaseCommandModule.CreateListingPRRequestInput
+> {
+  @service declare private matrixService: MatrixService;
+  @service declare private store: StoreService;
+
+  description =
+    'Request a GitHub PR from a catalog listing and notify the bot runner.';
+
+  async getInputType() {
+    let commandModule = await this.loadCommandModule();
+    const { CreateListingPRRequestInput } = commandModule;
+    return CreateListingPRRequestInput;
+  }
+
+  requireInputFields = ['realm', 'listingId'];
+
+  protected async run(
+    input: BaseCommandModule.CreateListingPRRequestInput,
+  ): Promise<undefined> {
+    await this.matrixService.ready;
+
+    let { realm, listingId } = input;
+    let listingName: string | undefined;
+    let listingSummary: string | undefined;
+    let listing = await this.store.get<Listing>(listingId);
+    if (listing && isCardInstance(listing)) {
+      listingName = listing.name ?? listing.id;
+      listingSummary = listing.summary ?? undefined;
+    }
+
+    let useAiAssistantCommand = new UseAiAssistantCommand(this.commandContext);
+    let createRoomResult = await useAiAssistantCommand.execute({
+      roomId: 'new',
+      roomName: `PR: ${listingName ?? listingId ?? 'Listing'}`,
+      openRoom: false,
+    });
+    let roomId = createRoomResult.roomId;
+
+    let submissionBotId = this.matrixService.submissionBotUserId;
+    if (!(await this.matrixService.isUserInRoom(roomId, submissionBotId))) {
+      await this.matrixService.inviteUserToRoom(roomId, submissionBotId);
+    }
+
+    let submittedBy = this.matrixService.userId ?? undefined;
+
+    await new SendBotTriggerEventCommand(this.commandContext).execute({
+      roomId,
+      realm,
+      type: 'pr-listing-create',
+      input: {
+        roomId,
+        realm,
+        listingId,
+        ...(listingName ? { listingName } : {}),
+        ...(listingSummary ? { listingSummary } : {}),
+        ...(submittedBy ? { submittedBy } : {}),
+      },
+    });
+  }
+}

package/bundled-types/host-app/commands/bot-requests/send-bot-trigger-event.ts

@@ -0,0 +1,53 @@
+import { service } from '@ember/service';
+
+import { isBotTriggerEvent } from '@cardstack/runtime-common';
+
+import type * as BaseCommandModule from 'https://cardstack.com/base/command';
+import type { BotTriggerEvent } from 'https://cardstack.com/base/matrix-event';
+
+import HostBaseCommand from '../../lib/host-base-command';
+
+import type MatrixService from '../../services/matrix-service';
+
+export default class SendBotTriggerEventCommand extends HostBaseCommand<
+  typeof BaseCommandModule.SendBotTriggerEventInput
+> {
+  @service declare private matrixService: MatrixService;
+
+  static actionVerb = 'Send';
+
+  async getInputType() {
+    let commandModule = await this.loadCommandModule();
+    const { SendBotTriggerEventInput } = commandModule;
+    return SendBotTriggerEventInput;
+  }
+
+  requireInputFields = ['roomId', 'type', 'input', 'realm'];
+
+  protected async run(
+    input: BaseCommandModule.SendBotTriggerEventInput,
+  ): Promise<undefined> {
+    await this.matrixService.ready;
+    let userId = this.matrixService.userId;
+    if (!userId) {
+      throw new Error('userId is required to send bot trigger events');
+    }
+
+    const botTriggerEventType = 'app.boxel.bot-trigger';
+    let event = {
+      type: botTriggerEventType,
+      content: {
+        type: input.type,
+        input: input.input,
+        realm: input.realm,
+        userId,
+      },
+    } as BotTriggerEvent;
+
+    if (!isBotTriggerEvent(event)) {
+      throw new Error(`Invalid bot trigger event payload`);
+    }
+
+    await this.matrixService.sendEvent(input.roomId, event.type, event.content);
+  }
+}