logdig 0.1.1 → 0.1.2

package/src/transcript.js

@@ -1,4 +1,3 @@
-import { createHash } from "node:crypto";
 import path from "node:path";
 
 const READ_TOOLS = new Set([
@@ -45,12 +44,6 @@ export function sessionFromJsonl(text, sourcePath = "<session>") {
   return parseSessionJsonl(text, sourcePath);
 }
 
-export function fingerprintSession(session) {
-  return createHash("sha256")
-    .update(JSON.stringify([session.header, session.entries]))
-    .digest("hex");
-}
-
 export function textContent(content) {
   if (typeof content === "string") return content;
   if (!Array.isArray(content)) return "";
@@ -69,7 +62,7 @@ export function redactAndClip(value, maxLength = 1800) {
   return `${text.slice(0, maxLength)}\n[truncated]`;
 }
 
-function timestampOf(entry) {
+export function timestampOf(entry) {
   const value = entry.timestamp ?? entry.message?.timestamp;
   if (typeof value === "number") return value;
   if (typeof value === "string") {
@@ -121,8 +114,8 @@ export function sessionMetrics(session) {
   return metrics;
 }
 
-function localParts(timestamp, timeZone) {
-  const parts = new Intl.DateTimeFormat("en-CA", {
+export function localTimeFormatter(timeZone) {
+  return new Intl.DateTimeFormat("en-CA", {
     timeZone,
     year: "numeric",
     month: "2-digit",
@@ -130,7 +123,11 @@ function localParts(timestamp, timeZone) {
     hour: "2-digit",
     minute: "2-digit",
     hourCycle: "h23",
-  }).formatToParts(new Date(timestamp));
+  });
+}
+
+export function localParts(timestamp, formatter) {
+  const parts = formatter.formatToParts(new Date(timestamp));
   const values = Object.fromEntries(parts.map((part) => [part.type, part.value]));
   return {
     date: `${values.year}-${values.month}-${values.day}`,
@@ -172,10 +169,10 @@ function outputExcerpt(content, limit = 420) {
   return `${text.slice(0, half)}\n[…output clipped…]\n${text.slice(-half)}`;
 }
 
-function eventFor(entry, timeZone, toolCalls) {
+function eventFor(entry, formatter, toolCalls) {
   const timestamp = timestampOf(entry);
   if (timestamp === undefined) return undefined;
-  const { date, time } = localParts(timestamp, timeZone);
+  const { date, time } = localParts(timestamp, formatter);
   const message = entry.message;
 
   if (entry.type === "compaction" || entry.type === "branch_summary") {
@@ -251,14 +248,14 @@ function eventFor(entry, timeZone, toolCalls) {
   return undefined;
 }
 
-export function eventsForSession(session, timeZone) {
+export function eventsForSession(session, timeZone, extraction = { formatter: localTimeFormatter(timeZone), toolCalls: new Map() }) {
   const events = [];
-  const toolCalls = new Map();
+  const { formatter, toolCalls } = extraction;
   const cwd = session.header.cwd || "";
   const project = (cwd ? path.basename(cwd) : "").replace(/^\d{4}-\d{2}-\d{2}-(?=.)/, "") || "unknown project";
 
   for (const entry of session.entries) {
-    const generated = eventFor(entry, timeZone, toolCalls);
+    const generated = eventFor(entry, formatter, toolCalls);
     if (!generated) continue;
     for (const event of Array.isArray(generated) ? generated : [generated]) {
       events.push({

package/src/work-blocks.js

@@ -0,0 +1,99 @@
+import { createHash } from "node:crypto";
+import { eventsForSession, localParts, localTimeFormatter, timestampOf } from "./transcript.js";
+
+const CONTINUATION_GAP_MS = 4 * 60 * 60 * 1000;
+const CONTEXT_LIMIT = 3200;
+const CONTEXT_EVENTS = 6;
+const ACTIVITY_ROLES = new Set(["user", "assistant", "toolResult", "bashExecution"]);
+
+function precedingContext(events) {
+  const context = [];
+  let size = 0;
+  for (let index = events.length - 1; index >= 0 && context.length < CONTEXT_EVENTS; index--) {
+    const event = events[index];
+    const length = JSON.stringify(event).length;
+    if (size + length > CONTEXT_LIMIT) break;
+    context.unshift(event);
+    size += length;
+  }
+  return context;
+}
+
+export function workBlocksForSession(session, timeZone) {
+  const formatter = localTimeFormatter(timeZone);
+  const blocks = [];
+  let current;
+  let lastActivity;
+  let userIndex = 0;
+  const pending = [];
+
+  for (const entry of session.entries) {
+    const contextSummary = ["compaction", "branch_summary"].includes(entry.type) && typeof entry.summary === "string" && entry.summary.trim();
+    const activity = (entry.type === "message" && ACTIVITY_ROLES.has(entry.message?.role)) || contextSummary;
+    const timestamp = activity ? timestampOf(entry) : undefined;
+    if (timestamp !== undefined) {
+      const { date, time } = localParts(timestamp, formatter);
+      const user = entry.message?.role === "user";
+      if (user) userIndex++;
+      if (!current || (user && date > current.date && timestamp - lastActivity >= CONTINUATION_GAP_MS)) {
+        const blockId = createHash("sha256")
+          .update(JSON.stringify([session.header.id, entry.id || [timestamp, userIndex]]))
+          .digest("hex");
+        current = {
+          ...session,
+          header: blocks.length ? { ...session.header, timestamp: new Date(timestamp).toISOString() } : session.header,
+          entries: blocks.length ? [] : pending.splice(0),
+          blockId,
+          blockStart: new Date(timestamp).toISOString(),
+          date,
+          time,
+          timezone: timeZone,
+          activityDates: new Set(),
+        };
+        blocks.push(current);
+      }
+      current.activityDates.add(date);
+      lastActivity = Math.max(lastActivity ?? timestamp, timestamp);
+    }
+    if (current) current.entries.push(entry);
+    else pending.push(entry);
+  }
+
+  const journalable = [];
+  const extraction = { formatter, toolCalls: new Map() };
+  for (const block of blocks) {
+    const events = eventsForSession(block, timeZone, extraction);
+    if (!events.length) continue;
+    const previous = journalable.at(-1);
+    journalable.push({
+      ...block,
+      blockIndex: journalable.length,
+      project: events[0].project,
+      events,
+      context: previous ? precedingContext(previous.events) : [],
+      previousBlockId: previous?.blockId,
+      activityDates: [...block.activityDates],
+    });
+  }
+  return journalable;
+}
+
+export function blockInRange(block, range) {
+  return !range.firstDate || block.activityDates.some((date) => date >= range.firstDate && date <= range.lastDate);
+}
+
+// Legacy entries used their last user timestamp. Blocks that disappear after a
+// timezone change also need reassignment, without altering their linked notes.
+export function assignLegacyBlocks(versions, blocks) {
+  if (!blocks.length) return;
+  const currentIds = new Set(blocks.map((block) => block.blockId));
+  for (const version of versions) {
+    if (currentIds.has(version.blockId)) continue;
+    const anchor = `${version.date} ${version.time}`;
+    const block = blocks.findLast((candidate) => version.blockStart
+      ? candidate.blockStart <= version.blockStart
+      : `${candidate.date} ${candidate.time}` <= anchor) || blocks[0];
+    version.blockId = block.blockId;
+    version.legacy = true;
+  }
+}