voratiq 0.1.0-beta.2 → 0.1.0-beta.21

package/dist/workspace/chat/native-usage.d.ts

@@ -0,0 +1,13 @@
+import type { TokenUsageResult } from "./token-usage-result.js";
+import type { ChatArtifactFormat } from "./types.js";
+export declare function extractProviderNativeTokenUsageForSession(options: {
+    root: string;
+    domain: string;
+    sessionId: string;
+    agentId: string;
+    provider: string;
+    modelId: string;
+    chatCaptured: boolean;
+    format?: ChatArtifactFormat;
+    artifactPath?: string;
+}): Promise<TokenUsageResult>;

package/dist/workspace/chat/native-usage.js

@@ -0,0 +1,60 @@
+import { resolvePath } from "../../utils/path.js";
+import { getAgentSessionChatArtifactPath } from "../structure.js";
+import { extractChatUsageFromArtifact } from "./usage-extractor.js";
+export async function extractProviderNativeTokenUsageForSession(options) {
+    const { root, domain, sessionId, agentId, provider, modelId, chatCaptured, format, artifactPath, } = options;
+    if (!chatCaptured || !format) {
+        return {
+            status: "unavailable",
+            reason: "chat_not_captured",
+            provider,
+            modelId,
+            artifactPath,
+            format,
+            message: "Chat usage capture was not enabled or did not produce an artifact.",
+        };
+    }
+    const providerId = toChatUsageProviderId(provider);
+    if (!providerId) {
+        return {
+            status: "unavailable",
+            reason: "unsupported_provider",
+            provider,
+            modelId,
+            artifactPath,
+            format,
+            message: `Usage extraction is not implemented for provider \`${provider}\` yet.`,
+        };
+    }
+    const resolvedArtifactPath = artifactPath ??
+        resolvePath(root, getAgentSessionChatArtifactPath(domain, sessionId, agentId, format));
+    try {
+        return await extractChatUsageFromArtifact({
+            artifactPath: resolvedArtifactPath,
+            format,
+            providerId,
+            modelId,
+        });
+    }
+    catch (error) {
+        return {
+            status: "unavailable",
+            reason: "extractor_error",
+            provider,
+            modelId,
+            artifactPath: resolvedArtifactPath,
+            format,
+            message: `Chat usage extraction failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+function toChatUsageProviderId(value) {
+    switch (value) {
+        case "claude":
+        case "codex":
+        case "gemini":
+            return value;
+        default:
+            return undefined;
+    }
+}

package/dist/workspace/chat/sources.d.ts

@@ -1,5 +1,9 @@
-export type TranscriptLocator = (agentRoot: string) => Promise<readonly string[]>;
-export declare function findProviderTranscripts(providerId: string, agentRoot: string): Promise<readonly string[]>;
-export declare function findClaudeTranscripts(agentRoot: string): Promise<readonly string[]>;
-export declare function findCodexTranscripts(agentRoot: string): Promise<readonly string[]>;
-export declare function findGeminiTranscripts(agentRoot: string): Promise<readonly string[]>;
+export interface ProviderTranscriptSearchOptions {
+    agentRoot: string;
+    env?: NodeJS.ProcessEnv;
+}
+export type TranscriptLocator = (options: ProviderTranscriptSearchOptions) => Promise<readonly string[]>;
+export declare function findProviderTranscripts(providerId: string, options: ProviderTranscriptSearchOptions): Promise<readonly string[]>;
+export declare function findClaudeTranscripts(options: ProviderTranscriptSearchOptions): Promise<readonly string[]>;
+export declare function findCodexTranscripts(options: ProviderTranscriptSearchOptions): Promise<readonly string[]>;
+export declare function findGeminiTranscripts(options: ProviderTranscriptSearchOptions): Promise<readonly string[]>;

package/dist/workspace/chat/sources.js

@@ -1,5 +1,5 @@
 import { readdir } from "node:fs/promises";
-import { resolve as resolvePath } from "node:path";
+import { isAbsolute, resolve as resolvePath } from "node:path";
 import { isMissing } from "../../utils/fs.js";
 import { SANDBOX_DIRNAME } from "../structure.js";
 const locatorMap = {
@@ -7,44 +7,110 @@ const locatorMap = {
     codex: findCodexTranscripts,
     gemini: findGeminiTranscripts,
 };
-export async function findProviderTranscripts(providerId, agentRoot) {
+export async function findProviderTranscripts(providerId, options) {
     const locator = locatorMap[providerId];
     if (!locator) {
         return [];
     }
-    return locator(agentRoot);
+    return locator(options);
 }
-export async function findClaudeTranscripts(agentRoot) {
-    const projectsRoot = resolveSandboxPath(agentRoot, ".claude", "projects");
-    return collectFiles(projectsRoot, {
+export async function findClaudeTranscripts(options) {
+    return await collectFilesFromRoots(resolveClaudeTranscriptRoots(options), {
         extensions: [".jsonl"],
         maxDepth: 2,
     });
 }
-export async function findCodexTranscripts(agentRoot) {
-    const sessionsRoot = resolveSandboxPath(agentRoot, ".codex", "sessions");
-    return collectFiles(sessionsRoot, { extensions: [".jsonl"], maxDepth: 6 });
+export async function findCodexTranscripts(options) {
+    return await collectFilesFromRoots(resolveCodexTranscriptRoots(options), {
+        extensions: [".jsonl"],
+        maxDepth: 6,
+    });
 }
-export async function findGeminiTranscripts(agentRoot) {
-    const tmpRoot = resolveSandboxPath(agentRoot, ".gemini", "tmp");
-    const entries = await safeReadDir(tmpRoot);
-    const transcripts = [];
-    for (const entry of entries) {
-        if (!entry.isDirectory()) {
-            continue;
+export async function findGeminiTranscripts(options) {
+    const transcripts = new Set();
+    for (const tmpRoot of resolveGeminiTranscriptRoots(options)) {
+        const entries = await safeReadDir(tmpRoot);
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            const chatsDir = resolvePath(tmpRoot, entry.name, "chats");
+            const chatFiles = await collectFiles(chatsDir, {
+                extensions: [".json", ".jsonl"],
+                maxDepth: 1,
+            });
+            for (const file of chatFiles) {
+                transcripts.add(file);
+            }
         }
-        const chatsDir = resolvePath(tmpRoot, entry.name, "chats");
-        const chatFiles = await collectFiles(chatsDir, {
-            extensions: [".json", ".jsonl"],
-            maxDepth: 1,
-        });
-        transcripts.push(...chatFiles);
     }
-    return transcripts.sort();
+    return [...transcripts].sort();
 }
 function resolveSandboxPath(agentRoot, ...segments) {
     return resolvePath(agentRoot, SANDBOX_DIRNAME, ...segments);
 }
+function resolveCodexTranscriptRoots(options) {
+    return resolveTranscriptRoots(options, {
+        sandboxSegments: [".codex", "sessions"],
+        envVar: "CODEX_HOME",
+        defaultSubdir: ".codex",
+        suffix: ["sessions"],
+    });
+}
+function resolveClaudeTranscriptRoots(options) {
+    return resolveTranscriptRoots(options, {
+        sandboxSegments: [".claude", "projects"],
+        envVar: "CLAUDE_CONFIG_DIR",
+        defaultSubdir: ".claude",
+        suffix: ["projects"],
+    });
+}
+function resolveGeminiTranscriptRoots(options) {
+    return resolveTranscriptRoots(options, {
+        sandboxSegments: [".gemini", "tmp"],
+        defaultSubdir: ".gemini",
+        suffix: ["tmp"],
+    });
+}
+function resolveTranscriptRoots(options, config) {
+    const roots = new Set();
+    roots.add(resolveSandboxPath(options.agentRoot, ...config.sandboxSegments));
+    if (options.env) {
+        const ambientRoot = resolveAmbientProviderRoot(options.env, {
+            envVar: config.envVar,
+            defaultSubdir: config.defaultSubdir,
+        });
+        if (ambientRoot) {
+            roots.add(resolvePath(ambientRoot, ...config.suffix));
+        }
+    }
+    return [...roots];
+}
+function resolveAmbientProviderRoot(env, config) {
+    const configured = config.envVar ? env[config.envVar]?.trim() : undefined;
+    const home = env.HOME?.trim();
+    if (configured) {
+        return isAbsolute(configured)
+            ? configured
+            : home
+                ? resolvePath(home, configured)
+                : resolvePath(process.cwd(), configured);
+    }
+    if (!home) {
+        return undefined;
+    }
+    return resolvePath(home, config.defaultSubdir);
+}
+async function collectFilesFromRoots(roots, options) {
+    const results = new Set();
+    for (const root of roots) {
+        const files = await collectFiles(root, options);
+        for (const file of files) {
+            results.add(file);
+        }
+    }
+    return [...results].sort();
+}
 async function collectFiles(root, { extensions, maxDepth = Number.POSITIVE_INFINITY }) {
     const results = [];
     await traverse(root, 0);

package/dist/workspace/chat/token-usage-result.d.ts

@@ -0,0 +1,23 @@
+import type { ExtractedTokenUsage } from "../../domain/run/model/types.js";
+import type { ChatArtifactFormat } from "./types.js";
+export declare const TOKEN_USAGE_UNAVAILABLE_REASONS: readonly ["chat_not_captured", "missing", "malformed", "unsupported_provider", "extractor_error"];
+export type TokenUsageUnavailableReason = (typeof TOKEN_USAGE_UNAVAILABLE_REASONS)[number];
+interface TokenUsageResultBase {
+    provider: string;
+    modelId: string;
+    artifactPath?: string;
+    format?: ChatArtifactFormat;
+    message?: string;
+}
+export interface AvailableTokenUsageResult extends TokenUsageResultBase {
+    status: "available";
+    tokenUsage: ExtractedTokenUsage;
+    reason?: undefined;
+}
+export interface UnavailableTokenUsageResult extends TokenUsageResultBase {
+    status: "unavailable";
+    reason: TokenUsageUnavailableReason;
+    tokenUsage?: undefined;
+}
+export type TokenUsageResult = AvailableTokenUsageResult | UnavailableTokenUsageResult;
+export {};

package/dist/workspace/chat/token-usage-result.js

@@ -0,0 +1,7 @@
+export const TOKEN_USAGE_UNAVAILABLE_REASONS = [
+    "chat_not_captured",
+    "missing",
+    "malformed",
+    "unsupported_provider",
+    "extractor_error",
+];

package/dist/workspace/chat/usage-extractor.d.ts

@@ -0,0 +1,30 @@
+import type { ChatUsageProviderId } from "../../domain/run/model/types.js";
+import type { TokenUsageResult } from "./token-usage-result.js";
+import type { ChatArtifactFormat } from "./types.js";
+export interface ExtractChatUsageArtifactOptions {
+    artifactPath: string;
+    format: ChatArtifactFormat;
+    providerId: ChatUsageProviderId;
+    modelId: string;
+}
+export type ChatUsageExtractionResult = TokenUsageResult;
+interface ExtractCodexChatUsageFromJsonlOptions {
+    artifactPath: string;
+    content: string;
+    modelId: string;
+}
+interface ExtractClaudeChatUsageFromJsonlOptions {
+    artifactPath: string;
+    content: string;
+    modelId: string;
+}
+interface ExtractGeminiChatUsageFromJsonOptions {
+    artifactPath: string;
+    content: string;
+    modelId: string;
+}
+export declare function extractChatUsageFromArtifact(options: ExtractChatUsageArtifactOptions): Promise<ChatUsageExtractionResult>;
+export declare function extractCodexChatUsageFromJsonl(options: ExtractCodexChatUsageFromJsonlOptions): ChatUsageExtractionResult;
+export declare function extractClaudeChatUsageFromJsonl(options: ExtractClaudeChatUsageFromJsonlOptions): ChatUsageExtractionResult;
+export declare function extractGeminiChatUsageFromJson(options: ExtractGeminiChatUsageFromJsonOptions): ChatUsageExtractionResult;
+export {};