@tracemarketplace/shared 0.0.8 → 0.0.9

package/src/redact.ts

@@ -5,33 +5,46 @@ export interface RedactOptions {
   homeDir?: string;
 }
 
+export interface RedactionStats {
+  changed: boolean;
+  homePathMatches: number;
+  secretMatches: number;
+  piiMatches: number;
+  totalMatches: number;
+}
+
+export interface RedactionResult {
+  trace: NormalizedTrace;
+  stats: RedactionStats;
+}
+
 // ─── Secret patterns ────────────────────────────────────────────────────────
 // Ordered from specific → generic to avoid partial matches being swallowed.
 
 const SECRET_PATTERNS: Array<{ re: RegExp; label: string }> = [
   // Anthropic
-  { re: /sk-ant-[a-zA-Z0-9\-_]{20,}/g,                          label: "ANTHROPIC_KEY" },
+  { re: /sk-ant-[a-zA-Z0-9\-_]{20,}/g, label: "ANTHROPIC_KEY" },
   // OpenAI (must come before generic sk- catch-all)
-  { re: /sk-proj-[a-zA-Z0-9\-_]{20,}/g,                         label: "OPENAI_KEY" },
-  { re: /sk-[a-zA-Z0-9]{20,}/g,                                  label: "OPENAI_KEY" },
+  { re: /sk-proj-[a-zA-Z0-9\-_]{20,}/g, label: "OPENAI_KEY" },
+  { re: /sk-[a-zA-Z0-9]{20,}/g, label: "OPENAI_KEY" },
   // AWS
-  { re: /AKIA[0-9A-Z]{16}/g,                                     label: "AWS_ACCESS_KEY" },
+  { re: /AKIA[0-9A-Z]{16}/g, label: "AWS_ACCESS_KEY" },
   { re: /(aws_secret_access_key\s*[=:]\s*)[A-Za-z0-9/+]{40}/gi, label: "AWS_SECRET_KEY" },
   // GitHub
-  { re: /github_pat_[a-zA-Z0-9_]{82}/g,                         label: "GITHUB_PAT" },
-  { re: /ghp_[a-zA-Z0-9]{36}/g,                                  label: "GITHUB_TOKEN" },
-  { re: /ghs_[a-zA-Z0-9]{36}/g,                                  label: "GITHUB_TOKEN" },
+  { re: /github_pat_[a-zA-Z0-9_]{82}/g, label: "GITHUB_PAT" },
+  { re: /ghp_[a-zA-Z0-9]{36}/g, label: "GITHUB_TOKEN" },
+  { re: /ghs_[a-zA-Z0-9]{36}/g, label: "GITHUB_TOKEN" },
   // Stripe
-  { re: /sk_live_[a-zA-Z0-9]{24,}/g,                             label: "STRIPE_SECRET_KEY" },
-  { re: /rk_live_[a-zA-Z0-9]{24,}/g,                             label: "STRIPE_RESTRICTED_KEY" },
+  { re: /sk_live_[a-zA-Z0-9]{24,}/g, label: "STRIPE_SECRET_KEY" },
+  { re: /rk_live_[a-zA-Z0-9]{24,}/g, label: "STRIPE_RESTRICTED_KEY" },
   // Resend
-  { re: /re_[a-zA-Z0-9]{32,}/g,                                  label: "RESEND_KEY" },
+  { re: /re_[a-zA-Z0-9]{32,}/g, label: "RESEND_KEY" },
   // JWTs — eyJ<base64>.<base64>.<base64>
   { re: /eyJ[a-zA-Z0-9\-_]+\.[a-zA-Z0-9\-_]+\.[a-zA-Z0-9\-_]*/g, label: "JWT" },
   // Bearer tokens in Authorization headers
-  { re: /(Bearer\s+)[a-zA-Z0-9\-._~+/]+=*/gi,                   label: "BEARER_TOKEN" },
+  { re: /(Bearer\s+)[a-zA-Z0-9\-._~+/]+=*/gi, label: "BEARER_TOKEN" },
   // Passwords in URLs:  https://user:PASSWORD@host
-  { re: /(https?:\/\/[^:@\s]+:)[^:@\s]+(@)/g,                   label: "URL_PASSWORD" },
+  { re: /(https?:\/\/[^:@\s]+:)[^:@\s]+(@)/g, label: "URL_PASSWORD" },
   // Database DSNs:  postgres://user:PASSWORD@host
   { re: /((?:postgres(?:ql)?|mysql|redis):\/\/[^:]+:)[^@\s]+(@)/g, label: "DB_PASSWORD" },
   // Generic key/secret assignments:  API_KEY=abc123...  or  secret: "abc123..."
@@ -41,63 +54,144 @@ const SECRET_PATTERNS: Array<{ re: RegExp; label: string }> = [
   },
 ];
 
+const EMPTY_STATS: RedactionStats = {
+  changed: false,
+  homePathMatches: 0,
+  secretMatches: 0,
+  piiMatches: 0,
+  totalMatches: 0,
+};
+
 // ─── Core string transforms ──────────────────────────────────────────────────
 
-function stripHome(s: string, home: string): string {
-  return home ? s.replaceAll(home, "~") : s;
+function stripHomeWithCount(s: string, home: string): { value: string; count: number } {
+  if (!home || !s.includes(home)) {
+    return { value: s, count: 0 };
+  }
+
+  return {
+    value: s.replaceAll(home, "~"),
+    count: s.split(home).length - 1,
+  };
 }
 
-function stripSecrets(s: string): string {
+function stripSecretsWithCount(s: string): { value: string; count: number } {
   let out = s;
+  let count = 0;
+
   for (const { re, label } of SECRET_PATTERNS) {
-    // Patterns with capture groups: preserve group 1 (key name), replace group 2 (value)
     if (re.source.includes("(")) {
       out = out.replace(re, (...args) => {
-        // Replace only the non-group parts; keep named prefixes intact
+        count++;
         const groups = args.slice(1, -2) as string[];
         if (groups.length === 1) return `${groups[0]}[${label}]`;
         if (groups.length === 2) return `${groups[0]}[${label}]${groups[1]}`;
         return `[${label}]`;
       });
     } else {
-      out = out.replace(re, `[${label}]`);
+      out = out.replace(re, () => {
+        count++;
+        return `[${label}]`;
+      });
     }
-    re.lastIndex = 0; // reset stateful global regexes
+    re.lastIndex = 0;
   }
-  return out;
+
+  return { value: out, count };
+}
+
+function redactStringWithStats(
+  s: string,
+  home: string
+): { value: string; stats: RedactionStats } {
+  const homeResult = stripHomeWithCount(s, home);
+  const secretResult = stripSecretsWithCount(homeResult.value);
+  const totalMatches = homeResult.count + secretResult.count;
+
+  return {
+    value: secretResult.value,
+    stats: {
+      changed: totalMatches > 0,
+      homePathMatches: homeResult.count,
+      secretMatches: secretResult.count,
+      piiMatches: 0,
+      totalMatches,
+    },
+  };
 }
 
-function redactString(s: string, home: string): string {
-  return stripSecrets(stripHome(s, home));
+function mergeStats(...stats: RedactionStats[]): RedactionStats {
+  return stats.reduce<RedactionStats>(
+    (acc, stat) => ({
+      changed: acc.changed || stat.changed,
+      homePathMatches: acc.homePathMatches + stat.homePathMatches,
+      secretMatches: acc.secretMatches + stat.secretMatches,
+      piiMatches: acc.piiMatches + stat.piiMatches,
+      totalMatches: acc.totalMatches + stat.totalMatches,
+    }),
+    EMPTY_STATS
+  );
 }
 
 // ─── Content block traversal ─────────────────────────────────────────────────
 
-function redactToolInput(input: Record<string, unknown>, home: string): Record<string, unknown> {
-  return Object.fromEntries(
-    Object.entries(input).map(([k, v]) => [
-      k,
-      typeof v === "string" ? redactString(v, home) : v,
-    ])
-  );
+function redactUnknown(value: unknown, home: string): { value: unknown; stats: RedactionStats } {
+  if (typeof value === "string") {
+    return redactStringWithStats(value, home);
+  }
+
+  if (Array.isArray(value)) {
+    const items = value.map((item) => redactUnknown(item, home));
+    return {
+      value: items.map((item) => item.value),
+      stats: mergeStats(...items.map((item) => item.stats)),
+    };
+  }
+
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value as Record<string, unknown>).map(([key, entryValue]) => {
+      const result = redactUnknown(entryValue, home);
+      return { key, ...result };
+    });
+
+    return {
+      value: Object.fromEntries(entries.map(({ key, value: entryValue }) => [key, entryValue])),
+      stats: mergeStats(...entries.map((entry) => entry.stats)),
+    };
+  }
+
+  return { value, stats: EMPTY_STATS };
 }
 
-function redactBlock(block: ContentBlock, home: string): ContentBlock {
+function redactBlock(
+  block: ContentBlock,
+  home: string
+): { block: ContentBlock; stats: RedactionStats } {
   switch (block.type) {
     case "text":
-    case "thinking":
-      return { ...block, text: redactString(block.text, home) };
-    case "tool_use":
-      return { ...block, tool_input: redactToolInput(block.tool_input, home) };
-    case "tool_result":
+    case "thinking": {
+      const result = redactStringWithStats(block.text, home);
+      return { block: { ...block, text: result.value }, stats: result.stats };
+    }
+    case "tool_use": {
+      const result = redactUnknown(block.tool_input, home);
+      return {
+        block: { ...block, tool_input: result.value as Record<string, unknown> },
+        stats: result.stats,
+      };
+    }
+    case "tool_result": {
+      if (!block.result_content) {
+        return { block, stats: EMPTY_STATS };
+      }
+      const result = redactStringWithStats(block.result_content, home);
       return {
-        ...block,
-        result_content: block.result_content
-          ? redactString(block.result_content, home)
-          : null,
+        block: { ...block, result_content: result.value },
+        stats: result.stats,
       };
+    }
     default:
-      return block;
+      return { block, stats: EMPTY_STATS };
   }
 }
 
@@ -113,26 +207,49 @@ export function redactTrace(
   trace: NormalizedTrace,
   opts: RedactOptions = {}
 ): NormalizedTrace {
+  return redactTraceWithStats(trace, opts).trace;
+}
+
+export function redactTraceWithStats(
+  trace: NormalizedTrace,
+  opts: RedactOptions = {}
+): RedactionResult {
   const home = opts.homeDir ?? "";
 
-  return {
-    ...trace,
-    turns: trace.turns.map(
-      (turn): Turn => ({
+  const turnResults = trace.turns.map((turn) => {
+    const blockResults = turn.content.map((block) => redactBlock(block, home));
+    return {
+      turn: {
         ...turn,
-        content: turn.content.map((b) => redactBlock(b, home)),
-      })
-    ),
-    env_state: trace.env_state
-      ? {
-          ...trace.env_state,
-          inferred_file_tree:
-            trace.env_state.inferred_file_tree?.map((p) => stripHome(p, home)) ?? null,
-          inferred_changed_files:
-            trace.env_state.inferred_changed_files?.map((p) => stripHome(p, home)) ?? null,
-          inferred_error_files:
-            trace.env_state.inferred_error_files?.map((p) => stripHome(p, home)) ?? null,
-        }
-      : null,
+        content: blockResults.map((result) => result.block),
+      } satisfies Turn,
+      stats: mergeStats(...blockResults.map((result) => result.stats)),
+    };
+  });
+
+  const envFileTree = trace.env_state?.inferred_file_tree?.map((path) => redactStringWithStats(path, home)) ?? [];
+  const envChangedFiles = trace.env_state?.inferred_changed_files?.map((path) => redactStringWithStats(path, home)) ?? [];
+  const envErrorFiles = trace.env_state?.inferred_error_files?.map((path) => redactStringWithStats(path, home)) ?? [];
+  const envStats = mergeStats(
+    ...envFileTree.map((entry) => entry.stats),
+    ...envChangedFiles.map((entry) => entry.stats),
+    ...envErrorFiles.map((entry) => entry.stats)
+  );
+
+  return {
+    trace: {
+      ...trace,
+      submitted_by: "[redacted]",
+      turns: turnResults.map((result) => result.turn),
+      env_state: trace.env_state
+        ? {
+            ...trace.env_state,
+            inferred_file_tree: envFileTree.map((entry) => entry.value) ?? null,
+            inferred_changed_files: envChangedFiles.map((entry) => entry.value) ?? null,
+            inferred_error_files: envErrorFiles.map((entry) => entry.value) ?? null,
+          }
+        : null,
+    },
+    stats: mergeStats(...turnResults.map((result) => result.stats), envStats),
   };
 }

package/src/turn-actors.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it } from "vitest";
+import type { Turn } from "./types.js";
+import { deriveTurnActors } from "./turn-actors.js";
+
+function makeTurn(overrides: Partial<Turn>): Turn {
+  return {
+    turn_id: "turn-" + Math.random().toString(36).slice(2),
+    parent_turn_id: null,
+    role: "user",
+    timestamp: null,
+    content: [],
+    model: null,
+    usage: null,
+    source_metadata: {},
+    ...overrides,
+  };
+}
+
+describe("deriveTurnActors", () => {
+  it("marks tool results and chained skill context as tool-authored", () => {
+    const assistantTool = makeTurn({
+      turn_id: "a1",
+      role: "assistant",
+      content: [{ type: "tool_use", tool_call_id: "skill-1", tool_name: "Skill", tool_input: {} }],
+    });
+    const toolResult = makeTurn({
+      turn_id: "u1",
+      parent_turn_id: "a1",
+      content: [{ type: "tool_result", tool_call_id: "skill-1", is_error: false, result_content: "Launching skill: trent-lazyvim", exit_code: null }],
+    });
+    const skillContext = makeTurn({
+      turn_id: "u2",
+      parent_turn_id: "u1",
+      content: [{ type: "text", text: "Base directory for this skill: ~/.claude/skills/trent-lazyvim" }],
+    });
+    const assistantReply = makeTurn({
+      turn_id: "a2",
+      role: "assistant",
+      parent_turn_id: "u2",
+      content: [{ type: "text", text: "Let me check the dependency versions." }],
+    });
+    const humanFollowUp = makeTurn({
+      turn_id: "u3",
+      parent_turn_id: "a2",
+      content: [{ type: "text", text: "that still did not fix it" }],
+    });
+
+    const actors = deriveTurnActors([
+      assistantTool,
+      toolResult,
+      skillContext,
+      assistantReply,
+      humanFollowUp,
+    ]);
+
+    expect(actors.a1).toBe("assistant");
+    expect(actors.u1).toBe("tool");
+    expect(actors.u2).toBe("tool");
+    expect(actors.u3).toBe("human");
+  });
+
+  it("respects a stored actor when one is already present", () => {
+    const turn = makeTurn({
+      turn_id: "u1",
+      actor: "tool",
+      content: [{ type: "text", text: "Base directory for this skill: ~/.claude/skills/example" }],
+    });
+
+    expect(deriveTurnActors([turn]).u1).toBe("tool");
+  });
+});

package/src/turn-actors.ts

@@ -0,0 +1,71 @@
+import type { Turn, TurnActor } from "./types.js";
+
+function hasToolResult(turn: Turn): boolean {
+  return turn.content.some((block) => block.type === "tool_result");
+}
+
+function hasToolUse(turn: Turn): boolean {
+  return turn.content.some((block) => block.type === "tool_use");
+}
+
+function getParentTurnId(turn: Turn): string | null {
+  if (turn.parent_turn_id) return turn.parent_turn_id;
+
+  const parentUuid = turn.source_metadata.parentUuid;
+  return typeof parentUuid === "string" && parentUuid ? parentUuid : null;
+}
+
+export function deriveTurnActors(turns: Turn[]): Record<string, TurnActor> {
+  const byId = new Map(turns.map((turn) => [turn.turn_id, turn]));
+  const actors = new Map<string, TurnActor>();
+
+  function resolve(turn: Turn, seen = new Set<string>()): TurnActor {
+    const cached = actors.get(turn.turn_id);
+    if (cached) return cached;
+
+    if (turn.actor) {
+      actors.set(turn.turn_id, turn.actor);
+      return turn.actor;
+    }
+
+    if (turn.role === "assistant") {
+      actors.set(turn.turn_id, "assistant");
+      return "assistant";
+    }
+
+    if (hasToolResult(turn)) {
+      actors.set(turn.turn_id, "tool");
+      return "tool";
+    }
+
+    const parentTurnId = getParentTurnId(turn);
+    if (!parentTurnId || seen.has(turn.turn_id)) {
+      actors.set(turn.turn_id, "human");
+      return "human";
+    }
+
+    const parent = byId.get(parentTurnId);
+    if (!parent) {
+      actors.set(turn.turn_id, "human");
+      return "human";
+    }
+
+    const nextSeen = new Set(seen);
+    nextSeen.add(turn.turn_id);
+
+    const parentActor = resolve(parent, nextSeen);
+    if (parentActor === "tool" || (parentActor === "assistant" && hasToolUse(parent))) {
+      actors.set(turn.turn_id, "tool");
+      return "tool";
+    }
+
+    actors.set(turn.turn_id, "human");
+    return "human";
+  }
+
+  for (const turn of turns) {
+    resolve(turn);
+  }
+
+  return Object.fromEntries(actors);
+}

package/src/types.ts

@@ -18,6 +18,8 @@ export interface TokenUsage {
   reasoning_tokens: number | null;
 }
 
+export type TurnActor = "human" | "assistant" | "tool";
+
 export type ContentBlock =
   | { type: "text"; text: string }
   | { type: "thinking"; text: string }
@@ -29,6 +31,7 @@ export interface Turn {
   turn_id: string;
   parent_turn_id: string | null;
   role: "user" | "assistant";
+  actor?: TurnActor;
   timestamp: string | null;
   content: ContentBlock[];
   model: string | null;
@@ -71,6 +74,9 @@ export interface NormalizedTrace {
   source_session_id: string;
   chunk_index?: number;        // 0-based chunk within the session (set by chunkTrace, default 0)
   chunk_start_turn?: number;   // turn offset in the original session (set by chunkTrace, default 0)
+  chunk_complete?: boolean;
+  chunk_close_reason?: "100k_tokens" | "idle_2d";
+  chunk_closed_at?: string | null;
   source_version: string | null;
   submitted_by: string;
   submitted_at: string;

package/src/validators.ts

@@ -7,6 +7,9 @@ export const NormalizedTraceSchema = z.object({
   source_session_id: z.string().min(1),
   chunk_index: z.number().int().nonnegative().default(0),
   chunk_start_turn: z.number().int().nonnegative().default(0),
+  chunk_complete: z.boolean().optional(),
+  chunk_close_reason: z.enum(["100k_tokens", "idle_2d"]).optional(),
+  chunk_closed_at: z.string().nullable().optional(),
   source_version: z.string().nullable().optional(),
   submitted_by: z.string().optional(),
   submitted_at: z.string().optional(),