standout 0.1.0 → 0.2.0

package/dist/gather.js

@@ -0,0 +1,869 @@
+import { execSync } from "child_process";
+import { existsSync, readFileSync, statSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { STANDOUT_API_URL } from "./api.js";
+import { gatherAiUsage } from "./ai-usage.js";
+import { gatherDevEnvironment } from "./dev-env.js";
+import { scrapeTwitterHandle } from "./twitter-scrape.js";
+import { redactSecrets } from "./redact.js";
+export function emptyGatheredProfile(readiness = {
+    usage_stats_status: "unavailable",
+    profile_basics_status: "unavailable",
+    enrichment_status: "unavailable",
+}) {
+    return {
+        readiness,
+        identity: {
+            name: null,
+            email: null,
+            github_username: null,
+            twitter_username: null,
+            remotes: [],
+        },
+        github: {
+            profile: null,
+            repos: [],
+            starred: [],
+            following: [],
+            events: [],
+            prs_authored: [],
+            contribution_graph: null,
+            repo_contents: {},
+            readmes: {},
+            commit_messages: {},
+            npm_packages: [],
+            enrichment: null,
+        },
+        linkedin: {
+            url: null,
+            url_resolution_source: null,
+            profile: null,
+            company_enrichments: {},
+        },
+        twitter: {
+            handle: null,
+            url: null,
+            profile: null,
+        },
+        local: {
+            repos: [],
+            commit_patterns: [],
+            collaborators: [],
+        },
+        ai_coding: {
+            total_commits_since_2024: 0,
+            ai_assisted_commits: 0,
+            lines_added_since_2024: 0,
+            lines_deleted_since_2024: 0,
+            median_commit_size: 0,
+            biggest_commit_size: 0,
+            commit_subjects: [],
+            claude_md_contents: null,
+            claude_dirs: [],
+            other_ai_tools: [],
+            cursorrules: null,
+        },
+        ai_usage: {
+            claude_code: null,
+            codex: null,
+            cursor: null,
+        },
+        dev_environment: {
+            agents_md: [],
+            claude_settings: [],
+            claude_commands: [],
+            claude_skills: [],
+            cursor_rules: [],
+            vscode_extensions: [],
+            global_npm_packages: [],
+            global_brew_packages: [],
+            global_pip_packages: [],
+            tools: [],
+        },
+    };
+}
+function hasAnyUsage(aiUsage) {
+    return Boolean(aiUsage.claude_code || aiUsage.codex || aiUsage.cursor);
+}
+function gatherLog(options, message) {
+    if (options.verbose === false)
+        return;
+    process.stderr.write(message);
+}
+export async function gatherUsageStats() {
+    try {
+        const aiUsage = await gatherAiUsage();
+        return {
+            ai_usage: aiUsage,
+            readiness: {
+                usage_stats_status: hasAnyUsage(aiUsage) ? "ready" : "unavailable",
+                profile_basics_status: "unavailable",
+                enrichment_status: "unavailable",
+            },
+        };
+    }
+    catch {
+        return {
+            ai_usage: {
+                claude_code: null,
+                codex: null,
+                cursor: null,
+            },
+            readiness: {
+                usage_stats_status: "error",
+                profile_basics_status: "unavailable",
+                enrichment_status: "unavailable",
+            },
+        };
+    }
+}
+export async function gatherProfileBasics() {
+    const base = emptyGatheredProfile({
+        usage_stats_status: "unavailable",
+        profile_basics_status: "scanning",
+        enrichment_status: "unavailable",
+    });
+    try {
+        const name = execSafe("git config user.name");
+        const email = execSafe("git config user.email");
+        const remotes = execSafe("git remote -v").split("\n").filter(Boolean);
+        const remoteCandidates = [];
+        for (const remote of remotes) {
+            const match = remote.match(/github\.com[:/]([a-zA-Z0-9_-]+)\/[a-zA-Z0-9_.-]+/);
+            if (match && !remoteCandidates.includes(match[1])) {
+                remoteCandidates.push(match[1]);
+            }
+        }
+        let githubUsername = null;
+        for (const candidate of remoteCandidates) {
+            const profile = (await fetchGitHub(`https://api.github.com/users/${sanitize(candidate)}`));
+            if (profile?.type === "User" && profile.login) {
+                githubUsername = profile.login;
+                break;
+            }
+        }
+        const safeUsername = githubUsername ? sanitize(githubUsername) : null;
+        const [ghProfile, ghRepos] = safeUsername
+            ? await Promise.all([
+                fetchGitHub(`https://api.github.com/users/${safeUsername}`),
+                fetchGitHub(`https://api.github.com/users/${safeUsername}/repos?per_page=100&sort=pushed`),
+            ])
+            : [null, []];
+        base.readiness.profile_basics_status = "ready";
+        base.identity = {
+            name: name || null,
+            email: email || null,
+            github_username: githubUsername,
+            twitter_username: ghProfile && typeof ghProfile === "object"
+                ? (ghProfile.twitter_username ??
+                    null)
+                : null,
+            remotes,
+        };
+        base.github.profile = ghProfile
+            ? trimProfile(ghProfile)
+            : null;
+        base.github.repos = (Array.isArray(ghRepos) ? ghRepos : [])
+            .slice(0, 30)
+            .map(trimRepo);
+        return {
+            identity: base.identity,
+            github: base.github,
+            local: base.local,
+            readiness: base.readiness,
+        };
+    }
+    catch {
+        base.readiness.profile_basics_status = "error";
+        return {
+            identity: base.identity,
+            github: base.github,
+            local: base.local,
+            readiness: base.readiness,
+        };
+    }
+}
+export async function gatherFullEnrichment(options = {}) {
+    return gather(options);
+}
+function execSafe(cmd, timeout = 10000) {
+    try {
+        return execSync(cmd, {
+            timeout,
+            maxBuffer: 1024 * 1024,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        }).trim();
+    }
+    catch {
+        return "";
+    }
+}
+// First chunk of a repo's README (or CLAUDE.md fallback) — seeds the one-line
+// project blurb. Markdown headers/links are kept; the LLM handles the prose.
+function readRepoReadme(repoPath) {
+    for (const name of ["README.md", "README", "readme.md", "CLAUDE.md"]) {
+        const p = join(repoPath, name);
+        if (!existsSync(p))
+            continue;
+        try {
+            const text = readFileSync(p, "utf-8").trim();
+            // Redact first, THEN slice — slicing first can cut a secret mid-pattern so
+            // it no longer matches and its head leaks into the excerpt.
+            if (text.length > 0)
+                return redactSecrets(text).slice(0, 1200);
+        }
+        catch {
+            // unreadable — try the next candidate
+        }
+    }
+    return null;
+}
+// All GitHub traffic goes through the Standout-hosted proxy so users don't need a GITHUB_TOKEN.
+function toProxyUrl(githubUrl) {
+    const apiMatch = githubUrl.match(/^https:\/\/api\.github\.com(\/.*)$/);
+    if (apiMatch) {
+        return `${STANDOUT_API_URL}/api/public/agent-github/api${apiMatch[1]}`;
+    }
+    const rawMatch = githubUrl.match(/^https:\/\/raw\.githubusercontent\.com(\/.*)$/);
+    if (rawMatch) {
+        return `${STANDOUT_API_URL}/api/public/agent-github/raw${rawMatch[1]}`;
+    }
+    return null;
+}
+async function fetchGitHub(url, acceptPreview) {
+    const proxied = toProxyUrl(url);
+    if (!proxied)
+        return null;
+    const headers = { Accept: "application/json" };
+    if (acceptPreview)
+        headers["x-github-accept-preview"] = acceptPreview;
+    try {
+        const res = await fetch(proxied, { headers });
+        if (res.status === 403 || res.status === 429) {
+            process.stderr.write("GitHub proxy rate limit hit. Try again in a few minutes.\n");
+            return null;
+        }
+        if (!res.ok)
+            return null;
+        return await res.json();
+    }
+    catch {
+        return null;
+    }
+}
+async function fetchGitHubText(url) {
+    const proxied = toProxyUrl(url);
+    if (!proxied)
+        return null;
+    try {
+        const res = await fetch(proxied);
+        if (!res.ok)
+            return null;
+        return await res.text();
+    }
+    catch {
+        return null;
+    }
+}
+async function fetchJson(url) {
+    try {
+        const res = await fetch(url);
+        if (!res.ok)
+            return null;
+        return await res.json();
+    }
+    catch {
+        return null;
+    }
+}
+async function enrichApi(type, value, context) {
+    try {
+        const res = await fetch(`${STANDOUT_API_URL}/api/public/agent-enrich`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(context ? { type, value, context } : { type, value }),
+        });
+        if (!res.ok)
+            return null;
+        return (await res.json());
+    }
+    catch {
+        return null;
+    }
+}
+function sanitize(input) {
+    return input.replace(/[^a-zA-Z0-9@._+\-]/g, "");
+}
+function findGitRepos() {
+    const dirs = [
+        "Document",
+        "Documents",
+        "Projects",
+        "projects",
+        "code",
+        "Code",
+        "dev",
+        "Dev",
+        "src",
+        "work",
+        "Work",
+        "workspace",
+    ];
+    const home = homedir();
+    // Dedupe by inode (dev:ino), not path string — on case-insensitive filesystems
+    // "work" and "Work" are the SAME directory but realpath keeps their distinct
+    // casing, so a path/realpath-based dedupe would scan + count them twice.
+    const inodeKey = (p) => {
+        try {
+            const s = statSync(p);
+            return `${s.dev}:${s.ino}`;
+        }
+        catch {
+            return null;
+        }
+    };
+    const seenRoots = new Set();
+    const searchPaths = [];
+    for (const d of dirs) {
+        const p = join(home, d);
+        if (!existsSync(p))
+            continue;
+        const key = inodeKey(p);
+        if (key && seenRoots.has(key))
+            continue;
+        if (key)
+            seenRoots.add(key);
+        searchPaths.push(p);
+    }
+    if (searchPaths.length === 0)
+        return [];
+    const result = execSafe(`find ${searchPaths.join(" ")} -maxdepth 3 -name ".git" -type d`, 15000);
+    const raw = result ? result.split("\n").filter(Boolean) : [];
+    // Dedupe repos by inode, then order by most-recently-active (.git mtime) so the
+    // downstream cap keeps the repos you actually work in, not whatever the
+    // filesystem happened to list first (e.g. old clones in ~/Documents).
+    const seen = new Set();
+    const withMtime = [];
+    for (const gitDir of raw) {
+        let mtime = 0;
+        let key = null;
+        try {
+            const s = statSync(gitDir);
+            mtime = s.mtimeMs;
+            key = `${s.dev}:${s.ino}`;
+        }
+        catch {
+            // unreadable — fall back to the path string as the dedupe key
+        }
+        const dedupe = key ?? gitDir;
+        if (seen.has(dedupe))
+            continue;
+        seen.add(dedupe);
+        withMtime.push({ path: gitDir, mtime });
+    }
+    return withMtime.sort((a, b) => b.mtime - a.mtime).map((r) => r.path);
+}
+// Trim helpers — keep only fields the LLM needs
+function trimRepo(r) {
+    return {
+        name: r.name,
+        language: r.language,
+        description: r.description,
+        stars: r.stargazers_count ?? r.stars,
+        pushed_at: r.pushed_at,
+        fork: r.fork,
+        default_branch: r.default_branch,
+        topics: r.topics,
+        homepage: r.homepage,
+        created_at: r.created_at,
+    };
+}
+function trimStarred(r) {
+    return {
+        full_name: r.full_name,
+        description: r.description,
+        language: r.language,
+        stars: r.stargazers_count,
+    };
+}
+function trimFollowing(u) {
+    return { login: u.login, bio: u.bio };
+}
+function trimEvent(e) {
+    const repo = e.repo;
+    const payload = e.payload;
+    const pr = payload?.pull_request;
+    return {
+        type: e.type,
+        repo: repo?.name,
+        created_at: e.created_at,
+        ...(pr ? { pr_title: pr.title, pr_merged: pr.merged } : {}),
+    };
+}
+function trimPr(pr) {
+    const repoUrl = pr.repository_url;
+    const pullRequest = pr.pull_request;
+    return {
+        title: pr.title,
+        url: pr.html_url,
+        repo: repoUrl?.split("/").slice(-2).join("/"),
+        state: pr.state,
+        created_at: pr.created_at,
+        merged_at: pullRequest?.merged_at ?? null,
+    };
+}
+function trimProfile(p) {
+    return {
+        name: p.name,
+        bio: p.bio,
+        location: p.location,
+        company: p.company,
+        blog: p.blog,
+        twitter: p.twitter_username ?? p.twitter,
+        public_repos: p.public_repos,
+        followers: p.followers,
+        following: p.following,
+        created_at: p.created_at,
+        hireable: p.hireable,
+    };
+}
+function trimContent(f) {
+    return { name: f.name, type: f.type };
+}
+function trimNpmPackage(p) {
+    const pkg = p.package;
+    return {
+        name: pkg?.name,
+        version: pkg?.version,
+        description: pkg?.description,
+    };
+}
+export async function gather(options = {}) {
+    const profileBasics = options.profileBasics?.readiness.profile_basics_status === "ready"
+        ? options.profileBasics
+        : undefined;
+    // Phase 1: Git identity
+    const name = profileBasics
+        ? (profileBasics.identity.name ?? "")
+        : execSafe("git config user.name");
+    const email = profileBasics
+        ? (profileBasics.identity.email ?? "")
+        : execSafe("git config user.email");
+    const remotes = profileBasics
+        ? profileBasics.identity.remotes
+        : execSafe("git remote -v").split("\n").filter(Boolean);
+    // Extract GitHub username candidates from remotes (may be an org, not the user)
+    let githubUsername = profileBasics?.identity.github_username ?? null;
+    if (!profileBasics) {
+        const remoteCandidates = [];
+        for (const remote of remotes) {
+            const match = remote.match(/github\.com[:/]([a-zA-Z0-9_-]+)\/[a-zA-Z0-9_.-]+/);
+            if (match && !remoteCandidates.includes(match[1])) {
+                remoteCandidates.push(match[1]);
+            }
+        }
+        // Resolve to a USER (not an Organization) profile
+        for (const candidate of remoteCandidates) {
+            const profile = (await fetchGitHub(`https://api.github.com/users/${sanitize(candidate)}`));
+            if (profile?.type === "User" && profile.login) {
+                githubUsername = profile.login;
+                break;
+            }
+        }
+    }
+    // Fallback: search GitHub by email (public profile email match)
+    if (!githubUsername && email) {
+        const searchResult = (await fetchGitHub(`https://api.github.com/search/users?q=${encodeURIComponent(email)}+in:email`));
+        if (searchResult?.items?.[0]) {
+            githubUsername = searchResult.items[0].login;
+        }
+    }
+    // Fallback: search commits by author-email (catches users with private email)
+    if (!githubUsername && email) {
+        const commitSearch = (await fetchGitHub(`https://api.github.com/search/commits?q=author-email:${encodeURIComponent(email)}`));
+        const login = commitSearch?.items?.[0]?.author?.login;
+        if (login)
+            githubUsername = login;
+    }
+    const safeUsername = githubUsername ? sanitize(githubUsername) : null;
+    const safeEmail = email ? sanitize(email) : null;
+    // Phase 2: GitHub API (parallelized)
+    gatherLog(options, "Gathering GitHub data...\n");
+    const canUseCachedGithubBasics = Boolean(profileBasics?.identity.github_username) &&
+        profileBasics?.identity.github_username === githubUsername;
+    const [ghProfile, ghRepos, ghStarred, ghFollowing, ghEvents, ghPrs, ghContrib, ghNpm,] = safeUsername
+        ? await Promise.all([
+            canUseCachedGithubBasics
+                ? Promise.resolve(profileBasics?.github.profile ?? null)
+                : fetchGitHub(`https://api.github.com/users/${safeUsername}`),
+            canUseCachedGithubBasics
+                ? Promise.resolve(profileBasics?.github.repos ?? [])
+                : fetchGitHub(`https://api.github.com/users/${safeUsername}/repos?per_page=100&sort=pushed`),
+            fetchGitHub(`https://api.github.com/users/${safeUsername}/starred?per_page=100`),
+            fetchGitHub(`https://api.github.com/users/${safeUsername}/following?per_page=100`),
+            fetchGitHub(`https://api.github.com/users/${safeUsername}/events?per_page=30`),
+            fetchGitHub(`https://api.github.com/search/issues?q=author:${safeUsername}+type:pr&per_page=20`),
+            fetchJson(`https://github-contributions-api.jogruber.de/v4/${safeUsername}?y=last`),
+            fetchJson(`https://registry.npmjs.org/-/v1/search?text=maintainer:${safeUsername}&size=20`),
+        ])
+        : [null, [], [], [], [], { items: [] }, null, { objects: [] }];
+    const repos = Array.isArray(ghRepos) ? ghRepos : [];
+    const nonForkRepos = repos.filter((r) => !r.fork && r.language);
+    // Phase 2b: Repo contents, READMEs, commit messages (top repos)
+    const topRepos = nonForkRepos.slice(0, 5);
+    const repoContents = {};
+    const readmes = {};
+    const commitMessages = {};
+    if (safeUsername) {
+        const contentPromises = topRepos.map(async (repo) => {
+            const repoName = repo.name;
+            const contents = (await fetchGitHub(`https://api.github.com/repos/${safeUsername}/${repoName}/contents`));
+            if (Array.isArray(contents)) {
+                repoContents[repoName] = contents.map(trimContent);
+            }
+        });
+        const readmeRepos = nonForkRepos.slice(0, 3);
+        const readmePromises = readmeRepos.map(async (repo) => {
+            const repoName = repo.name;
+            const defaultBranch = repo.default_branch || "main";
+            const text = await fetchGitHubText(`https://raw.githubusercontent.com/${safeUsername}/${repoName}/${defaultBranch}/README.md`);
+            if (text)
+                readmes[repoName] = text.slice(0, 3000);
+        });
+        const commitRepos = nonForkRepos.slice(0, 3);
+        const commitPromises = commitRepos.map(async (repo) => {
+            const repoName = repo.name;
+            const commits = (await fetchGitHub(`https://api.github.com/repos/${safeUsername}/${repoName}/commits?per_page=10`));
+            if (Array.isArray(commits)) {
+                commitMessages[repoName] = commits
+                    .map((c) => c.commit?.message || "")
+                    .filter(Boolean)
+                    .map((m) => m.split("\n")[0].slice(0, 120));
+            }
+        });
+        await Promise.all([
+            ...contentPromises,
+            ...readmePromises,
+            ...commitPromises,
+        ]);
+    }
+    // Phase 2c: AI tool usage + dev environment (run in background during LinkedIn)
+    gatherLog(options, "Scanning AI tool usage and dev environment...\n");
+    const githubEnrichPromise = safeUsername
+        ? enrichApi("github", safeUsername).catch(() => null)
+        : Promise.resolve(null);
+    const aiUsagePromise = options.aiUsage
+        ? Promise.resolve(options.aiUsage)
+        : gatherAiUsage().catch(() => ({
+            claude_code: null,
+            codex: null,
+            cursor: null,
+        }));
+    const devEnvPromise = gatherDevEnvironment().catch(() => ({
+        agents_md: [],
+        claude_settings: [],
+        claude_commands: [],
+        claude_skills: [],
+        cursor_rules: [],
+        vscode_extensions: [],
+        global_npm_packages: [],
+        global_brew_packages: [],
+        global_pip_packages: [],
+        tools: [],
+    }));
+    // Phase 3: LinkedIn enrichment
+    gatherLog(options, "Checking LinkedIn...\n");
+    let linkedinUrl = null;
+    let linkedinResolutionSource = null;
+    let linkedinProfile = null;
+    const companyEnrichments = {};
+    if (safeEmail) {
+        const emailResult = await enrichApi("email_to_linkedin", email);
+        if (emailResult && typeof emailResult === "object") {
+            linkedinUrl =
+                emailResult
+                    .linkedin_profile_url || null;
+            if (linkedinUrl)
+                linkedinResolutionSource = "email";
+        }
+    }
+    // Fallback: name + signals via AI web search when email lookup comes up empty
+    if (!linkedinUrl && ghProfile && name) {
+        gatherLog(options, "Resolving LinkedIn via name + signals...\n");
+        const profile = ghProfile;
+        const signals = [];
+        if (profile.company)
+            signals.push(`Company: ${profile.company}`);
+        if (profile.location)
+            signals.push(`Location: ${profile.location}`);
+        if (profile.bio)
+            signals.push(`Bio: ${profile.bio}`);
+        if (profile.blog)
+            signals.push(`Website/blog: ${profile.blog}`);
+        if (safeUsername)
+            signals.push(`GitHub handle: ${safeUsername}`);
+        const topLangs = nonForkRepos
+            .slice(0, 5)
+            .map((r) => r.language)
+            .filter(Boolean);
+        if (topLangs.length)
+            signals.push(`Top GitHub languages: ${[...new Set(topLangs)].join(", ")}`);
+        const topRepoNames = nonForkRepos
+            .slice(0, 3)
+            .map((r) => r.name);
+        if (topRepoNames.length)
+            signals.push(`Notable GitHub repos: ${topRepoNames.join(", ")}`);
+        const resolveResult = await enrichApi("resolve_linkedin", name, {
+            email_domain: email ? email.split("@")[1] : undefined,
+            signals,
+        });
+        const resolved = resolveResult;
+        if (resolved?.linkedin_url) {
+            linkedinUrl = resolved.linkedin_url;
+            linkedinResolutionSource = "ai_search";
+        }
+    }
+    if (linkedinUrl) {
+        linkedinProfile = await enrichApi("linkedin_profile", linkedinUrl);
+        // Company enrichment
+        if (linkedinProfile &&
+            Array.isArray(linkedinProfile.experiences)) {
+            const experiences = linkedinProfile.experiences;
+            const companyUrls = [
+                ...new Set(experiences.map((e) => e.company_linkedin_profile_url).filter(Boolean)),
+            ].slice(0, 5);
+            await Promise.all(companyUrls.map(async (url) => {
+                const data = await enrichApi("company", url);
+                if (data)
+                    companyEnrichments[url] = data;
+            }));
+        }
+    }
+    // Phase 3b: Twitter/X handle + optional enrichment
+    let twitterHandle = profileBasics?.identity.twitter_username ?? null;
+    if (ghProfile && typeof ghProfile === "object") {
+        const raw = ghProfile
+            .twitter_username ??
+            ghProfile.twitter;
+        if (!twitterHandle && typeof raw === "string" && raw.trim()) {
+            twitterHandle = raw.trim();
+        }
+    }
+    if (!twitterHandle && linkedinProfile) {
+        const socialHandles = linkedinProfile.social_handles;
+        if (socialHandles && typeof socialHandles.twitter === "string") {
+            twitterHandle = socialHandles.twitter;
+        }
+    }
+    // Fallback: scrape the user's logged-in Chrome session for an X handle.
+    if (!twitterHandle) {
+        gatherLog(options, "Checking for an X/Twitter session in Chrome...\n");
+        try {
+            const scraped = await scrapeTwitterHandle();
+            if (scraped)
+                twitterHandle = scraped;
+        }
+        catch {
+            // silent
+        }
+    }
+    const safeTwitter = twitterHandle ? sanitize(twitterHandle) : null;
+    let twitterProfile = null;
+    if (safeTwitter) {
+        twitterProfile = await enrichApi("twitter", safeTwitter);
+    }
+    const twitterUrl = safeTwitter ? `https://x.com/${safeTwitter}` : null;
+    // Phase 4: Local machine analysis
+    gatherLog(options, "Scanning local repos...\n");
+    const gitRepoPaths = findGitRepos();
+    const localRepos = [];
+    // Aggregated line stats across all local repos (since 2024).
+    let linesAdded = 0;
+    let linesDeleted = 0;
+    const commitSizes = [];
+    for (const gitDir of gitRepoPaths.slice(0, 30)) {
+        const repoPath = gitDir.replace(/\/\.git$/, "");
+        if (!safeEmail)
+            continue;
+        const count = parseInt(execSafe(`git -C "${repoPath}" log --author="${safeEmail}" --oneline | wc -l`), 10);
+        const lastCommit = execSafe(`git -C "${repoPath}" log --author="${safeEmail}" -1 --format="%ai %s"`);
+        if (count > 0) {
+            localRepos.push({
+                path: repoPath.replace(homedir(), "~"),
+                name: repoPath.split("/").filter(Boolean).pop() ?? repoPath,
+                commit_count: count || 0,
+                last_commit: lastCommit,
+                readme_excerpt: readRepoReadme(repoPath),
+            });
+            // Per-commit added/deleted lines (since 2024). The %H line marks a commit;
+            // numstat lines are "added\tdeleted\tfile" ("-" for binary).
+            const numstat = execSafe(`git -C "${repoPath}" log --author="${safeEmail}" --since="2024-01-01" --pretty=tformat:"%H" --numstat`);
+            let cur = 0;
+            let inCommit = false;
+            for (const line of numstat.split("\n")) {
+                if (/^[0-9a-f]{40}$/.test(line)) {
+                    if (inCommit)
+                        commitSizes.push(cur);
+                    cur = 0;
+                    inCommit = true;
+                    continue;
+                }
+                const t = line.split("\t");
+                if (t.length >= 2) {
+                    const a = t[0] === "-" ? 0 : parseInt(t[0], 10) || 0;
+                    const d = t[1] === "-" ? 0 : parseInt(t[1], 10) || 0;
+                    linesAdded += a;
+                    linesDeleted += d;
+                    cur += a + d;
+                }
+            }
+            if (inCommit)
+                commitSizes.push(cur);
+        }
+    }
+    commitSizes.sort((a, b) => a - b);
+    const medianCommitSize = commitSizes.length
+        ? commitSizes[Math.floor(commitSizes.length / 2)]
+        : 0;
+    const biggestCommitSize = commitSizes.length
+        ? commitSizes[commitSizes.length - 1]
+        : 0;
+    // Commit patterns from largest local repo
+    const commitPatterns = [];
+    const collaborators = [];
+    if (localRepos.length > 0 && safeEmail) {
+        const sorted = [...localRepos].sort((a, b) => b.commit_count - a.commit_count);
+        const repoPath = sorted[0].path.replace("~", homedir());
+        const patterns = execSafe(`git -C "${repoPath}" log --author="${safeEmail}" --format="%ai" --since="2024-01-01"`);
+        if (patterns) {
+            commitPatterns.push(...patterns.split("\n").filter(Boolean).slice(0, 200));
+        }
+        const collabs = execSafe(`git -C "${repoPath}" log --format="%aN <%aE>" --since="2024-01-01" | sort | uniq -c | sort -rn | head -10`);
+        if (collabs) {
+            collaborators.push(...collabs.split("\n").filter(Boolean));
+        }
+    }
+    // Phase 5: AI coding tool analysis
+    gatherLog(options, "Analyzing AI coding tools...\n");
+    let totalCommits = 0;
+    let aiAssistedCommits = 0;
+    // Sum commits since 2024 across ALL local repos (matching the git email), not
+    // just the current directory — one repo badly under-counts a multi-repo dev.
+    if (safeEmail) {
+        for (const gitDir of gitRepoPaths.slice(0, 30)) {
+            const repoPath = gitDir.replace(/\/\.git$/, "");
+            const total = parseInt(execSafe(`git -C "${repoPath}" log --author="${safeEmail}" --format="%H" --since="2024-01-01" | wc -l`), 10) || 0;
+            if (total === 0)
+                continue;
+            totalCommits += total;
+            // Co-Authored-By at the commit level (not trailer lines: %b is multi-line
+            // and squash-merges stack several trailers per commit).
+            aiAssistedCommits +=
+                parseInt(execSafe(`git -C "${repoPath}" log --author="${safeEmail}" --since="2024-01-01" --grep="Co-Authored-By" --format="%H" | wc -l`), 10) || 0;
+        }
+    }
+    // Recent commit subjects (last 90 days) — feed the "what you shipped" summary.
+    let commitSubjects = [];
+    if (safeEmail) {
+        const subjectsRaw = execSafe(`git log --author="${safeEmail}" --since="90 days ago" --no-merges --format="%s"`);
+        commitSubjects = subjectsRaw
+            ? subjectsRaw
+                .split("\n")
+                .map((s) => s.trim())
+                .filter(Boolean)
+                .slice(0, 200)
+                .map((s) => redactSecrets(s).slice(0, 160))
+            : [];
+    }
+    const claudeMd = existsSync("CLAUDE.md")
+        ? readFileSync("CLAUDE.md", "utf-8").slice(0, 3000)
+        : null;
+    const claudeDirsRaw = execSafe(`find ${homedir()} -maxdepth 3 -path "*/.claude" -type d | head -5`);
+    const claudeDirs = claudeDirsRaw
+        ? claudeDirsRaw
+            .split("\n")
+            .filter(Boolean)
+            .map((d) => d.replace(homedir(), "~"))
+        : [];
+    const otherAiTools = [];
+    const aiToolPaths = [".cursor", ".continue", ".github/copilot", ".codeium"];
+    for (const tool of aiToolPaths) {
+        if (existsSync(join(homedir(), tool))) {
+            otherAiTools.push(tool);
+        }
+    }
+    let cursorrules = null;
+    if (existsSync(".cursorrules")) {
+        cursorrules = readFileSync(".cursorrules", "utf-8").slice(0, 2000);
+    }
+    // Phase 6: Await AI usage + dev environment + GitHub enrichment
+    const [aiUsage, devEnvironment, githubEnrichment] = await Promise.all([
+        aiUsagePromise,
+        devEnvPromise,
+        githubEnrichPromise,
+    ]);
+    gatherLog(options, "Done gathering.\n");
+    return {
+        readiness: {
+            usage_stats_status: hasAnyUsage(aiUsage) ? "ready" : "unavailable",
+            profile_basics_status: "ready",
+            enrichment_status: "ready",
+        },
+        identity: {
+            name: name || null,
+            email: email || null,
+            github_username: githubUsername,
+            twitter_username: twitterHandle,
+            remotes,
+        },
+        github: {
+            profile: ghProfile
+                ? trimProfile(ghProfile)
+                : null,
+            repos: repos.slice(0, 50).map(trimRepo),
+            starred: (Array.isArray(ghStarred) ? ghStarred : []).map(trimStarred),
+            following: (Array.isArray(ghFollowing) ? ghFollowing : []).map(trimFollowing),
+            events: (Array.isArray(ghEvents) ? ghEvents : []).map(trimEvent),
+            prs_authored: (ghPrs?.items || []).map(trimPr),
+            contribution_graph: ghContrib || null,
+            repo_contents: repoContents,
+            readmes,
+            commit_messages: commitMessages,
+            npm_packages: (ghNpm?.objects || []).map(trimNpmPackage),
+            enrichment: githubEnrichment,
+        },
+        linkedin: {
+            url: linkedinUrl,
+            url_resolution_source: linkedinResolutionSource,
+            profile: linkedinProfile,
+            company_enrichments: companyEnrichments,
+        },
+        twitter: {
+            handle: twitterHandle,
+            url: twitterUrl,
+            profile: twitterProfile,
+        },
+        local: {
+            repos: localRepos,
+            commit_patterns: commitPatterns,
+            collaborators,
+        },
+        ai_coding: {
+            total_commits_since_2024: totalCommits,
+            ai_assisted_commits: aiAssistedCommits,
+            lines_added_since_2024: linesAdded,
+            lines_deleted_since_2024: linesDeleted,
+            median_commit_size: medianCommitSize,
+            biggest_commit_size: biggestCommitSize,
+            commit_subjects: commitSubjects,
+            claude_md_contents: claudeMd,
+            claude_dirs: claudeDirs,
+            other_ai_tools: otherAiTools,
+            cursorrules,
+        },
+        ai_usage: aiUsage,
+        dev_environment: devEnvironment,
+    };
+}