poe-code 4.0.31-beta.1 → 4.0.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "4.0.31-beta.1",
+  "version": "4.0.32",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "license": "MIT",
   "type": "module",

package/packages/agent-trace-viewer/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { detectTraceFile, listTraces, loadSubagentSummaries, loadTrace, loadTraceFromFile, loadTraceTree } from "./loader.js";
+export { defaultTraceIndexDir, detectTraceFile, listTraces, loadSubagentSummaries, loadTrace, loadTraceFromFile, loadTraceTree } from "./loader.js";
 export { computeContextBreakdown } from "./breakdown.js";
 export { CONTEXT_WINDOWS, DEFAULT_CONTEXT_WINDOW } from "./context.js";
 export { renderBreakdown, renderContextGauge, renderSubagents, renderTraceDetail, renderTraceLine } from "./render.js";
@@ -10,5 +10,5 @@ export { openTraceHtml } from "./open-html.js";
 export type { OpenTraceHtmlOptions } from "./open-html.js";
 export { runTraceViewer } from "./run.js";
 export type { RunTraceViewerOptions } from "./run.js";
-export type { ContextBreakdown, ContextBreakdownCategory, ContextBreakdownItem, ContextUsage, ListTracesOptions, LoadTraceOptions, LoadTraceTreeOptions, SubagentSummary, TraceTreeNode, TraceView } from "./types.js";
+export type { ContextBreakdown, ContextBreakdownCategory, ContextBreakdownItem, ContextUsage, ListTracesOptions, LoadTraceOptions, LoadTraceTreeOptions, SubagentSummary, TraceIndexMode, TraceTreeNode, TraceView } from "./types.js";
 export type { AgentTraceFileSystem, AgentTraceSource, NormalizedTrace, NormalizedTraceTurn, SqliteTraceDatabase, SqliteTraceDatabaseFactory, TraceReference, TraceUsage } from "../../agent-traces/dist/index.js";

package/packages/agent-trace-viewer/dist/index.js

@@ -1,4 +1,4 @@
-export { detectTraceFile, listTraces, loadSubagentSummaries, loadTrace, loadTraceFromFile, loadTraceTree } from "./loader.js";
+export { defaultTraceIndexDir, detectTraceFile, listTraces, loadSubagentSummaries, loadTrace, loadTraceFromFile, loadTraceTree } from "./loader.js";
 export { computeContextBreakdown } from "./breakdown.js";
 export { CONTEXT_WINDOWS, DEFAULT_CONTEXT_WINDOW } from "./context.js";
 export { renderBreakdown, renderContextGauge, renderSubagents, renderTraceDetail, renderTraceLine } from "./render.js";

package/packages/agent-trace-viewer/dist/loader.d.ts

@@ -1,5 +1,6 @@
 import { type AgentTraceSource, type TraceReference } from "../../agent-traces/dist/index.js";
 import type { ListTracesOptions, LoadTraceOptions, LoadTraceTreeOptions, SubagentSummary, TraceTreeNode, TraceView } from "./types.js";
+export declare function defaultTraceIndexDir(): string;
 export declare function listTraces(options: ListTracesOptions): Promise<TraceReference[]>;
 export declare function loadTrace(reference: TraceReference, options: LoadTraceOptions): Promise<TraceView>;
 export declare function loadSubagentSummaries(view: TraceView, options: LoadTraceOptions): Promise<SubagentSummary[]>;

package/packages/agent-trace-viewer/dist/loader.js

@@ -1,14 +1,16 @@
-import { traceReaders } from "@poe-code/agent-traces";
+import path from "node:path";
+import { openTraceIndex, traceReaders } from "@poe-code/agent-traces";
+import { resolveCacheDir } from "@poe-code/cached-resource";
 import { UserError } from "@poe-code/user-error";
 import { computeContextBreakdown } from "./breakdown.js";
 import { computeContextUsage } from "./context.js";
 import { defaultTraceTokenCacheDir, readCachedBreakdown, traceFileIdentity, writeCachedBreakdown } from "./token-cache.js";
 const DEFAULT_TREE_MAX_DEPTH = 8;
 const DEFAULT_TREE_MAX_NODES = 50;
-export async function listTraces(options) {
-    const readers = options.sources === undefined
-        ? traceReaders
-        : traceReaders.filter((reader) => options.sources?.includes(reader.id) ?? false);
+export function defaultTraceIndexDir() {
+    return path.join(resolveCacheDir("poe-code"), "trace-index");
+}
+async function discoverWithReaders(readers, options) {
     const discovered = [];
     for (const reader of readers) {
         try {
@@ -25,9 +27,91 @@ export async function listTraces(options) {
             // Trace backends are optional; missing local stores should not hide other sources.
         }
     }
-    const sorted = discovered.sort((left, right) => dateValue(right.updatedAt) - dateValue(left.updatedAt));
+    return discovered;
+}
+function assembleReferences(options, ...groups) {
+    const sorted = groups
+        .flat()
+        .sort((left, right) => dateValue(right.updatedAt) - dateValue(left.updatedAt));
     return sorted.slice(0, options.limit ?? 50);
 }
+function isIndexable(reader) {
+    return reader.scan !== undefined && reader.readHeadMetadata !== undefined;
+}
+export async function listTraces(options) {
+    const readers = options.sources === undefined
+        ? traceReaders
+        : traceReaders.filter((reader) => options.sources?.includes(reader.id) ?? false);
+    const mode = options.index ?? "off";
+    const indexable = readers.filter(isIndexable);
+    let index;
+    if (mode !== "off" && indexable.length > 0) {
+        try {
+            index = await openTraceIndex({
+                dir: options.indexDir ?? defaultTraceIndexDir(),
+                fs: options.fs
+            });
+        }
+        catch {
+            // An unusable index cache falls back to direct discovery.
+        }
+    }
+    if (index === undefined) {
+        const references = assembleReferences(options, await discoverWithReaders(readers, options));
+        if (mode === "background") {
+            queueMicrotask(() => options.onIndexUpdate?.(references));
+        }
+        return references;
+    }
+    const direct = readers.filter((reader) => !isIndexable(reader));
+    const runSync = async () => {
+        const syncOptions = {
+            readers: indexable,
+            homeDir: options.homeDir,
+            ...(options.onIndexProgress ? { onProgress: options.onIndexProgress } : {})
+        };
+        if (options.rebuildIndex === true) {
+            await index.rebuild(syncOptions);
+        }
+        else {
+            await index.sync(syncOptions);
+        }
+    };
+    const queryIndexed = () => index
+        .query({
+        cwd: options.cwd,
+        allWorkspaces: options.allWorkspaces,
+        since: options.since,
+        sources: indexable.map((reader) => reader.id),
+        limit: options.limit ?? 50
+    })
+        .catch(() => []);
+    if (mode === "sync") {
+        try {
+            await runSync();
+        }
+        catch {
+            return assembleReferences(options, await discoverWithReaders(readers, options));
+        }
+        const [indexed, directRefs] = await Promise.all([
+            queryIndexed(),
+            discoverWithReaders(direct, options)
+        ]);
+        return assembleReferences(options, indexed, directRefs);
+    }
+    const [indexed, directRefs] = await Promise.all([
+        queryIndexed(),
+        discoverWithReaders(direct, options)
+    ]);
+    const initial = assembleReferences(options, indexed, directRefs);
+    void runSync()
+        .then(async () => assembleReferences(options, await queryIndexed(), await discoverWithReaders(direct, options)))
+        .catch(() => initial)
+        .then((updated) => {
+        options.onIndexUpdate?.(updated);
+    });
+    return initial;
+}
 export async function loadTrace(reference, options) {
     const reader = traceReaders.find((candidate) => candidate.id === reference.source);
     if (reader === undefined) {

package/packages/agent-trace-viewer/dist/run.d.ts

@@ -16,6 +16,8 @@ export interface RunTraceViewerOptions {
     openExternal?: (target: string) => Promise<void>;
     tmpDir?: string;
     output?: WritableOutput;
+    indexDir?: string;
+    rebuildIndex?: boolean;
 }
 interface WritableOutput {
     write(chunk: string | Uint8Array): unknown;

package/packages/agent-trace-viewer/dist/run.js

@@ -29,21 +29,24 @@ export async function runTraceViewer(options) {
         writeLine(output, await renderTraceDetail(view, subagents));
         return;
     }
-    const discover = () => listTraces({
+    const listOptions = {
         cwd: options.cwd,
         homeDir: options.homeDir,
         fs: options.fs,
         sources: options.sources,
         allWorkspaces: options.allWorkspaces,
         since: options.since,
-        limit: options.limit ?? Number.POSITIVE_INFINITY
-    });
-    const references = await discover();
-    if (references.length === 0) {
-        writeLine(output, "No traces found");
-        return;
-    }
+        limit: options.limit ?? Number.POSITIVE_INFINITY,
+        ...(options.indexDir !== undefined ? { indexDir: options.indexDir } : {}),
+        ...(options.rebuildIndex === true ? { rebuildIndex: true } : {})
+    };
+    const discover = () => listTraces({ ...listOptions, index: "sync" });
     if (options.json || options.assumeYes || process.stdin.isTTY !== true) {
+        const references = await discover();
+        if (references.length === 0) {
+            writeLine(output, "No traces found");
+            return;
+        }
         if (options.json) {
             const listed = options.fullTitles === true ? references : references.map(withTruncatedTitle);
             writeLine(output, JSON.stringify(listed, null, 2));
@@ -52,9 +55,26 @@ export async function runTraceViewer(options) {
         writeLine(output, renderTraceReferenceTable(references));
         return;
     }
+    let resolveRevalidated;
+    const revalidated = new Promise((resolve) => {
+        resolveRevalidated = resolve;
+    });
+    const stale = await listTraces({
+        ...listOptions,
+        index: "background",
+        onIndexUpdate: resolveRevalidated
+    });
+    const references = stale.length > 0
+        ? stale
+        : await withSpinner({ message: "Indexing traces...", fn: async () => revalidated });
+    if (references.length === 0) {
+        writeLine(output, "No traces found");
+        return;
+    }
     await runExplorer(buildTraceExplorerConfig({
         title: "Agent traces",
         references,
+        ...(references === stale ? { revalidated } : {}),
         fs: options.fs,
         output,
         openExternal: options.openExternal,
@@ -116,8 +136,7 @@ function compactWhitespace(value) {
 }
 function buildTraceExplorerConfig(options) {
     const state = createExplorerState(options.references);
-    async function refresh() {
-        const references = await options.onRefresh();
+    function applyReferences(references) {
         const next = createExplorerState(references);
         state.references = next.references;
         state.rows = next.rows;
@@ -125,6 +144,18 @@ function buildTraceExplorerConfig(options) {
         state.childrenByRowId = next.childrenByRowId;
         state.detailByRowId = next.detailByRowId;
     }
+    async function refresh() {
+        applyReferences(await options.onRefresh());
+    }
+    let revalidation = options.revalidated;
+    async function rows() {
+        if (revalidation !== undefined) {
+            const pending = revalidation;
+            revalidation = undefined;
+            applyReferences(await pending);
+        }
+        return state.rows;
+    }
     const actions = [
         {
             id: "open",
@@ -228,8 +259,9 @@ function buildTraceExplorerConfig(options) {
     ];
     return normalizeExplorerConfig({
         title: options.title,
+        initialRows: state.rows,
         panes: [
-            { id: "traces", kind: "list", title: options.title, rows: async () => state.rows, emptyHint: "No traces found", multiSelect: false },
+            { id: "traces", kind: "list", title: options.title, rows, emptyHint: "No traces found", multiSelect: false },
             {
                 id: "preview",
                 kind: "detail",

package/packages/agent-trace-viewer/dist/types.d.ts

@@ -1,4 +1,5 @@
 import type { AgentTraceFileSystem, AgentTraceSource, NormalizedTrace, SqliteTraceDatabaseFactory, TraceReference } from "../../agent-traces/dist/index.js";
+export type TraceIndexMode = "sync" | "background" | "off";
 export interface ListTracesOptions {
     cwd: string;
     homeDir: string;
@@ -8,6 +9,14 @@ export interface ListTracesOptions {
     since?: Date;
     limit?: number;
     sqlite?: SqliteTraceDatabaseFactory;
+    index?: TraceIndexMode;
+    indexDir?: string;
+    rebuildIndex?: boolean;
+    onIndexProgress?: (progress: {
+        scannedDirs: number;
+        headReads: number;
+    }) => void;
+    onIndexUpdate?: (references: TraceReference[]) => void;
 }
 export interface LoadTraceOptions {
     fs: AgentTraceFileSystem;

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

@@ -1,5 +1,6 @@
 import { promises as nodeFs } from "node:fs";
 import os from "node:os";
+import { openTraceIndex } from "./index-store/store.js";
 import { traceReaders } from "./readers/index.js";
 const DEFAULT_SOURCES = traceReaders.map((reader) => reader.id);
 function compareRecordsNewestFirst(first, second) {
@@ -51,19 +52,46 @@ export async function collectHumanPromptsFromReaders(readers, options = {}) {
     const records = [];
     const seenRecords = new Set();
     let traceCount = 0;
+    let indexedReferences;
+    if (options.indexDir !== undefined) {
+        try {
+            const indexable = sources
+                .map((source) => readerById.get(source))
+                .filter((reader) => reader !== undefined &&
+                reader.scan !== undefined &&
+                reader.readHeadMetadata !== undefined);
+            const index = await openTraceIndex({ dir: options.indexDir, fs });
+            await index.sync({ readers: indexable, homeDir });
+            const references = await index.query({
+                cwd,
+                allWorkspaces: options.allWorkspaces,
+                since: options.since,
+                sources: indexable.map((reader) => reader.id),
+                limit: Number.POSITIVE_INFINITY
+            });
+            indexedReferences = new Map(indexable.map((reader) => [reader.id, []]));
+            for (const reference of references) {
+                indexedReferences.get(reference.source)?.push(reference);
+            }
+        }
+        catch {
+            indexedReferences = undefined;
+        }
+    }
     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
-        });
+        const references = indexedReferences?.get(source) ??
+            (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 });

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

@@ -0,0 +1 @@
+export declare function mapConcurrent<T, R>(items: readonly T[], limit: number, fn: (item: T, index: number) => Promise<R>): Promise<R[]>;

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

@@ -0,0 +1,16 @@
+export async function mapConcurrent(items, limit, fn) {
+    const results = new Array(items.length);
+    let next = 0;
+    const worker = async () => {
+        while (true) {
+            const index = next;
+            next += 1;
+            if (index >= items.length) {
+                return;
+            }
+            results[index] = await fn(items[index], index);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, worker));
+    return results;
+}

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

@@ -0,0 +1,3 @@
+import type { AgentTraceFileSystem } from "../types.js";
+export declare const DEFAULT_HEAD_BYTES = 65536;
+export declare function readHead(fs: AgentTraceFileSystem, filePath: string, maxBytes?: number): Promise<string>;

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

@@ -0,0 +1,19 @@
+export const DEFAULT_HEAD_BYTES = 65_536;
+function supportsOpen(fs) {
+    return typeof fs.open === "function";
+}
+export async function readHead(fs, filePath, maxBytes = DEFAULT_HEAD_BYTES) {
+    if (supportsOpen(fs)) {
+        const handle = await fs.open(filePath, "r");
+        try {
+            const buffer = Buffer.alloc(maxBytes);
+            const { bytesRead } = await handle.read(buffer, 0, maxBytes, 0);
+            return buffer.toString("utf8", 0, bytesRead);
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    const contents = await fs.readFile(filePath, "utf8");
+    return contents.length > maxBytes ? contents.slice(0, maxBytes) : contents;
+}

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

@@ -0,0 +1,45 @@
+import type { AgentTraceFileSystem, AgentTraceSource, TraceReader, TraceReference } from "../types.js";
+export interface TraceIndexRecord {
+    path: string;
+    source: AgentTraceSource;
+    id: string;
+    cwd?: string;
+    title?: string;
+    metadata?: Record<string, unknown>;
+    updatedAtMs: number;
+    mtimeMs: number;
+    size: number;
+}
+export interface TraceIndexSyncOptions {
+    readers: TraceReader[];
+    homeDir: string;
+    now?: () => number;
+    onProgress?: (progress: {
+        scannedDirs: number;
+        headReads: number;
+    }) => void;
+}
+export interface TraceIndexSyncStats {
+    scannedDirs: number;
+    statted: number;
+    headReads: number;
+    added: number;
+    updated: number;
+    removed: number;
+}
+export interface TraceIndexQueryOptions {
+    cwd?: string;
+    allWorkspaces?: boolean;
+    since?: Date;
+    sources?: AgentTraceSource[];
+    limit: number;
+}
+export interface TraceIndex {
+    sync(options: TraceIndexSyncOptions): Promise<TraceIndexSyncStats>;
+    query(options: TraceIndexQueryOptions): Promise<TraceReference[]>;
+    rebuild(options: TraceIndexSyncOptions): Promise<TraceIndexSyncStats>;
+}
+export declare function openTraceIndex(options: {
+    dir: string;
+    fs: AgentTraceFileSystem;
+}): Promise<TraceIndex>;