crca 1.4.0__py3-none-any.whl

tools/bolt.diy/app/utils/selectStarterTemplate.ts

@@ -0,0 +1,255 @@
+import ignore from 'ignore';
+import type { ProviderInfo } from '~/types/model';
+import type { Template } from '~/types/template';
+import { STARTER_TEMPLATES } from './constants';
+
+const starterTemplateSelectionPrompt = (templates: Template[]) => `
+You are an experienced developer who helps people choose the best starter template for their projects.
+IMPORTANT: Vite is preferred
+IMPORTANT: Only choose shadcn templates if the user explicitly asks for shadcn.
+
+Available templates:
+<template>
+  <name>blank</name>
+  <description>Empty starter for simple scripts and trivial tasks that don't require a full template setup</description>
+  <tags>basic, script</tags>
+</template>
+${templates
+  .map(
+    (template) => `
+<template>
+  <name>${template.name}</name>
+  <description>${template.description}</description>
+  ${template.tags ? `<tags>${template.tags.join(', ')}</tags>` : ''}
+</template>
+`,
+  )
+  .join('\n')}
+
+Response Format:
+<selection>
+  <templateName>{selected template name}</templateName>
+  <title>{a proper title for the project}</title>
+</selection>
+
+Examples:
+
+<example>
+User: I need to build a todo app
+Response:
+<selection>
+  <templateName>react-basic-starter</templateName>
+  <title>Simple React todo application</title>
+</selection>
+</example>
+
+<example>
+User: Write a script to generate numbers from 1 to 100
+Response:
+<selection>
+  <templateName>blank</templateName>
+  <title>script to generate numbers from 1 to 100</title>
+</selection>
+</example>
+
+Instructions:
+1. For trivial tasks and simple scripts, always recommend the blank template
+2. For more complex projects, recommend templates from the provided list
+3. Follow the exact XML format
+4. Consider both technical requirements and tags
+5. If no perfect match exists, recommend the closest option
+
+Important: Provide only the selection tags in your response, no additional text.
+MOST IMPORTANT: YOU DONT HAVE TIME TO THINK JUST START RESPONDING BASED ON HUNCH 
+`;
+
+const templates: Template[] = STARTER_TEMPLATES.filter((t) => !t.name.includes('shadcn'));
+
+const parseSelectedTemplate = (llmOutput: string): { template: string; title: string } | null => {
+  try {
+    // Extract content between <templateName> tags
+    const templateNameMatch = llmOutput.match(/<templateName>(.*?)<\/templateName>/);
+    const titleMatch = llmOutput.match(/<title>(.*?)<\/title>/);
+
+    if (!templateNameMatch) {
+      return null;
+    }
+
+    return { template: templateNameMatch[1].trim(), title: titleMatch?.[1].trim() || 'Untitled Project' };
+  } catch (error) {
+    console.error('Error parsing template selection:', error);
+    return null;
+  }
+};
+
+export const selectStarterTemplate = async (options: { message: string; model: string; provider: ProviderInfo }) => {
+  const { message, model, provider } = options;
+  const requestBody = {
+    message,
+    model,
+    provider,
+    system: starterTemplateSelectionPrompt(templates),
+  };
+  const response = await fetch('/api/llmcall', {
+    method: 'POST',
+    body: JSON.stringify(requestBody),
+  });
+  const respJson: { text: string } = await response.json();
+  console.log(respJson);
+
+  const { text } = respJson;
+  const selectedTemplate = parseSelectedTemplate(text);
+
+  if (selectedTemplate) {
+    return selectedTemplate;
+  } else {
+    console.log('No template selected, using blank template');
+
+    return {
+      template: 'blank',
+      title: '',
+    };
+  }
+};
+
+const getGitHubRepoContent = async (repoName: string): Promise<{ name: string; path: string; content: string }[]> => {
+  try {
+    // Instead of directly fetching from GitHub, use our own API endpoint as a proxy
+    const response = await fetch(`/api/github-template?repo=${encodeURIComponent(repoName)}`);
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    // Our API will return the files in the format we need
+    const files = (await response.json()) as any;
+
+    return files;
+  } catch (error) {
+    console.error('Error fetching release contents:', error);
+    throw error;
+  }
+};
+
+export async function getTemplates(templateName: string, title?: string) {
+  const template = STARTER_TEMPLATES.find((t) => t.name == templateName);
+
+  if (!template) {
+    return null;
+  }
+
+  const githubRepo = template.githubRepo;
+  const files = await getGitHubRepoContent(githubRepo);
+
+  let filteredFiles = files;
+
+  /*
+   * ignoring common unwanted files
+   * exclude    .git
+   */
+  filteredFiles = filteredFiles.filter((x) => x.path.startsWith('.git') == false);
+
+  /*
+   * exclude    lock files
+   * WE NOW INCLUDE LOCK FILES FOR IMPROVED INSTALL TIMES
+   */
+  {
+    /*
+     *const comminLockFiles = ['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml'];
+     *filteredFiles = filteredFiles.filter((x) => comminLockFiles.includes(x.name) == false);
+     */
+  }
+
+  // exclude    .bolt
+  filteredFiles = filteredFiles.filter((x) => x.path.startsWith('.bolt') == false);
+
+  // check for ignore file in .bolt folder
+  const templateIgnoreFile = files.find((x) => x.path.startsWith('.bolt') && x.name == 'ignore');
+
+  const filesToImport = {
+    files: filteredFiles,
+    ignoreFile: [] as typeof filteredFiles,
+  };
+
+  if (templateIgnoreFile) {
+    // redacting files specified in ignore file
+    const ignorepatterns = templateIgnoreFile.content.split('\n').map((x) => x.trim());
+    const ig = ignore().add(ignorepatterns);
+
+    // filteredFiles = filteredFiles.filter(x => !ig.ignores(x.path))
+    const ignoredFiles = filteredFiles.filter((x) => ig.ignores(x.path));
+
+    filesToImport.files = filteredFiles;
+    filesToImport.ignoreFile = ignoredFiles;
+  }
+
+  const assistantMessage = `
+Bolt is initializing your project with the required files using the ${template.name} template.
+<boltArtifact id="imported-files" title="${title || 'Create initial files'}" type="bundled">
+${filesToImport.files
+  .map(
+    (file) =>
+      `<boltAction type="file" filePath="${file.path}">
+${file.content}
+</boltAction>`,
+  )
+  .join('\n')}
+</boltArtifact>
+`;
+  let userMessage = ``;
+  const templatePromptFile = files.filter((x) => x.path.startsWith('.bolt')).find((x) => x.name == 'prompt');
+
+  if (templatePromptFile) {
+    userMessage = `
+TEMPLATE INSTRUCTIONS:
+${templatePromptFile.content}
+
+---
+`;
+  }
+
+  if (filesToImport.ignoreFile.length > 0) {
+    userMessage =
+      userMessage +
+      `
+STRICT FILE ACCESS RULES - READ CAREFULLY:
+
+The following files are READ-ONLY and must never be modified:
+${filesToImport.ignoreFile.map((file) => `- ${file.path}`).join('\n')}
+
+Permitted actions:
+✓ Import these files as dependencies
+✓ Read from these files
+✓ Reference these files
+
+Strictly forbidden actions:
+❌ Modify any content within these files
+❌ Delete these files
+❌ Rename these files
+❌ Move these files
+❌ Create new versions of these files
+❌ Suggest changes to these files
+
+Any attempt to modify these protected files will result in immediate termination of the operation.
+
+If you need to make changes to functionality, create new files instead of modifying the protected ones listed above.
+---
+`;
+  }
+
+  userMessage += `
+---
+template import is done, and you can now use the imported files,
+edit only the files that need to be changed, and you can create new files as needed.
+NO NOT EDIT/WRITE ANY FILES THAT ALREADY EXIST IN THE PROJECT AND DOES NOT NEED TO BE MODIFIED
+---
+Now that the Template is imported please continue with my original request
+
+IMPORTANT: Dont Forget to install the dependencies before running the app by using \`npm install && npm run dev\`
+`;
+
+  return {
+    assistantMessage,
+    userMessage,
+  };
+}

tools/bolt.diy/app/utils/shell.ts

@@ -0,0 +1,384 @@
+import type { WebContainer, WebContainerProcess } from '@webcontainer/api';
+import type { ITerminal } from '~/types/terminal';
+import { withResolvers } from './promises';
+import { atom } from 'nanostores';
+import { expoUrlAtom } from '~/lib/stores/qrCodeStore';
+
+export async function newShellProcess(webcontainer: WebContainer, terminal: ITerminal) {
+  const args: string[] = [];
+
+  // we spawn a JSH process with a fallback cols and rows in case the process is not attached yet to a visible terminal
+  const process = await webcontainer.spawn('/bin/jsh', ['--osc', ...args], {
+    terminal: {
+      cols: terminal.cols ?? 80,
+      rows: terminal.rows ?? 15,
+    },
+  });
+
+  const input = process.input.getWriter();
+  const output = process.output;
+
+  const jshReady = withResolvers<void>();
+
+  let isInteractive = false;
+  output.pipeTo(
+    new WritableStream({
+      write(data) {
+        if (!isInteractive) {
+          const [, osc] = data.match(/\x1b\]654;([^\x07]+)\x07/) || [];
+
+          if (osc === 'interactive') {
+            // wait until we see the interactive OSC
+            isInteractive = true;
+
+            jshReady.resolve();
+          }
+        }
+
+        terminal.write(data);
+
+        // Capture terminal output for debugging
+        try {
+          import('~/utils/debugLogger')
+            .then(({ captureTerminalLog }) => {
+              // Clean the data by removing ANSI escape sequences for logging
+              const cleanData = data.replace(/\x1b\[[0-9;]*[mG]/g, '').trim();
+
+              if (cleanData) {
+                captureTerminalLog(cleanData, 'output');
+              }
+            })
+            .catch(() => {
+              // Ignore if debug logger is not available
+            });
+        } catch {
+          // Ignore errors in debug logging
+        }
+      },
+    }),
+  );
+
+  terminal.onData((data) => {
+    // console.log('terminal onData', { data, isInteractive });
+
+    if (isInteractive) {
+      input.write(data);
+
+      // Capture terminal input for debugging
+      try {
+        import('~/utils/debugLogger')
+          .then(({ captureTerminalLog }) => {
+            // Clean the data and check if it's a command (not just cursor movement)
+            const cleanData = data.replace(/\x1b\[[0-9;]*[A-Z]/g, '').trim();
+
+            if (cleanData && cleanData !== '\r' && cleanData !== '\n') {
+              captureTerminalLog(cleanData, 'input');
+            }
+          })
+          .catch(() => {
+            // Ignore if debug logger is not available
+          });
+      } catch {
+        // Ignore errors in debug logging
+      }
+    }
+  });
+
+  await jshReady.promise;
+
+  return process;
+}
+
+export type ExecutionResult = { output: string; exitCode: number } | undefined;
+
+export class BoltShell {
+  #initialized: (() => void) | undefined;
+  #readyPromise: Promise<void>;
+  #webcontainer: WebContainer | undefined;
+  #terminal: ITerminal | undefined;
+  #process: WebContainerProcess | undefined;
+  executionState = atom<
+    { sessionId: string; active: boolean; executionPrms?: Promise<any>; abort?: () => void } | undefined
+  >();
+  #outputStream: ReadableStreamDefaultReader<string> | undefined;
+  #shellInputStream: WritableStreamDefaultWriter<string> | undefined;
+
+  constructor() {
+    this.#readyPromise = new Promise((resolve) => {
+      this.#initialized = resolve;
+    });
+  }
+
+  ready() {
+    return this.#readyPromise;
+  }
+
+  async init(webcontainer: WebContainer, terminal: ITerminal) {
+    this.#webcontainer = webcontainer;
+    this.#terminal = terminal;
+
+    // Use all three streams from tee: one for terminal, one for command execution, one for Expo URL detection
+    const { process, commandStream, expoUrlStream } = await this.newBoltShellProcess(webcontainer, terminal);
+    this.#process = process;
+    this.#outputStream = commandStream.getReader();
+
+    // Start background Expo URL watcher immediately
+    this._watchExpoUrlInBackground(expoUrlStream);
+
+    await this.waitTillOscCode('interactive');
+    this.#initialized?.();
+  }
+
+  async newBoltShellProcess(webcontainer: WebContainer, terminal: ITerminal) {
+    const args: string[] = [];
+    const process = await webcontainer.spawn('/bin/jsh', ['--osc', ...args], {
+      terminal: {
+        cols: terminal.cols ?? 80,
+        rows: terminal.rows ?? 15,
+      },
+    });
+
+    const input = process.input.getWriter();
+    this.#shellInputStream = input;
+
+    // Tee the output so we can have three independent readers
+    const [streamA, streamB] = process.output.tee();
+    const [streamC, streamD] = streamB.tee();
+
+    const jshReady = withResolvers<void>();
+    let isInteractive = false;
+    streamA.pipeTo(
+      new WritableStream({
+        write(data) {
+          if (!isInteractive) {
+            const [, osc] = data.match(/\x1b\]654;([^\x07]+)\x07/) || [];
+
+            if (osc === 'interactive') {
+              isInteractive = true;
+              jshReady.resolve();
+            }
+          }
+
+          terminal.write(data);
+        },
+      }),
+    );
+
+    terminal.onData((data) => {
+      if (isInteractive) {
+        input.write(data);
+      }
+    });
+
+    await jshReady.promise;
+
+    // Return all streams for use in init
+    return { process, terminalStream: streamA, commandStream: streamC, expoUrlStream: streamD };
+  }
+
+  // Dedicated background watcher for Expo URL
+  private async _watchExpoUrlInBackground(stream: ReadableStream<string>) {
+    const reader = stream.getReader();
+    let buffer = '';
+    const expoUrlRegex = /(exp:\/\/[^\s]+)/;
+
+    while (true) {
+      const { value, done } = await reader.read();
+
+      if (done) {
+        break;
+      }
+
+      buffer += value || '';
+
+      const expoUrlMatch = buffer.match(expoUrlRegex);
+
+      if (expoUrlMatch) {
+        const cleanUrl = expoUrlMatch[1]
+          .replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '')
+          .replace(/[^\x20-\x7E]+$/g, '');
+        expoUrlAtom.set(cleanUrl);
+        buffer = buffer.slice(buffer.indexOf(expoUrlMatch[1]) + expoUrlMatch[1].length);
+      }
+
+      if (buffer.length > 2048) {
+        buffer = buffer.slice(-2048);
+      }
+    }
+  }
+
+  get terminal() {
+    return this.#terminal;
+  }
+
+  get process() {
+    return this.#process;
+  }
+
+  async executeCommand(sessionId: string, command: string, abort?: () => void): Promise<ExecutionResult> {
+    if (!this.process || !this.terminal) {
+      return undefined;
+    }
+
+    const state = this.executionState.get();
+
+    if (state?.active && state.abort) {
+      state.abort();
+    }
+
+    /*
+     * interrupt the current execution
+     *  this.#shellInputStream?.write('\x03');
+     */
+    this.terminal.input('\x03');
+    await this.waitTillOscCode('prompt');
+
+    if (state && state.executionPrms) {
+      await state.executionPrms;
+    }
+
+    //start a new execution
+    this.terminal.input(command.trim() + '\n');
+
+    //wait for the execution to finish
+    const executionPromise = this.getCurrentExecutionResult();
+    this.executionState.set({ sessionId, active: true, executionPrms: executionPromise, abort });
+
+    const resp = await executionPromise;
+    this.executionState.set({ sessionId, active: false });
+
+    if (resp) {
+      try {
+        resp.output = cleanTerminalOutput(resp.output);
+      } catch (error) {
+        console.log('failed to format terminal output', error);
+      }
+    }
+
+    return resp;
+  }
+
+  async getCurrentExecutionResult(): Promise<ExecutionResult> {
+    const { output, exitCode } = await this.waitTillOscCode('exit');
+    return { output, exitCode };
+  }
+
+  onQRCodeDetected?: (qrCode: string) => void;
+
+  async waitTillOscCode(waitCode: string) {
+    let fullOutput = '';
+    let exitCode: number = 0;
+    let buffer = ''; // <-- Add a buffer to accumulate output
+
+    if (!this.#outputStream) {
+      return { output: fullOutput, exitCode };
+    }
+
+    const tappedStream = this.#outputStream;
+
+    // Regex for Expo URL
+    const expoUrlRegex = /(exp:\/\/[^\s]+)/;
+
+    while (true) {
+      const { value, done } = await tappedStream.read();
+
+      if (done) {
+        break;
+      }
+
+      const text = value || '';
+      fullOutput += text;
+      buffer += text; // <-- Accumulate in buffer
+
+      // Extract Expo URL from buffer and set store
+      const expoUrlMatch = buffer.match(expoUrlRegex);
+
+      if (expoUrlMatch) {
+        // Remove any trailing ANSI escape codes or non-printable characters
+        const cleanUrl = expoUrlMatch[1]
+          .replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '')
+          .replace(/[^\x20-\x7E]+$/g, '');
+        expoUrlAtom.set(cleanUrl);
+
+        // Remove everything up to and including the URL from the buffer to avoid duplicate matches
+        buffer = buffer.slice(buffer.indexOf(expoUrlMatch[1]) + expoUrlMatch[1].length);
+      }
+
+      // Check if command completion signal with exit code
+      const [, osc, , , code] = text.match(/\x1b\]654;([^\x07=]+)=?((-?\d+):(\d+))?\x07/) || [];
+
+      if (osc === 'exit') {
+        exitCode = parseInt(code, 10);
+      }
+
+      if (osc === waitCode) {
+        break;
+      }
+    }
+
+    return { output: fullOutput, exitCode };
+  }
+}
+
+/**
+ * Cleans and formats terminal output while preserving structure and paths
+ * Handles ANSI, OSC, and various terminal control sequences
+ */
+export function cleanTerminalOutput(input: string): string {
+  // Step 1: Remove OSC sequences (including those with parameters)
+  const removeOsc = input
+    .replace(/\x1b\](\d+;[^\x07\x1b]*|\d+[^\x07\x1b]*)\x07/g, '')
+    .replace(/\](\d+;[^\n]*|\d+[^\n]*)/g, '');
+
+  // Step 2: Remove ANSI escape sequences and color codes more thoroughly
+  const removeAnsi = removeOsc
+    // Remove all escape sequences with parameters
+    .replace(/\u001b\[[\?]?[0-9;]*[a-zA-Z]/g, '')
+    .replace(/\x1b\[[\?]?[0-9;]*[a-zA-Z]/g, '')
+    // Remove color codes
+    .replace(/\u001b\[[0-9;]*m/g, '')
+    .replace(/\x1b\[[0-9;]*m/g, '')
+    // Clean up any remaining escape characters
+    .replace(/\u001b/g, '')
+    .replace(/\x1b/g, '');
+
+  // Step 3: Clean up carriage returns and newlines
+  const cleanNewlines = removeAnsi
+    .replace(/\r\n/g, '\n')
+    .replace(/\r/g, '\n')
+    .replace(/\n{3,}/g, '\n\n');
+
+  // Step 4: Add newlines at key breakpoints while preserving paths
+  const formatOutput = cleanNewlines
+    // Preserve prompt line
+    .replace(/^([~\/][^\n❯]+)❯/m, '$1\n❯')
+    // Add newline before command output indicators
+    .replace(/(?<!^|\n)>/g, '\n>')
+    // Add newline before error keywords without breaking paths
+    .replace(/(?<!^|\n|\w)(error|failed|warning|Error|Failed|Warning):/g, '\n$1:')
+    // Add newline before 'at' in stack traces without breaking paths
+    .replace(/(?<!^|\n|\/)(at\s+(?!async|sync))/g, '\nat ')
+    // Ensure 'at async' stays on same line
+    .replace(/\bat\s+async/g, 'at async')
+    // Add newline before npm error indicators
+    .replace(/(?<!^|\n)(npm ERR!)/g, '\n$1');
+
+  // Step 5: Clean up whitespace while preserving intentional spacing
+  const cleanSpaces = formatOutput
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+    .join('\n');
+
+  // Step 6: Final cleanup
+  return cleanSpaces
+    .replace(/\n{3,}/g, '\n\n') // Replace multiple newlines with double newlines
+    .replace(/:\s+/g, ': ') // Normalize spacing after colons
+    .replace(/\s{2,}/g, ' ') // Remove multiple spaces
+    .replace(/^\s+|\s+$/g, '') // Trim start and end
+    .replace(/\u0000/g, ''); // Remove null characters
+}
+
+export function newBoltShellProcess() {
+  return new BoltShell();
+}

tools/bolt.diy/app/utils/stacktrace.ts

@@ -0,0 +1,27 @@
+/**
+ * Cleans webcontainer URLs from stack traces to show relative paths instead
+ */
+export function cleanStackTrace(stackTrace: string): string {
+  // Function to clean a single URL
+  const cleanUrl = (url: string): string => {
+    const regex = /^https?:\/\/[^\/]+\.webcontainer-api\.io(\/.*)?$/;
+
+    if (!regex.test(url)) {
+      return url;
+    }
+
+    const pathRegex = /^https?:\/\/[^\/]+\.webcontainer-api\.io\/(.*?)$/;
+    const match = url.match(pathRegex);
+
+    return match?.[1] || '';
+  };
+
+  // Split the stack trace into lines and process each line
+  return stackTrace
+    .split('\n')
+    .map((line) => {
+      // Match any URL in the line that contains webcontainer-api.io
+      return line.replace(/(https?:\/\/[^\/]+\.webcontainer-api\.io\/[^\s\)]+)/g, (match) => cleanUrl(match));
+    })
+    .join('\n');
+}

tools/bolt.diy/app/utils/stripIndent.ts

@@ -0,0 +1,23 @@
+export function stripIndents(value: string): string;
+export function stripIndents(strings: TemplateStringsArray, ...values: any[]): string;
+export function stripIndents(arg0: string | TemplateStringsArray, ...values: any[]) {
+  if (typeof arg0 !== 'string') {
+    const processedString = arg0.reduce((acc, curr, i) => {
+      acc += curr + (values[i] ?? '');
+      return acc;
+    }, '');
+
+    return _stripIndents(processedString);
+  }
+
+  return _stripIndents(arg0);
+}
+
+function _stripIndents(value: string) {
+  return value
+    .split('\n')
+    .map((line) => line.trim())
+    .join('\n')
+    .trimStart()
+    .replace(/[\r\n]$/, '');
+}

tools/bolt.diy/app/utils/terminal.ts

@@ -0,0 +1,11 @@
+const reset = '\x1b[0m';
+
+export const escapeCodes = {
+  reset,
+  clear: '\x1b[g',
+  red: '\x1b[1;31m',
+};
+
+export const coloredText = {
+  red: (text: string) => `${escapeCodes.red}${text}${reset}`,
+};

tools/bolt.diy/app/utils/unreachable.ts

@@ -0,0 +1,3 @@
+export function unreachable(message: string): never {
+  throw new Error(`Unreachable: ${message}`);
+}