bps-kit 1.0.1 → 1.0.2

package/templates/vault/claude-monitor/scripts/monitor.py

@@ -0,0 +1,296 @@
+#!/usr/bin/env python3
+"""
+Claude Monitor — Monitor Contínuo de Performance
+
+Coleta snapshots periódicos de CPU, RAM e browsers.
+Gera relatório com tendências e alertas ao final.
+
+Uso:
+    python monitor.py                          # 5 min, amostras a cada 30s
+    python monitor.py --interval 10 --duration 120  # 2 min, amostras a cada 10s
+    python monitor.py --output meu_log.json    # Salvar em arquivo específico
+"""
+
+import json
+import os
+import signal
+import subprocess
+import sys
+import time
+from datetime import datetime
+from pathlib import Path
+
+try:
+    import psutil
+except ImportError:
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "psutil", "--quiet"])
+    import psutil
+
+sys.path.insert(0, str(Path(__file__).parent))
+from config import BROWSER_NAMES, CLAUDE_NAMES, MONITOR_DEFAULTS
+
+
+def take_snapshot():
+    """Coleta um snapshot rápido do sistema."""
+    cpu = psutil.cpu_percent(interval=0.5)
+    ram = psutil.virtual_memory()
+
+    # Browser totals
+    browser_ram = 0
+    browser_count = 0
+    for proc in psutil.process_iter(["name", "memory_info"]):
+        try:
+            name = proc.info["name"].lower()
+            for bname in BROWSER_NAMES:
+                if bname in name:
+                    browser_ram += proc.info["memory_info"].rss
+                    browser_count += 1
+                    break
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            pass
+
+    # Claude totals
+    claude_ram = 0
+    claude_count = 0
+    for proc in psutil.process_iter(["name", "memory_info"]):
+        try:
+            name = proc.info["name"].lower()
+            for cname in CLAUDE_NAMES:
+                if cname in name:
+                    claude_ram += proc.info["memory_info"].rss
+                    claude_count += 1
+                    break
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            pass
+
+    return {
+        "timestamp": datetime.now().isoformat(),
+        "cpu_percent": cpu,
+        "ram_percent": ram.percent,
+        "ram_used_gb": round(ram.used / 1024**3, 2),
+        "ram_available_gb": round(ram.available / 1024**3, 2),
+        "browser_ram_gb": round(browser_ram / 1024**3, 2),
+        "browser_processes": browser_count,
+        "claude_ram_gb": round(claude_ram / 1024**3, 2),
+        "claude_processes": claude_count,
+    }
+
+
+def analyze_snapshots(snapshots, alert_cpu, alert_ram):
+    """Analisa os snapshots coletados e gera relatório."""
+    if not snapshots:
+        return {"error": "Nenhum snapshot coletado"}
+
+    n = len(snapshots)
+    cpu_values = [s["cpu_percent"] for s in snapshots]
+    ram_values = [s["ram_percent"] for s in snapshots]
+    browser_ram_values = [s["browser_ram_gb"] for s in snapshots]
+
+    # Alertas
+    alerts = []
+    for s in snapshots:
+        if s["cpu_percent"] >= alert_cpu:
+            alerts.append({
+                "time": s["timestamp"],
+                "type": "cpu",
+                "value": s["cpu_percent"],
+                "threshold": alert_cpu,
+            })
+        if s["ram_percent"] >= alert_ram:
+            alerts.append({
+                "time": s["timestamp"],
+                "type": "ram",
+                "value": s["ram_percent"],
+                "threshold": alert_ram,
+            })
+
+    # Tendência (compara primeira metade com segunda metade)
+    mid = n // 2
+    if mid > 0:
+        cpu_first = sum(cpu_values[:mid]) / mid
+        cpu_second = sum(cpu_values[mid:]) / (n - mid)
+        ram_first = sum(ram_values[:mid]) / mid
+        ram_second = sum(ram_values[mid:]) / (n - mid)
+
+        cpu_diff = cpu_second - cpu_first
+        ram_diff = ram_second - ram_first
+
+        if abs(cpu_diff) < 5 and abs(ram_diff) < 3:
+            trend = "estavel"
+        elif cpu_diff > 5 or ram_diff > 3:
+            trend = "piorando"
+        else:
+            trend = "melhorando"
+    else:
+        trend = "insuficiente"
+        cpu_diff = 0
+        ram_diff = 0
+
+    # Resumo
+    report = {
+        "samples": n,
+        "duration_seconds": round(
+            (datetime.fromisoformat(snapshots[-1]["timestamp"]) -
+             datetime.fromisoformat(snapshots[0]["timestamp"])).total_seconds(), 0
+        ) if n > 1 else 0,
+        "cpu": {
+            "avg": round(sum(cpu_values) / n, 1),
+            "max": round(max(cpu_values), 1),
+            "min": round(min(cpu_values), 1),
+        },
+        "ram": {
+            "avg_percent": round(sum(ram_values) / n, 1),
+            "max_percent": round(max(ram_values), 1),
+            "avg_used_gb": round(sum(s["ram_used_gb"] for s in snapshots) / n, 1),
+        },
+        "browsers": {
+            "avg_ram_gb": round(sum(browser_ram_values) / n, 1),
+            "max_ram_gb": round(max(browser_ram_values), 1),
+            "avg_processes": round(sum(s["browser_processes"] for s in snapshots) / n, 0),
+        },
+        "trend": trend,
+        "trend_detail": {
+            "cpu_change": round(cpu_diff, 1),
+            "ram_change": round(ram_diff, 1),
+        },
+        "alerts_count": len(alerts),
+        "alerts": alerts[:20],  # Máximo 20 alertas no relatório
+    }
+
+    # Recomendação final
+    if report["cpu"]["avg"] > alert_cpu:
+        report["recommendation"] = (
+            f"CPU consistentemente alta (media {report['cpu']['avg']}%). "
+            f"Fechar aplicativos pesados e abas de browser desnecessarias."
+        )
+    elif len(alerts) > n * 0.3:
+        report["recommendation"] = (
+            f"Alertas frequentes ({len(alerts)} de {n} amostras). "
+            f"Sistema sob pressao intermitente. Reduzir carga."
+        )
+    elif trend == "piorando":
+        report["recommendation"] = (
+            f"Tendencia de piora detectada (CPU {'+' if cpu_diff > 0 else ''}{cpu_diff:.0f}%, "
+            f"RAM {'+' if ram_diff > 0 else ''}{ram_diff:.0f}%). Monitorar."
+        )
+    else:
+        report["recommendation"] = "Sistema estavel durante o monitoramento."
+
+    return report
+
+
+def format_report(report):
+    """Formata o relatório para exibição."""
+    lines = ["## Relatorio de Monitoramento\n"]
+    lines.append(f"- **Amostras**: {report['samples']} em {report['duration_seconds']}s")
+    lines.append(f"- **Tendencia**: {report['trend'].upper()}")
+    lines.append(f"- **Alertas**: {report['alerts_count']}\n")
+
+    lines.append("### CPU")
+    lines.append(f"- Media: {report['cpu']['avg']}%")
+    lines.append(f"- Max: {report['cpu']['max']}% | Min: {report['cpu']['min']}%\n")
+
+    lines.append("### RAM")
+    lines.append(f"- Media: {report['ram']['avg_percent']}% ({report['ram']['avg_used_gb']} GB)")
+    lines.append(f"- Pico: {report['ram']['max_percent']}%\n")
+
+    lines.append("### Browsers")
+    lines.append(f"- Media RAM: {report['browsers']['avg_ram_gb']} GB")
+    lines.append(f"- Pico RAM: {report['browsers']['max_ram_gb']} GB")
+    lines.append(f"- Media processos: {report['browsers']['avg_processes']}\n")
+
+    lines.append(f"### Recomendacao")
+    lines.append(f"{report['recommendation']}")
+
+    return "\n".join(lines)
+
+
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Claude Monitor - Monitor Continuo")
+    parser.add_argument("--interval", type=int, default=MONITOR_DEFAULTS["interval"],
+                        help=f"Segundos entre amostras (default: {MONITOR_DEFAULTS['interval']})")
+    parser.add_argument("--duration", type=int, default=MONITOR_DEFAULTS["duration"],
+                        help=f"Duracao total em segundos (default: {MONITOR_DEFAULTS['duration']})")
+    parser.add_argument("--output", type=str, default=None,
+                        help="Arquivo de saida JSON")
+    parser.add_argument("--alert-cpu", type=int, default=MONITOR_DEFAULTS["alert_cpu"],
+                        help=f"Threshold CPU para alerta (default: {MONITOR_DEFAULTS['alert_cpu']})")
+    parser.add_argument("--alert-ram", type=int, default=MONITOR_DEFAULTS["alert_ram"],
+                        help=f"Threshold RAM para alerta (default: {MONITOR_DEFAULTS['alert_ram']})")
+    parser.add_argument("--json", action="store_true", help="Output em JSON")
+    args = parser.parse_args()
+
+    snapshots = []
+    start_time = time.time()
+    sample_count = 0
+    expected_samples = args.duration // args.interval
+
+    print(f"Monitorando por {args.duration}s (amostra a cada {args.interval}s)...")
+    print(f"Esperando {expected_samples} amostras. Ctrl+C para parar.\n")
+
+    # Permite interromper com Ctrl+C
+    interrupted = False
+
+    def handle_interrupt(sig, frame):
+        nonlocal interrupted
+        interrupted = True
+        print("\nInterrompido pelo usuario. Gerando relatorio...\n")
+
+    signal.signal(signal.SIGINT, handle_interrupt)
+
+    while not interrupted and (time.time() - start_time) < args.duration:
+        snapshot = take_snapshot()
+        snapshots.append(snapshot)
+        sample_count += 1
+
+        # Print inline progress
+        print(
+            f"[{sample_count}/{expected_samples}] "
+            f"CPU: {snapshot['cpu_percent']:5.1f}% | "
+            f"RAM: {snapshot['ram_percent']:5.1f}% | "
+            f"Browsers: {snapshot['browser_ram_gb']:.1f}GB ({snapshot['browser_processes']} proc) | "
+            f"Claude: {snapshot['claude_ram_gb']:.1f}GB ({snapshot['claude_processes']} proc)"
+        )
+
+        # Espera até a próxima amostra
+        elapsed = time.time() - start_time
+        next_sample_at = sample_count * args.interval
+        sleep_time = max(0, next_sample_at - elapsed)
+        if sleep_time > 0 and not interrupted:
+            time.sleep(sleep_time)
+
+    # Analisa
+    report = analyze_snapshots(snapshots, args.alert_cpu, args.alert_ram)
+
+    # Salva log
+    output_data = {
+        "config": {
+            "interval": args.interval,
+            "duration": args.duration,
+            "alert_cpu": args.alert_cpu,
+            "alert_ram": args.alert_ram,
+        },
+        "snapshots": snapshots,
+        "report": report,
+    }
+
+    if args.output:
+        output_path = args.output
+    else:
+        output_path = f"monitor_log_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+
+    with open(output_path, "w", encoding="utf-8") as f:
+        json.dump(output_data, f, indent=2, ensure_ascii=False)
+
+    print(f"\nLog salvo em: {output_path}\n")
+
+    if args.json:
+        print(json.dumps(report, indent=2, ensure_ascii=False))
+    else:
+        print(format_report(report))
+
+
+if __name__ == "__main__":
+    main()

package/templates/vault/content-creator/scripts/brand_voice_analyzer.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+"""
+Brand Voice Analyzer - Analyzes content to establish and maintain brand voice consistency
+"""
+
+import re
+from typing import Dict, List, Tuple
+import json
+
+class BrandVoiceAnalyzer:
+    def __init__(self):
+        self.voice_dimensions = {
+            'formality': {
+                'formal': ['hereby', 'therefore', 'furthermore', 'pursuant', 'regarding'],
+                'casual': ['hey', 'cool', 'awesome', 'stuff', 'yeah', 'gonna']
+            },
+            'tone': {
+                'professional': ['expertise', 'solution', 'optimize', 'leverage', 'strategic'],
+                'friendly': ['happy', 'excited', 'love', 'enjoy', 'together', 'share']
+            },
+            'perspective': {
+                'authoritative': ['proven', 'research shows', 'experts agree', 'data indicates'],
+                'conversational': ['you might', 'let\'s explore', 'we think', 'imagine if']
+            }
+        }
+    
+    def analyze_text(self, text: str) -> Dict:
+        """Analyze text for brand voice characteristics"""
+        text_lower = text.lower()
+        word_count = len(text.split())
+        
+        results = {
+            'word_count': word_count,
+            'readability_score': self._calculate_readability(text),
+            'voice_profile': {},
+            'sentence_analysis': self._analyze_sentences(text),
+            'recommendations': []
+        }
+        
+        # Analyze voice dimensions
+        for dimension, categories in self.voice_dimensions.items():
+            dim_scores = {}
+            for category, keywords in categories.items():
+                score = sum(1 for keyword in keywords if keyword in text_lower)
+                dim_scores[category] = score
+            
+            # Determine dominant voice
+            if sum(dim_scores.values()) > 0:
+                dominant = max(dim_scores, key=dim_scores.get)
+                results['voice_profile'][dimension] = {
+                    'dominant': dominant,
+                    'scores': dim_scores
+                }
+        
+        # Generate recommendations
+        results['recommendations'] = self._generate_recommendations(results)
+        
+        return results
+    
+    def _calculate_readability(self, text: str) -> float:
+        """Calculate Flesch Reading Ease score"""
+        sentences = re.split(r'[.!?]+', text)
+        words = text.split()
+        syllables = sum(self._count_syllables(word) for word in words)
+        
+        if len(sentences) == 0 or len(words) == 0:
+            return 0
+        
+        avg_sentence_length = len(words) / len(sentences)
+        avg_syllables_per_word = syllables / len(words)
+        
+        # Flesch Reading Ease formula
+        score = 206.835 - 1.015 * avg_sentence_length - 84.6 * avg_syllables_per_word
+        return max(0, min(100, score))
+    
+    def _count_syllables(self, word: str) -> int:
+        """Count syllables in a word (simplified)"""
+        word = word.lower()
+        vowels = 'aeiou'
+        syllable_count = 0
+        previous_was_vowel = False
+        
+        for char in word:
+            is_vowel = char in vowels
+            if is_vowel and not previous_was_vowel:
+                syllable_count += 1
+            previous_was_vowel = is_vowel
+        
+        # Adjust for silent e
+        if word.endswith('e'):
+            syllable_count -= 1
+        
+        return max(1, syllable_count)
+    
+    def _analyze_sentences(self, text: str) -> Dict:
+        """Analyze sentence structure"""
+        sentences = re.split(r'[.!?]+', text)
+        sentences = [s.strip() for s in sentences if s.strip()]
+        
+        if not sentences:
+            return {'average_length': 0, 'variety': 'low'}
+        
+        lengths = [len(s.split()) for s in sentences]
+        avg_length = sum(lengths) / len(lengths) if lengths else 0
+        
+        # Calculate variety
+        if len(set(lengths)) < 3:
+            variety = 'low'
+        elif len(set(lengths)) < 5:
+            variety = 'medium'
+        else:
+            variety = 'high'
+        
+        return {
+            'average_length': round(avg_length, 1),
+            'variety': variety,
+            'count': len(sentences)
+        }
+    
+    def _generate_recommendations(self, analysis: Dict) -> List[str]:
+        """Generate recommendations based on analysis"""
+        recommendations = []
+        
+        # Readability recommendations
+        if analysis['readability_score'] < 30:
+            recommendations.append("Consider simplifying language for better readability")
+        elif analysis['readability_score'] > 70:
+            recommendations.append("Content is very easy to read - consider if this matches your audience")
+        
+        # Sentence variety
+        if analysis['sentence_analysis']['variety'] == 'low':
+            recommendations.append("Vary sentence length for better flow and engagement")
+        
+        # Voice consistency
+        if analysis['voice_profile']:
+            recommendations.append("Maintain consistent voice across all content")
+        
+        return recommendations
+
+def analyze_content(content: str, output_format: str = 'json') -> str:
+    """Main function to analyze content"""
+    analyzer = BrandVoiceAnalyzer()
+    results = analyzer.analyze_text(content)
+    
+    if output_format == 'json':
+        return json.dumps(results, indent=2)
+    else:
+        # Human-readable format
+        output = [
+            f"=== Brand Voice Analysis ===",
+            f"Word Count: {results['word_count']}",
+            f"Readability Score: {results['readability_score']:.1f}/100",
+            f"",
+            f"Voice Profile:"
+        ]
+        
+        for dimension, profile in results['voice_profile'].items():
+            output.append(f"  {dimension.title()}: {profile['dominant']}")
+        
+        output.extend([
+            f"",
+            f"Sentence Analysis:",
+            f"  Average Length: {results['sentence_analysis']['average_length']} words",
+            f"  Variety: {results['sentence_analysis']['variety']}",
+            f"  Total Sentences: {results['sentence_analysis']['count']}",
+            f"",
+            f"Recommendations:"
+        ])
+        
+        for rec in results['recommendations']:
+            output.append(f"  • {rec}")
+        
+        return '\n'.join(output)
+
+if __name__ == "__main__":
+    import sys
+    
+    if len(sys.argv) > 1:
+        with open(sys.argv[1], 'r') as f:
+            content = f.read()
+        
+        output_format = sys.argv[2] if len(sys.argv) > 2 else 'text'
+        print(analyze_content(content, output_format))
+    else:
+        print("Usage: python brand_voice_analyzer.py <file> [json|text]")