dev-dna 0.1.0__py3-none-any.whl

dev_dna/__init__.py

@@ -0,0 +1,11 @@
+"""dev-dna — 23andMe for developers.
+
+Analyze any GitHub user's developer DNA: dominant languages, evolution
+over time, commit personality archetype, specialization score, star power,
+and a shareable summary.
+"""
+
+from dev_dna.analyzer import analyze_user, fetch_repos
+
+__version__ = "0.1.0"
+__all__ = ["analyze_user", "fetch_repos"]

dev_dna/analyzer.py

@@ -0,0 +1,597 @@
+"""Core analysis logic for dev-dna.
+
+Fetches GitHub public API data and computes developer DNA metrics.
+All HTTP calls use urllib.request — no third-party HTTP libraries.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+import urllib.error
+import urllib.request
+from collections import Counter
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Tuple
+
+GITHUB_API = "https://api.github.com"
+
+# ---------------------------------------------------------------------------
+# GitHub API helpers
+# ---------------------------------------------------------------------------
+
+
+def _build_headers(token: Optional[str] = None) -> Dict[str, str]:
+    headers: Dict[str, str] = {
+        "Accept": "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+        "User-Agent": "dev-dna-cli/0.1.0",
+    }
+    resolved_token = token or os.environ.get("GITHUB_TOKEN")
+    if resolved_token:
+        headers["Authorization"] = f"Bearer {resolved_token}"
+    return headers
+
+
+def _get(url: str, token: Optional[str] = None) -> Any:
+    """Perform a GET request and return parsed JSON, or raise on error."""
+    req = urllib.request.Request(url, headers=_build_headers(token))
+    try:
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+    except urllib.error.HTTPError as exc:
+        if exc.code == 403:
+            body = exc.read().decode("utf-8", errors="replace")
+            if "rate limit" in body.lower():
+                raise RateLimitError(
+                    "GitHub API rate limit exceeded. "
+                    "Set GITHUB_TOKEN or pass --token for higher limits."
+                ) from exc
+            raise GitHubError(f"HTTP 403 from GitHub API: {body}") from exc
+        if exc.code == 404:
+            raise NotFoundError(f"GitHub user or resource not found: {url}") from exc
+        raise GitHubError(f"GitHub API error {exc.code}: {exc.reason}") from exc
+    except urllib.error.URLError as exc:
+        raise GitHubError(f"Network error: {exc.reason}") from exc
+
+
+class RateLimitError(RuntimeError):
+    pass
+
+
+class NotFoundError(RuntimeError):
+    pass
+
+
+class GitHubError(RuntimeError):
+    pass
+
+
+# ---------------------------------------------------------------------------
+# Data fetching
+# ---------------------------------------------------------------------------
+
+
+def fetch_user(username: str, token: Optional[str] = None) -> Dict[str, Any]:
+    """Fetch the public profile for *username*."""
+    return _get(f"{GITHUB_API}/users/{username}", token=token)
+
+
+def fetch_repos(username: str, token: Optional[str] = None) -> List[Dict[str, Any]]:
+    """Fetch all public repos for *username* (up to 100, sorted by update date)."""
+    url = (
+        f"{GITHUB_API}/users/{username}/repos"
+        "?per_page=100&sort=updated&type=public"
+    )
+    repos: List[Dict[str, Any]] = _get(url, token=token)
+    if not isinstance(repos, list):
+        return []
+    # Filter out forks to focus on original work (keep forks if they have stars)
+    return [r for r in repos if not r.get("fork") or (r.get("stargazers_count", 0) > 0)]
+
+
+# ---------------------------------------------------------------------------
+# Metric computation
+# ---------------------------------------------------------------------------
+
+
+def _parse_date(date_str: Optional[str]) -> Optional[datetime]:
+    if not date_str:
+        return None
+    try:
+        # GitHub returns ISO 8601 with Z suffix
+        return datetime.fromisoformat(date_str.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+
+
+def compute_language_dna(repos: List[Dict[str, Any]]) -> List[Tuple[str, int]]:
+    """Return [(language, repo_count), ...] sorted descending, top 8."""
+    counter: Counter = Counter()
+    for repo in repos:
+        lang = repo.get("language")
+        if lang:
+            counter[lang] += 1
+    return counter.most_common(8)
+
+
+def compute_star_power(repos: List[Dict[str, Any]]) -> Dict[str, Any]:
+    total = sum(r.get("stargazers_count", 0) for r in repos)
+    if not repos:
+        return {"total": 0, "top_repo": None, "top_stars": 0}
+    top = max(repos, key=lambda r: r.get("stargazers_count", 0))
+    return {
+        "total": total,
+        "top_repo": top.get("name", ""),
+        "top_stars": top.get("stargazers_count", 0),
+    }
+
+
+def compute_velocity(
+    repos: List[Dict[str, Any]], user: Dict[str, Any]
+) -> Dict[str, Any]:
+    """Repos per month since account creation."""
+    created_at = _parse_date(user.get("created_at"))
+    if not created_at:
+        return {"repos_per_month": 0.0, "total_repos": len(repos), "months": 0}
+
+    now = datetime.now(timezone.utc)
+    months = max(
+        1,
+        (now.year - created_at.year) * 12 + (now.month - created_at.month),
+    )
+    rpm = round(len(repos) / months, 1)
+    return {
+        "repos_per_month": rpm,
+        "total_repos": len(repos),
+        "months": months,
+        "account_created": created_at,
+    }
+
+
+def compute_evolution(
+    repos: List[Dict[str, Any]],
+) -> Dict[str, Any]:
+    """Compare primary language in oldest 20% vs newest 20% of repos."""
+    dated = []
+    for r in repos:
+        dt = _parse_date(r.get("created_at"))
+        if dt:
+            dated.append((dt, r))
+    if not dated:
+        return {"early": "N/A", "recent": "N/A", "earliest_year": None}
+
+    dated.sort(key=lambda x: x[0])
+    n = max(1, len(dated) // 5)  # 20%
+
+    def top_lang(subset: List[Tuple[datetime, Dict[str, Any]]]) -> str:
+        c: Counter = Counter()
+        for _, r in subset:
+            lang = r.get("language")
+            if lang:
+                c[lang] += 1
+        return c.most_common(1)[0][0] if c else "N/A"
+
+    earliest_year = dated[0][0].year
+    early_lang = top_lang(dated[:n])
+    recent_langs: Counter = Counter()
+    for _, r in dated[-n:]:
+        lang = r.get("language")
+        if lang:
+            recent_langs[lang] += 1
+
+    # Trajectory label
+    top_recent = [l for l, _ in recent_langs.most_common(3)]
+    if len(top_recent) >= 2:
+        recent_str = " + ".join(top_recent[:2])
+        trajectory = "Diversifying"
+    elif top_recent:
+        recent_str = top_recent[0]
+        trajectory = "Deepening specialization" if recent_str == early_lang else "Language shift"
+    else:
+        recent_str = "N/A"
+        trajectory = "Not enough data"
+
+    return {
+        "early": early_lang,
+        "recent": recent_str,
+        "trajectory": trajectory,
+        "earliest_year": earliest_year,
+    }
+
+
+def compute_open_source_signal(repos: List[Dict[str, Any]]) -> int:
+    """Percentage of repos that have a license."""
+    if not repos:
+        return 0
+    licensed = sum(1 for r in repos if r.get("license"))
+    return round(licensed / len(repos) * 100)
+
+
+def compute_documentation_score(repos: List[Dict[str, Any]]) -> int:
+    """Percentage of repos with both a description and (assumed) README.
+
+    The repos endpoint doesn't expose README presence directly, so we
+    use description as a proxy — it's a reasonable signal for how much
+    care the developer puts into documentation.
+    """
+    if not repos:
+        return 0
+    with_desc = sum(
+        1
+        for r in repos
+        if r.get("description") and r["description"].strip()
+    )
+    return round(with_desc / len(repos) * 100)
+
+
+def compute_specialization_score(
+    repos: List[Dict[str, Any]], lang_dna: List[Tuple[str, int]]
+) -> int:
+    """0-100. High = deep in one domain, Low = generalist.
+
+    Formula: weighted by language concentration (Herfindahl-style) + topic
+    coherence signal.
+    """
+    if not repos or not lang_dna:
+        return 0
+    total_with_lang = sum(c for _, c in lang_dna)
+    if total_with_lang == 0:
+        return 0
+    # Herfindahl index: sum of squares of shares
+    hhi = sum((c / total_with_lang) ** 2 for _, c in lang_dna)
+    # Map 0..1 to 0..100 (pure mono-language = 1.0 → 100, equal split → near 0)
+    # We scale so that HHI of 0.5 → ~50
+    score = round(min(100, hhi * 100 * 1.5))
+    return score
+
+
+def _score_velocity(rpm: float) -> int:
+    """Map repos-per-month to a 0-100 score."""
+    if rpm >= 5:
+        return 99
+    if rpm >= 3:
+        return 90
+    if rpm >= 2:
+        return 80
+    if rpm >= 1:
+        return 65
+    if rpm >= 0.5:
+        return 45
+    if rpm >= 0.2:
+        return 25
+    return 10
+
+
+def _velocity_percentile_label(rpm: float) -> str:
+    if rpm >= 5:
+        return "faster than 95% of GitHub developers"
+    if rpm >= 3:
+        return "faster than 90% of GitHub developers"
+    if rpm >= 2:
+        return "faster than 80% of GitHub developers"
+    if rpm >= 1:
+        return "faster than 65% of GitHub developers"
+    if rpm >= 0.5:
+        return "around the median GitHub developer"
+    return "a deliberate, quality-focused pace"
+
+
+# ---------------------------------------------------------------------------
+# Archetype detection
+# ---------------------------------------------------------------------------
+
+_ARCHETYPE_KEYWORDS: Dict[str, List[str]] = {
+    "toolsmith": [
+        "cli", "tool", "utility", "script", "automation", "helper",
+        "generator", "formatter", "linter", "plugin", "extension",
+        "command", "terminal", "shell", "devtool",
+    ],
+    "researcher": [
+        "ml", "ai", "deep-learning", "neural", "nlp", "llm", "gpt",
+        "bert", "transformer", "dataset", "research", "paper",
+        "experiment", "model", "training", "embedding", "rag",
+        "diffusion", "vision", "reinforcement",
+    ],
+    "fullstack": [
+        "frontend", "backend", "fullstack", "full-stack", "api",
+        "webapp", "web-app", "dashboard", "react", "vue", "angular",
+        "nextjs", "django", "flask", "fastapi", "express", "node",
+        "rest", "graphql", "tailwind", "css",
+    ],
+    "data_engineer": [
+        "etl", "pipeline", "data", "analytics", "warehouse",
+        "spark", "kafka", "airflow", "dbt", "postgres", "mysql",
+        "bigquery", "snowflake", "pandas", "numpy", "visualization",
+        "chart", "dashboard", "metrics",
+    ],
+    "hacker": [],  # fallback for wide variety, many repos
+    "craftsperson": [],  # fallback for few, polished repos
+}
+
+_ARCHETYPE_META: Dict[str, Dict[str, str]] = {
+    "toolsmith": {
+        "label": "The Toolsmith",
+        "blurb": (
+            "Ships fast. Builds tools that make other developers' lives "
+            "easier. Prefers CLI over GUI. Has opinions about your commit "
+            "messages."
+        ),
+    },
+    "researcher": {
+        "label": "The Researcher",
+        "blurb": (
+            "Lives at the intersection of academia and engineering. "
+            "Reads papers on weekends. Turns ideas into prototypes before "
+            "most people have finished the abstract."
+        ),
+    },
+    "fullstack": {
+        "label": "The Full-Stack Builder",
+        "blurb": (
+            "Comfortable everywhere from the database to the browser. "
+            "Thinks in user journeys. Can wire up an API and style a "
+            "landing page before lunch."
+        ),
+    },
+    "data_engineer": {
+        "label": "The Data Engineer",
+        "blurb": (
+            "Speaks fluent SQL and pipeline DSL. Believes clean data is "
+            "a prerequisite for everything. Has a strong opinion on "
+            "column naming conventions."
+        ),
+    },
+    "hacker": {
+        "label": "The Hacker",
+        "blurb": (
+            "Wide variety, fast shipping, zero apologies. Tries "
+            "everything. Learns by building. The repo count alone is a "
+            "flex."
+        ),
+    },
+    "craftsperson": {
+        "label": "The Craftsperson",
+        "blurb": (
+            "Fewer repos, but each one is polished. Sweats the details. "
+            "Writes the README before the code. Quality over quantity, "
+            "always."
+        ),
+    },
+}
+
+
+def detect_archetype(
+    repos: List[Dict[str, Any]], lang_dna: List[Tuple[str, int]]
+) -> str:
+    """Return an archetype key based on repo metadata signals."""
+    scores: Counter = Counter()
+
+    for repo in repos:
+        text = " ".join(
+            filter(
+                None,
+                [
+                    repo.get("name", ""),
+                    repo.get("description", "") or "",
+                    repo.get("language", "") or "",
+                    " ".join(repo.get("topics", []) or []),
+                ],
+            )
+        ).lower()
+
+        for archetype, keywords in _ARCHETYPE_KEYWORDS.items():
+            if not keywords:
+                continue
+            hits = sum(1 for kw in keywords if kw in text)
+            if hits:
+                scores[archetype] += hits
+
+    if not scores:
+        # No keyword matches — use structural heuristics
+        if len(repos) >= 30:
+            return "hacker"
+        return "craftsperson"
+
+    top_archetype, top_score = scores.most_common(1)[0]
+
+    # If top score is very low and we have many repos, prefer hacker
+    if top_score <= 2 and len(repos) >= 30:
+        return "hacker"
+
+    return top_archetype
+
+
+# ---------------------------------------------------------------------------
+# Traits / insights
+# ---------------------------------------------------------------------------
+
+
+def compute_traits(
+    repos: List[Dict[str, Any]],
+    lang_dna: List[Tuple[str, int]],
+    velocity: Dict[str, Any],
+    star_power: Dict[str, Any],
+    doc_score: int,
+    oss_score: int,
+) -> List[Dict[str, str]]:
+    """Return a list of {sign: '+'/'-', text: '...'} trait items."""
+    traits = []
+    total = len(repos)
+    rpm = velocity.get("repos_per_month", 0)
+
+    # Prolific builder
+    if total >= 50:
+        traits.append({"sign": "+", "text": f"Prolific builder — top 5% by repo count ({total} repos)"})
+    elif total >= 20:
+        traits.append({"sign": "+", "text": f"Active builder — {total} public repos"})
+
+    # AI native
+    ai_keywords = {"ml", "ai", "llm", "gpt", "nlp", "neural", "rag", "diffusion"}
+    ai_repos = sum(
+        1
+        for r in repos
+        if any(
+            kw in " ".join([
+                r.get("name", ""),
+                r.get("description", "") or "",
+                " ".join(r.get("topics", []) or []),
+                r.get("language", "") or "",
+            ]).lower()
+            for kw in ai_keywords
+        )
+    )
+    if total > 0 and ai_repos / total >= 0.4:
+        traits.append({"sign": "+", "text": f"AI-native — {round(ai_repos/total*100)}%+ of repos involve ML/LLMs"})
+
+    # Velocity
+    if rpm >= 3:
+        traits.append({"sign": "+", "text": f"Rapid shipper — {rpm} repos/month average"})
+
+    # Stars
+    if star_power["total"] >= 100:
+        traits.append({"sign": "+", "text": f"Community recognition — {star_power['total']} total stars"})
+    elif star_power["total"] == 0 and total >= 10:
+        traits.append({"sign": "-", "text": "Discovery gap — great code, low visibility"})
+
+    # Documentation
+    if doc_score >= 70:
+        traits.append({"sign": "+", "text": f"Well-documented — {doc_score}% of repos have descriptions"})
+    elif doc_score < 40:
+        traits.append({"sign": "-", "text": f"Documentation debt — many repos lack descriptions ({doc_score}%)"})
+
+    # Open source
+    if oss_score >= 60:
+        traits.append({"sign": "+", "text": f"Open source contributor — {oss_score}% repos have licenses"})
+    elif oss_score < 30:
+        traits.append({"sign": "-", "text": f"Few repos have open-source licenses ({oss_score}%)"})
+
+    return traits
+
+
+def compute_insight(
+    repos: List[Dict[str, Any]],
+    archetype: str,
+    velocity: Dict[str, Any],
+    star_power: Dict[str, Any],
+    doc_score: int,
+    oss_score: int,
+    spec_score: int,
+) -> str:
+    rpm = velocity.get("repos_per_month", 0)
+    total = len(repos)
+
+    if archetype == "researcher":
+        if star_power["total"] < 10:
+            return (
+                "Your research depth is rare. Consider publishing one "
+                "polished project with a demo, a paper summary, and a "
+                "clear README — that's what turns followers into stars."
+            )
+        return (
+            "Strong research portfolio. Packaging your best experiments "
+            "as installable libraries could multiply your impact."
+        )
+
+    if archetype == "toolsmith":
+        if rpm >= 3 and star_power["total"] < 20:
+            return (
+                "You build at a rare velocity. The bottleneck isn't output — "
+                "it's surface area. Adding descriptions, PyPI packages, and "
+                "one viral project would unlock the stars your code deserves."
+            )
+        return (
+            "Quality tooling with good visibility. "
+            "Consider writing about your tools on Dev.to or Hacker News "
+            "to compound your reach."
+        )
+
+    if archetype == "fullstack":
+        if doc_score < 50:
+            return (
+                "Full-stack range is a genuine superpower. "
+                "A few well-documented showcase projects would make this "
+                "profile stand out to any hiring team."
+            )
+        return (
+            "Well-rounded full-stack presence. "
+            "Pinning your three best projects on GitHub would create a "
+            "strong first impression."
+        )
+
+    if archetype == "data_engineer":
+        return (
+            "Data pipelines are the invisible backbone of every great "
+            "product. Sharing one end-to-end example with a dataset "
+            "and dashboard would make your skills tangible to outsiders."
+        )
+
+    if archetype == "hacker":
+        return (
+            f"You've shipped {total} repos — that's creative energy most "
+            "developers never tap. Picking your top 3 and investing in "
+            "their README, docs, and packaging would unlock outsized returns."
+        )
+
+    # craftsperson or fallback
+    return (
+        "Quality-over-quantity is a defensible strategy. "
+        "Your next step is distribution — make sure each polished "
+        "project has a demo link, license, and 3-line install guide."
+    )
+
+
+# ---------------------------------------------------------------------------
+# Main analysis entry point
+# ---------------------------------------------------------------------------
+
+
+def analyze_user(
+    username: str, token: Optional[str] = None
+) -> Dict[str, Any]:
+    """Fetch GitHub data and return a structured DNA report dict."""
+    user = fetch_user(username, token=token)
+    repos = fetch_repos(username, token=token)
+
+    lang_dna = compute_language_dna(repos)
+    star_power = compute_star_power(repos)
+    velocity = compute_velocity(repos, user)
+    evolution = compute_evolution(repos)
+    oss_score = compute_open_source_signal(repos)
+    doc_score = compute_documentation_score(repos)
+    spec_score = compute_specialization_score(repos, lang_dna)
+    archetype_key = detect_archetype(repos, lang_dna)
+    archetype_meta = _ARCHETYPE_META[archetype_key]
+    traits = compute_traits(
+        repos, lang_dna, velocity, star_power, doc_score, oss_score
+    )
+    velocity_score = _score_velocity(velocity["repos_per_month"])
+    velocity_label = _velocity_percentile_label(velocity["repos_per_month"])
+    insight = compute_insight(
+        repos, archetype_key, velocity, star_power, doc_score, oss_score, spec_score
+    )
+
+    return {
+        "username": username,
+        "name": user.get("name") or username,
+        "bio": user.get("bio") or "",
+        "followers": user.get("followers", 0),
+        "following": user.get("following", 0),
+        "public_repos_api": user.get("public_repos", len(repos)),
+        "repos_analyzed": len(repos),
+        "lang_dna": lang_dna,
+        "star_power": star_power,
+        "velocity": velocity,
+        "velocity_score": velocity_score,
+        "velocity_label": velocity_label,
+        "evolution": evolution,
+        "oss_score": oss_score,
+        "doc_score": doc_score,
+        "spec_score": spec_score,
+        "archetype_key": archetype_key,
+        "archetype_label": archetype_meta["label"],
+        "archetype_blurb": archetype_meta["blurb"],
+        "traits": traits,
+        "insight": insight,
+    }

dev_dna/cli.py

@@ -0,0 +1,509 @@
+"""CLI entry point for dev-dna.
+
+Commands
+--------
+  dev-dna <username>
+  dev-dna <username> --json
+  dev-dna <username> --token <ghp_...>
+  dev-dna <username> --compare <other_username>
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import textwrap
+from typing import Any, Dict, List, Optional, Tuple
+
+import click
+from rich import box
+from rich.columns import Columns
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from dev_dna.analyzer import (
+    GitHubError,
+    NotFoundError,
+    RateLimitError,
+    analyze_user,
+)
+
+console = Console()
+
+# ---------------------------------------------------------------------------
+# Rendering helpers
+# ---------------------------------------------------------------------------
+
+
+def _bar(fraction: float, width: int = 20, fill: str = "█", empty: str = "░") -> str:
+    """Return a Unicode block bar of given width."""
+    filled = round(fraction * width)
+    filled = max(0, min(width, filled))
+    return fill * filled + empty * (width - filled)
+
+
+def _terminal_width() -> int:
+    try:
+        return os.get_terminal_size().columns
+    except OSError:
+        return 80
+
+
+def _wrap(text: str, indent: int = 2) -> str:
+    width = max(40, _terminal_width() - indent - 4)
+    lines = textwrap.wrap(text, width=width)
+    prefix = " " * indent
+    return ("\n" + prefix).join(lines)
+
+
+def _lang_bar_width() -> int:
+    """Dynamic bar chart width based on terminal size."""
+    cols = _terminal_width()
+    # Reserve: 2 indent + 12 name + 1 space + bar + 1 space + 4 pct = ~20 fixed
+    bar_width = max(10, min(40, cols - 30))
+    return bar_width
+
+
+# ---------------------------------------------------------------------------
+# Rich panel renderers
+# ---------------------------------------------------------------------------
+
+_LANG_COLORS = [
+    "bright_cyan",
+    "bright_green",
+    "bright_yellow",
+    "bright_magenta",
+    "bright_blue",
+    "bright_red",
+    "cyan",
+    "green",
+]
+
+
+def render_header(data: Dict[str, Any]) -> Panel:
+    username = data["username"]
+    name = data["name"]
+    bio = data["bio"]
+
+    lines = Text()
+    lines.append(f"  github.com/{username}\n", style="bold bright_white")
+    if name and name != username:
+        lines.append(f"  {name}\n", style="dim white")
+    if bio:
+        lines.append(f"  {bio}\n", style="italic dim white")
+
+    return Panel(
+        lines,
+        title="[bold bright_green]DEV DNA ANALYSIS[/bold bright_green]",
+        title_align="center",
+        border_style="bright_green",
+        padding=(0, 1),
+    )
+
+
+def render_archetype(data: Dict[str, Any]) -> Panel:
+    label = data["archetype_label"]
+    blurb = data["archetype_blurb"]
+    wrapped = _wrap(blurb, indent=0)
+    content = Text()
+    content.append(f"{label}\n\n", style="bold bright_yellow")
+    content.append(f'"{wrapped}"', style="italic dim white")
+    return Panel(
+        content,
+        title="[bold]ARCHETYPE[/bold]",
+        border_style="yellow",
+        padding=(0, 2),
+    )
+
+
+def render_language_dna(data: Dict[str, Any]) -> Panel:
+    lang_dna: List[Tuple[str, int]] = data["lang_dna"]
+    bar_width = _lang_bar_width()
+
+    if not lang_dna:
+        return Panel(
+            Text("No language data available.", style="dim"),
+            title="[bold]LANGUAGE DNA[/bold]",
+            border_style="cyan",
+        )
+
+    total = sum(c for _, c in lang_dna)
+    content = Text()
+    for idx, (lang, count) in enumerate(lang_dna[:6]):
+        frac = count / total if total else 0
+        pct = round(frac * 100)
+        bar = _bar(frac, width=bar_width)
+        color = _LANG_COLORS[idx % len(_LANG_COLORS)]
+        lang_str = (lang[:13] + "…" if len(lang) > 14 else lang).ljust(14)
+        content.append(f"  {lang_str}", style="bold white")
+        content.append(bar, style=color)
+        content.append(f"  {pct:>3}%\n", style="dim white")
+
+    return Panel(
+        content,
+        title="[bold cyan]LANGUAGE DNA[/bold cyan]",
+        border_style="cyan",
+        padding=(0, 1),
+    )
+
+
+def render_evolution(data: Dict[str, Any]) -> Panel:
+    evo = data["evolution"]
+    content = Text()
+    year = evo.get("earliest_year")
+    year_str = f" ({year})" if year else ""
+
+    content.append("  Started with:  ", style="dim white")
+    content.append(f"{evo['early']}{year_str}\n", style="bold white")
+    content.append("  Now building:  ", style="dim white")
+    content.append(f"{evo['recent']}\n", style="bold bright_cyan")
+    content.append("  Trajectory:    ", style="dim white")
+    content.append(evo.get("trajectory", ""), style="italic bright_yellow")
+
+    return Panel(
+        content,
+        title="[bold green]EVOLUTION[/bold green]",
+        border_style="green",
+        padding=(0, 1),
+    )
+
+
+def render_velocity(data: Dict[str, Any]) -> Panel:
+    vel = data["velocity"]
+    rpm = vel.get("repos_per_month", 0)
+    total = vel.get("total_repos", 0)
+    months = vel.get("months", 0)
+    label = data["velocity_label"]
+
+    content = Text()
+    content.append(f"  {total} repos", style="bold bright_white")
+    content.append(" over ", style="dim white")
+    content.append(f"~{months} months", style="bold bright_white")
+    content.append(f" = {rpm} repos/month\n", style="bright_yellow")
+    content.append(f"  That's {label}\n", style="italic dim white")
+
+    return Panel(
+        content,
+        title="[bold yellow]VELOCITY[/bold yellow]",
+        border_style="yellow",
+        padding=(0, 1),
+    )
+
+
+def render_star_power(data: Dict[str, Any]) -> Panel:
+    sp = data["star_power"]
+    total = sp["total"]
+    top_repo = sp.get("top_repo") or "—"
+    top_stars = sp.get("top_stars", 0)
+    repos_analyzed = data["repos_analyzed"]
+
+    content = Text()
+    content.append(f"  Total stars:      ", style="dim white")
+    content.append(f"{total}\n", style="bold bright_yellow")
+    content.append(f"  Best performer:   ", style="dim white")
+    content.append(f"{top_repo}", style="bold white")
+    content.append(f" ({top_stars} {'star' if top_stars == 1 else 'stars'})\n", style="dim white")
+
+    if total == 0 and repos_analyzed >= 5:
+        content.append(
+            "  Untapped potential: high output, early-stage discovery\n",
+            style="italic dim yellow",
+        )
+    elif total >= 100:
+        content.append(
+            "  Community recognition: established open-source presence\n",
+            style="italic bright_green",
+        )
+
+    return Panel(
+        content,
+        title="[bold yellow]STAR POWER[/bold yellow]",
+        border_style="yellow",
+        padding=(0, 1),
+    )
+
+
+def render_scores(data: Dict[str, Any]) -> Panel:
+    # Dynamically choose bar width so the full line fits in the terminal
+    # Layout: 2 indent + 16 label + bar + 2 + 7 score + 2 + note(~20) + 2 border = ~51 + bar
+    avail = max(10, _terminal_width() - 53)
+    bar_w = min(20, avail)
+    scores = [
+        ("Specialization", data["spec_score"], "(focused)"),
+        ("Documentation",  data["doc_score"],  "(has description)"),
+        ("Open Source",    data["oss_score"],  "(has license)"),
+        ("Velocity",       data["velocity_score"], "(ships fast)"),
+    ]
+
+    content = Text()
+    for label, score, note in scores:
+        frac = score / 100
+        bar = _bar(frac, width=bar_w)
+        color = "bright_green" if score >= 70 else ("bright_yellow" if score >= 40 else "bright_red")
+        label_str = label.ljust(16)
+        content.append(f"  {label_str}", style="dim white")
+        content.append(bar, style=color)
+        content.append(f"  {score:>3}/100  ", style="bold white")
+        content.append(f"{note}\n", style="dim white")
+
+    return Panel(
+        content,
+        title="[bold magenta]SCORES[/bold magenta]",
+        border_style="magenta",
+        padding=(0, 1),
+    )
+
+
+def render_traits(data: Dict[str, Any]) -> Panel:
+    traits: List[Dict[str, str]] = data["traits"]
+    if not traits:
+        return Panel(
+            Text("Not enough data to compute traits.", style="dim"),
+            title="[bold]DEVELOPER TRAITS[/bold]",
+            border_style="bright_white",
+        )
+
+    content = Text()
+    for t in traits:
+        sign = t["sign"]
+        if sign == "+":
+            content.append("  + ", style="bold bright_green")
+        else:
+            content.append("  - ", style="bold bright_red")
+        content.append(t["text"] + "\n", style="white")
+
+    return Panel(
+        content,
+        title="[bold]DEVELOPER TRAITS[/bold]",
+        border_style="bright_white",
+        padding=(0, 1),
+    )
+
+
+def render_insight(data: Dict[str, Any]) -> Panel:
+    insight = data["insight"]
+    # Use panel padding for left indent; let Rich handle wrapping
+    return Panel(
+        Text(insight, style="italic bright_white"),
+        title="[bold bright_green]DNA INSIGHT[/bold bright_green]",
+        border_style="bright_green",
+        padding=(0, 2),
+    )
+
+
+def render_footer(data: Dict[str, Any]) -> Text:
+    t = Text(justify="center")
+    t.append("\n  Generated by ", style="dim")
+    t.append("dev-dna", style="bold bright_green")
+    t.append(" — pip install dev-dna\n", style="dim")
+    return t
+
+
+# ---------------------------------------------------------------------------
+# Full report rendering
+# ---------------------------------------------------------------------------
+
+
+def print_report(data: Dict[str, Any]) -> None:
+    console.print()
+    console.print(render_header(data))
+    console.print()
+    console.print(render_archetype(data))
+    console.print()
+    console.print(render_language_dna(data))
+    console.print()
+    console.print(render_evolution(data))
+    console.print()
+    console.print(render_velocity(data))
+    console.print()
+    console.print(render_star_power(data))
+    console.print()
+    console.print(render_scores(data))
+    console.print()
+    console.print(render_traits(data))
+    console.print()
+    console.print(render_insight(data))
+    console.print(render_footer(data))
+
+
+# ---------------------------------------------------------------------------
+# Comparison mode
+# ---------------------------------------------------------------------------
+
+
+def _compact_lang_bar(lang_dna: List[Tuple[str, int]], bar_width: int = 16) -> Text:
+    total = sum(c for _, c in lang_dna) or 1
+    t = Text()
+    for idx, (lang, count) in enumerate(lang_dna[:5]):
+        frac = count / total
+        pct = round(frac * 100)
+        bar = _bar(frac, width=bar_width)
+        color = _LANG_COLORS[idx % len(_LANG_COLORS)]
+        t.append(f"  {lang:<12}", style="bold white")
+        t.append(bar, style=color)
+        t.append(f"  {pct:>3}%\n", style="dim white")
+    return t
+
+
+def print_comparison(data_a: Dict[str, Any], data_b: Dict[str, Any]) -> None:
+    console.print()
+    console.rule("[bold bright_green]DEV DNA — HEAD TO HEAD[/bold bright_green]")
+    console.print()
+
+    def _side_panel(data: Dict[str, Any]) -> Panel:
+        content = Text()
+        content.append(f"github.com/{data['username']}\n", style="bold bright_white")
+        if data["name"] != data["username"]:
+            content.append(f"{data['name']}\n", style="dim white")
+        content.append(f"\nARCHETYPE: {data['archetype_label']}\n\n", style="bold bright_yellow")
+
+        # Language DNA
+        content.append("LANGUAGE DNA\n", style="bold cyan")
+        total = sum(c for _, c in data["lang_dna"]) or 1
+        for idx, (lang, count) in enumerate(data["lang_dna"][:5]):
+            frac = count / total
+            pct = round(frac * 100)
+            bar = _bar(frac, width=14)
+            color = _LANG_COLORS[idx % len(_LANG_COLORS)]
+            lang_short = (lang[:11] + "…" if len(lang) > 12 else lang).ljust(12)
+            content.append(f"  {lang_short}", style="bold white")
+            content.append(bar, style=color)
+            content.append(f" {pct:>3}%\n", style="dim white")
+
+        # Scores
+        content.append("\nSCORES\n", style="bold magenta")
+        for label, score in [
+            ("Specialization", data["spec_score"]),
+            ("Documentation",  data["doc_score"]),
+            ("Open Source",    data["oss_score"]),
+            ("Velocity",       data["velocity_score"]),
+        ]:
+            bar = _bar(score / 100, width=14)
+            color = "bright_green" if score >= 70 else ("bright_yellow" if score >= 40 else "bright_red")
+            content.append(f"  {label:<16}", style="dim white")
+            content.append(bar, style=color)
+            content.append(f" {score:>3}\n", style="bold white")
+
+        # Star power
+        sp = data["star_power"]
+        content.append(f"\nSTARS: {sp['total']}", style="bold bright_yellow")
+        content.append(f"  (best: {sp.get('top_repo','—')} {sp['top_stars']})\n", style="dim white")
+
+        # Velocity
+        vel = data["velocity"]
+        content.append(
+            f"VELOCITY: {vel['repos_per_month']} repos/month "
+            f"({vel['total_repos']} repos)\n",
+            style="bright_white",
+        )
+
+        # Traits
+        content.append("\nTRAITS\n", style="bold white")
+        for t in data["traits"][:4]:
+            sign_color = "bright_green" if t["sign"] == "+" else "bright_red"
+            content.append(f"  {t['sign']} ", style=f"bold {sign_color}")
+            content.append(t["text"] + "\n", style="white")
+
+        return Panel(
+            content,
+            title=f"[bold]{data['username']}[/bold]",
+            border_style="bright_cyan" if data == data_a else "bright_magenta",
+            padding=(0, 1),
+        )
+
+    cols = Columns([_side_panel(data_a), _side_panel(data_b)], equal=True, expand=True)
+    console.print(cols)
+    console.print()
+
+    # Verdict
+    a_total = data_a["spec_score"] + data_a["doc_score"] + data_a["oss_score"] + data_a["velocity_score"]
+    b_total = data_b["spec_score"] + data_b["doc_score"] + data_b["oss_score"] + data_b["velocity_score"]
+    if a_total > b_total:
+        verdict = f"[bold bright_cyan]{data_a['username']}[/bold bright_cyan] edges ahead on aggregate scores."
+    elif b_total > a_total:
+        verdict = f"[bold bright_magenta]{data_b['username']}[/bold bright_magenta] edges ahead on aggregate scores."
+    else:
+        verdict = "These developers are evenly matched — different strengths, same drive."
+    console.print(Panel(verdict, title="[bold]VERDICT[/bold]", border_style="bright_white"))
+    console.print()
+
+
+# ---------------------------------------------------------------------------
+# CLI definition
+# ---------------------------------------------------------------------------
+
+
+@click.command(context_settings={"help_option_names": ["-h", "--help"]})
+@click.argument("username")
+@click.option(
+    "--token", "-t",
+    default=None,
+    envvar="GITHUB_TOKEN",
+    metavar="TOKEN",
+    help="GitHub personal access token (or set GITHUB_TOKEN env var). Increases rate limits.",
+)
+@click.option(
+    "--json", "output_json",
+    is_flag=True,
+    default=False,
+    help="Output raw JSON instead of the formatted report.",
+)
+@click.option(
+    "--compare", "-c",
+    default=None,
+    metavar="USERNAME",
+    help="Compare with another GitHub user side-by-side.",
+)
+def main(username: str, token: Optional[str], output_json: bool, compare: Optional[str]) -> None:
+    """Analyze a GitHub developer's DNA.
+
+    \b
+    Examples:
+      dev-dna torvalds
+      dev-dna torvalds --json
+      dev-dna gvanrossum --compare torvalds
+      dev-dna myuser --token ghp_xxxx
+    """
+    try:
+        with console.status(
+            f"[bright_green]Fetching GitHub data for [bold]{username}[/bold]...[/bright_green]",
+            spinner="dots",
+        ):
+            data = analyze_user(username, token=token)
+
+        if compare:
+            with console.status(
+                f"[bright_magenta]Fetching GitHub data for [bold]{compare}[/bold]...[/bright_magenta]",
+                spinner="dots",
+            ):
+                data_b = analyze_user(compare, token=token)
+
+            if output_json:
+                click.echo(json.dumps({"a": data, "b": data_b}, indent=2, default=str))
+            else:
+                print_comparison(data, data_b)
+        else:
+            if output_json:
+                click.echo(json.dumps(data, indent=2, default=str))
+            else:
+                print_report(data)
+
+    except NotFoundError as exc:
+        console.print(f"\n[bold red]Not found:[/bold red] {exc}\n")
+        sys.exit(1)
+    except RateLimitError as exc:
+        console.print(f"\n[bold yellow]Rate limited:[/bold yellow] {exc}\n")
+        sys.exit(1)
+    except GitHubError as exc:
+        console.print(f"\n[bold red]GitHub API error:[/bold red] {exc}\n")
+        sys.exit(1)
+    except KeyboardInterrupt:
+        console.print("\n[dim]Interrupted.[/dim]\n")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

dev_dna-0.1.0.dist-info/METADATA

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: dev-dna
+Version: 0.1.0
+Summary: 23andMe for developers — analyze any GitHub user's developer DNA
+Author: dev-dna contributors
+License: MIT
+Project-URL: Homepage, https://github.com/lakshmisravyavedantham/dev-dna
+Project-URL: Repository, https://github.com/lakshmisravyavedantham/dev-dna
+Project-URL: Issues, https://github.com/lakshmisravyavedantham/dev-dna/issues
+Keywords: github,developer,analytics,cli,profile
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.0
+Requires-Dist: rich>=13.0
+Dynamic: license-file
+
+# dev-dna
+
+**23andMe for developers.** Point it at any GitHub username and get a rich terminal report of their Developer DNA — dominant languages, evolution over time, commit personality archetype, specialization vs. generalist score, star power, and a shareable summary.
+
+## Install
+
+```bash
+pip install dev-dna
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/lakshmisravyavedantham/dev-dna
+cd dev-dna
+pip install -e .
+```
+
+## Usage
+
+```bash
+# Analyze any public GitHub profile
+dev-dna torvalds
+
+# Output raw JSON
+dev-dna torvalds --json
+
+# Pass a GitHub token for higher rate limits (60 → 5000 req/hr)
+dev-dna torvalds --token ghp_xxx
+# or set the env var:
+export GITHUB_TOKEN=ghp_xxx
+dev-dna torvalds
+
+# Compare two developers side-by-side
+dev-dna gvanrossum --compare torvalds
+```
+
+## Sample Output
+
+```
+╔══════════════════════════════════════════════════════════╗
+║              DEV DNA ANALYSIS                            ║
+║              github.com/lakshmisravyavedantham           ║
+╚══════════════════════════════════════════════════════════╝
+
+ARCHETYPE: The Toolsmith
+"Ships fast. Builds tools that make other developers' lives
+ easier. Prefers CLI over GUI. Has opinions about your commit
+ messages."
+
+LANGUAGE DNA
+  Python         ████████████████████  67%
+  TypeScript     ██████░░░░░░░░░░░░░░  18%
+  JavaScript     ████░░░░░░░░░░░░░░░░  10%
+  HTML           ██░░░░░░░░░░░░░░░░░░   5%
+
+EVOLUTION
+  Started with:  Python (2022)
+  Now building:  Python + TypeScript
+  Trajectory:    Expanding into full-stack
+
+VELOCITY
+  108 repos over ~24 months = 4.5 repos/month
+  That's faster than 94% of GitHub developers
+
+STAR POWER
+  Total stars:      4
+  Best performer:   Coherence (1 star)
+  Untapped potential: high output, early-stage discovery
+
+SCORES
+  Specialization   ████████████░░░░░░░░   72/100  (focused depth)
+  Documentation    ████████░░░░░░░░░░░░   41/100  (descriptions + readability)
+  Open Source      ███████░░░░░░░░░░░░░   38/100  (repos with license)
+  Velocity         ████████████████████   96/100  (shipping speed)
+
+DEVELOPER TRAITS
+  + Prolific builder — top 5% by repo count
+  + AI-native — 60%+ of recent work involves LLMs
+  - Discovery gap — great code, low visibility
+  - Documentation debt — many repos lack descriptions
+
+DNA INSIGHT
+  You build at a rare velocity. The bottleneck isn't output —
+  it's surface area. Adding descriptions, PyPI packages, and
+  one viral project would unlock the stars your code deserves.
+```
+
+## What it analyzes
+
+| Signal | Description |
+|---|---|
+| **Language DNA** | Top 6 languages by repo count, shown as a terminal bar chart |
+| **Archetype** | Personality classification: Toolsmith, Researcher, Full-Stack Builder, Data Engineer, Hacker, or Craftsperson |
+| **Specialization Score** | 0–100. High = deep in one domain. Low = polyglot generalist |
+| **Velocity** | Repos created per month; scored against a GitHub-wide distribution |
+| **Star Power** | Total stars + top repo; flags discovery gap for prolific but under-starred devs |
+| **Evolution** | Primary language in oldest 20% of repos vs newest 20% — shows trajectory |
+| **Open Source Signal** | % of repos with a license |
+| **Documentation Score** | % of repos with a description |
+
+## Architecture
+
+```
+src/dev_dna/
+├── __init__.py       — public API
+├── cli.py            — Click CLI + Rich rendering
+└── analyzer.py       — GitHub API calls + metric computation
+```
+
+- Uses only `urllib.request` for HTTP (no `requests` library)
+- Zero external dependencies beyond `click` and `rich`
+- Supports `GITHUB_TOKEN` env var or `--token` flag for 5000 req/hr rate limit
+- Gracefully handles: rate limits, private-only accounts, 0-star accounts, missing data
+
+## License
+
+MIT

dev_dna-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+dev_dna/__init__.py,sha256=Snip_hK6IY02DME-vHKoBscQxuzdp5ZEka-AJcF00V8,336
+dev_dna/analyzer.py,sha256=cGiHnRLITPlgC3SPhRHQuWfKWQdR0Xkicbxt-8eYzHk,20262
+dev_dna/cli.py,sha256=zC_8qcbF-ahFY-Njd2u0F8XQnzrmIBfoIaDi_eiBoms,16872
+dev_dna-0.1.0.dist-info/licenses/LICENSE,sha256=a1JqlBXUwW3JVspjcrTggLsSzoVyM80GVlA6J9debzU,1077
+dev_dna-0.1.0.dist-info/METADATA,sha256=EI3LCVF4nmZ2az4U7vHtmqlQqkUXMfxHjekaUzD_jjI,5517
+dev_dna-0.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+dev_dna-0.1.0.dist-info/entry_points.txt,sha256=ZpBFNo2kUBUTBi6oNULecy20dx9ZmnfjPoyP3KByRfs,45
+dev_dna-0.1.0.dist-info/top_level.txt,sha256=M6gdaYdfGaJ8LEs-Gv1Xgynbf51lPNH3gyJbg313eAE,8
+dev_dna-0.1.0.dist-info/RECORD,,

dev_dna-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dev_dna-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dev-dna = dev_dna.cli:main

dev_dna-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dev-dna contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dev_dna-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dev_dna