standout 0.5.33 → 0.5.35

package/dist/gather.js

@@ -1,922 +0,0 @@
-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 { scrapeLinkedinUrl } from "./linkedin-scrape.js";
-import { resolveDisplayName } from "./identity.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, "");
-}
-// Co-author signatures left by AI coding tools (Claude, Copilot, Cursor, etc.).
-const AI_COAUTHOR_RE = /claude|anthropic|copilot|cursor|devin-ai|aider|codeium|windsurf|sourcegraph|tabnine|google-labs-jules/i;
-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 localOnly = options.localOnly === true;
-    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]);
-            }
-        }
-        if (localOnly) {
-            // No network to verify User vs Org — take the first remote candidate as a
-            // best-effort handle. Only used to label identity; the deck falls back to
-            // the git name regardless.
-            githubUsername = remoteCandidates[0] ?? null;
-        }
-        else {
-            // 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 && !localOnly) {
-        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 && !localOnly) {
-        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 && !localOnly
-        ? 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 && !localOnly) {
-        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 && !localOnly
-        ? 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 && !localOnly) {
-        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 && !localOnly) {
-        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";
-        }
-    }
-    // Fallback: read a logged-in LinkedIn session from the local Chrome profile
-    // (headless, silent). Same technique as the X handle scrape — the only anchor
-    // for users with no git email/name and no GitHub remote. Reads the local
-    // browser but resolves a URL the enrich proxy would then look up, so it's
-    // skipped in local-only mode too.
-    if (!linkedinUrl && !localOnly) {
-        gatherLog(options, "Checking for a LinkedIn session in Chrome...\n");
-        try {
-            const scraped = await scrapeLinkedinUrl();
-            if (scraped) {
-                linkedinUrl = scraped;
-                linkedinResolutionSource = "chrome_session";
-            }
-        }
-        catch {
-            // silent
-        }
-    }
-    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 && !localOnly) {
-        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 && !localOnly) {
-        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;
-    // Count commits since 2024 across ALL local repos (matching the git email),
-    // deduped by SHA so worktrees/clones of the same repo count once. A commit is
-    // AI-assisted when it carries a co-author trailer from a known AI coding tool —
-    // matched case-insensitively via git's trailer parser, not a literal grep.
-    if (safeEmail) {
-        const fieldSep = String.fromCharCode(0x1f);
-        const recordSep = String.fromCharCode(0x1e);
-        const allCommitShas = new Set();
-        const aiCommitShas = new Set();
-        for (const gitDir of gitRepoPaths.slice(0, 30)) {
-            const repoPath = gitDir.replace(/\/\.git$/, "");
-            const log = execSafe(`git -C "${repoPath}" log --author="${safeEmail}" --since="2024-01-01" --format="%H%x1f%(trailers:key=Co-authored-by,valueonly)%x1e"`);
-            for (const entry of log.split(recordSep)) {
-                const trimmed = entry.trim();
-                if (!trimmed)
-                    continue;
-                const sepIdx = trimmed.indexOf(fieldSep);
-                const sha = sepIdx === -1 ? trimmed : trimmed.slice(0, sepIdx);
-                const coauthors = sepIdx === -1 ? "" : trimmed.slice(sepIdx + 1);
-                if (!sha)
-                    continue;
-                allCommitShas.add(sha);
-                if (coauthors && AI_COAUTHOR_RE.test(coauthors))
-                    aiCommitShas.add(sha);
-            }
-        }
-        totalCommits = allCommitShas.size;
-        aiAssistedCommits = aiCommitShas.size;
-    }
-    // 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");
-    const resolvedName = resolveDisplayName({
-        gitName: name,
-        githubName: ghProfile?.name,
-        linkedinProfile: linkedinProfile,
-        githubUsername,
-        twitterHandle,
-    });
-    return {
-        readiness: {
-            usage_stats_status: hasAnyUsage(aiUsage) ? "ready" : "unavailable",
-            profile_basics_status: "ready",
-            // Local-only mode performs no network enrichment.
-            enrichment_status: localOnly ? "unavailable" : "ready",
-        },
-        identity: {
-            name: resolvedName,
-            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,
-    };
-}