promptarc 0.0.2 → 0.0.4

package/dist/share-direct.js

@@ -0,0 +1,360 @@
+/**
+ * Direct share: build a SharedReplay artifact locally and POST it
+ * to the hosted /api/upload endpoint. No local dashboard needed.
+ *
+ * This is a self-contained implementation that reads a JSONL session
+ * file, builds a minimal SharedReplay, strips secrets, and uploads.
+ * It duplicates some logic from @promptarc/core intentionally — the
+ * CLI can't import from the core workspace package at runtime.
+ */
+import { readFileSync } from 'node:fs';
+import { basename } from 'node:path';
+// ─── Secret patterns for redaction ────────────────────────────────────────
+const SECRET_PATTERNS = [
+    /\bsk-ant-[a-zA-Z0-9_-]{10,}/g,
+    /\bsk-(?:proj-)?[a-zA-Z0-9_-]{20,}/g,
+    /\bAKIA[0-9A-Z]{16}/g,
+    /\bghp_[A-Za-z0-9]{20,}/g,
+    /\bghs_[A-Za-z0-9]{20,}/g,
+    /\bgho_[A-Za-z0-9]{20,}/g,
+    /\bglpat-[A-Za-z0-9_-]{20,}/g,
+    /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g,
+    /\bsb_secret_[A-Za-z0-9_-]{10,}/g,
+    /\bxoxb-[0-9]{10,}-[A-Za-z0-9-]+/g,
+    /\bnpm_[A-Za-z0-9]{20,}/g,
+];
+const HOME_RE = new RegExp(process.env.HOME?.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') ?? '/dev/null', 'g');
+function redactString(s) {
+    let secrets = 0;
+    let paths = 0;
+    let result = s;
+    for (const pat of SECRET_PATTERNS) {
+        result = result.replace(pat, () => { secrets++; return '[REDACTED]'; });
+    }
+    if (HOME_RE.test(result)) {
+        result = result.replace(HOME_RE, '~');
+        paths++;
+    }
+    return { text: result, secrets, paths };
+}
+// ─── JSONL → SharedReplay ─────────────────────────────────────────────────
+export function buildReplayFromJsonl(filePath, projectName) {
+    const raw = readFileSync(filePath, 'utf8');
+    const lines = raw.split('\n').filter(Boolean);
+    const messages = [];
+    let msgIndex = 0;
+    let toolCallCount = 0;
+    let fileChangeCount = 0;
+    let userMessageCount = 0;
+    let firstTimestamp = '';
+    let lastTimestamp = '';
+    let title = '';
+    let totalSecrets = 0;
+    let totalPaths = 0;
+    for (const line of lines) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        // Claude Code format.
+        if (parsed.type === 'user' || parsed.type === 'assistant') {
+            const role = parsed.type;
+            const ts = parsed.timestamp ?? new Date().toISOString();
+            if (!firstTimestamp)
+                firstTimestamp = ts;
+            lastTimestamp = ts;
+            const content = parseClaudeContent(parsed, role);
+            if (content.length === 0)
+                continue;
+            // Redact content.
+            const redacted = content.map((block) => redactBlock(block));
+            totalSecrets += redacted.reduce((n, r) => n + r.secrets, 0);
+            totalPaths += redacted.reduce((n, r) => n + r.paths, 0);
+            if (role === 'user') {
+                userMessageCount++;
+                if (!title) {
+                    const textBlock = redacted.find((r) => r.block.type === 'text');
+                    if (textBlock && textBlock.block.type === 'text') {
+                        title = textBlock.block.text.slice(0, 200);
+                    }
+                }
+            }
+            for (const r of redacted) {
+                if (r.block.type === 'tool_use')
+                    toolCallCount++;
+                if (r.block.type === 'tool_use' && ['Edit', 'Write', 'apply_patch', 'write_file'].includes(r.block.name)) {
+                    fileChangeCount++;
+                }
+            }
+            messages.push({
+                id: parsed.uuid ?? `msg-${msgIndex}`,
+                parentId: parsed.parentUuid ?? null,
+                role,
+                timestamp: ts,
+                content: redacted.map((r) => r.block),
+                ...(parsed.type === 'assistant' && parsed.message?.model
+                    ? { model: parsed.message.model }
+                    : {}),
+                isSidechain: parsed.isSidechain ?? false,
+            });
+            msgIndex++;
+            continue;
+        }
+        // Codex format.
+        if (parsed.type === 'response_item' || parsed.type === 'event_msg') {
+            const ts = parsed.timestamp ?? new Date().toISOString();
+            if (!firstTimestamp)
+                firstTimestamp = ts;
+            lastTimestamp = ts;
+            const payload = parsed.payload;
+            if (!payload)
+                continue;
+            if (payload.type === 'message' && (payload.role === 'user' || payload.role === 'assistant')) {
+                const role = payload.role;
+                const contentArr = payload.content;
+                if (!Array.isArray(contentArr))
+                    continue;
+                const blocks = contentArr
+                    .map((b) => parseCodexBlock(b))
+                    .filter((b) => b !== null);
+                if (blocks.length === 0)
+                    continue;
+                const redacted = blocks.map(redactBlock);
+                totalSecrets += redacted.reduce((n, r) => n + r.secrets, 0);
+                if (role === 'user')
+                    userMessageCount++;
+                if (role === 'user' && !title) {
+                    const tb = redacted.find((r) => r.block.type === 'text');
+                    if (tb && tb.block.type === 'text')
+                        title = tb.block.text.slice(0, 200);
+                }
+                messages.push({
+                    id: `codex-${msgIndex}`,
+                    parentId: null,
+                    role,
+                    timestamp: ts,
+                    content: redacted.map((r) => r.block),
+                    isSidechain: false,
+                });
+                msgIndex++;
+            }
+            else if (payload.type === 'function_call') {
+                toolCallCount++;
+                const block = {
+                    type: 'tool_use',
+                    id: payload.call_id ?? `call-${msgIndex}`,
+                    name: payload.name ?? 'unknown',
+                    input: safeParseJson(payload.arguments),
+                };
+                appendToLastAssistant(messages, block, ts, msgIndex++);
+            }
+            else if (payload.type === 'function_call_output') {
+                const output = payload.output ?? '';
+                const r = redactString(output);
+                totalSecrets += r.secrets;
+                const block = {
+                    type: 'tool_result',
+                    toolUseId: payload.call_id ?? '',
+                    output: r.text.slice(0, 12000),
+                    isError: false,
+                };
+                appendToLastAssistant(messages, block, ts, msgIndex++);
+            }
+            if (parsed.type === 'event_msg' && payload.type === 'user_message') {
+                const text = payload.message ?? '';
+                if (!text.trim())
+                    continue;
+                const r = redactString(text);
+                totalSecrets += r.secrets;
+                if (!title)
+                    title = r.text.slice(0, 200);
+                userMessageCount++;
+                messages.push({
+                    id: `codex-user-${msgIndex}`,
+                    parentId: null,
+                    role: 'user',
+                    timestamp: ts,
+                    content: [{ type: 'text', text: r.text }],
+                    isSidechain: false,
+                });
+                msgIndex++;
+            }
+            continue;
+        }
+        // Cursor format.
+        if (parsed.role === 'user' || parsed.role === 'assistant') {
+            const role = parsed.role;
+            const msg = parsed.message;
+            const contentArr = msg?.content;
+            if (!Array.isArray(contentArr))
+                continue;
+            const blocks = [];
+            for (const item of contentArr) {
+                const c = item;
+                if (c.type === 'text') {
+                    let text = c.text ?? '';
+                    text = text.replace(/<\/?user_query>/g, '').replace(/\[REDACTED\]/g, '').trim();
+                    if (text) {
+                        const r = redactString(text);
+                        totalSecrets += r.secrets;
+                        totalPaths += r.paths;
+                        blocks.push({ type: 'text', text: r.text });
+                    }
+                }
+                else if (c.type === 'tool_use') {
+                    toolCallCount++;
+                    blocks.push({
+                        type: 'tool_use',
+                        id: c.id ?? `cursor-tool-${msgIndex}`,
+                        name: c.name ?? 'unknown',
+                        input: c.input ?? {},
+                    });
+                }
+            }
+            if (blocks.length === 0)
+                continue;
+            if (role === 'user') {
+                userMessageCount++;
+                if (!title) {
+                    const tb = blocks.find((b) => b.type === 'text');
+                    if (tb && tb.type === 'text')
+                        title = tb.text.slice(0, 200);
+                }
+            }
+            messages.push({
+                id: `cursor-${msgIndex}`,
+                parentId: null,
+                role,
+                timestamp: new Date().toISOString(),
+                content: blocks,
+                isSidechain: false,
+            });
+            msgIndex++;
+        }
+    }
+    return {
+        formatVersion: 1,
+        createdAt: new Date().toISOString(),
+        meta: {
+            title: title || `Session from ${projectName}`,
+            projectName,
+            startedAt: firstTimestamp || new Date().toISOString(),
+            endedAt: lastTimestamp || null,
+            messageCount: messages.length,
+            userMessageCount,
+            toolCallCount,
+            fileChangeCount,
+        },
+        messages,
+        diffs: [],
+        tasks: [],
+        todos: [],
+        redactionStats: {
+            secretsRedacted: totalSecrets,
+            pathsRedacted: totalPaths,
+            imagesDropped: 0,
+            toolResultsTruncated: 0,
+        },
+    };
+}
+// ─── Helpers ──────────────────────────────────────────────────────────────
+function parseClaudeContent(parsed, role) {
+    const msg = parsed.message;
+    if (typeof msg === 'string') {
+        return [{ type: 'text', text: msg }];
+    }
+    if (typeof msg === 'object' && msg) {
+        const content = msg.content;
+        if (typeof content === 'string') {
+            return [{ type: 'text', text: content }];
+        }
+        if (Array.isArray(content)) {
+            const blocks = [];
+            for (const item of content) {
+                const c = item;
+                if (c.type === 'text' && typeof c.text === 'string') {
+                    blocks.push({ type: 'text', text: c.text });
+                }
+                else if (c.type === 'thinking' && typeof c.thinking === 'string') {
+                    // Strip thinking blocks — same as buildSharedReplay.
+                }
+                else if (c.type === 'tool_use') {
+                    blocks.push({
+                        type: 'tool_use',
+                        id: c.id ?? '',
+                        name: c.name ?? '',
+                        input: c.input ?? {},
+                    });
+                }
+                else if (c.type === 'tool_result') {
+                    const output = typeof c.content === 'string'
+                        ? c.content
+                        : typeof c.output === 'string'
+                            ? c.output
+                            : JSON.stringify(c.content ?? c.output ?? '');
+                    blocks.push({
+                        type: 'tool_result',
+                        toolUseId: c.tool_use_id ?? c.toolUseId ?? '',
+                        output: output.slice(0, 12000),
+                        isError: Boolean(c.is_error ?? c.isError),
+                    });
+                }
+            }
+            return blocks;
+        }
+    }
+    return [];
+}
+function parseCodexBlock(c) {
+    if ((c.type === 'input_text' || c.type === 'text') && typeof c.text === 'string') {
+        return { type: 'text', text: c.text };
+    }
+    if (c.type === 'output_text' && typeof c.text === 'string') {
+        return { type: 'text', text: c.text };
+    }
+    return null;
+}
+function redactBlock(block) {
+    if (block.type === 'text') {
+        const r = redactString(block.text);
+        return { block: { type: 'text', text: r.text }, secrets: r.secrets, paths: r.paths };
+    }
+    if (block.type === 'tool_result') {
+        const r = redactString(block.output);
+        return {
+            block: { type: 'tool_result', toolUseId: block.toolUseId, output: r.text, isError: block.isError },
+            secrets: r.secrets,
+            paths: r.paths,
+        };
+    }
+    return { block, secrets: 0, paths: 0 };
+}
+function appendToLastAssistant(messages, block, ts, idx) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].role === 'assistant') {
+            messages[i].content.push(block);
+            return;
+        }
+    }
+    messages.push({
+        id: `auto-${idx}`,
+        parentId: null,
+        role: 'assistant',
+        timestamp: ts,
+        content: [block],
+        isSidechain: false,
+    });
+}
+function safeParseJson(s) {
+    if (!s)
+        return {};
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return { raw: s };
+    }
+}

package/dist/web/.next/BUILD_ID

@@ -1 +1 @@
-ZxFskpyUoxefJOzSxSb6s
+LF69v3WA6LbEAkvRHNqfG