standout 0.1.0 → 0.5.15

package/dist/api.d.ts

@@ -0,0 +1,10 @@
+export declare const STANDOUT_API_URL: string;
+export declare function enrichProfile(type: string, value: string): Promise<string>;
+export interface SubmitProfileOptions {
+    prefetchedProfile?: Record<string, unknown>;
+    wrappedId?: string | null;
+}
+export declare function mergeSubmissionProfile(profileData: Record<string, unknown>, prefetchedProfile?: Record<string, unknown>): Record<string, unknown>;
+export declare function linkWrappedToSubmission(wrappedId: string, submissionId: string): Promise<void>;
+export declare function markWrappedShared(wrappedId: string): Promise<void>;
+export declare function submitProfile(profile: string, options?: SubmitProfileOptions): Promise<string>;

package/dist/api.js

@@ -0,0 +1,86 @@
+export const STANDOUT_API_URL = process.env.STANDOUT_API_URL || "https://standout.work";
+export async function enrichProfile(type, value) {
+    try {
+        const res = await fetch(`${STANDOUT_API_URL}/api/public/agent-enrich`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ type, value }),
+        });
+        if (!res.ok) {
+            const error = await res.text();
+            return `Enrichment failed (${res.status}): ${error}`;
+        }
+        return JSON.stringify(await res.json(), null, 2);
+    }
+    catch (error) {
+        return `Enrichment error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+export function mergeSubmissionProfile(profileData, prefetchedProfile) {
+    if (!prefetchedProfile)
+        return profileData;
+    return {
+        ...profileData,
+        // The LLM compiles a recruiter-facing profile and can accidentally omit
+        // raw gathered datasets. Preserve the authoritative local scan payloads.
+        ai_usage: profileData.ai_usage ?? prefetchedProfile.ai_usage,
+        readiness: profileData.readiness ?? prefetchedProfile.readiness,
+        local: profileData.local ?? prefetchedProfile.local,
+        twitter: profileData.twitter ?? prefetchedProfile.twitter,
+        linkedin: profileData.linkedin ?? prefetchedProfile.linkedin,
+        ai_coding: {
+            ...(prefetchedProfile.ai_coding ?? {}),
+            ...(profileData.ai_coding ?? {}),
+        },
+        dev_environment: profileData.dev_environment ?? prefetchedProfile.dev_environment,
+    };
+}
+export async function linkWrappedToSubmission(wrappedId, submissionId) {
+    try {
+        await fetch(`${STANDOUT_API_URL}/api/public/wrapped/${wrappedId}`, {
+            method: "PATCH",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ submission_id: submissionId }),
+        });
+    }
+    catch {
+        // Non-critical: the profile submission already succeeded.
+    }
+}
+export async function markWrappedShared(wrappedId) {
+    try {
+        await fetch(`${STANDOUT_API_URL}/api/public/wrapped/${wrappedId}`, {
+            method: "PATCH",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ shared: true }),
+        });
+    }
+    catch {
+        // Non-critical analytics signal.
+    }
+}
+export async function submitProfile(profile, options = {}) {
+    try {
+        const profileData = JSON.parse(profile);
+        const jobId = process.env.STANDOUT_JOB_ID;
+        const mergedProfile = mergeSubmissionProfile(profileData, options.prefetchedProfile);
+        const payload = jobId ? { ...mergedProfile, jobId } : mergedProfile;
+        const res = await fetch(`${STANDOUT_API_URL}/api/public/agent-submit`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(payload),
+        });
+        if (!res.ok) {
+            const error = await res.text();
+            return `Submission failed (${res.status}): ${error}`;
+        }
+        const result = (await res.json());
+        if (options.wrappedId && result.id) {
+            await linkWrappedToSubmission(options.wrappedId, result.id);
+        }
+        return `Profile submitted successfully! ID: ${result.id}`;
+    }
+    catch (error) {
+        return `Submission error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,351 @@
+#!/usr/bin/env node
+import Anthropic from "@anthropic-ai/sdk";
+import chalk from "chalk";
+import { createInterface } from "readline";
+import { markWrappedShared, STANDOUT_API_URL } from "./api.js";
+import { gatherFullEnrichment, gatherProfileBasics, gatherUsageStats, } from "./gather.js";
+import { startMcpServer } from "./mcp.js";
+import { SYSTEM_PROMPT } from "./prompt.js";
+import { TOOLS, executeTool } from "./tools.js";
+import { renderWrappedAll } from "./wrapped/render.js";
+import { createWrapped } from "./wrapped-client.js";
+import { openShareToX } from "./wrapped-share.js";
+const MAX_TURNS = 40;
+// The post-wrapped agent chat (interactive profile-building Q&A) is OFF by
+// default so the command runs to completion non-interactively (e.g. invoked
+// from a Claude Code Bash call with no TTY). Re-enable by setting
+// STANDOUT_PROFILE_CHAT=1 or passing --chat.
+function profileChatEnabled() {
+    const env = process.env.STANDOUT_PROFILE_CHAT;
+    if (env === "1" || env === "true")
+        return true;
+    return process.argv.slice(2).includes("--chat");
+}
+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" +
+        "By continuing, you agree to Standout's Terms and Privacy Policy:\n" +
+        "https://standout.work/terms\n" +
+        "https://standout.work/privacy-policy\n\n");
+    if (process.stdin.isTTY) {
+        const answer = await new Promise((resolve) => {
+            const iface = createInterface({
+                input: process.stdin,
+                output: process.stderr,
+            });
+            iface.question("Continue? [Y/n] ", (ans) => {
+                iface.close();
+                resolve(ans.trim().toLowerCase());
+            });
+        });
+        if (answer === "n" || answer === "no") {
+            process.stderr.write("Cancelled.\n");
+            process.exit(0);
+        }
+    }
+    else {
+        process.stderr.write("(non-interactive, proceeding)\n");
+    }
+}
+function ensureInteractive(reason) {
+    if (process.stdin.isTTY)
+        return;
+    console.error("\n  Standout needs an interactive terminal.");
+    console.error(`  ${reason} requires keyboard input that this environment can't deliver.`);
+    console.error("");
+    console.error("  Common fixes:");
+    console.error("    • Run from a regular terminal window, not from inside another agent or CI.");
+    console.error("    • Don't pipe stdin (e.g. `echo y |`) or run in a containerized shell.");
+    console.error("    • If you're inside Claude Code or another wrapping tool, exit it and");
+    console.error("      run standout directly in your shell.");
+    console.error("");
+    console.error("    npx standout@latest");
+    console.error("");
+    process.exit(1);
+}
+function startLoadingLine(label) {
+    if (!process.stderr.isTTY) {
+        process.stderr.write(`  ${label}...\n`);
+        return () => { };
+    }
+    // No blank frame: dots must be visible on the very first render, otherwise the
+    // line shows for ~140ms with nothing and looks like it's slow to start.
+    const frames = [".  ", ".. ", "...", " ..", "  ."];
+    let frame = 0;
+    const render = () => {
+        const dots = frames[frame % frames.length];
+        const accent = chalk.hex("#ad5cff")(dots);
+        const text = chalk.white(label);
+        process.stderr.write(`\r\x1b[2K  ${accent} ${text}`);
+        frame += 1;
+    };
+    render();
+    const timer = setInterval(render, 120);
+    return () => {
+        clearInterval(timer);
+        process.stderr.write("\r\x1b[2K");
+    };
+}
+async function askLine(prompt) {
+    if (!process.stdin.isTTY)
+        return "y";
+    return new Promise((resolve) => {
+        const iface = createInterface({
+            input: process.stdin,
+            output: process.stderr,
+        });
+        iface.question(prompt, (ans) => {
+            iface.close();
+            resolve(ans.trim());
+        });
+    });
+}
+async function maybeShareWrapped(wrapped) {
+    if (!process.stdin.isTTY) {
+        process.stderr.write(`  your wrapped: ${wrapped.share_url}\n\n`);
+        return;
+    }
+    const ans = await askLine(chalk.white("  share to X? [Y/n] "));
+    process.stderr.write("\n");
+    const shared = !ans || ans.toLowerCase() !== "n";
+    if (!shared) {
+        process.stderr.write(`  your wrapped: ${wrapped.share_url}\n\n`);
+        return;
+    }
+    process.stderr.write("  opening x.com to share...\n");
+    try {
+        await openShareToX(wrapped.view);
+        await markWrappedShared(wrapped.id);
+        process.stderr.write("  browser opened with prefilled tweet.\n\n");
+    }
+    catch (err) {
+        process.stderr.write(`  couldn't open browser — share manually: ${wrapped.share_url}\n`);
+        process.stderr.write(`  (${err instanceof Error ? err.message : err})\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
+    // optional post-wrapped profile chat needs a real terminal.
+    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");
+    if (jobId) {
+        console.log(`  Applying to: ${STANDOUT_API_URL}/jobs/${jobId}\n`);
+    }
+    // LLM calls are proxied through Standout — users don't need an Anthropic key.
+    // Override the SDK's default User-Agent because Vercel's platform firewall
+    // matches `Anthropic/JS` as bot traffic and returns 403.
+    const client = new Anthropic({
+        apiKey: "proxied-by-standout",
+        baseURL: `${STANDOUT_API_URL}/api/public/agent-chat`,
+        defaultHeaders: {
+            "User-Agent": "Standout/0.4.0 (node)",
+        },
+    });
+    await confirmPrivacy();
+    const stopInitialLoading = startLoadingLine("Generating your Standout wrapped");
+    const usagePromise = gatherUsageStats();
+    const basicsPromise = gatherProfileBasics();
+    let usageStats;
+    let profileBasics;
+    try {
+        [usageStats, profileBasics] = await Promise.all([
+            usagePromise,
+            basicsPromise,
+        ]);
+    }
+    finally {
+        stopInitialLoading();
+    }
+    // Enrich the profile AND create the wrapped (all server LLM cards + rank) in one
+    // shot under the spinner; the whole deck is then paged at once.
+    const wrappedPromise = gatherFullEnrichment({
+        aiUsage: usageStats.ai_usage,
+        profileBasics,
+        verbose: false,
+    }).then(async (prefetched) => {
+        try {
+            const wrapped = await createWrapped({
+                profile: prefetched,
+                submissionId: null,
+            });
+            return { wrapped, prefetched };
+        }
+        catch {
+            return { wrapped: null, prefetched };
+        }
+    });
+    // Generate EVERYTHING up front (gather + all the server LLM cards) under one
+    // spinner, then page the whole deck at once — no two-pass preview/finale split.
+    const stopWrappedLoading = startLoadingLine("Generating your Standout wrapped");
+    let wrapped;
+    let prefetched;
+    try {
+        ({ wrapped, prefetched } = await wrappedPromise);
+    }
+    finally {
+        stopWrappedLoading();
+    }
+    let wrappedId = wrapped?.id ?? null;
+    if (wrapped) {
+        await renderWrappedAll(wrapped.view);
+        await maybeShareWrapped(wrapped);
+    }
+    else {
+        process.stderr.write("  (couldn't generate wrapped right now — continuing profile setup.)\n\n");
+    }
+    if (!profileChatEnabled()) {
+        if (wrappedId) {
+            process.stderr.write("  Profile chat disabled — run with --chat (or STANDOUT_PROFILE_CHAT=1) to build a full profile.\n\n");
+        }
+        return;
+    }
+    const jobInstruction = jobId
+        ? `I'm applying to Standout job ID "${jobId}" — include this as \`jobId\` when you call standout_submit.\n\n`
+        : "";
+    const initialMessage = "Build my developer profile.\n\n" +
+        jobInstruction +
+        "The following context has already been gathered automatically. " +
+        "Use it as the source of truth — do not re-run equivalent shell commands.\n\n" +
+        "<prefetched_profile>\n" +
+        JSON.stringify(prefetched, null, 2) +
+        "\n</prefetched_profile>";
+    // Mark the first user message as a cache breakpoint so the prefetched JSON
+    // (typically 20-40k tokens) is read from cache on every subsequent turn.
+    const messages = [
+        {
+            role: "user",
+            content: [
+                {
+                    type: "text",
+                    text: initialMessage,
+                    cache_control: { type: "ephemeral" },
+                },
+            ],
+        },
+    ];
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalCacheReadTokens = 0;
+    let totalCacheWriteTokens = 0;
+    const startedAt = Date.now();
+    for (let turn = 0; turn < MAX_TURNS; turn++) {
+        const stream = client.messages.stream({
+            model: "claude-opus-4-7",
+            max_tokens: 16384,
+            // System prompt cached — saves the ~1.5k token instruction block on every turn after #1.
+            system: [
+                {
+                    type: "text",
+                    text: SYSTEM_PROMPT,
+                    cache_control: { type: "ephemeral" },
+                },
+            ],
+            messages,
+            // Cache the entire tools array via cache_control on the last tool definition.
+            tools: [
+                ...TOOLS,
+                {
+                    type: "web_search_20250305",
+                    name: "web_search",
+                    max_uses: 5,
+                    cache_control: { type: "ephemeral" },
+                },
+            ],
+        });
+        stream.on("text", (delta) => {
+            process.stdout.write(delta);
+        });
+        const response = await stream.finalMessage();
+        totalInputTokens += response.usage.input_tokens;
+        totalOutputTokens += response.usage.output_tokens;
+        const usage = response.usage;
+        totalCacheWriteTokens += usage.cache_creation_input_tokens ?? 0;
+        totalCacheReadTokens += usage.cache_read_input_tokens ?? 0;
+        // Merge or push assistant message (handles pause_turn continuations)
+        const lastMsg = messages[messages.length - 1];
+        if (lastMsg?.role === "assistant") {
+            // Continuation — merge into previous assistant message
+            const prevContent = lastMsg.content;
+            lastMsg.content = [...prevContent, ...response.content];
+        }
+        else {
+            messages.push({
+                role: "assistant",
+                content: response.content,
+            });
+        }
+        if (response.stop_reason === "end_turn") {
+            break;
+        }
+        if (response.stop_reason === "pause_turn") {
+            continue;
+        }
+        if (response.stop_reason === "tool_use") {
+            const toolResults = [];
+            for (const block of response.content) {
+                if (block.type === "tool_use") {
+                    const result = await executeTool(block.name, block.input, {
+                        prefetchedProfile: prefetched,
+                        wrappedId,
+                    });
+                    const submittedId = result.match(/Profile submitted successfully! ID: ([0-9a-f-]+)/i)?.[1];
+                    if (submittedId)
+                        wrappedId = null;
+                    toolResults.push({
+                        type: "tool_result",
+                        tool_use_id: block.id,
+                        content: result,
+                    });
+                }
+            }
+            messages.push({
+                role: "user",
+                content: toolResults,
+            });
+        }
+        else {
+            // Unhandled stop reason (max_tokens, refusal, etc.)
+            console.error(`\n  Unexpected stop reason: ${response.stop_reason}. Stopping.`);
+            break;
+        }
+    }
+    const elapsed = ((Date.now() - startedAt) / 1000).toFixed(1);
+    if (jobId) {
+        console.log(`\n  Done! Finish your application: ${STANDOUT_API_URL}/jobs/${jobId}`);
+    }
+    else {
+        console.log(`\n  Done. Visit ${STANDOUT_API_URL} to see your profile.`);
+    }
+    const cacheNote = totalCacheReadTokens > 0
+        ? ` · cache: ${totalCacheReadTokens.toLocaleString()} read, ${totalCacheWriteTokens.toLocaleString()} written`
+        : "";
+    console.log(`  Tokens: ${totalInputTokens.toLocaleString()} in / ${totalOutputTokens.toLocaleString()} out${cacheNote} in ${elapsed}s\n`);
+}
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.includes("--gather")) {
+        await confirmPrivacy();
+        const data = await gatherFullEnrichment();
+        process.stdout.write(JSON.stringify(data, null, 2));
+    }
+    else if (args.includes("--mcp")) {
+        await startMcpServer();
+    }
+    else {
+        const jobId = args.find((a) => !a.startsWith("-"));
+        if (jobId) {
+            process.env.STANDOUT_JOB_ID = jobId;
+        }
+        await runAgent(jobId);
+    }
+}
+main().catch((error) => {
+    console.error("Error:", error instanceof Error ? error.message : error);
+    process.exit(1);
+});

package/dist/cursor.d.ts

@@ -0,0 +1,54 @@
+import type { ConversationExchange, InteractionSignals, PromptFrequency } from "./ai-usage.js";
+export interface CursorStats {
+    total_sessions: number;
+    active_days: number;
+    first_session: string | null;
+    last_session: string | null;
+    total_duration_hours: number;
+    message_counts: {
+        user: number;
+        assistant: number;
+        total: number;
+    };
+    models: string[];
+    hour_buckets: number[];
+    weekend_ratio: number;
+    languages: Record<string, number>;
+    prompt_samples: string[];
+    prompt_frequency: PromptFrequency[];
+    exchanges: ConversationExchange[];
+    interaction: InteractionSignals;
+    monthly_buckets: {
+        month: string;
+        sessions: number;
+        duration_hours: number;
+        input_tokens: number;
+        output_tokens: number;
+        cache_tokens: number;
+        primary_model: string | null;
+    }[];
+    all_time?: {
+        total_sessions: number;
+        active_days: number;
+        first_session: string | null;
+        last_session: string | null;
+        total_duration_hours: number;
+        total_input_tokens: number;
+        total_output_tokens: number;
+        total_cache_read_tokens: number;
+        total_cache_write_tokens: number;
+        monthly_buckets: {
+            month: string;
+            sessions: number;
+            duration_hours: number;
+            input_tokens: number;
+            output_tokens: number;
+            cache_tokens: number;
+            primary_model: string | null;
+        }[];
+    };
+}
+export declare function gatherCursor(opts?: {
+    dbPath?: string;
+    windowStartMs?: number;
+}): Promise<CursorStats | null>;