@the-bearded-bear/claude-craft 3.0.0

package/Tools/i18n/projects/pt.sh

@@ -0,0 +1,132 @@
+#!/bin/bash
+# =============================================================================
+# Claude Projects - Mensagens em Português
+# =============================================================================
+
+# Header
+MSG_HEADER="Gestor de Projetos Claude"
+
+# Menu
+MSG_MENU_TITLE="O que queres fazer?"
+MSG_MENU_LIST="Listar projetos"
+MSG_MENU_ADD="Adicionar um projeto"
+MSG_MENU_EDIT="Editar um projeto"
+MSG_MENU_MODULE="Adicionar um módulo"
+MSG_MENU_DELETE="Eliminar um projeto"
+MSG_MENU_VALIDATE="Validar configuração"
+MSG_MENU_CHANGE_CONFIG="Mudar arquivo config"
+MSG_MENU_QUIT="Sair"
+
+# Config file
+MSG_CONFIG_TITLE="Arquivo de configuração"
+MSG_CONFIG_FILES_FOUND="Arquivos encontrados:"
+MSG_CONFIG_OTHER="Outro caminho..."
+MSG_CONFIG_NEW="Novo arquivo"
+MSG_CONFIG_PROMPT="Escolha:"
+MSG_CONFIG_NEW_PATH="Caminho do novo arquivo:"
+MSG_CONFIG_PATH="Caminho do arquivo:"
+MSG_CONFIG_NONE="Nenhum arquivo encontrado."
+MSG_CONFIG_DEFAULT="(padrão:"
+MSG_CONFIG_CREATING="A criar arquivo de configuração..."
+MSG_CONFIG_CREATED="Arquivo criado:"
+MSG_CONFIG_CURRENT="Configuração:"
+
+# Projects
+MSG_PROJECTS_TITLE="Projetos configurados"
+MSG_PROJECTS_NONE="Nenhum projeto configurado"
+MSG_PROJECTS_USE_ADD="Usa Adicionar projeto para começar"
+MSG_PROJECTS_SELECT="Seleciona um projeto:"
+MSG_PROJECTS_MODULES="módulo(s)"
+MSG_PROJECTS_COMMON="Common:"
+
+# Add project
+MSG_ADD_PROJECT_TITLE="Adicionar um novo projeto"
+MSG_ADD_PROJECT_NAME="Nome do projeto (ex: minha-app):"
+MSG_ADD_PROJECT_NAME_EMPTY="O nome não pode estar vazio"
+MSG_ADD_PROJECT_EXISTS="O projeto já existe"
+MSG_ADD_PROJECT_DESC="Descrição (opcional):"
+MSG_ADD_PROJECT_ROOT="Caminho raiz (ex: ~/Projects/minha-app):"
+MSG_ADD_PROJECT_ROOT_EMPTY="O caminho não pode estar vazio"
+MSG_ADD_PROJECT_COMMON="Instalar regras comuns na raiz?"
+MSG_ADD_PROJECT_CREATED="Projeto criado"
+MSG_ADD_PROJECT_MODULES_NOW="Adicionar módulos agora?"
+
+# Edit project
+MSG_EDIT_PROJECT_TITLE="Editar um projeto"
+MSG_EDIT_PROJECT_SELECT="Seleciona um projeto para editar:"
+MSG_EDIT_PROJECT_EDITING="A editar"
+MSG_EDIT_PROJECT_KEEP="(Prime Enter para manter o valor atual)"
+MSG_EDIT_PROJECT_NAME="Nome"
+MSG_EDIT_PROJECT_DESC="Descrição"
+MSG_EDIT_PROJECT_ROOT="Caminho raiz"
+MSG_EDIT_PROJECT_COMMON="Instalar common?"
+MSG_EDIT_PROJECT_DONE="Projeto modificado"
+MSG_EDIT_PROJECT_MANAGE_MODULES="Gerir módulos?"
+
+# Delete project
+MSG_DELETE_PROJECT_TITLE="Eliminar um projeto"
+MSG_DELETE_PROJECT_SELECT="Seleciona um projeto para eliminar:"
+MSG_DELETE_PROJECT_CONFIRM="Vais eliminar o projeto"
+MSG_DELETE_PROJECT_CANCELLED="Eliminação cancelada"
+MSG_DELETE_PROJECT_DONE="Projeto eliminado"
+
+# Modules
+MSG_MODULES_TITLE="Módulos de"
+MSG_MODULES_NONE="Nenhum módulo"
+MSG_MODULES_ADD="Adicionar um módulo"
+MSG_MODULES_DELETE="Eliminar um módulo"
+MSG_MODULES_BACK="Voltar"
+MSG_MODULES_ADD_TO="Adicionar um módulo a"
+MSG_MODULES_PATH="Caminho do módulo (ex: frontend, backend, . para raiz):"
+MSG_MODULES_PATH_EMPTY="O caminho não pode estar vazio"
+MSG_MODULES_TECH="Tecnologias disponíveis:"
+MSG_MODULES_TECH_PROMPT="Escolha:"
+MSG_MODULES_DESC="Descrição (opcional):"
+MSG_MODULES_ADDED="Módulo adicionado"
+MSG_MODULES_DELETE_PROMPT="Número do módulo a eliminar:"
+MSG_MODULES_DELETED="Módulo eliminado"
+MSG_MODULES_ADD_ANOTHER="Adicionar outro módulo?"
+
+# Validation
+MSG_VALIDATE_TITLE="Validação da configuração"
+MSG_VALIDATE_PROJECT="Projeto:"
+MSG_VALIDATE_NAME_MISSING="Nome em falta"
+MSG_VALIDATE_ROOT_MISSING="Caminho raiz em falta"
+MSG_VALIDATE_DIR_NOT_FOUND="Diretório não encontrado:"
+MSG_VALIDATE_DIR_FOUND="Diretório encontrado:"
+MSG_VALIDATE_NO_MODULE="Nenhum módulo configurado"
+MSG_VALIDATE_INVALID_TECH="tecnologia inválida"
+MSG_VALIDATE_MODULE="Módulo"
+MSG_VALIDATE_SUMMARY="Resumo:"
+MSG_VALIDATE_PROJECTS="Projetos:"
+MSG_VALIDATE_ERRORS="Erros:"
+MSG_VALIDATE_WARNINGS="Avisos:"
+MSG_VALIDATE_OK="Configuração válida"
+MSG_VALIDATE_FAIL="Configuração inválida - corrige os erros"
+
+# Usage/Help
+MSG_USAGE_TITLE="Utilização"
+MSG_USAGE_INTERACTIVE="Modo interativo:"
+MSG_USAGE_MENU="Menu interativo"
+MSG_USAGE_COMMANDS="Comandos diretos:"
+MSG_USAGE_LIST="Lista projetos"
+MSG_USAGE_ADD="Adiciona um projeto"
+MSG_USAGE_EDIT="Edita um projeto"
+MSG_USAGE_DELETE="Elimina um projeto"
+MSG_USAGE_VALIDATE="Valida a configuração"
+MSG_USAGE_OPTIONS="Opções:"
+MSG_USAGE_CONFIG="Arquivo de configuração"
+MSG_USAGE_LANG="Língua (en, fr, es, de, pt)"
+MSG_USAGE_EXAMPLES="Exemplos:"
+
+# Common
+MSG_YQ_REQUIRED="yq é necessário mas não está instalado"
+MSG_YQ_INSTALL="Instalação:"
+MSG_INVALID_CHOICE="Escolha inválida"
+MSG_UNKNOWN_COMMAND="Comando desconhecido:"
+MSG_GOODBYE="Até breve!"
+MSG_CONFIRM_YES_NO="(s/N)"
+MSG_YES_NO_DEFAULT="(S/n)"
+MSG_PRESS_ENTER="Prime Enter para continuar..."
+MSG_INVALID_LANG="Língua inválida:"
+MSG_VALID_LANGS="Línguas válidas:"

package/cli/flattener.js

@@ -0,0 +1,487 @@
+#!/usr/bin/env node
+
+/**
+ * Codebase Flattener
+ * Generates a context-optimized summary of a codebase for AI assistants
+ *
+ * Features:
+ * - Smart file selection (ignores node_modules, vendor, etc.)
+ * - Document sharding for large codebases
+ * - Token estimation
+ * - Priority-based file ordering
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// ANSI colors
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+};
+
+// Default ignore patterns
+const DEFAULT_IGNORES = [
+  'node_modules',
+  'vendor',
+  '.git',
+  '.claude',
+  '__pycache__',
+  '.pytest_cache',
+  '.next',
+  '.nuxt',
+  'dist',
+  'build',
+  'coverage',
+  '.idea',
+  '.vscode',
+  '*.log',
+  '*.lock',
+  'package-lock.json',
+  'yarn.lock',
+  'composer.lock',
+  'pubspec.lock',
+  '*.min.js',
+  '*.min.css',
+  '*.map',
+  '*.pyc',
+  '*.pyo',
+  '.DS_Store',
+  'Thumbs.db',
+  '*.sqlite',
+  '*.db',
+  '.env',
+  '.env.*',
+  '*.key',
+  '*.pem',
+  '*.cert',
+];
+
+// Priority extensions (most relevant for understanding code)
+const PRIORITY_EXTENSIONS = {
+  high: ['.md', '.yaml', '.yml', '.json', '.ts', '.tsx', '.js', '.jsx', '.py', '.php', '.dart', '.sql'],
+  medium: ['.html', '.css', '.scss', '.less', '.vue', '.svelte', '.graphql', '.prisma'],
+  low: ['.txt', '.xml', '.ini', '.cfg', '.conf', '.toml'],
+};
+
+// Approximate tokens per character (GPT-4 average)
+const TOKENS_PER_CHAR = 0.25;
+
+// Max tokens per shard (leaving room for conversation)
+const MAX_TOKENS_PER_SHARD = 50000;
+
+class CodebaseFlattener {
+  constructor(rootPath, options = {}) {
+    this.rootPath = path.resolve(rootPath);
+    this.options = {
+      maxTokens: options.maxTokens || MAX_TOKENS_PER_SHARD,
+      maxFileSize: options.maxFileSize || 50000, // 50KB per file
+      ignorePatterns: [...DEFAULT_IGNORES, ...(options.ignore || [])],
+      includePatterns: options.include || null,
+      sharding: options.sharding !== false,
+      priority: options.priority || 'high',
+      ...options,
+    };
+
+    this.stats = {
+      totalFiles: 0,
+      includedFiles: 0,
+      totalSize: 0,
+      estimatedTokens: 0,
+      shards: 0,
+    };
+
+    this.files = [];
+  }
+
+  // Check if path should be ignored
+  shouldIgnore(relativePath) {
+    const basename = path.basename(relativePath);
+
+    for (const pattern of this.options.ignorePatterns) {
+      if (pattern.startsWith('*')) {
+        // Extension pattern
+        if (basename.endsWith(pattern.slice(1))) return true;
+      } else {
+        // Directory/file name pattern
+        if (relativePath.includes(pattern) || basename === pattern) return true;
+      }
+    }
+
+    return false;
+  }
+
+  // Get file priority
+  getFilePriority(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+
+    if (PRIORITY_EXTENSIONS.high.includes(ext)) return 1;
+    if (PRIORITY_EXTENSIONS.medium.includes(ext)) return 2;
+    if (PRIORITY_EXTENSIONS.low.includes(ext)) return 3;
+    return 4;
+  }
+
+  // Check if file is binary
+  isBinaryFile(filePath) {
+    const binaryExtensions = [
+      '.png', '.jpg', '.jpeg', '.gif', '.ico', '.svg', '.webp',
+      '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',
+      '.zip', '.tar', '.gz', '.rar', '.7z',
+      '.mp3', '.mp4', '.wav', '.avi', '.mov',
+      '.exe', '.dll', '.so', '.dylib',
+      '.ttf', '.otf', '.woff', '.woff2', '.eot',
+    ];
+
+    const ext = path.extname(filePath).toLowerCase();
+    return binaryExtensions.includes(ext);
+  }
+
+  // Scan directory recursively
+  scanDirectory(dirPath, relativePath = '') {
+    try {
+      const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name);
+        const relPath = path.join(relativePath, entry.name);
+
+        if (this.shouldIgnore(relPath)) continue;
+
+        if (entry.isDirectory()) {
+          this.scanDirectory(fullPath, relPath);
+        } else if (entry.isFile()) {
+          this.stats.totalFiles++;
+
+          if (this.isBinaryFile(fullPath)) continue;
+
+          try {
+            const stats = fs.statSync(fullPath);
+            if (stats.size > this.options.maxFileSize) continue;
+
+            this.files.push({
+              path: relPath,
+              fullPath: fullPath,
+              size: stats.size,
+              priority: this.getFilePriority(fullPath),
+              tokens: Math.ceil(stats.size * TOKENS_PER_CHAR),
+            });
+
+            this.stats.includedFiles++;
+            this.stats.totalSize += stats.size;
+
+          } catch (e) {
+            // Skip unreadable files
+          }
+        }
+      }
+    } catch (e) {
+      console.error(`${c.yellow}Warning: Cannot read directory ${dirPath}${c.reset}`);
+    }
+  }
+
+  // Generate file tree
+  generateFileTree() {
+    const tree = {};
+
+    for (const file of this.files) {
+      const parts = file.path.split(path.sep);
+      let current = tree;
+
+      for (let i = 0; i < parts.length - 1; i++) {
+        if (!current[parts[i]]) current[parts[i]] = {};
+        current = current[parts[i]];
+      }
+
+      current[parts[parts.length - 1]] = null;
+    }
+
+    const renderTree = (node, prefix = '', isLast = true) => {
+      let result = '';
+      const entries = Object.entries(node);
+
+      entries.forEach(([name, children], index) => {
+        const isLastEntry = index === entries.length - 1;
+        const connector = isLastEntry ? '└── ' : '├── ';
+        const extension = isLastEntry ? '    ' : '│   ';
+
+        result += prefix + connector + name + '\n';
+
+        if (children !== null) {
+          result += renderTree(children, prefix + extension, isLastEntry);
+        }
+      });
+
+      return result;
+    };
+
+    return renderTree(tree);
+  }
+
+  // Generate output content
+  generateOutput() {
+    // Sort files by priority, then by path
+    this.files.sort((a, b) => {
+      if (a.priority !== b.priority) return a.priority - b.priority;
+      return a.path.localeCompare(b.path);
+    });
+
+    let content = `# Codebase Context: ${path.basename(this.rootPath)}
+
+Generated: ${new Date().toISOString()}
+Root: ${this.rootPath}
+
+## Statistics
+
+- Total files scanned: ${this.stats.totalFiles}
+- Files included: ${this.stats.includedFiles}
+- Total size: ${(this.stats.totalSize / 1024).toFixed(2)} KB
+- Estimated tokens: ~${Math.ceil(this.stats.totalSize * TOKENS_PER_CHAR).toLocaleString()}
+
+## File Tree
+
+\`\`\`
+${path.basename(this.rootPath)}/
+${this.generateFileTree()}\`\`\`
+
+## File Contents
+
+`;
+
+    // Add file contents
+    for (const file of this.files) {
+      try {
+        const fileContent = fs.readFileSync(file.fullPath, 'utf8');
+        const ext = path.extname(file.path).slice(1) || 'text';
+
+        content += `### ${file.path}
+
+\`\`\`${ext}
+${fileContent}
+\`\`\`
+
+`;
+      } catch (e) {
+        content += `### ${file.path}
+
+\`\`\`
+[Error reading file: ${e.message}]
+\`\`\`
+
+`;
+      }
+    }
+
+    this.stats.estimatedTokens = Math.ceil(content.length * TOKENS_PER_CHAR);
+    return content;
+  }
+
+  // Generate sharded output
+  generateShardedOutput() {
+    // Sort files by priority
+    this.files.sort((a, b) => {
+      if (a.priority !== b.priority) return a.priority - b.priority;
+      return a.path.localeCompare(b.path);
+    });
+
+    const shards = [];
+    let currentShard = {
+      files: [],
+      tokens: 0,
+    };
+
+    const headerTokens = 500; // Approximate header tokens
+
+    for (const file of this.files) {
+      if (currentShard.tokens + file.tokens + headerTokens > this.options.maxTokens) {
+        if (currentShard.files.length > 0) {
+          shards.push(currentShard);
+          currentShard = { files: [], tokens: 0 };
+        }
+      }
+
+      currentShard.files.push(file);
+      currentShard.tokens += file.tokens;
+    }
+
+    if (currentShard.files.length > 0) {
+      shards.push(currentShard);
+    }
+
+    this.stats.shards = shards.length;
+    return shards;
+  }
+
+  // Flatten the codebase
+  async flatten(outputFile) {
+    console.log(`${c.cyan}Scanning:${c.reset} ${this.rootPath}\n`);
+
+    // Scan directory
+    this.scanDirectory(this.rootPath);
+
+    if (this.files.length === 0) {
+      console.log(`${c.yellow}No files found to include.${c.reset}`);
+      return;
+    }
+
+    console.log(`${c.dim}Found ${this.stats.totalFiles} files, including ${this.stats.includedFiles}${c.reset}\n`);
+
+    // Check if sharding is needed
+    const totalTokens = Math.ceil(this.stats.totalSize * TOKENS_PER_CHAR);
+
+    if (this.options.sharding && totalTokens > this.options.maxTokens) {
+      // Generate sharded output
+      const shards = this.generateShardedOutput();
+
+      console.log(`${c.yellow}Large codebase detected - generating ${shards.length} shards${c.reset}\n`);
+
+      const baseName = outputFile.replace(/\.[^.]+$/, '');
+      const ext = path.extname(outputFile) || '.md';
+
+      for (let i = 0; i < shards.length; i++) {
+        const shardFile = `${baseName}_shard${i + 1}${ext}`;
+        const content = this.generateShardContent(shards[i], i + 1, shards.length);
+        fs.writeFileSync(shardFile, content);
+        console.log(`  ${c.green}Created:${c.reset} ${shardFile} (${shards[i].files.length} files, ~${shards[i].tokens.toLocaleString()} tokens)`);
+      }
+
+      // Generate index file
+      const indexContent = this.generateIndexContent(shards, baseName, ext);
+      const indexFile = `${baseName}_index${ext}`;
+      fs.writeFileSync(indexFile, indexContent);
+      console.log(`  ${c.green}Created:${c.reset} ${indexFile} (index)`);
+
+    } else {
+      // Generate single output
+      const content = this.generateOutput();
+      fs.writeFileSync(outputFile, content);
+      console.log(`${c.green}Created:${c.reset} ${outputFile}`);
+    }
+
+    // Print summary
+    this.printSummary();
+  }
+
+  // Generate shard content
+  generateShardContent(shard, shardNum, totalShards) {
+    let content = `# Codebase Context: ${path.basename(this.rootPath)} (Shard ${shardNum}/${totalShards})
+
+Generated: ${new Date().toISOString()}
+Root: ${this.rootPath}
+
+## Shard Information
+
+- Shard: ${shardNum} of ${totalShards}
+- Files in this shard: ${shard.files.length}
+- Estimated tokens: ~${shard.tokens.toLocaleString()}
+
+## Files in This Shard
+
+${shard.files.map(f => `- ${f.path}`).join('\n')}
+
+## File Contents
+
+`;
+
+    for (const file of shard.files) {
+      try {
+        const fileContent = fs.readFileSync(file.fullPath, 'utf8');
+        const ext = path.extname(file.path).slice(1) || 'text';
+
+        content += `### ${file.path}
+
+\`\`\`${ext}
+${fileContent}
+\`\`\`
+
+`;
+      } catch (e) {
+        content += `### ${file.path}
+
+\`\`\`
+[Error reading file: ${e.message}]
+\`\`\`
+
+`;
+      }
+    }
+
+    return content;
+  }
+
+  // Generate index content
+  generateIndexContent(shards, baseName, ext) {
+    const fileTree = this.generateFileTree();
+
+    return `# Codebase Context Index: ${path.basename(this.rootPath)}
+
+Generated: ${new Date().toISOString()}
+Root: ${this.rootPath}
+
+## Overview
+
+This codebase has been sharded into ${shards.length} parts for optimal context management.
+
+### Statistics
+
+- Total files: ${this.stats.includedFiles}
+- Total size: ${(this.stats.totalSize / 1024).toFixed(2)} KB
+- Total estimated tokens: ~${Math.ceil(this.stats.totalSize * TOKENS_PER_CHAR).toLocaleString()}
+- Shards: ${shards.length}
+
+### Shards
+
+${shards.map((shard, i) => `- **Shard ${i + 1}**: ${path.basename(baseName)}_shard${i + 1}${ext} (${shard.files.length} files, ~${shard.tokens.toLocaleString()} tokens)`).join('\n')}
+
+## Complete File Tree
+
+\`\`\`
+${path.basename(this.rootPath)}/
+${fileTree}\`\`\`
+
+## File Distribution
+
+### Shard Contents
+
+${shards.map((shard, i) => `
+#### Shard ${i + 1}
+${shard.files.map(f => `- ${f.path}`).join('\n')}
+`).join('\n')}
+
+## Usage Instructions
+
+1. Start with this index file to understand the structure
+2. Load shards as needed based on the area you're working on
+3. High-priority files (config, entry points) are in earlier shards
+4. Each shard stays within ~${this.options.maxTokens.toLocaleString()} tokens
+
+`;
+  }
+
+  // Print summary
+  printSummary() {
+    console.log(`
+${c.bold}Summary:${c.reset}
+─────────────────────────────────────
+  Files scanned:    ${this.stats.totalFiles}
+  Files included:   ${this.stats.includedFiles}
+  Total size:       ${(this.stats.totalSize / 1024).toFixed(2)} KB
+  Est. tokens:      ~${this.stats.estimatedTokens.toLocaleString()}
+  ${this.stats.shards > 1 ? `Shards:           ${this.stats.shards}` : ''}
+─────────────────────────────────────
+`);
+  }
+}
+
+// Export flatten function
+async function flatten(rootPath, outputFile, options = {}) {
+  const flattener = new CodebaseFlattener(rootPath, options);
+  await flattener.flatten(outputFile);
+}
+
+module.exports = { flatten, CodebaseFlattener };