archbyte 0.6.0 → 0.7.0

package/dist/agents/observability/adapters/archbyte.d.ts

@@ -0,0 +1,3 @@
+import type { AgentSession } from "../types.js";
+/** Import a .archbyte/ directory into AgentSession(s) */
+export declare function importArchbyte(archbyteDir: string): Promise<AgentSession[]>;

package/dist/agents/observability/adapters/archbyte.js

@@ -0,0 +1,104 @@
+// Archbyte Adapter — reads .archbyte/runs/ + session.json + metadata.json
+// Converts archbyte pipeline run data into AgentSession for the Sessions panel
+import { readFile, readdir } from "fs/promises";
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+/** Read a text file if it exists, return null otherwise */
+async function readOptional(filePath) {
+    if (!existsSync(filePath))
+        return null;
+    try {
+        return await readFile(filePath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+/** Read and parse a JSON file, return null on failure */
+function readJsonSync(filePath) {
+    if (!existsSync(filePath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+/** Import a .archbyte/ directory into AgentSession(s) */
+export async function importArchbyte(archbyteDir) {
+    const runsDir = path.join(archbyteDir, "runs");
+    if (!existsSync(runsDir))
+        return [];
+    // Read run subdirectories
+    let entries;
+    try {
+        const dirEntries = await readdir(runsDir, { withFileTypes: true });
+        entries = dirEntries.filter(e => e.isDirectory()).map(e => e.name).sort();
+    }
+    catch {
+        return [];
+    }
+    if (entries.length === 0)
+        return [];
+    // Read session.json for session-level metadata
+    const session = readJsonSync(path.join(archbyteDir, "session.json"));
+    const metadata = readJsonSync(path.join(archbyteDir, "metadata.json"));
+    const sessionId = session?.sessionId ?? `archbyte-${path.basename(path.dirname(archbyteDir))}`;
+    // Build runs from subdirectories
+    const runs = [];
+    for (const dirName of entries) {
+        const runPath = path.join(runsDir, dirName);
+        const meta = readJsonSync(path.join(runPath, "meta.json"));
+        if (!meta)
+            continue;
+        const prompt = await readOptional(path.join(runPath, "prompt.md"));
+        const output = await readOptional(path.join(runPath, "output.md"));
+        runs.push({
+            ...meta,
+            artifacts: {
+                ...(prompt ? { prompt } : {}),
+                ...(output ? { output } : {}),
+            },
+        });
+    }
+    if (runs.length === 0)
+        return [];
+    // Derive session summary
+    const totalElapsed = session?.totalElapsedSeconds ?? runs.reduce((s, r) => s + (r.elapsedSeconds ?? 0), 0);
+    const totalTokens = session?.totalTokens ?? {
+        input: runs.reduce((s, r) => s + (r.tokens?.input ?? 0), 0),
+        output: runs.reduce((s, r) => s + (r.tokens?.output ?? 0), 0),
+    };
+    const phases = [...new Set(runs.map(r => r.phase))];
+    const models = [...new Set(runs.map(r => r.model))];
+    const successfulRuns = runs.filter(r => r.status === "success").length;
+    const failedRuns = runs.filter(r => r.status === "error").length;
+    const skippedRuns = runs.filter(r => r.status === "skipped").length;
+    const firstRun = runs[0];
+    const lastRun = runs[runs.length - 1];
+    const startedAt = session?.startedAt ?? firstRun.startedAt;
+    const completedAt = session?.completedAt ?? lastRun.completedAt ?? lastRun.startedAt;
+    const status = failedRuns > 0 ? "partial" : "success";
+    return [{
+            sessionId,
+            startedAt,
+            completedAt,
+            status: session?.status ?? status,
+            source: "archbyte",
+            projectMeta: {
+                mode: session?.mode ?? metadata?.mode ?? "pipeline",
+            },
+            summary: {
+                totalRuns: runs.length,
+                successfulRuns,
+                failedRuns,
+                skippedRuns,
+                totalElapsedSeconds: totalElapsed,
+                totalTokens,
+                phases,
+                models,
+            },
+            runs,
+        }];
+}

package/dist/agents/observability/adapters/claude-transcripts.d.ts

@@ -0,0 +1,31 @@
+import type { AgentSession } from "../types.js";
+/** Invalidate cached index entries. Call with a path to invalidate one file, or no args to clear all. */
+export declare function invalidateIndexCache(filePath?: string): void;
+export declare function getClaudeProjectsDir(): string;
+export declare function encodeProjectPath(cwd: string): string;
+export declare function getProjectTranscriptDir(cwd: string): string | null;
+export type SessionCategory = "implementation" | "exploration" | "conversation" | "pipeline";
+export interface SessionIndexEntry {
+    sessionId: string;
+    startedAt: string;
+    completedAt?: string;
+    status: "success" | "partial";
+    runCount: number;
+    phases: string[];
+    source: string;
+    model?: string;
+    version?: string;
+    gitBranch?: string;
+    subagentCount?: number;
+    category?: SessionCategory;
+    label?: string;
+    touchedDirs?: string[];
+    eventCount?: number;
+    dirMetrics?: Record<string, {
+        reads: number;
+        writes: number;
+    }>;
+    estimatedCost?: number;
+}
+export declare function scanTranscriptIndex(projectDir: string): Promise<SessionIndexEntry[]>;
+export declare function importClaudeTranscript(projectDir: string, sessionId: string): Promise<AgentSession | null>;