standout 0.5.31 → 0.5.33

package/dist/cli.js

@@ -1,14 +1,19 @@
 #!/usr/bin/env node
 import Anthropic from "@anthropic-ai/sdk";
 import chalk from "chalk";
+import { writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 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 +28,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",
+        lines: [
+            "Your stats stay on your computer — no account, no leaderboard, nothing saved.",
+            "Renders your wrapped right in the terminal (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 +238,131 @@ 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);
+}
+function profileName(prefetched) {
+    return prefetched.identity?.name || prefetched.identity?.email || "you";
+}
+// Render the shareable card PNG via the stateless endpoint. This is a
+// server-to-server call (CLI -> Standout), so there's no browser, no CORS, and
+// no cross-origin/private-network blocking. The endpoint stores nothing.
+async function fetchCardPng(prefetched) {
+    try {
+        const { payload } = capPayload(prefetched);
+        const res = await fetch(`${STANDOUT_API_URL}/api/public/wrapped/local/share-card`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "User-Agent": "Standout/0.4.0 (node)",
+            },
+            body: JSON.stringify({
+                profile: payload,
+                name: profileName(prefetched),
+            }),
+        });
+        if (!res.ok)
+            return null;
+        return Buffer.from(await res.arrayBuffer());
+    }
+    catch {
+        return null;
+    }
+}
+// Print a PNG inline using the terminal's image protocol. Returns false if the
+// terminal doesn't support inline images (caller then falls back to the saved
+// file path). Covers iTerm2-protocol terminals (iTerm2, WezTerm, VS Code, Hyper,
+// Tabby) and Kitty-protocol terminals (Kitty, Ghostty).
+function showImageInline(png) {
+    if (!process.stdout.isTTY)
+        return false;
+    const tp = process.env.TERM_PROGRAM || "";
+    const term = process.env.TERM || "";
+    const b64 = png.toString("base64");
+    const itermLike = tp === "iTerm.app" ||
+        tp === "WezTerm" ||
+        tp === "vscode" ||
+        tp === "Hyper" ||
+        tp === "Tabby" ||
+        process.env.LC_TERMINAL === "iTerm2";
+    if (itermLike) {
+        process.stdout.write(`\x1b]1337;File=inline=1;size=${png.length};width=44;preserveAspectRatio=1:${b64}\x07\n`);
+        return true;
+    }
+    const kittyLike = !!process.env.KITTY_WINDOW_ID || term.includes("kitty") || tp === "ghostty";
+    if (kittyLike) {
+        const CHUNK = 4096;
+        for (let i = 0; i < b64.length; i += CHUNK) {
+            const part = b64.slice(i, i + CHUNK);
+            const more = i + CHUNK < b64.length ? 1 : 0;
+            const ctrl = i === 0 ? `a=T,f=100,m=${more}` : `m=${more}`;
+            process.stdout.write(`\x1b_G${ctrl};${part}\x1b\\`);
+        }
+        process.stdout.write("\n");
+        return true;
+    }
+    return false;
+}
+// Local path: gather on-device, page the deck, then render the real shareable
+// card image right in the terminal. The card is rendered on the fly by a
+// stateless endpoint (nothing is saved on our servers) and saved to a temp file
+// so it can be attached when sharing. `--terminal` stays fully offline (deck
+// only, no network, no image).
+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;
+    }
+    const stop2 = startLoadingLine("Rendering your shareable card");
+    let png;
+    try {
+        png = await fetchCardPng(prefetched);
+    }
+    finally {
+        stop2();
+    }
+    if (!png) {
+        process.stderr.write("\n  (Couldn't render the shareable card image right now — your stats are above.)\n\n");
+        return;
+    }
+    const file = join(tmpdir(), `standout-wrapped-${Date.now()}.png`);
+    writeFileSync(file, png);
+    process.stderr.write("\n");
+    const shown = showImageInline(png);
+    if (!shown) {
+        process.stderr.write("  (Your terminal can't show inline images — open the saved card below.)\n");
+    }
+    const post = encodeURIComponent("Check out my AI Wrapped 🤖 — get yours: npx standout");
+    process.stderr.write(`\n  Saved card: ${file}\n\n` +
+        `  Share it:\n` +
+        `    X:        https://x.com/intent/post?text=${post}\n` +
+        `    LinkedIn: https://www.linkedin.com/feed/?shareActive=true&text=${post}\n\n` +
+        `  (Card rendered on the fly — nothing was saved on our servers.)\n\n`);
+}
 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 +370,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 +574,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.33",
   "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",