standout 0.5.31 → 0.5.32

package/dist/cli.js

@@ -1,14 +1,17 @@
 #!/usr/bin/env node
 import Anthropic from "@anthropic-ai/sdk";
 import chalk from "chalk";
+import http from "node:http";
 import { createInterface } from "readline";
 import { markWrappedShared, STANDOUT_API_URL } from "./api.js";
+import { capPayload } from "./payload.js";
 import { gatherFullEnrichment, gatherProfileBasics, gatherUsageStats, } from "./gather.js";
 import { ensureHeapHeadroom } from "./heap.js";
 import { startMcpServer } from "./mcp.js";
 import { configureProxyFromEnv } from "./proxy.js";
 import { SYSTEM_PROMPT } from "./prompt.js";
 import { TOOLS, executeTool } from "./tools.js";
+import { aggregateView } from "./wrapped/aggregate.js";
 import { renderWrappedAll } from "./wrapped/render.js";
 import { createWrapped } from "./wrapped-client.js";
 import { openWrapped } from "./wrapped-share.js";
@@ -23,6 +26,114 @@ function profileChatEnabled() {
         return true;
     return process.argv.slice(2).includes("--chat");
 }
+// Local-only mode: compute and render the wrapped entirely on this machine. No
+// profile is uploaded, no wrapped row is created, no leaderboard entry is made,
+// and gathering skips every network call. Enable with --local / --no-upload or
+// STANDOUT_LOCAL=1.
+function localOnlyEnabled() {
+    const env = process.env.STANDOUT_LOCAL;
+    if (env === "1" || env === "true")
+        return true;
+    const args = process.argv.slice(2);
+    return args.includes("--local") || args.includes("--no-upload");
+}
+function printBanner() {
+    console.log("\n  ┌────────────────────────────────┐");
+    console.log("  │  are you really tokenmaxxing?  │");
+    console.log("  │  Powered by Standout (YC P26)  │");
+    console.log("  └────────────────────────────────┘\n");
+}
+// First step of the default flow: an arrow-key menu to pick full (cloud) vs
+// local-only. Non-interactive shells (CI, agents) can't answer, so they keep the
+// full flow — pass --local / STANDOUT_LOCAL=1 to force local without a prompt.
+const MODE_OPTIONS = [
+    {
+        key: "full",
+        title: "Full",
+        tag: " (recommended)",
+        lines: [
+            "Your full AI wrapped: LLM-written cards, your score, and a leaderboard rank.",
+            "Reads your local stats plus your public GitHub / LinkedIn / X.",
+        ],
+    },
+    {
+        key: "local",
+        title: "Local only",
+        tag: " — private & offline",
+        lines: [
+            "Stays entirely on your computer. Nothing uploaded, nothing saved.",
+            "Just your local AI-tool stats — no LLM cards, score, or ranking.",
+        ],
+    },
+];
+function renderModeMenu(selected) {
+    const out = [
+        "",
+        chalk.white("  How do you want to run Standout?"),
+        "",
+    ];
+    MODE_OPTIONS.forEach((opt, i) => {
+        const active = i === selected;
+        const pointer = active ? chalk.hex("#ad5cff")("❯ ") : "  ";
+        const title = active
+            ? chalk.bold.white(opt.title) + chalk.dim(opt.tag)
+            : chalk.dim(opt.title + opt.tag);
+        out.push(`${pointer}${title}`);
+        for (const line of opt.lines)
+            out.push(chalk.dim(`    ${line}`));
+        out.push("");
+    });
+    out.push(chalk.dim("  ↑/↓ to move · enter to select"));
+    return out.join("\n");
+}
+async function chooseMode() {
+    if (!process.stdin.isTTY)
+        return "full";
+    let selected = 0;
+    const draw = () => {
+        const text = renderModeMenu(selected);
+        process.stderr.write(text + "\n");
+        return text.split("\n").length;
+    };
+    return new Promise((resolve) => {
+        const stdin = process.stdin;
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.setEncoding("utf8");
+        let lines = draw();
+        const redraw = () => {
+            // Jump back to the menu's first line and clear it before redrawing.
+            process.stderr.write(`\x1b[${lines}A\x1b[0J`);
+            lines = draw();
+        };
+        const cleanup = () => {
+            stdin.setRawMode(false);
+            stdin.pause();
+            stdin.removeListener("data", onData);
+        };
+        const onData = (data) => {
+            if (data === "\x03") {
+                cleanup();
+                process.stderr.write("\n  Cancelled.\n");
+                process.exit(0);
+            }
+            else if (data === "\r" || data === "\n") {
+                cleanup();
+                process.stderr.write("\n");
+                resolve(MODE_OPTIONS[selected].key);
+            }
+            else if (data === "\x1b[A" || data === "k") {
+                selected = (selected + MODE_OPTIONS.length - 1) % MODE_OPTIONS.length;
+                redraw();
+            }
+            else if (data === "\x1b[B" || data === "j") {
+                selected = (selected + 1) % MODE_OPTIONS.length;
+                redraw();
+            }
+        };
+        stdin.on("data", onData);
+    });
+}
 async function confirmPrivacy() {
     process.stderr.write("\nDiscover your Claude Code, Codex, and Cursor stats, then see how you rank.\n" +
         "You'll see your cards first, then review before submitting.\n\n" +
@@ -125,6 +236,94 @@ async function maybeShareWrapped(wrapped) {
         process.stderr.write(`  (${err instanceof Error ? err.message : err})\n\n`);
     }
 }
+// Fully offline path: gather only local signals and render the wrapped deck in
+// the terminal without ever contacting Standout. Reads only local fields, so the
+// deck looks the same minus the server-computed bits — the LLM-written
+// archetype/zinger (sensible defaults are used) and the leaderboard
+// rank/percentiles (omitted, since those need the server cohort).
+async function renderLocalTerminal(prefetched) {
+    const view = aggregateView({
+        profile: prefetched,
+        computed: {},
+        share_url: "",
+    });
+    await renderWrappedAll(view);
+}
+// Local path: gather on-device, then open the real wrapped UI on localhost. The
+// gathered profile is held only in this process and served from an ephemeral
+// in-memory HTTP server — nothing is written to disk, no DB row, no leaderboard
+// entry. The page renders the card image via a stateless endpoint (also not
+// stored) and shows the share options. `--terminal` forces the fully-offline
+// ASCII deck instead.
+async function runLocal() {
+    const terminalOnly = process.argv.slice(2).includes("--terminal");
+    const stop = startLoadingLine("Putting together your AI highlights");
+    let prefetched;
+    try {
+        prefetched = await gatherFullEnrichment({
+            localOnly: true,
+            verbose: false,
+        });
+    }
+    finally {
+        stop();
+    }
+    // Always page the deck in the terminal first.
+    await renderLocalTerminal(prefetched);
+    if (terminalOnly) {
+        process.stderr.write("\n  Local run complete. To publish your wrapped and see how you rank: npx standout\n\n");
+        return;
+    }
+    // Then open the full wrapped (card image + share options) on localhost.
+    // Trim the bulkiest raw fields so the in-memory body stays well under the
+    // render endpoint's request cap, same as the upload path.
+    const { payload } = capPayload(prefetched);
+    const body = JSON.stringify(payload);
+    const server = http.createServer((req, res) => {
+        // The wrapped page (https) reads this over http://localhost, which browsers
+        // treat as a trustworthy origin. Allow any origin for the simple GET.
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        if (req.url && req.url.startsWith("/profile.json")) {
+            res.setHeader("Content-Type", "application/json");
+            res.end(body);
+            return;
+        }
+        res.statusCode = 404;
+        res.end("not found");
+    });
+    await new Promise((resolve, reject) => {
+        server.on("error", reject);
+        server.listen(0, "127.0.0.1", resolve);
+    });
+    const address = server.address();
+    const port = address && typeof address === "object" ? address.port : null;
+    if (!port) {
+        server.close();
+        process.stderr.write("\n  Couldn't start the local server, so the browser view is unavailable.\n" +
+            "  Your wrapped is shown above. Re-run to try the browser view: npx standout --local\n\n");
+        return;
+    }
+    const url = `${STANDOUT_API_URL}/wrapped/live?port=${port}`;
+    process.stderr.write(`\n  Your wrapped is ready — nothing was uploaded or saved.\n` +
+        `  ${url}\n\n` +
+        `  Opening your browser. Keep this terminal open while you view or share.\n` +
+        `  Press Ctrl+C when you're done.\n\n`);
+    try {
+        await openWrapped(url);
+    }
+    catch {
+        process.stderr.write(`  Couldn't open the browser automatically. Open this link manually:\n  ${url}\n\n`);
+    }
+    // Hold the process open (the in-memory server keeps the data available) until
+    // the user exits; then drop everything.
+    await new Promise((resolve) => {
+        process.on("SIGINT", () => {
+            server.close();
+            process.stderr.write("\n  Closed. Nothing was saved.\n");
+            resolve();
+        });
+    });
+}
 async function runAgent(jobId) {
     // The wrapped render + share now run non-interactively (no TTY required), so
     // the command completes when invoked from a Claude Code Bash call. Only the
@@ -132,10 +331,6 @@ async function runAgent(jobId) {
     if (profileChatEnabled()) {
         ensureInteractive("The interactive profile chat");
     }
-    console.log("\n  ┌────────────────────────────────┐");
-    console.log("  │  are you really tokenmaxxing?  │");
-    console.log("  │  Powered by Standout (YC P26)  │");
-    console.log("  └────────────────────────────────┘\n");
     // Only frame the token as a job in the application flow. Otherwise it may be a
     // leaderboard group (`npx standout stanford`), confirmed after the wrapped runs.
     if (jobId && profileChatEnabled()) {
@@ -340,19 +535,37 @@ async function main() {
     const proxy = configureProxyFromEnv();
     if (proxy)
         process.stderr.write(`  (using proxy ${proxy})\n`);
+    const localOnly = localOnlyEnabled();
     if (args.includes("--gather")) {
-        await confirmPrivacy();
-        const data = await gatherFullEnrichment();
+        // Local-only gather skips the upload-consent gate (nothing leaves the box).
+        if (!localOnly)
+            await confirmPrivacy();
+        const data = await gatherFullEnrichment({ localOnly });
         process.stdout.write(JSON.stringify(data, null, 2));
+        return;
     }
-    else if (args.includes("--mcp")) {
+    if (args.includes("--mcp")) {
         await startMcpServer();
+        return;
+    }
+    const jobId = args.find((a) => !a.startsWith("-"));
+    printBanner();
+    // Pick the mode. An explicit --local/--no-upload/STANDOUT_LOCAL forces local;
+    // a group/job arg (`npx standout stanford`) is an explicit full-flow intent; a
+    // bare `npx standout` asks the user as the first step.
+    let mode;
+    if (localOnly)
+        mode = "local";
+    else if (jobId)
+        mode = "full";
+    else
+        mode = await chooseMode();
+    if (mode === "local") {
+        await runLocal();
     }
     else {
-        const jobId = args.find((a) => !a.startsWith("-"));
-        if (jobId) {
+        if (jobId)
             process.env.STANDOUT_JOB_ID = jobId;
-        }
         await runAgent(jobId);
     }
 }

package/dist/gather.d.ts

@@ -72,6 +72,7 @@ export interface FullEnrichmentOptions {
     aiUsage?: AiUsage;
     profileBasics?: ProfileBasics;
     verbose?: boolean;
+    localOnly?: boolean;
 }
 export declare function emptyGatheredProfile(readiness?: GatherReadiness): GatheredProfile;
 export declare function gatherUsageStats(): Promise<Pick<GatheredProfile, "ai_usage" | "readiness">>;

package/dist/gather.js

@@ -445,6 +445,7 @@ function trimNpmPackage(p) {
     };
 }
 export async function gather(options = {}) {
+    const localOnly = options.localOnly === true;
     const profileBasics = options.profileBasics?.readiness.profile_basics_status === "ready"
         ? options.profileBasics
         : undefined;
@@ -468,24 +469,32 @@ export async function gather(options = {}) {
                 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;
+        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) {
+    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) {
+    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)
@@ -497,7 +506,7 @@ export async function gather(options = {}) {
     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
+    const [ghProfile, ghRepos, ghStarred, ghFollowing, ghEvents, ghPrs, ghContrib, ghNpm,] = safeUsername && !localOnly
         ? await Promise.all([
             canUseCachedGithubBasics
                 ? Promise.resolve(profileBasics?.github.profile ?? null)
@@ -520,7 +529,7 @@ export async function gather(options = {}) {
     const repoContents = {};
     const readmes = {};
     const commitMessages = {};
-    if (safeUsername) {
+    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`));
@@ -555,7 +564,7 @@ export async function gather(options = {}) {
     }
     // 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
+    const githubEnrichPromise = safeUsername && !localOnly
         ? enrichApi("github", safeUsername).catch(() => null)
         : Promise.resolve(null);
     const aiUsagePromise = options.aiUsage
@@ -583,7 +592,7 @@ export async function gather(options = {}) {
     let linkedinResolutionSource = null;
     let linkedinProfile = null;
     const companyEnrichments = {};
-    if (safeEmail) {
+    if (safeEmail && !localOnly) {
         const emailResult = await enrichApi("email_to_linkedin", email);
         if (emailResult && typeof emailResult === "object") {
             linkedinUrl =
@@ -594,7 +603,7 @@ export async function gather(options = {}) {
         }
     }
     // Fallback: name + signals via AI web search when email lookup comes up empty
-    if (!linkedinUrl && ghProfile && name) {
+    if (!linkedinUrl && ghProfile && name && !localOnly) {
         gatherLog(options, "Resolving LinkedIn via name + signals...\n");
         const profile = ghProfile;
         const signals = [];
@@ -631,8 +640,10 @@ export async function gather(options = {}) {
     }
     // 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.
-    if (!linkedinUrl) {
+    // 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();
@@ -678,7 +689,7 @@ export async function gather(options = {}) {
         }
     }
     // Fallback: scrape the user's logged-in Chrome session for an X handle.
-    if (!twitterHandle) {
+    if (!twitterHandle && !localOnly) {
         gatherLog(options, "Checking for an X/Twitter session in Chrome...\n");
         try {
             const scraped = await scrapeTwitterHandle();
@@ -691,7 +702,7 @@ export async function gather(options = {}) {
     }
     const safeTwitter = twitterHandle ? sanitize(twitterHandle) : null;
     let twitterProfile = null;
-    if (safeTwitter) {
+    if (safeTwitter && !localOnly) {
         twitterProfile = await enrichApi("twitter", safeTwitter);
     }
     const twitterUrl = safeTwitter ? `https://x.com/${safeTwitter}` : null;
@@ -850,7 +861,8 @@ export async function gather(options = {}) {
         readiness: {
             usage_stats_status: hasAnyUsage(aiUsage) ? "ready" : "unavailable",
             profile_basics_status: "ready",
-            enrichment_status: "ready",
+            // Local-only mode performs no network enrichment.
+            enrichment_status: localOnly ? "unavailable" : "ready",
         },
         identity: {
             name: resolvedName,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "standout",
-  "version": "0.5.31",
+  "version": "0.5.32",
   "description": "Build your developer profile with AI. One command, zero friction.",
   "type": "module",
   "main": "./dist/cli.js",
@@ -18,7 +18,7 @@
   },
   "scripts": {
     "build": "tsc",
-    "dev": "tsx src/cli.ts",
+    "dev": "tsc && node dist/cli.js",
     "test": "tsx --test tests/*.test.ts",
     "preview:tiers": "tsx src/wrapped/preview.ts",
     "typecheck": "tsc --noEmit",