@mks2508/better-logger 0.0.2-alpha.2 → 0.3.0

package/project-utils/commit-ui.ts

@@ -0,0 +1,264 @@
+#!/usr/bin/env node
+
+import { execSync } from "child_process"
+import { platform } from "os"
+
+interface CommitOptions {
+  context: string
+  workType: string
+  affectedComponents: string[]
+  scope?: string
+  breakingChange?: boolean
+  performanceImpact?: string
+}
+
+class CommitUI {
+  private platform = platform()
+
+  async collectCommitInfo(): Promise<CommitOptions> {
+    console.log("🚀 Interactive Commit Generator")
+    console.log("================================")
+
+    try {
+      if (this.platform === "darwin") {
+        return await this.macOSDialog()
+      } else if (this.platform === "linux") {
+        return await this.linuxDialog()
+      } else {
+        return await this.fallbackDialog()
+      }
+    } catch (error) {
+      console.log("⚠️ GUI not available, falling back to text input")
+      return await this.fallbackDialog()
+    }
+  }
+
+  private async macOSDialog(): Promise<CommitOptions> {
+    // Create a unified form using AppleScript
+    const formScript = `
+      const app = Application.currentApplication()
+      app.includeStandardAdditions = true
+      
+      // First get the context text
+      const contextResult = app.displayDialog("📝 Commit Generator\\n\\nDescribe what you implemented/fixed:", {
+        defaultAnswer: "",
+        withTitle: "🚀 Interactive Commit",
+        buttons: ["Cancel", "Next →"],
+        defaultButton: "Next →"
+      })
+      
+      const context = contextResult.textReturned
+      
+      // Then get work type
+      const workTypes = ["feature", "fix", "refactor", "docs", "test"]
+      const workTypeResult = app.chooseFromList(workTypes, {
+        withTitle: "🚀 Interactive Commit - Work Type",
+        withPrompt: "Context: " + context + "\\n\\nSelect work type:",
+        defaultItems: ["feature"]
+      })
+      
+      if (workTypeResult === false) {
+        throw new Error("Cancelled")
+      }
+      
+      const workType = workTypeResult[0]
+      
+      // Then get components
+      const components = ["core", "styling", "exports", "cli", "docs", "tests", "examples"]
+      const componentsResult = app.chooseFromList(components, {
+        withTitle: "🚀 Interactive Commit - Components",
+        withPrompt: "Context: " + context + "\\nType: " + workType + "\\n\\nSelect affected components:",
+        multipleSelectionsAllowed: true,
+        defaultItems: ["core"]
+      })
+      
+      if (componentsResult === false) {
+        throw new Error("Cancelled")
+      }
+      
+      const affectedComponents = componentsResult.join(",")
+      
+      // Finally get performance impact
+      const impacts = ["none", "minor", "major"]
+      const performanceResult = app.chooseFromList(impacts, {
+        withTitle: "🚀 Interactive Commit - Performance",
+        withPrompt: "Context: " + context + "\\nType: " + workType + "\\nComponents: " + affectedComponents + "\\n\\nPerformance impact:",
+        defaultItems: ["none"]
+      })
+      
+      const performanceImpact = performanceResult === false ? "none" : performanceResult[0]
+      
+      // Return all values as JSON
+      JSON.stringify({
+        context: context,
+        workType: workType,
+        affectedComponents: affectedComponents,
+        performanceImpact: performanceImpact
+      })
+    `
+    
+    const result = execSync(`osascript -l JavaScript -e '${formScript}'`, { encoding: 'utf-8' }).trim()
+    const parsed = JSON.parse(result)
+
+    return {
+      context: parsed.context,
+      workType: parsed.workType,
+      affectedComponents: parsed.affectedComponents.split(","),
+      performanceImpact: parsed.performanceImpact
+    }
+  }
+
+  private async linuxDialog(): Promise<CommitOptions> {
+    // Check if zenity is available
+    try {
+      execSync("which zenity", { stdio: 'ignore' })
+    } catch {
+      throw new Error("zenity not available")
+    }
+
+    // Context Input first
+    const context = execSync(`zenity --entry --title="🚀 Interactive Commit" --text="📝 Describe what you implemented/fixed:" --width=400`, { encoding: 'utf-8' }).trim()
+
+    // Work Type Selection with context shown
+    const workType = execSync(`zenity --list --title="🚀 Interactive Commit - Work Type" --text="Context: ${context}\\n\\nSelect work type:" --radiolist --column="Select" --column="Type" --column="Description" --width=450 --height=300 \\
+      TRUE "feature" "New functionality" \\
+      FALSE "fix" "Bug fixes" \\
+      FALSE "refactor" "Code refactoring" \\
+      FALSE "docs" "Documentation" \\
+      FALSE "test" "Tests"`, { encoding: 'utf-8' }).trim()
+
+    // Components Selection with previous values shown
+    const componentsResult = execSync(`zenity --list --title="🚀 Interactive Commit - Components" --text="Context: ${context}\\nType: ${workType}\\n\\nSelect affected components:" --checklist --column="Select" --column="Component" --width=450 --height=300 \\
+      TRUE "core" \\
+      FALSE "styling" \\
+      FALSE "exports" \\
+      FALSE "cli" \\
+      FALSE "docs" \\
+      FALSE "tests" \\
+      FALSE "examples"`, { encoding: 'utf-8' }).trim()
+    
+    const affectedComponents = componentsResult.split("|").filter(Boolean)
+
+    // Performance Impact with summary
+    const performanceImpact = execSync(`zenity --list --title="🚀 Interactive Commit - Performance" --text="Context: ${context}\\nType: ${workType}\\nComponents: ${affectedComponents.join(', ')}\\n\\nSelect performance impact:" --radiolist --column="Select" --column="Impact" --width=450 --height=250 \\
+      TRUE "none" \\
+      FALSE "minor" \\
+      FALSE "major"`, { encoding: 'utf-8' }).trim()
+
+    return {
+      context,
+      workType,
+      affectedComponents,
+      performanceImpact
+    }
+  }
+
+  private async fallbackDialog(): Promise<CommitOptions> {
+    const readline = require('readline').createInterface({
+      input: process.stdin,
+      output: process.stdout
+    })
+
+    const question = (prompt: string): Promise<string> => {
+      return new Promise((resolve) => {
+        readline.question(prompt, resolve)
+      })
+    }
+
+    console.log("\n📝 Text-based commit input")
+    
+    const workType = await question("Work type (feature/fix/refactor/docs/test): ") || "feature"
+    const context = await question("Describe what you implemented/fixed: ")
+    const componentsInput = await question("Components changed (core,styling,exports,cli,docs,tests,examples): ") || "core"
+    const affectedComponents = componentsInput.split(",").map(c => c.trim())
+    const performanceImpact = await question("Performance impact (none/minor/major): ") || "none"
+
+    readline.close()
+
+    return {
+      context,
+      workType,
+      affectedComponents,
+      performanceImpact
+    }
+  }
+
+  async generateCommit(options: CommitOptions): Promise<void> {
+    const args = [
+      "--context", `"${options.context}"`,
+      "--work-type", options.workType,
+      "--affected-components", options.affectedComponents.join(",")
+    ]
+
+    if (options.performanceImpact && options.performanceImpact !== "none") {
+      args.push("--performance-impact", options.performanceImpact)
+    }
+
+    console.log("\n🔄 Generating commit...")
+    console.log(`📋 Context: ${options.context}`)
+    console.log(`🏷️ Type: ${options.workType}`)
+    console.log(`📦 Components: ${options.affectedComponents.join(", ")}`)
+    console.log(`⚡ Performance: ${options.performanceImpact}`)
+
+    const command = `bun project-utils/commit-generator.ts ${args.join(" ")} --auto-approve`
+    console.log(`\n🚀 Running: ${command}`)
+    
+    try {
+      execSync(command, { stdio: 'inherit' })
+      console.log("✅ Commits executed successfully!")
+    } catch (error) {
+      console.error("❌ Error executing commits:", error)
+      process.exit(1)
+    }
+  }
+}
+
+async function runTypeCheck(): Promise<void> {
+  console.log('🔍 Ejecutando typecheck...')
+  
+  try {
+    execSync('npm run type-check', { 
+      stdio: ['pipe', 'pipe', 'pipe'],
+      encoding: 'utf-8'
+    })
+    console.log('✅ Typecheck completado correctamente')
+  } catch (error) {
+    console.log('❌ Typecheck falló:', error)
+    process.exit(1)
+  }
+}
+
+async function main() {
+  // Ejecutar typecheck antes de continuar
+  await runTypeCheck()
+  
+  const ui = new CommitUI()
+  
+  // Check for quick mode
+  if (process.argv.includes("--quick")) {
+    const quickOptions: CommitOptions = {
+      context: "Quick commit via UI",
+      workType: "feature",
+      affectedComponents: ["core"],
+      performanceImpact: "none"
+    }
+    await ui.generateCommit(quickOptions)
+    return
+  }
+  
+  try {
+    const options = await ui.collectCommitInfo()
+    await ui.generateCommit(options)
+  } catch (error) {
+    if (error instanceof Error && error.message === "Cancelled") {
+      console.log("❌ Commit cancelled by user")
+      process.exit(0)
+    }
+    console.error("❌ Error:", error)
+    process.exit(1)
+  }
+}
+
+if (import.meta.main) {
+  main()
+}

package/project-utils/git-utils.ts

@@ -0,0 +1,199 @@
+/**
+ * Utilidades para manejo de Git
+ * Funciones auxiliares para el generador de commits
+ */
+
+export interface GitFileStatus {
+  path: string;
+  staged: boolean;
+  unstaged: boolean;
+  untracked: boolean;
+  deleted: boolean;
+  renamed?: string;
+}
+
+export interface CommitInfo {
+  hash: string;
+  message: string;
+  author: string;
+  date: string;
+}
+
+/**
+ * Parsea la salida de git status --porcelain
+ */
+export function parseGitStatus(statusOutput: string): GitFileStatus[] {
+  const files: GitFileStatus[] = [];
+  
+  for (const line of statusOutput.split('\n').filter(l => l.trim())) {
+    const staged = line[0];
+    const unstaged = line[1];
+    const filePath = line.substring(3);
+
+    files.push({
+      path: filePath,
+      staged: staged !== ' ' && staged !== '?',
+      unstaged: unstaged !== ' ',
+      untracked: staged === '?' && unstaged === '?',
+      deleted: staged === 'D' || unstaged === 'D',
+      renamed: staged === 'R' ? filePath.split(' -> ')[1] : undefined,
+    });
+  }
+
+  return files;
+}
+
+/**
+ * Determina el área funcional de un archivo basado en su ruta
+ */
+export function getFileArea(filePath: string): string {
+  const areas = [
+    { pattern: /^src\/components\/|^src\/layouts\//, area: 'ui' },
+    { pattern: /^src-tauri\//, area: 'backend' },
+    { pattern: /^src\/models\/|types|interfaces/, area: 'types' },
+    { pattern: /^src\/stores\/|state/, area: 'state' },
+    { pattern: /^src\/pages\/|routing|navigation/, area: 'navigation' },
+    { pattern: /^src\/styles\/|\.css$|theme/, area: 'theme' },
+    { pattern: /config|\.json$|\.toml$|package\.json/, area: 'config' },
+    { pattern: /^project-utils\/|tools|scripts/, area: 'tools' },
+    { pattern: /database|migration|sql/, area: 'database' },
+    { pattern: /test|spec|\.test\.|\.spec\./, area: 'testing' },
+    { pattern: /doc|readme|\.md$/, area: 'docs' },
+  ];
+
+  for (const { pattern, area } of areas) {
+    if (pattern.test(filePath.toLowerCase())) {
+      return area;
+    }
+  }
+
+  return 'misc';
+}
+
+/**
+ * Determina si los archivos están relacionados funcionalmente
+ */
+export function areFilesRelated(files: string[]): boolean {
+  if (files.length <= 1) return true;
+  
+  const areas = files.map(getFileArea);
+  const uniqueAreas = [...new Set(areas)];
+  
+  // Si todos están en la misma área, están relacionados
+  if (uniqueAreas.length === 1) return true;
+  
+  // Áreas que suelen ir juntas
+  const relatedAreas = [
+    ['ui', 'theme', 'navigation'],
+    ['backend', 'database', 'types'],
+    ['config', 'tools', 'docs'],
+    ['types', 'state'],
+  ];
+  
+  for (const group of relatedAreas) {
+    if (uniqueAreas.every(area => group.includes(area))) {
+      return true;
+    }
+  }
+  
+  return false;
+}
+
+/**
+ * Sugiere el tipo de commit basado en los cambios
+ */
+export function suggestCommitType(files: GitFileStatus[]): 'feat' | 'fix' | 'refactor' | 'feat-phase' {
+  const hasNewFiles = files.some(f => f.untracked);
+  const hasDeletedFiles = files.some(f => f.deleted);
+  const modifiedFiles = files.filter(f => f.staged || f.unstaged);
+  
+  // Si hay muchos archivos nuevos, probablemente es una feature
+  if (hasNewFiles && files.length > 3) {
+    return 'feat-phase';
+  }
+  
+  // Si hay archivos nuevos pero pocos, es feature completa
+  if (hasNewFiles) {
+    return 'feat';
+  }
+  
+  // Si solo se modificaron archivos existentes, probablemente es fix o refactor
+  if (modifiedFiles.length > 0 && !hasNewFiles) {
+    // Si los cambios son grandes, es refactor
+    if (modifiedFiles.length > 5) {
+      return 'refactor';
+    }
+    // Si son pocos cambios, probablemente es fix
+    return 'fix';
+  }
+  
+  return 'feat';
+}
+
+/**
+ * Extrae información relevante del diff de un archivo
+ */
+export function analyzeDiff(diff: string): {
+  addedLines: number;
+  removedLines: number;
+  hasNewFunctions: boolean;
+  hasNewTypes: boolean;
+  hasNewImports: boolean;
+  hasFixes: boolean;
+} {
+  const lines = diff.split('\n');
+  const addedLines = lines.filter(l => l.startsWith('+')).length;
+  const removedLines = lines.filter(l => l.startsWith('-')).length;
+  
+  const addedCode = lines.filter(l => l.startsWith('+')).join('\n');
+  const removedCode = lines.filter(l => l.startsWith('-')).join('\n');
+  
+  return {
+    addedLines,
+    removedLines,
+    hasNewFunctions: /function\s+\w+|const\s+\w+\s*=|async\s+function/.test(addedCode),
+    hasNewTypes: /interface\s+\w+|type\s+\w+|enum\s+\w+/.test(addedCode),
+    hasNewImports: /import\s+.*from/.test(addedCode),
+    hasFixes: /fix|error|bug|issue|problem/i.test(addedCode) || removedCode.includes('TODO') || removedCode.includes('FIXME'),
+  };
+}
+
+/**
+ * Genera un resumen técnico basado en los archivos modificados
+ */
+export function generateTechnicalSummary(files: GitFileStatus[], diffs: Record<string, string>): string {
+  const summary: string[] = [];
+  
+  for (const file of files) {
+    const area = getFileArea(file.path);
+    const diff = diffs[file.path];
+    
+    if (!diff) continue;
+    
+    const analysis = analyzeDiff(diff);
+    const changes: string[] = [];
+    
+    if (file.untracked) {
+      changes.push(`Creado ${file.path}`);
+    } else if (file.deleted) {
+      changes.push(`Eliminado ${file.path}`);
+    } else {
+      if (analysis.hasNewFunctions) changes.push('nuevas funciones');
+      if (analysis.hasNewTypes) changes.push('nuevos tipos');
+      if (analysis.hasNewImports) changes.push('nuevas dependencias');
+      if (analysis.hasFixes) changes.push('correcciones');
+      
+      if (changes.length > 0) {
+        changes.unshift(`Modificado ${file.path} con`);
+      } else {
+        changes.push(`Actualizado ${file.path}`);
+      }
+    }
+    
+    if (changes.length > 0) {
+      summary.push(`- ${changes.join(' ')}`);
+    }
+  }
+  
+  return summary.join('\n');
+}