promptarc 0.0.2 → 0.0.4

package/dist/bin.js

@@ -11,16 +11,19 @@
  *   promptarc login      Run the auth flow without booting the server
  *   promptarc logout     Delete the saved auth token
  *   promptarc whoami     Print the signed-in account
+ *   promptarc pr         Generate a PR description from the current session
+ *   promptarc pull       Download a shared session for resume
  *   promptarc --version  Print the package version
  */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
+import { basename, dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawn } from 'node:child_process';
 import { createServer } from 'node:net';
 import { runLogin, loadAuth, deleteAuth } from './auth.js';
 import { startSyncLoop } from './sync.js';
+import { buildReplayFromJsonl } from './share-direct.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const VERSION = readJson(join(__dirname, '..', 'package.json')).version ?? '0.0.0';
@@ -54,6 +57,25 @@ async function main() {
         console.log(`Signed in as ${auth.email ?? auth.userId}${auth.login ? ` (@${auth.login})` : ''}`);
         return;
     }
+    if (cmd === 'context') {
+        await runContext(args.slice(1));
+        return;
+    }
+    if (cmd === 'pr') {
+        await runPR(args.slice(1));
+        return;
+    }
+    if (cmd === 'share') {
+        const sessionArg = args[1];
+        if (!sessionArg) {
+            console.error('Usage: promptarc share <session-id>');
+            console.error('  Share a local session to the cloud as private.');
+            process.exitCode = 1;
+            return;
+        }
+        await runShare(sessionArg, args.slice(2));
+        return;
+    }
     if (cmd === 'pull') {
         const slug = args[1];
         if (!slug) {
@@ -81,6 +103,10 @@ COMMANDS
   login       Sign in to your promptarc account via GitHub
   logout      Delete the saved auth token
   whoami      Print the currently signed-in account
+  context     What do I need to know? Past sessions for this project
+  pr          Generate a PR description from the current session
+  pr --share  Generate + share session as private (includes link)
+  share <id>  Share a local session to the cloud (private by default)
   pull <slug> Download a shared session into ~/.claude/ for resume
   --version   Print the CLI version
   --help      Show this message
@@ -89,13 +115,869 @@ LEARN MORE
   https://promptarc.dev
 `);
 }
-async function runPull(slug) {
+async function runContext(args) {
+    const cwd = process.cwd();
+    const query = args.filter((a) => !a.startsWith('--')).join(' ');
+    const filesFlag = args.includes('--files');
+    const cwdParts = cwd.split('/').filter(Boolean);
+    const projectName = cwdParts[cwdParts.length - 1] ?? '';
+    console.log(`promptarc context`);
+    console.log(`  ▸ project: ${projectName}`);
+    // 1. Detect recently changed files (git + find fallback).
+    let files = [];
+    if (filesFlag) {
+        try {
+            const { execSync } = await import('node:child_process');
+            // Try git first: staged + last 3 commits.
+            const gitFiles = execSync('git diff --name-only HEAD~3 HEAD 2>/dev/null; git diff --name-only --cached 2>/dev/null; git diff --name-only 2>/dev/null', { cwd, encoding: 'utf8' });
+            files = [...new Set(gitFiles.split('\n').filter(Boolean))].slice(0, 15);
+        }
+        catch { /* not a git repo */ }
+        // Fallback: recently modified files.
+        if (files.length === 0) {
+            try {
+                const { execSync } = await import('node:child_process');
+                const found = execSync('find . -maxdepth 3 -name "*.ts" -o -name "*.tsx" -o -name "*.js" -o -name "*.py" -o -name "*.rs" -o -name "*.go" | head -15', { cwd, encoding: 'utf8' });
+                files = found.split('\n').filter(Boolean).map((f) => f.replace(/^\.\//, ''));
+            }
+            catch { /* no find */ }
+        }
+    }
+    if (files.length > 0) {
+        console.log(`  ▸ files: ${files.slice(0, 5).join(', ')}${files.length > 5 ? ` +${files.length - 5} more` : ''}`);
+    }
+    // 2. Local scan: find sessions across all three agents for this project.
+    console.log(`  ▸ scanning local sessions...`);
+    const localSessions = scanLocalSessions(cwd, projectName);
+    if (localSessions.length > 0) {
+        const lastActive = fmtRelativeTime(localSessions[0].mtime);
+        console.log(`\n  ${projectName} · ${localSessions.length} session${localSessions.length === 1 ? '' : 's'} · last active ${lastActive}`);
+    }
+    // 3. Cloud search + AI briefing (requires auth).
     const auth = loadAuth();
+    let cloudSessionsFound = false;
+    if (auth) {
+        console.log(`\n  ▸ searching cloud archive...`);
+        const siteUrl = process.env.PROMPTARC_SITE_URL ?? 'https://promptarc.dev';
+        // Build local context to send to the API for AI briefing.
+        const localContext = localSessions.slice(0, 3).map((s) => {
+            const prompt = s.firstPrompt
+                ? s.firstPrompt.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 300)
+                : '';
+            return `[${s.agent}] ${prompt} (${s.messageCount} messages)`;
+        }).join('\n');
+        try {
+            const res = await fetch(`${siteUrl}/api/ai/context`, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    authorization: `Bearer ${auth.token}`,
+                },
+                body: JSON.stringify({
+                    cwd,
+                    files,
+                    query,
+                    localContext,
+                }),
+            });
+            if (res.ok) {
+                const json = (await res.json());
+                if (json.count > 0) {
+                    cloudSessionsFound = true;
+                    console.log(`  ${json.count} cloud session${json.count === 1 ? '' : 's'} found.\n`);
+                }
+                else {
+                    console.log(`  No cloud sessions found.`);
+                    if (localSessions.length > 0) {
+                        console.log(`  Share sessions to unlock AI briefing from any machine.`);
+                    }
+                }
+                // Resume command — pick up the exact session.
+                if (localSessions.length > 0) {
+                    const latest = localSessions[0];
+                    const agentCmd = latest.agent === 'codex'
+                        ? 'codex'
+                        : latest.agent === 'cursor'
+                            ? 'cursor'
+                            : 'claude';
+                    const shortId = latest.sessionId ?? basename(latest.path, '.jsonl');
+                    console.log(`\n  Resume last session:`);
+                    console.log(`    ${agentCmd} --resume ${shortId}`);
+                }
+                // AI briefing — the actionable part.
+                if (json.aiBriefing) {
+                    if (json.aiBriefing.unfinished) {
+                        console.log(`\n  What's unfinished:`);
+                        for (const line of json.aiBriefing.unfinished.split('\n')) {
+                            const trimmed = line.trim();
+                            if (trimmed)
+                                console.log(`    ${trimmed}`);
+                        }
+                    }
+                    if (json.aiBriefing.resumePrompt) {
+                        console.log(`\n  Resume prompt (paste into your agent):`);
+                        console.log(`  ┌─`);
+                        for (const line of json.aiBriefing.resumePrompt.split('\n')) {
+                            console.log(`  │ ${line}`);
+                        }
+                        console.log(`  └─`);
+                    }
+                    if (json.aiBriefing.warnings) {
+                        console.log(`\n  Heads up:`);
+                        for (const line of json.aiBriefing.warnings.split('\n')) {
+                            const trimmed = line.trim();
+                            if (trimmed)
+                                console.log(`    ${trimmed}`);
+                        }
+                    }
+                }
+                else if (localSessions.length > 0 && json.count === 0) {
+                    console.log(`\n  Share sessions to get AI briefings with resume prompts.`);
+                }
+            }
+            else {
+                console.log(`  Cloud search failed (HTTP ${res.status}).`);
+            }
+        }
+        catch {
+            console.log(`  Could not reach promptarc.dev (offline?).`);
+            if (localSessions.length === 0) {
+                console.log(`  No local sessions found either.`);
+            }
+        }
+    }
+    else if (localSessions.length === 0) {
+        console.log(`\n  No local sessions found. Run \`promptarc login\` to search cloud archive.`);
+    }
+    else {
+        console.log(`\n  Run \`promptarc login\` to also search your cloud archive.`);
+    }
+    // Session list at the bottom (least important).
+    if (localSessions.length > 0) {
+        console.log('');
+        for (const s of localSessions.slice(0, 6)) {
+            const when = fmtRelativeTime(s.mtime);
+            const agent = s.agent === 'claude' ? 'Claude' : s.agent === 'codex' ? 'Codex' : 'Cursor';
+            const cleanPrompt = s.firstPrompt
+                ? s.firstPrompt.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim()
+                : '';
+            let title = cleanPrompt || `Session ${basename(s.path, '.jsonl').slice(0, 8)}`;
+            if (title.length > 50) {
+                title = title.slice(0, 50).replace(/\s\S*$/, '') + '...';
+            }
+            console.log(`  ${when.padEnd(13)} [${agent}]  ${title} · ${fmtNumber(s.messageCount)} msgs`);
+        }
+        // Gentle share nudge — only when no cloud sessions exist.
+        if (!auth || !cloudSessionsFound) {
+            const latest = localSessions[0];
+            console.log(`\n  ${localSessions.length} local session${localSessions.length === 1 ? '' : 's'} · 0 cloud sessions`);
+            console.log(`  Share to search from any machine: promptarc share ${latest.sessionId.slice(0, 8)}`);
+        }
+    }
+    console.log('');
+}
+/**
+ * Scan ~/.claude/, ~/.codex/, ~/.cursor/ for sessions matching the
+ * current project. Returns session summaries sorted by recency.
+ */
+function scanLocalSessions(cwd, projectName) {
+    const results = [];
+    const cwdEncoded = cwd.replace(/\//g, '-');
+    // Claude Code: ~/.claude/projects/<encoded-cwd>/*.jsonl
+    const claudeRoot = join(homedir(), '.claude', 'projects');
+    try {
+        for (const dir of readdirSync(claudeRoot)) {
+            if (dir === cwdEncoded || dir.endsWith(projectName)) {
+                const projectDir = join(claudeRoot, dir);
+                if (!statSync(projectDir).isDirectory())
+                    continue;
+                for (const file of readdirSync(projectDir)) {
+                    if (!file.endsWith('.jsonl'))
+                        continue;
+                    const fp = join(projectDir, file);
+                    const info = quickParseSession(fp, 'claude');
+                    if (info)
+                        results.push(info);
+                }
+            }
+        }
+    }
+    catch { /* no Claude sessions */ }
+    // Codex: ~/.codex/sessions/**/*.jsonl (match cwd in first line)
+    const codexRoot = join(homedir(), '.codex', 'sessions');
+    try {
+        const codexFiles = findJsonlRecursive(codexRoot);
+        for (const fp of codexFiles) {
+            try {
+                const firstLine = readFileSync(fp, 'utf8').split('\n')[0] ?? '';
+                if (firstLine.includes(cwd) || firstLine.includes(projectName)) {
+                    const info = quickParseSession(fp, 'codex');
+                    if (info)
+                        results.push(info);
+                }
+            }
+            catch { /* skip */ }
+        }
+    }
+    catch { /* no Codex sessions */ }
+    // Cursor: ~/.cursor/projects/<encoded>/agent-transcripts/<uuid>/<uuid>.jsonl
+    const cursorEncoded = cwd.replace(/\//g, '-').replace(/^-/, '');
+    const cursorRoot = join(homedir(), '.cursor', 'projects');
+    try {
+        for (const dir of readdirSync(cursorRoot)) {
+            if (dir === cursorEncoded || dir.endsWith(projectName)) {
+                const transcriptsDir = join(cursorRoot, dir, 'agent-transcripts');
+                try {
+                    for (const sd of readdirSync(transcriptsDir)) {
+                        const fp = join(transcriptsDir, sd, `${sd}.jsonl`);
+                        try {
+                            statSync(fp);
+                            const info = quickParseSession(fp, 'cursor');
+                            if (info)
+                                results.push(info);
+                        }
+                        catch { /* skip */ }
+                    }
+                }
+                catch { /* no transcripts */ }
+            }
+        }
+    }
+    catch { /* no Cursor sessions */ }
+    // Sort by most recent first.
+    results.sort((a, b) => b.mtime - a.mtime);
+    return results;
+}
+/**
+ * Quick parse a JSONL session to extract: mtime, message count,
+ * and the first user prompt. Reads only enough to get the data
+ * without loading the entire file.
+ */
+function quickParseSession(filePath, agent) {
+    try {
+        const stat = statSync(filePath);
+        // For large files, read only the first 100KB to find the first prompt.
+        // Estimate total message count from line count of the full file.
+        const fullRaw = readFileSync(filePath, 'utf8');
+        const totalLines = fullRaw.split('\n').filter(Boolean).length;
+        const scanRaw = fullRaw.length > 100_000 ? fullRaw.slice(0, 100_000) : fullRaw;
+        const lines = scanRaw.split('\n').filter(Boolean);
+        if (totalLines === 0)
+            return null;
+        let messageCount = totalLines; // approximate: 1 line ≈ 1 entry
+        let firstPrompt = '';
+        for (const line of lines) {
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            // Claude Code: {type: "user", message: "text"}
+            if (agent === 'claude') {
+                if (!firstPrompt && parsed.type === 'user') {
+                    let text = '';
+                    if (typeof parsed.message === 'string')
+                        text = parsed.message;
+                    else if (typeof parsed.message === 'object' && parsed.message) {
+                        const content = parsed.message.content;
+                        // content can be a string or an array of blocks.
+                        if (typeof content === 'string')
+                            text = content;
+                        else if (Array.isArray(content)) {
+                            const textBlock = content.find((b) => b.type === 'text');
+                            if (textBlock)
+                                text = textBlock.text;
+                        }
+                    }
+                    // Skip system messages and interrupted markers.
+                    if (text && !isSystemMessage(text))
+                        firstPrompt = text;
+                }
+            }
+            // Codex: {type: "event_msg", payload: {type: "user_message", message: "..."}}
+            if (agent === 'codex') {
+                if (!firstPrompt && parsed.type === 'event_msg') {
+                    const payload = parsed.payload;
+                    if (payload?.type === 'user_message' && typeof payload.message === 'string') {
+                        firstPrompt = payload.message;
+                    }
+                }
+            }
+            // Cursor: {role: "user", message: {content: [{type: "text", text: "..."}]}}
+            if (agent === 'cursor') {
+                if (!firstPrompt && parsed.role === 'user' && typeof parsed.message === 'object' && parsed.message) {
+                    const content = parsed.message.content;
+                    if (Array.isArray(content)) {
+                        const textBlock = content.find((b) => b.type === 'text');
+                        if (textBlock) {
+                            firstPrompt = textBlock.text
+                                .replace(/<\/?user_query>/g, '')
+                                .trim();
+                        }
+                    }
+                }
+            }
+            // Stop as soon as we find a real user prompt.
+            if (firstPrompt)
+                break;
+        }
+        if (totalLines < 2)
+            return null;
+        // Fallback title: use session ID from filename.
+        if (!firstPrompt) {
+            const name = basename(filePath, '.jsonl');
+            firstPrompt = `Session ${name.slice(0, 8)}... (${messageCount} messages)`;
+        }
+        // Extract session ID from filename or path.
+        const fileName = basename(filePath, '.jsonl');
+        const uuidMatch = fileName.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i);
+        const sessionId = uuidMatch?.[1] ?? fileName;
+        return {
+            path: filePath,
+            sessionId,
+            agent,
+            mtime: stat.mtimeMs,
+            messageCount,
+            firstPrompt,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Filter out system-generated messages that aren't real user prompts. */
+function isSystemMessage(text) {
+    const t = text.trim().toLowerCase();
+    return (t.startsWith('[request interrupted') ||
+        t.startsWith('[tool use') ||
+        t.startsWith('<system') ||
+        t.startsWith('<environment') ||
+        t.startsWith('<permissions') ||
+        t.startsWith('<app-context') ||
+        t === '' ||
+        t.length < 5);
+}
+async function runShare(sessionArg, extraArgs) {
+    let auth = loadAuth();
+    if (!auth) {
+        console.log('  ▸ not signed in, starting login...');
+        auth = await runLogin();
+    }
+    // Find the session file.
+    const session = sessionArg.length >= 8
+        ? findSessionById(sessionArg)
+        : null;
+    if (!session) {
+        // Try partial match — the user might pass just the first 8 chars.
+        const partialMatch = findSessionByPrefix(sessionArg);
+        if (!partialMatch) {
+            console.error(`Session not found: ${sessionArg}`);
+            console.error('Run `promptarc context` to see available sessions.');
+            process.exitCode = 1;
+            return;
+        }
+        return doShare(partialMatch, auth);
+    }
+    return doShare(session, auth);
+}
+async function doShare(session, auth) {
+    console.log(`promptarc share`);
+    console.log(`  ▸ session: ${session.sessionId.slice(0, 8)}...`);
+    console.log(`  ▸ building artifact locally...`);
+    // Extract project name from projectId.
+    const projectId = session.projectId ?? '';
+    const parts = projectId.replace(/^(codex:|cursor:)/, '').split('-').filter(Boolean);
+    const projectName = parts[parts.length - 1] ?? 'unknown';
+    // Build the SharedReplay artifact locally (reads JSONL, redacts secrets).
+    let replay;
+    try {
+        replay = buildReplayFromJsonl(session.path, projectName);
+    }
+    catch (err) {
+        console.error(`  ✗ Failed to build artifact: ${String(err)}`);
+        process.exitCode = 1;
+        return;
+    }
+    console.log(`  ▸ ${replay.meta.messageCount} messages, ${replay.redactionStats.secretsRedacted} secrets redacted`);
+    console.log(`  ▸ uploading to promptarc.dev...`);
+    // POST directly to hosted /api/upload with the bearer token.
+    const siteUrl = process.env.PROMPTARC_UPLOAD_ENDPOINT ?? 'https://promptarc.dev/api/upload';
+    const payload = JSON.stringify({
+        replay,
+        sourceSessionId: session.sessionId,
+        projectKey: projectId,
+        agentSource: projectId.startsWith('codex:') ? 'codex' : projectId.startsWith('cursor:') ? 'cursor' : 'claude-code',
+        visibility: 'private',
+        autoSync: false,
+        _h: '',
+    });
+    if (payload.length > 5 * 1024 * 1024) {
+        console.error(`  ✗ Session too large (${(payload.length / 1024 / 1024).toFixed(1)} MB). Max 5 MB.`);
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        const res = await fetch(siteUrl, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                authorization: `Bearer ${auth.token}`,
+            },
+            body: payload,
+        });
+        if (!res.ok) {
+            const text = await res.text();
+            console.error(`  ✗ Upload failed: HTTP ${res.status}`);
+            console.error(`    ${text.slice(0, 200)}`);
+            process.exitCode = 1;
+            return;
+        }
+        const json = (await res.json());
+        if (json.status === 'unchanged') {
+            console.log(`  ✓ Already shared (unchanged).`);
+        }
+        else {
+            console.log(`  ✓ Shared.`);
+        }
+        if (json.url) {
+            console.log(`  ${json.url}`);
+        }
+    }
+    catch (err) {
+        console.error(`  ✗ Upload failed: ${String(err)}`);
+        process.exitCode = 1;
+        return;
+    }
+    console.log('');
+}
+function findSessionByPrefix(prefix) {
+    const claudeRoot = join(homedir(), '.claude', 'projects');
+    try {
+        for (const dir of readdirSync(claudeRoot)) {
+            const projectDir = join(claudeRoot, dir);
+            if (!statSync(projectDir).isDirectory())
+                continue;
+            for (const file of readdirSync(projectDir)) {
+                if (file.startsWith(prefix) && file.endsWith('.jsonl')) {
+                    return {
+                        path: join(projectDir, file),
+                        sessionId: basename(file, '.jsonl'),
+                        projectId: dir,
+                    };
+                }
+            }
+        }
+    }
+    catch { /* no Claude projects */ }
+    // Cursor.
+    const cursorRoot = join(homedir(), '.cursor', 'projects');
+    try {
+        for (const dir of readdirSync(cursorRoot)) {
+            const transcriptsDir = join(cursorRoot, dir, 'agent-transcripts');
+            try {
+                for (const sd of readdirSync(transcriptsDir)) {
+                    if (sd.startsWith(prefix)) {
+                        const fp = join(transcriptsDir, sd, `${sd}.jsonl`);
+                        try {
+                            statSync(fp);
+                            return { path: fp, sessionId: sd, projectId: `cursor:${dir}` };
+                        }
+                        catch { /* skip */ }
+                    }
+                }
+            }
+            catch { /* no transcripts */ }
+        }
+    }
+    catch { /* no Cursor */ }
+    return null;
+}
+function fmtRelativeTime(ms) {
+    const diff = Date.now() - ms;
+    const mins = Math.floor(diff / 60_000);
+    if (mins < 1)
+        return 'just now';
+    if (mins < 60)
+        return `${mins}m ago`;
+    const hours = Math.floor(mins / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    if (days === 1)
+        return 'yesterday';
+    if (days < 7)
+        return `${days}d ago`;
+    const weeks = Math.floor(days / 7);
+    if (weeks < 5)
+        return `${weeks}w ago`;
+    const months = Math.floor(days / 30);
+    return `${months}mo ago`;
+}
+function fmtNumber(n) {
+    return n.toLocaleString('en-US');
+}
+async function runPR(args) {
+    let auth = loadAuth();
     if (!auth) {
-        console.error('Not signed in. Run `promptarc login` first.');
+        console.log('  ▸ not signed in, starting login...');
+        auth = await runLogin();
+    }
+    const shouldShare = args.includes('--share');
+    const sessionIdArg = args.find((a) => !a.startsWith('--'));
+    const copyFlag = args.includes('--copy');
+    // 1. Find the session.
+    const cwd = process.cwd();
+    const sessionFile = sessionIdArg
+        ? findSessionById(sessionIdArg)
+        : findLatestSession(cwd);
+    if (!sessionFile) {
+        console.error(sessionIdArg
+            ? `Session ${sessionIdArg} not found.`
+            : `No sessions found for ${cwd}. Run this from a project directory with Claude Code/Codex/Cursor sessions.`);
+        process.exitCode = 1;
+        return;
+    }
+    console.log(`  ▸ reading ${sessionFile.path}`);
+    // 2. Extract summary input from the local JSONL.
+    const input = extractLocalSummaryInput(sessionFile.path);
+    if (input.length < 20) {
+        console.error('Session is too short to generate a PR description.');
+        process.exitCode = 1;
+        return;
+    }
+    // 3. If --share, share the session first via the local dashboard.
+    let shareUrl = '';
+    if (shouldShare) {
+        console.log('  ▸ sharing session as private...');
+        const localOrigin = 'http://localhost:3030';
+        try {
+            const shareRes = await fetch(`${localOrigin}/api/share`, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({
+                    sessionId: sessionFile.sessionId,
+                    projectId: sessionFile.projectId,
+                    visibility: 'private',
+                    _h: '',
+                }),
+            });
+            if (shareRes.ok) {
+                const json = (await shareRes.json());
+                shareUrl = json.url ?? '';
+                console.log(`  ▸ shared: ${shareUrl}`);
+            }
+            else {
+                console.error('  ▸ share failed (dashboard may not be running). Continuing without link.');
+            }
+        }
+        catch {
+            console.error('  ▸ could not reach local dashboard. Run `promptarc` first, or skip --share.');
+        }
+    }
+    // 4. Generate PR description via hosted API.
+    console.log('  ▸ generating PR description...');
+    const siteUrl = process.env.PROMPTARC_SITE_URL ?? 'https://promptarc.dev';
+    let markdown;
+    try {
+        const res = await fetch(`${siteUrl}/api/ai/pr-summary-local`, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                authorization: `Bearer ${auth.token}`,
+            },
+            body: JSON.stringify({ input }),
+        });
+        if (!res.ok) {
+            const json = (await res.json());
+            console.error(`  ✗ ${json.error ?? `HTTP ${res.status}`}`);
+            process.exitCode = 1;
+            return;
+        }
+        const json = (await res.json());
+        markdown = json.markdown;
+    }
+    catch (err) {
+        console.error(`  ✗ Failed to reach ${siteUrl}: ${String(err)}`);
         process.exitCode = 1;
         return;
     }
+    // 5. Append session link if shared.
+    if (shareUrl) {
+        markdown += `\n\n---\n*Generated by [promptarc](https://promptarc.dev) from [session →](${shareUrl})*`;
+    }
+    // 6. Output.
+    if (copyFlag) {
+        try {
+            const cmd = process.platform === 'darwin'
+                ? 'pbcopy'
+                : process.platform === 'win32'
+                    ? 'clip'
+                    : 'xclip -selection clipboard';
+            const { execSync } = await import('node:child_process');
+            execSync(cmd, { input: markdown });
+            console.log('  ✓ Copied to clipboard.\n');
+        }
+        catch {
+            // Fall through to stdout.
+        }
+    }
+    console.log('');
+    console.log(markdown);
+    console.log('');
+}
+function findLatestSession(cwd) {
+    const candidates = [];
+    const cwdParts = cwd.split('/').filter(Boolean);
+    const lastPart = cwdParts[cwdParts.length - 1] ?? '';
+    const encoded = cwd.replace(/\//g, '-');
+    // 1. Claude Code: ~/.claude/projects/<encoded-cwd>/*.jsonl
+    const claudeRoot = join(homedir(), '.claude', 'projects');
+    try {
+        const dirs = readdirSync(claudeRoot);
+        for (const dir of dirs) {
+            if (dir === encoded || dir.endsWith(lastPart)) {
+                const projectDir = join(claudeRoot, dir);
+                if (!statSync(projectDir).isDirectory())
+                    continue;
+                const files = readdirSync(projectDir).filter((f) => f.endsWith('.jsonl'));
+                for (const f of files) {
+                    const fp = join(projectDir, f);
+                    candidates.push({
+                        path: fp,
+                        sessionId: basename(f, '.jsonl'),
+                        projectId: dir,
+                    });
+                }
+            }
+        }
+    }
+    catch { /* no Claude sessions */ }
+    // 2. Codex: ~/.codex/sessions/**/*.jsonl (scan all, match cwd from session_meta)
+    const codexRoot = join(homedir(), '.codex', 'sessions');
+    try {
+        const codexFiles = findJsonlRecursive(codexRoot);
+        for (const fp of codexFiles) {
+            // Quick check: read first line for cwd match.
+            try {
+                const firstLine = readFileSync(fp, 'utf8').split('\n')[0] ?? '';
+                if (firstLine.includes(cwd) || firstLine.includes(lastPart)) {
+                    const name = basename(fp, '.jsonl');
+                    const uuidMatch = name.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i);
+                    candidates.push({
+                        path: fp,
+                        sessionId: uuidMatch?.[1] ?? name,
+                        projectId: `codex:${cwd.replace(/\//g, '-')}`,
+                    });
+                }
+            }
+            catch { /* skip */ }
+        }
+    }
+    catch { /* no Codex sessions */ }
+    // 3. Cursor: ~/.cursor/projects/<encoded>/agent-transcripts/<uuid>/<uuid>.jsonl
+    const cursorEncoded = cwd.replace(/\//g, '-').replace(/^-/, '');
+    const cursorRoot = join(homedir(), '.cursor', 'projects');
+    try {
+        const dirs = readdirSync(cursorRoot);
+        for (const dir of dirs) {
+            if (dir === cursorEncoded || dir.endsWith(lastPart)) {
+                const transcriptsDir = join(cursorRoot, dir, 'agent-transcripts');
+                try {
+                    const sessionDirs = readdirSync(transcriptsDir);
+                    for (const sd of sessionDirs) {
+                        const fp = join(transcriptsDir, sd, `${sd}.jsonl`);
+                        try {
+                            statSync(fp);
+                            candidates.push({
+                                path: fp,
+                                sessionId: sd,
+                                projectId: `cursor:${dir}`,
+                            });
+                        }
+                        catch { /* skip */ }
+                    }
+                }
+                catch { /* no transcripts */ }
+            }
+        }
+    }
+    catch { /* no Cursor sessions */ }
+    if (candidates.length === 0)
+        return null;
+    // Return the most recently modified file.
+    candidates.sort((a, b) => {
+        try {
+            return statSync(b.path).mtimeMs - statSync(a.path).mtimeMs;
+        }
+        catch {
+            return 0;
+        }
+    });
+    return candidates[0];
+}
+function findJsonlRecursive(dir) {
+    const results = [];
+    try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const full = join(dir, entry.name);
+            if (entry.isDirectory())
+                results.push(...findJsonlRecursive(full));
+            else if (entry.name.endsWith('.jsonl'))
+                results.push(full);
+        }
+    }
+    catch { /* skip */ }
+    return results;
+}
+function findSessionById(id) {
+    // Search Claude Code.
+    const claudeRoot = join(homedir(), '.claude', 'projects');
+    try {
+        for (const dir of readdirSync(claudeRoot)) {
+            const fp = join(claudeRoot, dir, `${id}.jsonl`);
+            try {
+                statSync(fp);
+                return { path: fp, sessionId: id, projectId: dir };
+            }
+            catch { /* skip */ }
+        }
+    }
+    catch { /* no Claude */ }
+    // Search Cursor.
+    const cursorRoot = join(homedir(), '.cursor', 'projects');
+    try {
+        for (const dir of readdirSync(cursorRoot)) {
+            const fp = join(cursorRoot, dir, 'agent-transcripts', id, `${id}.jsonl`);
+            try {
+                statSync(fp);
+                return { path: fp, sessionId: id, projectId: `cursor:${dir}` };
+            }
+            catch { /* skip */ }
+        }
+    }
+    catch { /* no Cursor */ }
+    // Search Codex (scan all, match by UUID in filename).
+    const codexRoot = join(homedir(), '.codex', 'sessions');
+    const codexFiles = findJsonlRecursive(codexRoot);
+    for (const fp of codexFiles) {
+        if (fp.includes(id)) {
+            return { path: fp, sessionId: id, projectId: null };
+        }
+    }
+    return null;
+}
+/**
+ * Lightweight summary input extraction for the CLI. Reads the local
+ * JSONL and pulls: first user prompt, last user prompt, tool call
+ * names + file paths, and error outputs. Capped at 4K chars.
+ */
+function extractLocalSummaryInput(filePath) {
+    const raw = readFileSync(filePath, 'utf8');
+    const lines = raw.split('\n').filter(Boolean);
+    const parts = [];
+    const userPrompts = [];
+    const toolCalls = [];
+    const errors = [];
+    const filePaths = new Set();
+    for (const line of lines) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        // Claude Code format.
+        const type = parsed.type;
+        const msg = parsed.message;
+        if (type === 'user' && typeof msg === 'string') {
+            userPrompts.push(msg);
+        }
+        if (typeof msg === 'object' && msg && Array.isArray(msg.content)) {
+            for (const block of msg.content) {
+                if (block.type === 'text' && typeof block.text === 'string') {
+                    if (type === 'user')
+                        userPrompts.push(block.text);
+                }
+                if (block.type === 'tool_use') {
+                    const name = block.name;
+                    const input = block.input;
+                    const fp = input?.file_path ?? input?.path ?? '';
+                    if (fp)
+                        filePaths.add(fp);
+                    if (input?.command)
+                        toolCalls.push(`${name}: ${String(input.command).slice(0, 100)}`);
+                    else if (fp)
+                        toolCalls.push(`${name}: ${fp}`);
+                    else
+                        toolCalls.push(name);
+                }
+                if (block.type === 'tool_result' && block.is_error) {
+                    const output = typeof block.content === 'string' ? block.content : String(block.output ?? '');
+                    if (output)
+                        errors.push(output.slice(0, 200));
+                }
+            }
+        }
+        // Codex format: {timestamp, type, payload}.
+        if (parsed.payload && typeof parsed.payload === 'object') {
+            const payload = parsed.payload;
+            if (payload.type === 'message' && payload.role === 'user') {
+                const content = payload.content;
+                if (Array.isArray(content)) {
+                    for (const block of content) {
+                        if ((block.type === 'input_text' || block.type === 'text') && typeof block.text === 'string') {
+                            userPrompts.push(block.text);
+                        }
+                    }
+                }
+            }
+        }
+        // Cursor format: {role, message: {content}}.
+        if (parsed.role === 'user' && typeof parsed.message === 'object' && parsed.message) {
+            const content = parsed.message.content;
+            if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (block.type === 'text' && typeof block.text === 'string') {
+                        const text = block.text.replace(/<\/?user_query>/g, '').trim();
+                        if (text)
+                            userPrompts.push(text);
+                    }
+                }
+            }
+        }
+    }
+    if (userPrompts.length > 0) {
+        parts.push('--- First prompt ---');
+        parts.push(userPrompts[0].slice(0, 500));
+    }
+    if (userPrompts.length > 1) {
+        parts.push('--- Last prompt ---');
+        parts.push(userPrompts[userPrompts.length - 1].slice(0, 300));
+    }
+    if (toolCalls.length > 0) {
+        parts.push('--- Tool calls ---');
+        parts.push([...new Set(toolCalls)].slice(0, 15).join('\n'));
+    }
+    if (filePaths.size > 0) {
+        parts.push(`--- Files (${filePaths.size}) ---`);
+        parts.push([...filePaths].slice(0, 20).join(', '));
+    }
+    if (errors.length > 0) {
+        parts.push('--- Errors ---');
+        parts.push(errors.slice(0, 3).join('\n'));
+    }
+    return parts.join('\n').slice(0, 4000);
+}
+async function runPull(slug) {
+    let auth = loadAuth();
+    if (!auth) {
+        console.log('  ▸ not signed in, starting login...');
+        auth = await runLogin();
+    }
     console.log(`promptarc pull ${slug}`);
     console.log('  ▸ downloading session...');
     const siteUrl = process.env.PROMPTARC_SITE_URL ?? 'https://promptarc.dev';