Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /DansiDanutz_MyWork-AI /tools /analytics.py
| #!/usr/bin/env python3 | |
| """ | |
| MyWork Analytics Engine | |
| ======================= | |
| Project analytics, code insights, and health trends. | |
| Commands: | |
| mw analytics Full project analytics report | |
| mw analytics summary Quick summary | |
| mw analytics deps Dependency health check | |
| mw analytics complexity Code complexity analysis | |
| mw analytics trends Git activity trends | |
| mw analytics security Security posture overview | |
| """ | |
| import os | |
| import re | |
| import json | |
| import subprocess | |
| from pathlib import Path | |
| from datetime import datetime, timedelta | |
| from collections import Counter, defaultdict | |
| from typing import Dict, List, Optional, Tuple | |
| def color(text: str, code: str) -> str: | |
| return f"\033[{code}m{text}\033[0m" | |
| def green(t): return color(t, "32") | |
| def red(t): return color(t, "31") | |
| def yellow(t): return color(t, "33") | |
| def blue(t): return color(t, "34") | |
| def cyan(t): return color(t, "36") | |
| def bold(t): return color(t, "1") | |
| def dim(t): return color(t, "2") | |
| def run_cmd(cmd: str, cwd: str = ".") -> str: | |
| """Run shell command and return output.""" | |
| try: | |
| result = subprocess.run( | |
| cmd, shell=True, capture_output=True, text=True, | |
| cwd=cwd, timeout=30 | |
| ) | |
| return result.stdout.strip() | |
| except Exception: | |
| return "" | |
| def get_project_root() -> Path: | |
| """Find project root (has .git or pyproject.toml or package.json).""" | |
| cwd = Path.cwd() | |
| for marker in [".git", "pyproject.toml", "package.json", "setup.py"]: | |
| if (cwd / marker).exists(): | |
| return cwd | |
| # Walk up | |
| for parent in cwd.parents: | |
| for marker in [".git", "pyproject.toml", "package.json", "setup.py"]: | |
| if (parent / marker).exists(): | |
| return parent | |
| return cwd | |
| def analyze_languages(root: Path) -> Dict[str, int]: | |
| """Count lines by language.""" | |
| extensions = { | |
| ".py": "Python", ".js": "JavaScript", ".ts": "TypeScript", | |
| ".tsx": "TypeScript/React", ".jsx": "JavaScript/React", | |
| ".html": "HTML", ".css": "CSS", ".scss": "SCSS", | |
| ".json": "JSON", ".yaml": "YAML", ".yml": "YAML", | |
| ".md": "Markdown", ".sh": "Shell", ".sql": "SQL", | |
| ".rs": "Rust", ".go": "Go", ".java": "Java", | |
| } | |
| counts = Counter() | |
| skip_dirs = {".git", "node_modules", "__pycache__", ".venv", "venv", "dist", "build", ".next", ".tmp"} | |
| for path in root.rglob("*"): | |
| if any(s in path.parts for s in skip_dirs): | |
| continue | |
| if path.is_file() and path.suffix in extensions: | |
| try: | |
| lines = len(path.read_text(errors="ignore").splitlines()) | |
| counts[extensions[path.suffix]] += lines | |
| except Exception: | |
| pass | |
| return dict(counts.most_common(10)) | |
| def analyze_git_trends(root: Path) -> Dict: | |
| """Analyze git commit patterns.""" | |
| # Commits per day (last 30 days) | |
| log = run_cmd( | |
| 'git log --since="30 days ago" --format="%ai" 2>/dev/null', | |
| cwd=str(root) | |
| ) | |
| if not log: | |
| return {"available": False} | |
| dates = [] | |
| for line in log.splitlines(): | |
| if line.strip(): | |
| date_str = line.split()[0] | |
| dates.append(date_str) | |
| daily = Counter(dates) | |
| total_commits = len(dates) | |
| # Top contributors | |
| authors = run_cmd( | |
| 'git log --since="30 days ago" --format="%an" 2>/dev/null', | |
| cwd=str(root) | |
| ) | |
| author_counts = Counter(authors.splitlines()) if authors else {} | |
| # Files changed most | |
| files_changed = run_cmd( | |
| 'git log --since="30 days ago" --name-only --format="" 2>/dev/null', | |
| cwd=str(root) | |
| ) | |
| file_counts = Counter(f for f in files_changed.splitlines() if f.strip()) | |
| # Streak | |
| today = datetime.now().date() | |
| streak = 0 | |
| for i in range(30): | |
| d = (today - timedelta(days=i)).isoformat() | |
| if d in daily: | |
| streak += 1 | |
| else: | |
| break | |
| return { | |
| "available": True, | |
| "total_commits_30d": total_commits, | |
| "avg_per_day": round(total_commits / 30, 1), | |
| "active_days": len(daily), | |
| "current_streak": streak, | |
| "top_contributors": dict(author_counts.most_common(5)), | |
| "hottest_files": dict(file_counts.most_common(10)), | |
| "busiest_day": daily.most_common(1)[0] if daily else None, | |
| } | |
| def analyze_deps(root: Path) -> Dict: | |
| """Check dependency health.""" | |
| result = {"python": None, "node": None} | |
| # Python deps | |
| req_file = root / "requirements.txt" | |
| if not req_file.exists(): | |
| for sub in ["tools/requirements.txt", "tools/requirements.txt"]: | |
| if (root / sub).exists(): | |
| req_file = root / sub | |
| break | |
| if req_file.exists(): | |
| deps = [] | |
| for line in req_file.read_text().splitlines(): | |
| line = line.strip() | |
| if line and not line.startswith("#"): | |
| name = re.split(r'[><=!~]', line)[0].strip() | |
| if name: | |
| deps.append({"name": name, "spec": line}) | |
| result["python"] = {"count": len(deps), "deps": deps[:20]} | |
| # Node deps | |
| pkg_json = root / "package.json" | |
| if pkg_json.exists(): | |
| try: | |
| pkg = json.loads(pkg_json.read_text()) | |
| deps = pkg.get("dependencies", {}) | |
| dev_deps = pkg.get("devDependencies", {}) | |
| result["node"] = { | |
| "deps": len(deps), | |
| "devDeps": len(dev_deps), | |
| "total": len(deps) + len(dev_deps), | |
| } | |
| except Exception: | |
| pass | |
| return result | |
| def analyze_complexity(root: Path) -> Dict: | |
| """Simple code complexity analysis.""" | |
| skip_dirs = {".git", "node_modules", "__pycache__", ".venv", "venv", "dist", "build", ".next"} | |
| total_files = 0 | |
| total_lines = 0 | |
| large_files = [] # >300 lines | |
| long_functions = [] | |
| todo_count = 0 | |
| for path in root.rglob("*.py"): | |
| if any(s in path.parts for s in skip_dirs): | |
| continue | |
| try: | |
| content = path.read_text(errors="ignore") | |
| lines = content.splitlines() | |
| total_files += 1 | |
| total_lines += len(lines) | |
| if len(lines) > 300: | |
| large_files.append((str(path.relative_to(root)), len(lines))) | |
| # Count TODOs | |
| for line in lines: | |
| if "TODO" in line or "FIXME" in line or "HACK" in line: | |
| todo_count += 1 | |
| # Find long functions | |
| func_start = None | |
| func_name = None | |
| for i, line in enumerate(lines): | |
| if line.strip().startswith("def ") or line.strip().startswith("async def "): | |
| if func_start is not None and (i - func_start) > 50: | |
| long_functions.append((func_name, i - func_start, str(path.relative_to(root)))) | |
| func_name = line.strip().split("(")[0].replace("def ", "").replace("async ", "") | |
| func_start = i | |
| if func_start is not None and func_name and (len(lines) - func_start) > 50: | |
| long_functions.append((func_name, len(lines) - func_start, str(path.relative_to(root)))) | |
| except Exception: | |
| pass | |
| # Also scan JS/TS | |
| for ext in ["*.js", "*.ts", "*.tsx", "*.jsx"]: | |
| for path in root.rglob(ext): | |
| if any(s in path.parts for s in skip_dirs): | |
| continue | |
| try: | |
| lines = path.read_text(errors="ignore").splitlines() | |
| total_files += 1 | |
| total_lines += len(lines) | |
| if len(lines) > 300: | |
| large_files.append((str(path.relative_to(root)), len(lines))) | |
| for line in lines: | |
| if "TODO" in line or "FIXME" in line: | |
| todo_count += 1 | |
| except Exception: | |
| pass | |
| large_files.sort(key=lambda x: x[1], reverse=True) | |
| long_functions.sort(key=lambda x: x[1], reverse=True) | |
| return { | |
| "total_files": total_files, | |
| "total_lines": total_lines, | |
| "avg_lines_per_file": round(total_lines / max(total_files, 1), 1), | |
| "large_files": large_files[:10], | |
| "long_functions": long_functions[:10], | |
| "todo_fixme_count": todo_count, | |
| } | |
| def analyze_security(root: Path) -> Dict: | |
| """Basic security posture check.""" | |
| issues = [] | |
| skip_dirs = {".git", "node_modules", "__pycache__", ".venv", "venv", "dist"} | |
| # Check for hardcoded secrets patterns | |
| secret_patterns = [ | |
| (r'(?:password|passwd|pwd)\s*=\s*["\'][^"\']+["\']', "Hardcoded password"), | |
| (r'(?:api_key|apikey|api_secret)\s*=\s*["\'][^"\']+["\']', "Hardcoded API key"), | |
| (r'(?:secret_key|SECRET_KEY)\s*=\s*["\'][^"\']{8,}["\']', "Hardcoded secret"), | |
| ] | |
| secret_files = 0 | |
| for path in root.rglob("*.py"): | |
| if any(s in path.parts for s in skip_dirs): | |
| continue | |
| try: | |
| content = path.read_text(errors="ignore") | |
| for pattern, desc in secret_patterns: | |
| if re.search(pattern, content, re.IGNORECASE): | |
| secret_files += 1 | |
| issues.append(f"{desc} in {path.relative_to(root)}") | |
| break | |
| except Exception: | |
| pass | |
| # Check .env in git | |
| gitignore = root / ".gitignore" | |
| env_ignored = False | |
| if gitignore.exists(): | |
| env_ignored = ".env" in gitignore.read_text() | |
| if not env_ignored: | |
| issues.append(".env not in .gitignore") | |
| # Check for .env file | |
| has_env = (root / ".env").exists() | |
| has_env_example = (root / ".env.example").exists() | |
| return { | |
| "issues": issues[:20], | |
| "env_ignored": env_ignored, | |
| "has_env": has_env, | |
| "has_env_example": has_env_example, | |
| "secret_files_flagged": secret_files, | |
| "score": max(0, 100 - len(issues) * 10), | |
| } | |
| def print_bar(label: str, value: int, max_val: int, width: int = 30): | |
| """Print a horizontal bar.""" | |
| if max_val == 0: | |
| filled = 0 | |
| else: | |
| filled = int((value / max_val) * width) | |
| bar = "█" * filled + "░" * (width - filled) | |
| print(f" {label:20s} {bar} {value:,}") | |
| def print_section(title: str): | |
| print(f"\n{bold(cyan(f'━━━ {title} ━━━'))}") | |
| def cmd_analytics(args: List[str] = None) -> int: | |
| """Run project analytics.""" | |
| root = get_project_root() | |
| subcmd = args[0] if args else "full" | |
| print(bold(f"\n🔬 MyWork Analytics — {root.name}")) | |
| print(dim(f" {root}\n")) | |
| if subcmd in ("full", "summary"): | |
| print_section("📊 Language Breakdown") | |
| langs = analyze_languages(root) | |
| if langs: | |
| max_lines = max(langs.values()) | |
| for lang, lines in langs.items(): | |
| print_bar(lang, lines, max_lines) | |
| print(f"\n {dim('Total:')} {sum(langs.values()):,} lines") | |
| else: | |
| print(" No source files found.") | |
| if subcmd in ("full", "trends"): | |
| print_section("📈 Git Activity (30 days)") | |
| trends = analyze_git_trends(root) | |
| if trends.get("available"): | |
| print(f" Commits: {bold(str(trends['total_commits_30d']))}") | |
| print(f" Avg/day: {trends['avg_per_day']}") | |
| print(f" Active days: {trends['active_days']}/30") | |
| print(f" Current streak: {green(str(trends['current_streak']))} days") | |
| if trends.get("busiest_day"): | |
| print(f" Busiest day: {trends['busiest_day'][0]} ({trends['busiest_day'][1]} commits)") | |
| if trends.get("top_contributors"): | |
| print(f"\n {bold('Contributors:')}") | |
| for name, count in trends["top_contributors"].items(): | |
| print(f" {name}: {count} commits") | |
| if trends.get("hottest_files"): | |
| print(f"\n {bold('Most Changed Files:')}") | |
| for f, count in list(trends["hottest_files"].items())[:5]: | |
| print(f" {dim(str(count)+'x')} {f}") | |
| else: | |
| print(" No git history available.") | |
| if subcmd in ("full", "complexity"): | |
| print_section("🧩 Code Complexity") | |
| cx = analyze_complexity(root) | |
| print(f" Files: {cx['total_files']}") | |
| print(f" Total lines: {cx['total_lines']:,}") | |
| print(f" Avg lines/file: {cx['avg_lines_per_file']}") | |
| print(f" TODOs/FIXMEs: {yellow(str(cx['todo_fixme_count']))}") | |
| if cx["large_files"]: | |
| print(f"\n {bold('Large Files (>300 lines):')}") | |
| for f, lines in cx["large_files"][:5]: | |
| print(f" {red(str(lines))} lines — {f}") | |
| if cx["long_functions"]: | |
| print(f"\n {bold('Long Functions (>50 lines):')}") | |
| for name, lines, f in cx["long_functions"][:5]: | |
| print(f" {yellow(str(lines))} lines — {name}() in {f}") | |
| if subcmd in ("full", "deps"): | |
| print_section("📦 Dependencies") | |
| deps = analyze_deps(root) | |
| if deps["python"]: | |
| print(f" Python: {deps['python']['count']} packages") | |
| if deps["node"]: | |
| n = deps["node"] | |
| print(f" Node: {n['deps']} deps + {n['devDeps']} devDeps = {n['total']} total") | |
| if not deps["python"] and not deps["node"]: | |
| print(" No dependency files found.") | |
| if subcmd in ("full", "security"): | |
| print_section("🔒 Security Posture") | |
| sec = analyze_security(root) | |
| score_color = green if sec["score"] >= 80 else (yellow if sec["score"] >= 50 else red) | |
| print(f" Score: {score_color(str(sec['score']) + '/100')}") | |
| print(f" .env ignored: {'✅' if sec['env_ignored'] else '❌'}") | |
| print(f" .env exists: {'✅' if sec['has_env'] else '—'}") | |
| print(f" .env.example: {'✅' if sec['has_env_example'] else '❌'}") | |
| if sec["issues"]: | |
| print(f"\n {bold('Issues:')}") | |
| for issue in sec["issues"][:5]: | |
| print(f" ⚠️ {issue}") | |
| # Overall health score | |
| if subcmd == "full": | |
| print_section("🏆 Overall Health") | |
| cx = analyze_complexity(root) | |
| sec = analyze_security(root) | |
| trends = analyze_git_trends(root) | |
| scores = [] | |
| # Activity score | |
| if trends.get("available"): | |
| activity = min(100, trends["total_commits_30d"] * 3) | |
| scores.append(("Activity", activity)) | |
| # Security score | |
| scores.append(("Security", sec["score"])) | |
| # Maintainability (inverse of large files ratio) | |
| if cx["total_files"] > 0: | |
| large_ratio = len(cx["large_files"]) / cx["total_files"] | |
| maint = max(0, int(100 - large_ratio * 200)) | |
| scores.append(("Maintainability", maint)) | |
| # Documentation (check for README, docs/) | |
| doc_score = 0 | |
| if (root / "README.md").exists(): doc_score += 40 | |
| if (root / "docs").is_dir(): doc_score += 30 | |
| if (root / "CHANGELOG.md").exists(): doc_score += 15 | |
| if (root / "CONTRIBUTING.md").exists(): doc_score += 15 | |
| scores.append(("Documentation", doc_score)) | |
| overall = int(sum(s for _, s in scores) / max(len(scores), 1)) | |
| for name, score in scores: | |
| c = green if score >= 80 else (yellow if score >= 50 else red) | |
| bar_len = score // 5 | |
| bar = "█" * bar_len + "░" * (20 - bar_len) | |
| print(f" {name:18s} {bar} {c(str(score))}") | |
| overall_color = green if overall >= 80 else (yellow if overall >= 50 else red) | |
| print(f"\n {bold('Overall:')} {overall_color(str(overall) + '/100')} {'🌟' if overall >= 90 else '👍' if overall >= 70 else '⚠️'}") | |
| print() | |
| return 0 | |
| if __name__ == "__main__": | |
| import sys | |
| cmd_analytics(sys.argv[1:]) | |
Xet Storage Details
- Size:
- 16.1 kB
- Xet hash:
- 8a36baae416103af1392cc65ae24dd74b0658d00ef0b6dca06c1cad19ab79ab5
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.