poe-code 3.0.258 → 3.0.259-beta.1

package/packages/agent-traces/dist/collect.js

@@ -0,0 +1,102 @@
+import { promises as nodeFs } from "node:fs";
+import os from "node:os";
+import { traceReaders } from "./readers/index.js";
+const DEFAULT_SOURCES = ["claude", "codex"];
+function compareRecordsNewestFirst(first, second) {
+    const firstTime = first.timestamp ? new Date(first.timestamp).getTime() : 0;
+    const secondTime = second.timestamp ? new Date(second.timestamp).getTime() : 0;
+    return secondTime - firstTime;
+}
+function isInjectedContext(text) {
+    const trimmed = text.trim();
+    return (trimmed.startsWith("<codex_internal_context") ||
+        trimmed.startsWith("# AGENTS.md instructions") ||
+        trimmed.startsWith("## Prior conversation with Codex:") ||
+        trimmed.startsWith("<environment_context>") ||
+        trimmed.startsWith("<INSTRUCTIONS>") ||
+        trimmed.startsWith("<turn_aborted>") ||
+        trimmed.startsWith("<subagent_notification>") ||
+        trimmed.startsWith("Read this JSONL file of human prompts from coding-agent traces:"));
+}
+function removeContextTags(text) {
+    let result = text.trim();
+    while (result.startsWith("<ide_opened_file>")) {
+        const endIndex = result.indexOf("</ide_opened_file>");
+        if (endIndex === -1) {
+            return result;
+        }
+        result = result.slice(endIndex + "</ide_opened_file>".length).trim();
+    }
+    return result;
+}
+function recordKey(record) {
+    return [record.source, record.traceId, record.text].join("\u0000");
+}
+export async function collectHumanPromptsFromReaders(readers, options = {}) {
+    const sources = options.sources ?? DEFAULT_SOURCES;
+    const readerById = new Map(readers.map((reader) => [reader.id, reader]));
+    const fs = options.fs ?? nodeFs;
+    const homeDir = options.homeDir ?? os.homedir();
+    const cwd = options.cwd ?? process.cwd();
+    const records = [];
+    const seenRecords = new Set();
+    let traceCount = 0;
+    for (const source of sources) {
+        const reader = readerById.get(source);
+        if (!reader) {
+            throw new Error(`Unsupported trace source: ${source}`);
+        }
+        const references = await reader.discover({
+            cwd,
+            homeDir,
+            since: options.since,
+            allWorkspaces: options.allWorkspaces,
+            fs,
+            sqlite: options.sqlite
+        });
+        traceCount += references.length;
+        for (const reference of references) {
+            const trace = await reader.read(reference, { fs });
+            for (const turn of trace.turns) {
+                if (turn.role !== "human" || turn.text.trim().length === 0) {
+                    continue;
+                }
+                if (options.since && turn.timestamp && turn.timestamp < options.since) {
+                    continue;
+                }
+                const text = removeContextTags(turn.text);
+                if (text.length === 0) {
+                    continue;
+                }
+                if (isInjectedContext(text)) {
+                    continue;
+                }
+                const record = {
+                    traceId: trace.id,
+                    source: trace.source,
+                    ...(trace.cwd ? { cwd: trace.cwd } : {}),
+                    ...(trace.title ? { title: trace.title } : {}),
+                    ...(turn.timestamp ? { timestamp: turn.timestamp.toISOString() } : {}),
+                    text
+                };
+                const key = recordKey(record);
+                if (seenRecords.has(key)) {
+                    continue;
+                }
+                seenRecords.add(key);
+                records.push(record);
+            }
+        }
+    }
+    records.sort(compareRecordsNewestFirst);
+    return {
+        records: options.limit === undefined ? records : records.slice(0, options.limit),
+        traceCount
+    };
+}
+export async function collectHumanPrompts(options = {}) {
+    return (await collectHumanPromptsWithStats(options)).records;
+}
+export async function collectHumanPromptsWithStats(options = {}) {
+    return await collectHumanPromptsFromReaders(traceReaders, options);
+}

package/packages/agent-traces/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { collectHumanPrompts, collectHumanPromptsFromReaders, collectHumanPromptsWithStats } from "./collect.js";
+export { writeHumanPromptJsonl } from "./jsonl.js";
+export { claudeTraceReader, codexTraceReader, traceReaders } from "./readers/index.js";
+export type { AgentTraceFileSystem, AgentTraceSource, CollectHumanPromptsOptions, CollectHumanPromptsResult, HumanPromptRecord, NormalizedTrace, NormalizedTraceTurn, SqliteTraceDatabase, SqliteTraceDatabaseFactory, TraceDiscoverOptions, TraceReadOptions, TraceReader, TraceReference } from "./types.js";

package/packages/agent-traces/dist/index.js

@@ -0,0 +1,3 @@
+export { collectHumanPrompts, collectHumanPromptsFromReaders, collectHumanPromptsWithStats } from "./collect.js";
+export { writeHumanPromptJsonl } from "./jsonl.js";
+export { claudeTraceReader, codexTraceReader, traceReaders } from "./readers/index.js";

package/packages/agent-traces/dist/jsonl.d.ts

@@ -0,0 +1,2 @@
+import type { AgentTraceFileSystem, HumanPromptRecord } from "./types.js";
+export declare function writeHumanPromptJsonl(records: HumanPromptRecord[], filePath: string, fs?: AgentTraceFileSystem): Promise<void>;

package/packages/agent-traces/dist/jsonl.js

@@ -0,0 +1,7 @@
+import path from "node:path";
+import { promises as nodeFs } from "node:fs";
+export async function writeHumanPromptJsonl(records, filePath, fs = nodeFs) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const content = records.map((record) => JSON.stringify(record)).join("\n");
+    await fs.writeFile(filePath, content.length === 0 ? "" : `${content}\n`, { encoding: "utf8" });
+}

package/packages/agent-traces/dist/line-json.d.ts

@@ -0,0 +1,4 @@
+export declare function parseJsonLines(content: string): unknown[];
+export declare function asRecord(value: unknown): Record<string, unknown> | undefined;
+export declare function parseDate(value: unknown): Date | undefined;
+export declare function newestDate(first: Date | undefined, second: Date | undefined): Date | undefined;

package/packages/agent-traces/dist/line-json.js

@@ -0,0 +1,40 @@
+export function parseJsonLines(content) {
+    const values = [];
+    for (const rawLine of content.split("\n")) {
+        const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+        if (line.trim().length === 0) {
+            continue;
+        }
+        try {
+            values.push(JSON.parse(line));
+        }
+        catch {
+            // Agent trace files may contain partially written lines; keep scanning.
+        }
+    }
+    return values;
+}
+export function asRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}
+export function parseDate(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        const milliseconds = value > 10_000_000_000 ? value : value * 1_000;
+        return new Date(milliseconds);
+    }
+    if (typeof value !== "string" || value.trim().length === 0) {
+        return undefined;
+    }
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? undefined : date;
+}
+export function newestDate(first, second) {
+    if (!first)
+        return second;
+    if (!second)
+        return first;
+    return first.getTime() >= second.getTime() ? first : second;
+}

package/packages/agent-traces/dist/readers/claude.d.ts

@@ -0,0 +1,2 @@
+import type { TraceReader } from "../types.js";
+export declare const claudeTraceReader: TraceReader;

package/packages/agent-traces/dist/readers/claude.js

@@ -0,0 +1,192 @@
+import path from "node:path";
+import { asRecord, newestDate, parseDate, parseJsonLines } from "../line-json.js";
+function isMissingFile(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "ENOENT");
+}
+function encodeClaudeProjectPath(cwd) {
+    return cwd.split(path.sep).join("-");
+}
+async function listJsonlFiles(fs, directory) {
+    let names;
+    try {
+        names = await fs.readdir(directory);
+    }
+    catch (error) {
+        if (isMissingFile(error)) {
+            return [];
+        }
+        throw error;
+    }
+    return names
+        .filter((name) => name.endsWith(".jsonl"))
+        .sort()
+        .map((name) => path.join(directory, name));
+}
+async function listProjectDirectories(fs, projectsRoot) {
+    let names;
+    try {
+        names = await fs.readdir(projectsRoot);
+    }
+    catch (error) {
+        if (isMissingFile(error)) {
+            return [];
+        }
+        throw error;
+    }
+    const directories = [];
+    for (const name of names.sort()) {
+        const candidate = path.join(projectsRoot, name);
+        try {
+            if ((await fs.stat(candidate)).isDirectory()) {
+                directories.push(candidate);
+            }
+        }
+        catch (error) {
+            if (!isMissingFile(error)) {
+                throw error;
+            }
+        }
+    }
+    return directories;
+}
+function fileId(filePath) {
+    const name = path.basename(filePath);
+    return name.endsWith(".jsonl") ? name.slice(0, -".jsonl".length) : name;
+}
+function textFromContent(value) {
+    if (typeof value === "string") {
+        return value.trim();
+    }
+    if (!Array.isArray(value)) {
+        return "";
+    }
+    const parts = [];
+    for (const item of value) {
+        if (typeof item === "string") {
+            parts.push(item);
+            continue;
+        }
+        const record = asRecord(item);
+        if (!record) {
+            continue;
+        }
+        const type = typeof record.type === "string" ? record.type : undefined;
+        if (type !== undefined && type !== "text" && type !== "input_text") {
+            continue;
+        }
+        if (typeof record.text === "string") {
+            parts.push(record.text);
+        }
+    }
+    return parts
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0)
+        .join("\n");
+}
+function roleFromClaude(recordType, messageRole) {
+    if (messageRole === "user" || recordType === "user") {
+        return "human";
+    }
+    if (messageRole === "assistant" || recordType === "assistant") {
+        return "assistant";
+    }
+    if (recordType === "system") {
+        return "system";
+    }
+    return "tool";
+}
+function turnFromRecord(record) {
+    const message = asRecord(record.message);
+    if (!message) {
+        return undefined;
+    }
+    const text = textFromContent(message.content);
+    if (text.length === 0) {
+        return undefined;
+    }
+    return {
+        ...(typeof record.uuid === "string" ? { id: record.uuid } : {}),
+        role: roleFromClaude(record.type, message.role),
+        text,
+        ...(parseDate(record.timestamp) ? { timestamp: parseDate(record.timestamp) } : {}),
+        ...(typeof record.type === "string" ? { sourceKind: record.type } : {})
+    };
+}
+async function readTrace(filePath, fs) {
+    const records = parseJsonLines(await fs.readFile(filePath, "utf8"))
+        .map(asRecord)
+        .filter((record) => record !== undefined);
+    const turns = [];
+    let cwd;
+    let createdAt;
+    let updatedAt;
+    let title;
+    let sessionId;
+    for (const record of records) {
+        if (typeof record.cwd === "string" && cwd === undefined) {
+            cwd = record.cwd;
+        }
+        if (typeof record.sessionId === "string" && sessionId === undefined) {
+            sessionId = record.sessionId;
+        }
+        if (typeof record.aiTitle === "string" && title === undefined) {
+            title = record.aiTitle;
+        }
+        const timestamp = parseDate(record.timestamp);
+        createdAt = createdAt ?? timestamp;
+        updatedAt = newestDate(updatedAt, timestamp);
+        const turn = turnFromRecord(record);
+        if (turn) {
+            turns.push(turn);
+        }
+    }
+    return {
+        source: "claude",
+        id: sessionId ?? fileId(filePath),
+        path: filePath,
+        ...(cwd ? { cwd } : {}),
+        ...(title ? { title } : {}),
+        ...(createdAt ? { createdAt } : {}),
+        ...(updatedAt ? { updatedAt } : {}),
+        turns
+    };
+}
+export const claudeTraceReader = {
+    id: "claude",
+    defaultRoots(homeDir) {
+        return [path.join(homeDir, ".claude", "projects")];
+    },
+    async discover(options) {
+        const projectsRoot = path.join(options.homeDir, ".claude", "projects");
+        const directories = options.allWorkspaces || !options.cwd
+            ? await listProjectDirectories(options.fs, projectsRoot)
+            : [path.join(projectsRoot, encodeClaudeProjectPath(options.cwd))];
+        const references = [];
+        for (const directory of directories) {
+            for (const filePath of await listJsonlFiles(options.fs, directory)) {
+                const trace = await readTrace(filePath, options.fs);
+                if (options.since && trace.updatedAt && trace.updatedAt < options.since) {
+                    continue;
+                }
+                references.push({
+                    source: "claude",
+                    id: trace.id,
+                    path: filePath,
+                    ...(trace.cwd ? { cwd: trace.cwd } : {}),
+                    ...(trace.updatedAt ? { updatedAt: trace.updatedAt } : {}),
+                    ...(trace.title ? { title: trace.title } : {})
+                });
+            }
+        }
+        return references;
+    },
+    async read(reference, options) {
+        if (!reference.path) {
+            throw new Error(`Claude trace ${reference.id} has no path.`);
+        }
+        return await readTrace(reference.path, options.fs);
+    }
+};

package/packages/agent-traces/dist/readers/codex.d.ts

@@ -0,0 +1,2 @@
+import type { TraceReader } from "../types.js";
+export declare const codexTraceReader: TraceReader;

package/packages/agent-traces/dist/readers/codex.js

@@ -0,0 +1,266 @@
+import path from "node:path";
+import { asRecord, newestDate, parseDate, parseJsonLines } from "../line-json.js";
+function isMissingFile(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "ENOENT");
+}
+async function importNodeSqlite() {
+    const emitWarning = process.emitWarning;
+    process.emitWarning = ((warning, ...args) => {
+        if (args[0] === "ExperimentalWarning" && String(warning).includes("SQLite")) {
+            return;
+        }
+        return emitWarning(warning, ...args);
+    });
+    try {
+        return await import("node:sqlite");
+    }
+    finally {
+        process.emitWarning = emitWarning;
+    }
+}
+async function defaultSqliteFactory(databasePath) {
+    const sqlite = await importNodeSqlite();
+    const db = new sqlite.DatabaseSync(databasePath, { readOnly: true });
+    return {
+        all(sql, params) {
+            const sqlParams = params;
+            return db.prepare(sql).all(...sqlParams);
+        },
+        close() {
+            db.close();
+        }
+    };
+}
+function dateFromRow(seconds, milliseconds) {
+    if (typeof milliseconds === "number" && Number.isFinite(milliseconds)) {
+        return new Date(milliseconds);
+    }
+    return parseDate(seconds);
+}
+function rowFromUnknown(value) {
+    const record = asRecord(value);
+    if (!record || typeof record.id !== "string") {
+        return undefined;
+    }
+    return {
+        id: record.id,
+        ...(typeof record.rollout_path === "string" ? { rollout_path: record.rollout_path } : {}),
+        ...(typeof record.created_at === "number" ? { created_at: record.created_at } : {}),
+        ...(typeof record.updated_at === "number" ? { updated_at: record.updated_at } : {}),
+        ...("created_at_ms" in record && typeof record.created_at_ms === "number"
+            ? { created_at_ms: record.created_at_ms }
+            : {}),
+        ...("updated_at_ms" in record && typeof record.updated_at_ms === "number"
+            ? { updated_at_ms: record.updated_at_ms }
+            : {}),
+        ...(typeof record.source === "string" ? { source: record.source } : {}),
+        ...(typeof record.model === "string" ? { model: record.model } : {}),
+        ...(typeof record.cwd === "string" ? { cwd: record.cwd } : {}),
+        ...(typeof record.title === "string" ? { title: record.title } : {}),
+        ...(typeof record.first_user_message === "string"
+            ? { first_user_message: record.first_user_message }
+            : {})
+    };
+}
+function textFromContent(value) {
+    if (typeof value === "string") {
+        return value.trim();
+    }
+    if (!Array.isArray(value)) {
+        return "";
+    }
+    const parts = [];
+    for (const item of value) {
+        if (typeof item === "string") {
+            parts.push(item);
+            continue;
+        }
+        const record = asRecord(item);
+        if (!record) {
+            continue;
+        }
+        const type = typeof record.type === "string" ? record.type : undefined;
+        if (type !== undefined && type !== "input_text" && type !== "output_text" && type !== "text") {
+            continue;
+        }
+        if (typeof record.text === "string") {
+            parts.push(record.text);
+        }
+    }
+    return parts
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0)
+        .join("\n");
+}
+function textFromUserMessage(payload) {
+    if (typeof payload.message === "string") {
+        return payload.message.trim();
+    }
+    const textElements = textFromContent(payload.text_elements);
+    if (textElements.length > 0) {
+        return textElements;
+    }
+    return textFromContent(payload.message);
+}
+function turnFromRolloutRecord(record) {
+    const payload = asRecord(record.payload);
+    if (!payload || typeof payload.type !== "string") {
+        return undefined;
+    }
+    const timestamp = parseDate(record.timestamp);
+    if (payload.type === "user_message") {
+        const text = textFromUserMessage(payload);
+        return text.length === 0
+            ? undefined
+            : {
+                role: "human",
+                text,
+                ...(timestamp ? { timestamp } : {}),
+                sourceKind: "user_message"
+            };
+    }
+    if (payload.type === "message") {
+        const text = textFromContent(payload.content);
+        if (text.length === 0) {
+            return undefined;
+        }
+        const role = payload.role === "user" ? "human" : payload.role === "assistant" ? "assistant" : "tool";
+        return {
+            role,
+            text,
+            ...(timestamp ? { timestamp } : {}),
+            sourceKind: "message"
+        };
+    }
+    return undefined;
+}
+async function readRollout(filePath, fs) {
+    const content = await fs.readFile(filePath, "utf8");
+    return parseJsonLines(content)
+        .map(asRecord)
+        .filter((record) => record !== undefined)
+        .map(turnFromRolloutRecord)
+        .filter((turn) => turn !== undefined);
+}
+function referenceFromRow(row) {
+    const createdAt = dateFromRow(row.created_at, row.created_at_ms);
+    const updatedAt = dateFromRow(row.updated_at, row.updated_at_ms);
+    return {
+        source: "codex",
+        id: row.id,
+        ...(row.rollout_path ? { path: row.rollout_path } : {}),
+        ...(row.cwd ? { cwd: row.cwd } : {}),
+        ...(updatedAt ? { updatedAt } : {}),
+        ...(row.title ? { title: row.title } : {}),
+        metadata: {
+            ...(createdAt ? { createdAt } : {}),
+            ...(updatedAt ? { updatedAt } : {}),
+            ...(row.first_user_message ? { firstUserMessage: row.first_user_message } : {}),
+            ...(row.model ? { model: row.model } : {}),
+            ...(row.source ? { source: row.source } : {})
+        }
+    };
+}
+function fallbackTurn(reference) {
+    const firstUserMessage = reference.metadata?.firstUserMessage;
+    if (typeof firstUserMessage !== "string" || firstUserMessage.trim().length === 0) {
+        return [];
+    }
+    const createdAt = reference.metadata?.createdAt;
+    return [
+        {
+            role: "human",
+            text: firstUserMessage.trim(),
+            ...(createdAt instanceof Date ? { timestamp: createdAt } : {}),
+            sourceKind: "first_user_message"
+        }
+    ];
+}
+export const codexTraceReader = {
+    id: "codex",
+    defaultRoots(homeDir) {
+        return [path.join(homeDir, ".codex", "state_5.sqlite")];
+    },
+    async discover(options) {
+        const databasePath = path.join(options.homeDir, ".codex", "state_5.sqlite");
+        const sqlite = options.sqlite ?? defaultSqliteFactory;
+        let db;
+        try {
+            db = await sqlite(databasePath);
+        }
+        catch (error) {
+            if (isMissingFile(error)) {
+                return [];
+            }
+            throw error;
+        }
+        try {
+            const sinceSeconds = options.since ? Math.floor(options.since.getTime() / 1_000) : null;
+            const sql = [
+                "SELECT id, rollout_path, created_at, updated_at, created_at_ms, updated_at_ms, source, model, cwd, title, first_user_message",
+                "FROM threads",
+                options.allWorkspaces || !options.cwd
+                    ? sinceSeconds === null
+                        ? ""
+                        : "WHERE updated_at >= ? OR updated_at_ms >= ?"
+                    : "WHERE cwd = ? AND (? IS NULL OR updated_at >= ? OR updated_at_ms >= ?)",
+                "ORDER BY updated_at DESC"
+            ]
+                .filter((part) => part.length > 0)
+                .join(" ");
+            const params = options.allWorkspaces || !options.cwd
+                ? sinceSeconds === null
+                    ? []
+                    : [sinceSeconds, sinceSeconds * 1_000]
+                : [
+                    options.cwd,
+                    sinceSeconds,
+                    sinceSeconds,
+                    sinceSeconds === null ? null : sinceSeconds * 1_000
+                ];
+            const rows = (await db.all(sql, params))
+                .map(rowFromUnknown)
+                .filter((row) => row !== undefined);
+            return rows.map(referenceFromRow);
+        }
+        finally {
+            await db.close();
+        }
+    },
+    async read(reference, options) {
+        const createdAt = reference.metadata?.createdAt;
+        const updatedAt = reference.metadata?.updatedAt;
+        let turns = [];
+        if (reference.path) {
+            try {
+                turns = await readRollout(reference.path, options.fs);
+            }
+            catch (error) {
+                if (!isMissingFile(error)) {
+                    throw error;
+                }
+            }
+        }
+        if (turns.length === 0) {
+            turns = fallbackTurn(reference);
+        }
+        const turnUpdatedAt = turns.reduce((latest, turn) => newestDate(latest, turn.timestamp), undefined);
+        return {
+            source: "codex",
+            id: reference.id,
+            ...(reference.path ? { path: reference.path } : {}),
+            ...(reference.cwd ? { cwd: reference.cwd } : {}),
+            ...(reference.title ? { title: reference.title } : {}),
+            ...(createdAt instanceof Date ? { createdAt } : {}),
+            ...(updatedAt instanceof Date
+                ? { updatedAt }
+                : turnUpdatedAt
+                    ? { updatedAt: turnUpdatedAt }
+                    : {}),
+            turns
+        };
+    }
+};

package/packages/agent-traces/dist/readers/index.d.ts

@@ -0,0 +1,5 @@
+import { claudeTraceReader } from "./claude.js";
+import { codexTraceReader } from "./codex.js";
+import type { TraceReader } from "../types.js";
+export declare const traceReaders: TraceReader[];
+export { claudeTraceReader, codexTraceReader };

package/packages/agent-traces/dist/readers/index.js

@@ -0,0 +1,4 @@
+import { claudeTraceReader } from "./claude.js";
+import { codexTraceReader } from "./codex.js";
+export const traceReaders = [claudeTraceReader, codexTraceReader];
+export { claudeTraceReader, codexTraceReader };