standout 0.1.0 → 0.5.15

package/dist/cursor.js

@@ -0,0 +1,487 @@
+import { existsSync } from "fs";
+import { homedir, platform } from "os";
+import { join } from "path";
+import { redactSecrets } from "./redact.js";
+const MAX_PROMPT_SAMPLES = 30;
+const MAX_PROMPT_LEN = 200;
+const MAX_SESSION_HOURS = 4;
+const MAX_ACTIVE_GAP_MINUTES = 15;
+const SINGLE_EVENT_SESSION_MINUTES = 1;
+const MAX_FILE_PATHS = 5000;
+const MAX_EXCHANGES = 500;
+const MAX_ASSISTANT_LEN = 800;
+const MAX_EXCHANGE_PROMPT_LEN = 2000;
+const MAX_PROMPT_FREQUENCY = 12;
+const CORRECTION_RE = /\b(no|nope|actually|wrong|incorrect|instead|revert|undo|don'?t|stop|not what|that'?s not)\b/i;
+// Mirrors ai-usage.ts — cannot import (would create a module cycle).
+const TRIVIAL_ASK_RE = /^(y|n|yes|yep|yeah|ya|ok|okay|k|sure|go|go ahead|do it|continue|please continue|next|thanks|thank you|thx|ty|nice|cool|perfect|great|good|done|ship it|lgtm|👍|\.|\?)\b[\s.!]*$/i;
+const SHELL_COMMAND_RE = /^(npx|npm|pnpm|yarn|bun|git|cd|ls|cat|node|python|pip|brew|sudo|docker|curl|echo|mkdir|rm|mv|cp)\b/i;
+function isLowSignalAsk(sample) {
+    const t = sample.trim();
+    return t.length < 12 || TRIVIAL_ASK_RE.test(t) || SHELL_COMMAND_RE.test(t);
+}
+function cursorDedupKey(s) {
+    return s
+        .toLowerCase()
+        .replace(/[\s\p{P}]+$/u, "")
+        .slice(0, 160);
+}
+function sanitizeAssistantText(text) {
+    let out = text
+        .trim()
+        .replace(/```[\s\S]*?```/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (out.length < 8)
+        return null;
+    out = redactSecrets(out);
+    if (out.length > MAX_ASSISTANT_LEN)
+        out = out.slice(0, MAX_ASSISTANT_LEN) + "…";
+    return out;
+}
+const EXT_TO_LANG = {
+    ts: "typescript",
+    tsx: "typescript",
+    js: "javascript",
+    jsx: "javascript",
+    mjs: "javascript",
+    cjs: "javascript",
+    py: "python",
+    go: "go",
+    rs: "rust",
+    java: "java",
+    kt: "kotlin",
+    swift: "swift",
+    rb: "ruby",
+    php: "php",
+    cpp: "cpp",
+    cc: "cpp",
+    c: "c",
+    cs: "csharp",
+    sh: "shell",
+    bash: "shell",
+    zsh: "shell",
+    sql: "sql",
+    yaml: "yaml",
+    yml: "yaml",
+    json: "json",
+    md: "markdown",
+    mdx: "markdown",
+    css: "css",
+    scss: "sass",
+    vue: "vue",
+    svelte: "svelte",
+};
+function findCursorDb() {
+    const home = homedir();
+    const os = platform();
+    const candidates = os === "darwin"
+        ? [
+            join(home, "Library", "Application Support", "Cursor", "User", "globalStorage", "state.vscdb"),
+        ]
+        : os === "linux"
+            ? [
+                join(home, ".config", "Cursor", "User", "globalStorage", "state.vscdb"),
+            ]
+            : os === "win32"
+                ? [
+                    join(home, "AppData", "Roaming", "Cursor", "User", "globalStorage", "state.vscdb"),
+                ]
+                : [];
+    for (const p of candidates) {
+        if (existsSync(p))
+            return p;
+    }
+    return null;
+}
+async function loadSqliteDriver() {
+    try {
+        // Optional dep — better-sqlite3 ships prebuilds for common platforms but
+        // can fail to install in some environments. We must not crash gather().
+        const mod = (await import("better-sqlite3"));
+        return mod.default;
+    }
+    catch {
+        return null;
+    }
+}
+function sanitizePrompt(raw, maxLen = MAX_PROMPT_LEN) {
+    if (!raw)
+        return null;
+    let text = raw.trim();
+    text = text
+        .replace(/```[\s\S]*?```/g, " ")
+        .replace(/^#+\s*/gm, "")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!text || text.length < 8)
+        return null;
+    text = redactSecrets(text);
+    if (text.length > maxLen) {
+        text = text.slice(0, maxLen) + "…";
+    }
+    return text;
+}
+async function readState(dbPath, Driver) {
+    const yieldMacro = () => new Promise((r) => setImmediate(r));
+    const PAGE = 500;
+    const D = Driver;
+    let db;
+    try {
+        db = new D(dbPath, { readonly: true });
+    }
+    catch {
+        return null;
+    }
+    try {
+        const composers = new Map();
+        const bubbles = new Map();
+        // Page through rows (better-sqlite3 is synchronous; reading + JSON.parsing
+        // everything at once blocks the event loop for seconds and freezes the
+        // loading spinner). Yield a macrotask between pages so it keeps animating.
+        // Keyset pagination (key is the indexed PK) — O(n) range scan, unlike
+        // LIMIT/OFFSET which re-scans from the start each page.
+        const composerStmt = db.prepare("SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%' AND key > ? ORDER BY key LIMIT ?");
+        for (let lastKey = "";;) {
+            const rows = composerStmt.all(lastKey, PAGE);
+            if (rows.length === 0)
+                break;
+            for (const row of rows) {
+                lastKey = row.key;
+                let parsed;
+                try {
+                    parsed = JSON.parse(row.value);
+                }
+                catch {
+                    continue;
+                }
+                if (!parsed || typeof parsed !== "object")
+                    continue;
+                const composerId = parsed.composerId ??
+                    row.key.slice("composerData:".length);
+                composers.set(composerId, {
+                    composerId,
+                    createdAt: numericTs(parsed.createdAt),
+                    lastUpdatedAt: numericTs(parsed.lastUpdatedAt),
+                    modelConfig: typeof parsed.latestSelectedModel === "string"
+                        ? parsed.latestSelectedModel
+                        : null,
+                });
+            }
+            if (rows.length < PAGE)
+                break;
+            await yieldMacro();
+        }
+        const bubbleStmt = db.prepare("SELECT key, value FROM cursorDiskKV WHERE key LIKE 'bubbleId:%' AND key > ? ORDER BY key LIMIT ?");
+        for (let lastKey = "";;) {
+            const rows = bubbleStmt.all(lastKey, PAGE);
+            if (rows.length === 0)
+                break;
+            for (const row of rows) {
+                lastKey = row.key;
+                const parts = row.key.split(":");
+                if (parts.length < 3)
+                    continue;
+                const conversationId = parts[1];
+                let parsed;
+                try {
+                    parsed = JSON.parse(row.value);
+                }
+                catch {
+                    continue;
+                }
+                if (!parsed || typeof parsed !== "object")
+                    continue;
+                const type = typeof parsed.type === "number" ? parsed.type : null;
+                const text = typeof parsed.text === "string" ? parsed.text : null;
+                const createdAt = numericTs(parsed.createdAt);
+                const filePaths = extractFilePaths(parsed);
+                bubbles.set(parts[2], {
+                    conversationId,
+                    type,
+                    text,
+                    createdAt,
+                    filePaths,
+                });
+            }
+            if (rows.length < PAGE)
+                break;
+            await yieldMacro();
+        }
+        return { composers, bubbles };
+    }
+    finally {
+        try {
+            db.close();
+        }
+        catch {
+            // skip
+        }
+    }
+}
+function numericTs(v) {
+    if (typeof v === "number" && Number.isFinite(v)) {
+        // Cursor timestamps are sometimes ms since epoch (composers) or ISO string (bubbles).
+        return v > 1e12 ? v : v * 1000;
+    }
+    if (typeof v === "string") {
+        const t = Date.parse(v);
+        return Number.isNaN(t) ? null : t;
+    }
+    return null;
+}
+function extractFilePaths(bubble) {
+    const out = [];
+    const grab = (arr) => {
+        if (!Array.isArray(arr))
+            return;
+        for (const item of arr) {
+            if (typeof item === "string") {
+                out.push(item);
+            }
+            else if (item && typeof item === "object") {
+                const o = item;
+                if (typeof o.fsPath === "string")
+                    out.push(o.fsPath);
+                else if (typeof o.path === "string")
+                    out.push(o.path);
+                else if (typeof o.uri === "string")
+                    out.push(o.uri);
+                else if (typeof o.relativeWorkspacePath === "string")
+                    out.push(o.relativeWorkspacePath);
+            }
+        }
+    };
+    grab(bubble.relevantFiles);
+    grab(bubble.attachedFileCodeChunksMetadataOnly);
+    grab(bubble.attachedCodeChunks);
+    grab(bubble.recentlyViewedFiles);
+    return out.slice(0, 20);
+}
+function estimateActiveDurationMs(timestamps) {
+    const sorted = [...new Set(timestamps)]
+        .filter((ts) => Number.isFinite(ts))
+        .sort((a, b) => a - b);
+    if (sorted.length === 0)
+        return 0;
+    if (sorted.length === 1)
+        return SINGLE_EVENT_SESSION_MINUTES * 60 * 1000;
+    const maxGapMs = MAX_ACTIVE_GAP_MINUTES * 60 * 1000;
+    let total = 0;
+    for (let i = 1; i < sorted.length; i++) {
+        const gap = sorted[i] - sorted[i - 1];
+        if (gap <= 0)
+            continue;
+        total += Math.min(gap, maxGapMs);
+    }
+    return Math.min(total, MAX_SESSION_HOURS * 3600 * 1000);
+}
+export async function gatherCursor(opts = {}) {
+    const dbPath = opts.dbPath ?? findCursorDb();
+    if (!dbPath)
+        return null;
+    const Driver = await loadSqliteDriver();
+    if (!Driver)
+        return null;
+    const raw = await readState(dbPath, Driver);
+    if (!raw || raw.composers.size === 0)
+        return null;
+    const allTime = finalize(raw);
+    const stats = finalize(raw, { windowStartMs: opts.windowStartMs });
+    stats.all_time = {
+        total_sessions: allTime.total_sessions,
+        active_days: allTime.active_days,
+        first_session: allTime.first_session,
+        last_session: allTime.last_session,
+        total_duration_hours: allTime.total_duration_hours,
+        total_input_tokens: 0,
+        total_output_tokens: 0,
+        total_cache_read_tokens: 0,
+        total_cache_write_tokens: 0,
+        monthly_buckets: allTime.monthly_buckets,
+    };
+    return stats.total_sessions > 0 || allTime.total_sessions > 0 ? stats : null;
+}
+function finalize(raw, opts = {}) {
+    // Group bubbles by conversationId so we know how many messages per session.
+    const sessionBubbles = new Map();
+    for (const bubble of raw.bubbles.values()) {
+        let entry = sessionBubbles.get(bubble.conversationId);
+        if (!entry) {
+            entry = {
+                timestamps: [],
+                bubbles: [],
+            };
+            sessionBubbles.set(bubble.conversationId, entry);
+        }
+        if (bubble.createdAt != null)
+            entry.timestamps.push(bubble.createdAt);
+        entry.bubbles.push(bubble);
+    }
+    const hourBuckets = new Array(24).fill(0);
+    let weekendEvents = 0;
+    let totalEvents = 0;
+    const activeDays = new Set();
+    let firstTs = Infinity;
+    let lastTs = -Infinity;
+    let totalDurationMs = 0;
+    let userTotal = 0;
+    let assistantTotal = 0;
+    const allFiles = new Set();
+    const promptSamples = [];
+    const promptSamplesSeen = new Set();
+    const promptCounts = new Map();
+    const exchanges = [];
+    let userTurns = 0;
+    let correctionTurns = 0;
+    let countedSessions = 0;
+    const monthly = new Map();
+    for (const [composerId, composer] of raw.composers.entries()) {
+        const entry = sessionBubbles.get(composerId);
+        const windowBubbles = opts.windowStartMs === undefined
+            ? (entry?.bubbles ?? [])
+            : (entry?.bubbles ?? []).filter((bubble) => bubble.createdAt != null &&
+                bubble.createdAt >= opts.windowStartMs);
+        const composerTs = composer.createdAt;
+        const bubbleTimestamps = entry?.timestamps ?? [];
+        const allTs = composerTs
+            ? [composerTs, ...bubbleTimestamps]
+            : bubbleTimestamps;
+        const windowTs = opts.windowStartMs === undefined
+            ? allTs
+            : allTs.filter((ts) => ts >= opts.windowStartMs);
+        if (windowTs.length === 0)
+            continue;
+        countedSessions += 1;
+        const minTs = Math.min(...windowTs);
+        const maxTs = Math.max(...windowTs);
+        const durationMs = estimateActiveDurationMs(windowTs);
+        if (minTs < firstTs)
+            firstTs = minTs;
+        if (maxTs > lastTs)
+            lastTs = maxTs;
+        totalDurationMs += durationMs;
+        const monthKey = new Date(minTs).toISOString().slice(0, 7);
+        const month = monthly.get(monthKey) ?? { sessions: 0, durationMs: 0 };
+        month.sessions += 1;
+        month.durationMs += durationMs;
+        monthly.set(monthKey, month);
+        for (const ts of windowTs) {
+            const d = new Date(ts);
+            if (Number.isNaN(d.getTime()))
+                continue;
+            hourBuckets[d.getHours()] += 1;
+            const day = d.getDay();
+            if (day === 0 || day === 6)
+                weekendEvents += 1;
+            totalEvents += 1;
+            activeDays.add(d.toISOString().slice(0, 10));
+        }
+        if (entry) {
+            userTotal += windowBubbles.filter((bubble) => bubble.type === 1).length;
+            assistantTotal += windowBubbles.filter((bubble) => bubble.type === 2).length;
+            for (const bubble of windowBubbles) {
+                for (const fp of bubble.filePaths) {
+                    if (allFiles.size < MAX_FILE_PATHS)
+                        allFiles.add(fp);
+                }
+            }
+            const windowSamples = windowBubbles
+                .filter((bubble) => bubble.type === 1 && bubble.text)
+                .map((bubble) => sanitizePrompt(bubble.text))
+                .filter((sample) => Boolean(sample));
+            for (const sample of windowSamples) {
+                if (promptSamples.length >= MAX_PROMPT_SAMPLES)
+                    break;
+                const key = cursorDedupKey(sample);
+                if (promptSamplesSeen.has(key))
+                    continue;
+                promptSamplesSeen.add(key);
+                promptSamples.push(sample);
+            }
+            // Conversation corpus: walk bubbles in chronological order, count prompt
+            // frequency + correction signal, and pair each user prompt with the next
+            // assistant reply into a truncated exchange for collaboration analysis.
+            const ordered = [...windowBubbles].sort((a, b) => (a.createdAt ?? 0) - (b.createdAt ?? 0));
+            let pendingUser = null;
+            for (const bubble of ordered) {
+                if (bubble.type === 1 && bubble.text) {
+                    const sample = sanitizePrompt(bubble.text);
+                    if (!sample)
+                        continue;
+                    if (!isLowSignalAsk(sample)) {
+                        const key = cursorDedupKey(sample);
+                        const existing = promptCounts.get(key);
+                        if (existing)
+                            existing.count += 1;
+                        else
+                            promptCounts.set(key, { text: sample, count: 1 });
+                    }
+                    userTurns += 1;
+                    if (CORRECTION_RE.test(sample))
+                        correctionTurns += 1;
+                    pendingUser =
+                        sanitizePrompt(bubble.text, MAX_EXCHANGE_PROMPT_LEN) ?? sample;
+                }
+                else if (bubble.type === 2 && bubble.text && pendingUser) {
+                    if (exchanges.length >= MAX_EXCHANGES)
+                        continue;
+                    const reply = sanitizeAssistantText(bubble.text);
+                    if (!reply)
+                        continue;
+                    exchanges.push({ user: pendingUser, assistant: reply });
+                    pendingUser = null;
+                }
+            }
+        }
+    }
+    const languages = {};
+    for (const fp of allFiles) {
+        const ext = fp.toLowerCase().split(".").pop();
+        if (ext && EXT_TO_LANG[ext]) {
+            const lang = EXT_TO_LANG[ext];
+            languages[lang] = (languages[lang] || 0) + 1;
+        }
+    }
+    return {
+        total_sessions: countedSessions,
+        active_days: activeDays.size,
+        first_session: Number.isFinite(firstTs)
+            ? new Date(firstTs).toISOString()
+            : null,
+        last_session: Number.isFinite(lastTs)
+            ? new Date(lastTs).toISOString()
+            : null,
+        total_duration_hours: +(totalDurationMs / 1000 / 3600).toFixed(1),
+        message_counts: {
+            user: userTotal,
+            assistant: assistantTotal,
+            total: userTotal + assistantTotal,
+        },
+        models: [],
+        hour_buckets: hourBuckets,
+        weekend_ratio: totalEvents > 0 ? +(weekendEvents / totalEvents).toFixed(2) : 0,
+        languages,
+        prompt_samples: promptSamples,
+        prompt_frequency: [...promptCounts.values()]
+            .sort((a, b) => b.count - a.count)
+            .slice(0, MAX_PROMPT_FREQUENCY),
+        exchanges,
+        interaction: {
+            user_turns: userTurns,
+            correction_turns: correctionTurns,
+            tool_calls: 0,
+        },
+        monthly_buckets: [...monthly.entries()]
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([month, b]) => ({
+            month,
+            sessions: b.sessions,
+            duration_hours: +(b.durationMs / 1000 / 3600).toFixed(1),
+            input_tokens: 0,
+            output_tokens: 0,
+            cache_tokens: 0,
+            primary_model: null,
+        })),
+    };
+}

package/dist/dev-env.d.ts

@@ -0,0 +1,28 @@
+export interface ClaudeSettingsSummary {
+    path: string;
+    hooks: string[];
+    mcp_servers: string[];
+    permissions_count: number;
+}
+export interface DevEnvironment {
+    agents_md: {
+        path: string;
+        contents: string;
+    }[];
+    claude_settings: ClaudeSettingsSummary[];
+    claude_commands: string[];
+    claude_skills: string[];
+    cursor_rules: {
+        path: string;
+        contents: string;
+    }[];
+    vscode_extensions: string[];
+    global_npm_packages: string[];
+    global_brew_packages: string[];
+    global_pip_packages: string[];
+    tools: {
+        name: string;
+        version: string;
+    }[];
+}
+export declare function gatherDevEnvironment(): Promise<DevEnvironment>;