promptarc 0.0.1 → 0.0.3

package/README.md

@@ -1,16 +1,16 @@
 # promptarc
 
-> Local-first viewer for AI coding agent sessions. Browse, search, and share what your agent has been doing — without uploading anything you didn't ask to.
+> Local-first viewer for AI coding agent sessions. Browse, search, and share your Claude Code, Codex, and Cursor sessions — without uploading anything you didn't ask to.
 
 ```bash
 npx promptarc
 ```
 
-That's it. The CLI boots a dashboard at `http://localhost:3030` that reads `~/.claude/` and renders every Claude Code session as an inspectable timeline (messages, tool calls, file diffs, todos, errors, the works).
+That's it. The CLI boots a dashboard at `http://localhost:3030` that reads `~/.claude/`, `~/.codex/`, and `~/.cursor/` — rendering every session from Claude Code, OpenAI Codex, and Cursor as an inspectable timeline (messages, tool calls, file diffs, todos, errors, the works).
 
 ## Features
 
-- **Local-first.** Reads `~/.claude/` directly. No data leaves your machine unless you explicitly click *Share*.
+- **Multi-agent.** Reads `~/.claude/` (Claude Code), `~/.codex/` (Codex), and `~/.cursor/` (Cursor) in one dashboard with tabs to filter by agent.
 - **Live updates.** Open a session that's still running and the page refreshes within ~300ms of every new message Claude writes.
 - **Resume.** Lost track of which session you were on? Click any session and copy the `claude --resume <id>` command from the sidebar.
 - **Selective sharing.** Click *Share session* to upload a single session as a viewable link. Choose visibility per share: **public** (indexed), **unlisted** (anyone with the URL), or **private** (only you, default).
@@ -39,12 +39,12 @@ promptarc --help     Show usage
 ## Requirements
 
 - Node.js ≥ 20
-- A `~/.claude/` directory (created automatically by [Claude Code](https://docs.claude.com/en/docs/claude-code))
+- At least one of: `~/.claude/` (Claude Code), `~/.codex/` (Codex), or `~/.cursor/` (Cursor)
 
-## License
+## Feedback
 
-MIT — see [LICENSE](https://github.com/telugutribe/agentreplay/blob/main/LICENSE).
+[promptarc.dev/feedback](https://promptarc.dev/feedback)
 
-## Source
+## License
 
-[github.com/telugutribe/agentreplay](https://github.com/telugutribe/agentreplay)
+MIT

package/dist/bin.js

@@ -54,6 +54,10 @@ async function main() {
         console.log(`Signed in as ${auth.email ?? auth.userId}${auth.login ? ` (@${auth.login})` : ''}`);
         return;
     }
+    if (cmd === 'pr') {
+        await runPR(args.slice(1));
+        return;
+    }
     if (cmd === 'pull') {
         const slug = args[1];
         if (!slug) {
@@ -81,6 +85,8 @@ COMMANDS
   login       Sign in to your promptarc account via GitHub
   logout      Delete the saved auth token
   whoami      Print the currently signed-in account
+  pr          Generate a PR description from the current session
+  pr --share  Generate + share session as private (includes link)
   pull <slug> Download a shared session into ~/.claude/ for resume
   --version   Print the CLI version
   --help      Show this message
@@ -89,6 +95,366 @@ LEARN MORE
   https://promptarc.dev
 `);
 }
+async function runPR(args) {
+    const auth = loadAuth();
+    if (!auth) {
+        console.error('Not signed in. Run `promptarc login` first.');
+        process.exitCode = 1;
+        return;
+    }
+    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 fs = require('node:fs');
+    const path = require('node:path');
+    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 = path.join(homedir(), '.claude', 'projects');
+    try {
+        const dirs = fs.readdirSync(claudeRoot);
+        for (const dir of dirs) {
+            if (dir === encoded || dir.endsWith(lastPart)) {
+                const projectDir = path.join(claudeRoot, dir);
+                if (!fs.statSync(projectDir).isDirectory())
+                    continue;
+                const files = fs.readdirSync(projectDir).filter((f) => f.endsWith('.jsonl'));
+                for (const f of files) {
+                    const fp = path.join(projectDir, f);
+                    candidates.push({
+                        path: fp,
+                        sessionId: path.basename(f, '.jsonl'),
+                        projectId: dir,
+                    });
+                }
+            }
+        }
+    }
+    catch { /* no Claude sessions */ }
+    // 2. Codex: ~/.codex/sessions/**/*.jsonl (scan all, match cwd from session_meta)
+    const codexRoot = path.join(homedir(), '.codex', 'sessions');
+    try {
+        const codexFiles = findJsonlRecursive(codexRoot, fs, path);
+        for (const fp of codexFiles) {
+            // Quick check: read first line for cwd match.
+            try {
+                const firstLine = fs.readFileSync(fp, 'utf8').split('\n')[0] ?? '';
+                if (firstLine.includes(cwd) || firstLine.includes(lastPart)) {
+                    const name = path.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 = path.join(homedir(), '.cursor', 'projects');
+    try {
+        const dirs = fs.readdirSync(cursorRoot);
+        for (const dir of dirs) {
+            if (dir === cursorEncoded || dir.endsWith(lastPart)) {
+                const transcriptsDir = path.join(cursorRoot, dir, 'agent-transcripts');
+                try {
+                    const sessionDirs = fs.readdirSync(transcriptsDir);
+                    for (const sd of sessionDirs) {
+                        const fp = path.join(transcriptsDir, sd, `${sd}.jsonl`);
+                        try {
+                            fs.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 fs.statSync(b.path).mtimeMs - fs.statSync(a.path).mtimeMs;
+        }
+        catch {
+            return 0;
+        }
+    });
+    return candidates[0];
+}
+function findJsonlRecursive(dir, fs, path) {
+    const results = [];
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory())
+                results.push(...findJsonlRecursive(full, fs, path));
+            else if (entry.name.endsWith('.jsonl'))
+                results.push(full);
+        }
+    }
+    catch { /* skip */ }
+    return results;
+}
+function findSessionById(id) {
+    const fs = require('node:fs');
+    const path = require('node:path');
+    // Search Claude Code.
+    const claudeRoot = path.join(homedir(), '.claude', 'projects');
+    try {
+        for (const dir of fs.readdirSync(claudeRoot)) {
+            const fp = path.join(claudeRoot, dir, `${id}.jsonl`);
+            try {
+                fs.statSync(fp);
+                return { path: fp, sessionId: id, projectId: dir };
+            }
+            catch { /* skip */ }
+        }
+    }
+    catch { /* no Claude */ }
+    // Search Cursor.
+    const cursorRoot = path.join(homedir(), '.cursor', 'projects');
+    try {
+        for (const dir of fs.readdirSync(cursorRoot)) {
+            const fp = path.join(cursorRoot, dir, 'agent-transcripts', id, `${id}.jsonl`);
+            try {
+                fs.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 = path.join(homedir(), '.codex', 'sessions');
+    const codexFiles = findJsonlRecursive(codexRoot, fs, path);
+    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 { readFileSync } = require('node:fs');
+    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) {
     const auth = loadAuth();
     if (!auth) {

package/dist/web/.next/BUILD_ID

@@ -1 +1 @@
-05arLtyVtuaMhMczmbNEQ
+ABHGCNY7MSdkh00Z4Y8wS