crca 1.4.0__py3-none-any.whl

tools/bolt.diy/app/utils/diff.spec.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from 'vitest';
+import { extractRelativePath } from './diff';
+import { WORK_DIR } from './constants';
+
+describe('Diff', () => {
+  it('should strip out Work_dir', () => {
+    const filePath = `${WORK_DIR}/index.js`;
+    const result = extractRelativePath(filePath);
+    expect(result).toBe('index.js');
+  });
+});

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

@@ -0,0 +1,117 @@
+import { createTwoFilesPatch } from 'diff';
+import type { FileMap } from '~/lib/stores/files';
+import { MODIFICATIONS_TAG_NAME, WORK_DIR } from './constants';
+
+export const modificationsRegex = new RegExp(
+  `^<${MODIFICATIONS_TAG_NAME}>[\\s\\S]*?<\\/${MODIFICATIONS_TAG_NAME}>\\s+`,
+  'g',
+);
+
+interface ModifiedFile {
+  type: 'diff' | 'file';
+  content: string;
+}
+
+type FileModifications = Record<string, ModifiedFile>;
+
+export function computeFileModifications(files: FileMap, modifiedFiles: Map<string, string>) {
+  const modifications: FileModifications = {};
+
+  let hasModifiedFiles = false;
+
+  for (const [filePath, originalContent] of modifiedFiles) {
+    const file = files[filePath];
+
+    if (file?.type !== 'file') {
+      continue;
+    }
+
+    const unifiedDiff = diffFiles(filePath, originalContent, file.content);
+
+    if (!unifiedDiff) {
+      // files are identical
+      continue;
+    }
+
+    hasModifiedFiles = true;
+
+    if (unifiedDiff.length > file.content.length) {
+      // if there are lots of changes we simply grab the current file content since it's smaller than the diff
+      modifications[filePath] = { type: 'file', content: file.content };
+    } else {
+      // otherwise we use the diff since it's smaller
+      modifications[filePath] = { type: 'diff', content: unifiedDiff };
+    }
+  }
+
+  if (!hasModifiedFiles) {
+    return undefined;
+  }
+
+  return modifications;
+}
+
+/**
+ * Computes a diff in the unified format. The only difference is that the header is omitted
+ * because it will always assume that you're comparing two versions of the same file and
+ * it allows us to avoid the extra characters we send back to the llm.
+ *
+ * @see https://www.gnu.org/software/diffutils/manual/html_node/Unified-Format.html
+ */
+export function diffFiles(fileName: string, oldFileContent: string, newFileContent: string) {
+  let unifiedDiff = createTwoFilesPatch(fileName, fileName, oldFileContent, newFileContent);
+
+  const patchHeaderEnd = `--- ${fileName}\n+++ ${fileName}\n`;
+  const headerEndIndex = unifiedDiff.indexOf(patchHeaderEnd);
+
+  if (headerEndIndex >= 0) {
+    unifiedDiff = unifiedDiff.slice(headerEndIndex + patchHeaderEnd.length);
+  }
+
+  if (unifiedDiff === '') {
+    return undefined;
+  }
+
+  return unifiedDiff;
+}
+
+const regex = new RegExp(`^${WORK_DIR}\/`);
+
+/**
+ * Strips out the work directory from the file path.
+ */
+export function extractRelativePath(filePath: string) {
+  return filePath.replace(regex, '');
+}
+
+/**
+ * Converts the unified diff to HTML.
+ *
+ * Example:
+ *
+ * ```html
+ * <bolt_file_modifications>
+ * <diff path="/home/project/index.js">
+ * - console.log('Hello, World!');
+ * + console.log('Hello, Bolt!');
+ * </diff>
+ * </bolt_file_modifications>
+ * ```
+ */
+export function fileModificationsToHTML(modifications: FileModifications) {
+  const entries = Object.entries(modifications);
+
+  if (entries.length === 0) {
+    return undefined;
+  }
+
+  const result: string[] = [`<${MODIFICATIONS_TAG_NAME}>`];
+
+  for (const [filePath, { type, content }] of entries) {
+    result.push(`<${type} path=${JSON.stringify(filePath)}>`, content, `</${type}>`);
+  }
+
+  result.push(`</${MODIFICATIONS_TAG_NAME}>`);
+
+  return result.join('\n');
+}

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

@@ -0,0 +1,3 @@
+import { cubicBezier } from 'framer-motion';
+
+export const cubicEasingFn = cubicBezier(0.4, 0, 0.2, 1);

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

@@ -0,0 +1,96 @@
+import {
+  getLockedItems,
+  isFileLocked as isFileLockedInternal,
+  isFolderLocked as isFolderLockedInternal,
+  isPathInLockedFolder,
+} from '~/lib/persistence/lockedFiles';
+import { createScopedLogger } from './logger';
+
+const logger = createScopedLogger('FileLocks');
+
+/**
+ * Get the current chat ID from the URL
+ * @returns The current chat ID or a default value if not found
+ */
+export function getCurrentChatId(): string {
+  try {
+    if (typeof window !== 'undefined') {
+      // Extract chat ID from URL (format: /chat/123)
+      const match = window.location.pathname.match(/\/chat\/([^/]+)/);
+
+      if (match && match[1]) {
+        return match[1];
+      }
+    }
+
+    // Return a default chat ID if none is found
+    return 'default';
+  } catch (error) {
+    logger.error('Failed to get current chat ID', error);
+    return 'default';
+  }
+}
+
+/**
+ * Check if a file is locked directly from localStorage
+ * This avoids circular dependencies between components and stores
+ * @param filePath The path of the file to check
+ * @param chatId Optional chat ID (will be extracted from URL if not provided)
+ */
+export function isFileLocked(filePath: string, chatId?: string): { locked: boolean; lockedBy?: string } {
+  try {
+    const currentChatId = chatId || getCurrentChatId();
+
+    // Use the internal function from lockedFiles.ts
+    const result = isFileLockedInternal(currentChatId, filePath);
+
+    // If the file itself is not locked, check if it's in a locked folder
+    if (!result.locked) {
+      const folderLockResult = isPathInLockedFolder(currentChatId, filePath);
+
+      if (folderLockResult.locked) {
+        return folderLockResult;
+      }
+    }
+
+    return result;
+  } catch (error) {
+    logger.error('Failed to check if file is locked', error);
+    return { locked: false };
+  }
+}
+
+/**
+ * Check if a folder is locked directly from localStorage
+ * This avoids circular dependencies between components and stores
+ * @param folderPath The path of the folder to check
+ * @param chatId Optional chat ID (will be extracted from URL if not provided)
+ */
+export function isFolderLocked(folderPath: string, chatId?: string): { locked: boolean; lockedBy?: string } {
+  try {
+    const currentChatId = chatId || getCurrentChatId();
+
+    // Use the internal function from lockedFiles.ts
+    return isFolderLockedInternal(currentChatId, folderPath);
+  } catch (error) {
+    logger.error('Failed to check if folder is locked', error);
+    return { locked: false };
+  }
+}
+
+/**
+ * Check if any files are locked in the current chat
+ * @param chatId Optional chat ID (will be extracted from URL if not provided)
+ * @returns True if any files or folders are locked
+ */
+export function hasLockedItems(chatId?: string): boolean {
+  try {
+    const currentChatId = chatId || getCurrentChatId();
+    const lockedItems = getLockedItems();
+
+    return lockedItems.some((item) => item.chatId === currentChatId);
+  } catch (error) {
+    logger.error('Failed to check for locked items', error);
+    return false;
+  }
+}

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

@@ -0,0 +1,121 @@
+import ignore from 'ignore';
+
+// Common patterns to ignore, similar to .gitignore
+export const IGNORE_PATTERNS = [
+  'node_modules/**',
+  '.git/**',
+  'dist/**',
+  'build/**',
+  '.next/**',
+  'coverage/**',
+  '.cache/**',
+  '.vscode/**',
+  '.idea/**',
+  '**/*.log',
+  '**/.DS_Store',
+  '**/npm-debug.log*',
+  '**/yarn-debug.log*',
+  '**/yarn-error.log*',
+];
+
+export const MAX_FILES = 1000;
+export const ig = ignore().add(IGNORE_PATTERNS);
+
+export const generateId = () => Math.random().toString(36).substring(2, 15);
+
+export const isBinaryFile = async (file: File): Promise<boolean> => {
+  const chunkSize = 1024;
+  const buffer = new Uint8Array(await file.slice(0, chunkSize).arrayBuffer());
+
+  for (let i = 0; i < buffer.length; i++) {
+    const byte = buffer[i];
+
+    if (byte === 0 || (byte < 32 && byte !== 9 && byte !== 10 && byte !== 13)) {
+      return true;
+    }
+  }
+
+  return false;
+};
+
+export const shouldIncludeFile = (path: string): boolean => {
+  return !ig.ignores(path);
+};
+
+const readPackageJson = async (files: File[]): Promise<{ scripts?: Record<string, string> } | null> => {
+  const packageJsonFile = files.find((f) => f.webkitRelativePath.endsWith('package.json'));
+
+  if (!packageJsonFile) {
+    return null;
+  }
+
+  try {
+    const content = await new Promise<string>((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = () => resolve(reader.result as string);
+      reader.onerror = reject;
+      reader.readAsText(packageJsonFile);
+    });
+
+    return JSON.parse(content);
+  } catch (error) {
+    console.error('Error reading package.json:', error);
+    return null;
+  }
+};
+
+export const detectProjectType = async (
+  files: File[],
+): Promise<{ type: string; setupCommand: string; followupMessage: string }> => {
+  const hasFile = (name: string) => files.some((f) => f.webkitRelativePath.endsWith(name));
+
+  if (hasFile('package.json')) {
+    const packageJson = await readPackageJson(files);
+    const scripts = packageJson?.scripts || {};
+
+    // Check for preferred commands in priority order
+    const preferredCommands = ['dev', 'start', 'preview'];
+    const availableCommand = preferredCommands.find((cmd) => scripts[cmd]);
+
+    if (availableCommand) {
+      return {
+        type: 'Node.js',
+        setupCommand: `npm install && npm run ${availableCommand}`,
+        followupMessage: `Found "${availableCommand}" script in package.json. Running "npm run ${availableCommand}" after installation.`,
+      };
+    }
+
+    return {
+      type: 'Node.js',
+      setupCommand: 'npm install',
+      followupMessage:
+        'Would you like me to inspect package.json to determine the available scripts for running this project?',
+    };
+  }
+
+  if (hasFile('index.html')) {
+    return {
+      type: 'Static',
+      setupCommand: 'npx --yes serve',
+      followupMessage: '',
+    };
+  }
+
+  return { type: '', setupCommand: '', followupMessage: '' };
+};
+
+export const filesToArtifacts = (files: { [path: string]: { content: string } }, id: string): string => {
+  return `
+<boltArtifact id="${id}" title="User Updated Files">
+${Object.keys(files)
+  .map(
+    (filePath) => `
+<boltAction type="file" filePath="${filePath}">
+${files[filePath].content}
+</boltAction>
+`,
+  )
+  .join('\n')}
+</boltArtifact>
+  `;
+};

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

@@ -0,0 +1,73 @@
+import type { Message } from 'ai';
+import { generateId } from './fileUtils';
+import { detectProjectCommands, createCommandsMessage, escapeBoltTags } from './projectCommands';
+
+export const createChatFromFolder = async (
+  files: File[],
+  binaryFiles: string[],
+  folderName: string,
+): Promise<Message[]> => {
+  const fileArtifacts = await Promise.all(
+    files.map(async (file) => {
+      return new Promise<{ content: string; path: string }>((resolve, reject) => {
+        const reader = new FileReader();
+
+        reader.onload = () => {
+          const content = reader.result as string;
+          const relativePath = file.webkitRelativePath.split('/').slice(1).join('/');
+          resolve({
+            content,
+            path: relativePath,
+          });
+        };
+        reader.onerror = reject;
+        reader.readAsText(file);
+      });
+    }),
+  );
+
+  const commands = await detectProjectCommands(fileArtifacts);
+  const commandsMessage = createCommandsMessage(commands);
+
+  const binaryFilesMessage =
+    binaryFiles.length > 0
+      ? `\n\nSkipped ${binaryFiles.length} binary files:\n${binaryFiles.map((f) => `- ${f}`).join('\n')}`
+      : '';
+
+  const filesMessage: Message = {
+    role: 'assistant',
+    content: `I've imported the contents of the "${folderName}" folder.${binaryFilesMessage}
+
+<boltArtifact id="imported-files" title="Imported Files" type="bundled" >
+${fileArtifacts
+  .map(
+    (file) => `<boltAction type="file" filePath="${file.path}">
+${escapeBoltTags(file.content)}
+</boltAction>`,
+  )
+  .join('\n\n')}
+</boltArtifact>`,
+    id: generateId(),
+    createdAt: new Date(),
+  };
+
+  const userMessage: Message = {
+    role: 'user',
+    id: generateId(),
+    content: `Import the "${folderName}" folder`,
+    createdAt: new Date(),
+  };
+
+  const messages = [userMessage, filesMessage];
+
+  if (commandsMessage) {
+    messages.push({
+      role: 'user',
+      id: generateId(),
+      content: 'Setup the codebase and Start the application',
+    });
+    messages.push(commandsMessage);
+  }
+
+  return messages;
+};

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

@@ -0,0 +1,12 @@
+export function formatSize(bytes: number): string {
+  const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+  let size = bytes;
+  let unitIndex = 0;
+
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+
+  return `${size.toFixed(1)} ${units[unitIndex]}`;
+}

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

@@ -0,0 +1,24 @@
+export const getLanguageFromExtension = (ext: string): string => {
+  const map: Record<string, string> = {
+    js: 'javascript',
+    jsx: 'jsx',
+    ts: 'typescript',
+    tsx: 'tsx',
+    json: 'json',
+    html: 'html',
+    css: 'css',
+    py: 'python',
+    java: 'java',
+    rb: 'ruby',
+    cpp: 'cpp',
+    c: 'c',
+    cs: 'csharp',
+    go: 'go',
+    rs: 'rust',
+    php: 'php',
+    swift: 'swift',
+    md: 'plaintext',
+    sh: 'bash',
+  };
+  return map[ext] || 'typescript';
+};

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

@@ -0,0 +1,9 @@
+import type { GitHubStats } from '~/types/GitHub';
+
+export function calculateStatsSummary(stats: GitHubStats): GitHubStats {
+  return {
+    ...stats,
+
+    // Add any calculated fields that might be missing
+  };
+}

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

@@ -0,0 +1,54 @@
+import type { GitLabProjectInfo, GitLabStats } from '~/types/GitLab';
+
+export function calculateProjectStats(projects: any[]): { projects: GitLabProjectInfo[] } {
+  const projectStats = {
+    projects: projects.map((project: any) => ({
+      id: project.id,
+      name: project.name,
+      path_with_namespace: project.path_with_namespace,
+      description: project.description,
+      http_url_to_repo: project.http_url_to_repo,
+      star_count: project.star_count || 0,
+      forks_count: project.forks_count || 0,
+      default_branch: project.default_branch,
+      updated_at: project.updated_at,
+      visibility: project.visibility,
+    })),
+  };
+
+  return projectStats;
+}
+
+export function calculateStatsSummary(
+  projects: GitLabProjectInfo[],
+  events: any[],
+  groups: any[],
+  snippets: any[],
+  user: any,
+): GitLabStats {
+  const totalStars = projects.reduce((sum, p) => sum + (p.star_count || 0), 0);
+  const totalForks = projects.reduce((sum, p) => sum + (p.forks_count || 0), 0);
+  const privateProjects = projects.filter((p) => p.visibility === 'private').length;
+
+  const recentActivity = events.slice(0, 5).map((event: any) => ({
+    id: event.id,
+    action_name: event.action_name,
+    project_id: event.project_id,
+    project: event.project,
+    created_at: event.created_at,
+  }));
+
+  return {
+    projects,
+    recentActivity,
+    totalSnippets: snippets.length,
+    publicProjects: projects.filter((p) => p.visibility === 'public').length,
+    privateProjects,
+    stars: totalStars,
+    forks: totalForks,
+    followers: user.followers || 0,
+    snippets: snippets.length,
+    groups,
+    lastUpdated: new Date().toISOString(),
+  };
+}

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

@@ -0,0 +1,162 @@
+export type DebugLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'none';
+import { Chalk } from 'chalk';
+
+const chalk = new Chalk({ level: 3 });
+
+type LoggerFunction = (...messages: any[]) => void;
+
+interface Logger {
+  trace: LoggerFunction;
+  debug: LoggerFunction;
+  info: LoggerFunction;
+  warn: LoggerFunction;
+  error: LoggerFunction;
+  setLevel: (level: DebugLevel) => void;
+}
+
+let currentLevel: DebugLevel = import.meta.env.VITE_LOG_LEVEL || (import.meta.env.DEV ? 'debug' : 'info');
+
+export const logger: Logger = {
+  trace: (...messages: any[]) => logWithDebugCapture('trace', undefined, messages),
+  debug: (...messages: any[]) => logWithDebugCapture('debug', undefined, messages),
+  info: (...messages: any[]) => logWithDebugCapture('info', undefined, messages),
+  warn: (...messages: any[]) => logWithDebugCapture('warn', undefined, messages),
+  error: (...messages: any[]) => logWithDebugCapture('error', undefined, messages),
+  setLevel,
+};
+
+export function createScopedLogger(scope: string): Logger {
+  return {
+    trace: (...messages: any[]) => logWithDebugCapture('trace', scope, messages),
+    debug: (...messages: any[]) => logWithDebugCapture('debug', scope, messages),
+    info: (...messages: any[]) => logWithDebugCapture('info', scope, messages),
+    warn: (...messages: any[]) => logWithDebugCapture('warn', scope, messages),
+    error: (...messages: any[]) => logWithDebugCapture('error', scope, messages),
+    setLevel,
+  };
+}
+
+function setLevel(level: DebugLevel) {
+  if ((level === 'trace' || level === 'debug') && import.meta.env.PROD) {
+    return;
+  }
+
+  currentLevel = level;
+}
+
+function log(level: DebugLevel, scope: string | undefined, messages: any[]) {
+  const levelOrder: DebugLevel[] = ['trace', 'debug', 'info', 'warn', 'error', 'none'];
+
+  if (levelOrder.indexOf(level) < levelOrder.indexOf(currentLevel)) {
+    return;
+  }
+
+  // If current level is 'none', don't log anything
+  if (currentLevel === 'none') {
+    return;
+  }
+
+  const allMessages = messages.reduce((acc, current) => {
+    if (acc.endsWith('\n')) {
+      return acc + current;
+    }
+
+    if (!acc) {
+      return current;
+    }
+
+    return `${acc} ${current}`;
+  }, '');
+
+  const labelBackgroundColor = getColorForLevel(level);
+  const labelTextColor = level === 'warn' ? '#000000' : '#FFFFFF';
+
+  const labelStyles = getLabelStyles(labelBackgroundColor, labelTextColor);
+  const scopeStyles = getLabelStyles('#77828D', 'white');
+
+  const styles = [labelStyles];
+
+  if (typeof scope === 'string') {
+    styles.push('', scopeStyles);
+  }
+
+  let labelText = formatText(` ${level.toUpperCase()} `, labelTextColor, labelBackgroundColor);
+
+  if (scope) {
+    labelText = `${labelText} ${formatText(` ${scope} `, '#FFFFFF', '77828D')}`;
+  }
+
+  if (typeof window !== 'undefined') {
+    console.log(`%c${level.toUpperCase()}${scope ? `%c %c${scope}` : ''}`, ...styles, allMessages);
+  } else {
+    console.log(`${labelText}`, allMessages);
+  }
+}
+
+function formatText(text: string, color: string, bg: string) {
+  return chalk.bgHex(bg)(chalk.hex(color)(text));
+}
+
+function getLabelStyles(color: string, textColor: string) {
+  return `background-color: ${color}; color: white; border: 4px solid ${color}; color: ${textColor};`;
+}
+
+function getColorForLevel(level: DebugLevel): string {
+  switch (level) {
+    case 'trace':
+    case 'debug': {
+      return '#77828D';
+    }
+    case 'info': {
+      return '#1389FD';
+    }
+    case 'warn': {
+      return '#FFDB6C';
+    }
+    case 'error': {
+      return '#EE4744';
+    }
+    default: {
+      return '#000000';
+    }
+  }
+}
+
+export const renderLogger = createScopedLogger('Render');
+
+// Debug logging integration
+let debugLogger: any = null;
+
+// Lazy load debug logger to avoid circular dependencies
+const getDebugLogger = () => {
+  if (!debugLogger && typeof window !== 'undefined') {
+    try {
+      // Use dynamic import asynchronously but don't block the function
+      import('./debugLogger')
+        .then(({ debugLogger: loggerInstance }) => {
+          debugLogger = loggerInstance;
+        })
+        .catch(() => {
+          // Debug logger not available, skip integration
+        });
+    } catch {
+      // Debug logger not available, skip integration
+    }
+  }
+
+  return debugLogger;
+};
+
+// Override the log function to also capture to debug logger
+
+function logWithDebugCapture(level: DebugLevel, scope: string | undefined, messages: any[]) {
+  // Call original log function (the one that does the actual console logging)
+  log(level, scope, messages);
+
+  // Also capture to debug logger if available
+  const debug = getDebugLogger();
+
+  if (debug) {
+    debug.captureLog(level, scope, messages);
+  }
+}