logdig 0.1.0 → 0.1.2

package/src/session-runner.js

@@ -1,7 +1,8 @@
 import { readFile, readdir, stat } from "node:fs/promises";
 import path from "node:path";
-import { appendDailyEntry, inspectDailyEntry, inspectSessionSummary, saveSessionSummary } from "./journal.js";
-import { eventsForSession, fingerprintSession, sessionFromJsonl, sessionMetrics } from "./transcript.js";
+import { appendDailyEntry, dailyEntryId, inspectDailyEntry, inspectSessionSummary, listJournaledSessions, saveSessionSummary } from "./journal.js";
+import { sessionFromJsonl, sessionMetrics } from "./transcript.js";
+import { assignLegacyBlocks, blockInRange, workBlocksForSession } from "./work-blocks.js";
 
 function localDate(timestamp, timeZone) {
   const parts = new Intl.DateTimeFormat("en-CA", {
@@ -83,7 +84,6 @@ export async function collectSessions({ sessionDirectory, timeZone, days, curren
       if (modifiedAfter && fileStat.mtimeMs < modifiedAfter) continue;
       const session = sessionFromJsonl(await readFile(file, "utf8"), file);
       if (session.header.id === currentId || seen.has(session.header.id)) continue;
-      session.fingerprint = fingerprintSession(session);
       seen.add(session.header.id);
       sessions.push(session);
     } catch (error) {
@@ -96,90 +96,161 @@ export async function collectSessions({ sessionDirectory, timeZone, days, curren
   return { sessions, warnings, firstDate, lastDate: today };
 }
 
+function selectedBlockIndexes(blocks, versions, range) {
+  const selected = new Set(blocks.flatMap((block, index) => blockInRange(block, range) ? [index] : []));
+  // A continuation must link to a real snapshot, not a predicted filename.
+  for (let index = blocks.length - 1; index > 0; index--) {
+    if (selected.has(index) && !versions.some((version) => version.blockId === blocks[index - 1].blockId && version.summary)) {
+      selected.add(index - 1);
+    }
+  }
+  return selected;
+}
+
+async function precedingSnapshot(modelClient, previous, versions, settings) {
+  const snapshots = versions.filter((version) => version.blockId === previous.blockId && version.summary);
+  if (!snapshots.length) throw new Error("preceding work block has no saved snapshot; fix its error and retry");
+  const cached = await inspectSessionSummary(modelClient, settings.cacheDirectory, previous);
+  const expectedId = dailyEntryId({
+    sessionId: previous.header.id,
+    blockId: previous.blockId,
+    cacheFingerprint: cached.cacheFingerprint,
+    continuationOf: cached.continuationOf,
+    summaryLevel: settings.dailySummary,
+  }, settings.dailyHeader);
+  return (snapshots.find((snapshot) => snapshot.id === expectedId) || snapshots[0]).id;
+}
+
 export async function writeSessions(modelClient, sessions, settings, range = {}) {
   let summariesCreated = 0;
   let summariesReused = 0;
   let entriesAppended = 0;
+  let entriesUpdated = 0;
   let entriesSkipped = 0;
   let sessionsSkipped = 0;
   const dates = new Set();
   const dailyPaths = new Set();
   const errors = [];
+  const sessionResults = [];
+  const journaledEntries = range.journaledEntries || await listJournaledSessions(settings.cacheDirectory);
 
   for (const [index, session] of sessions.entries()) {
     const progress = { index: index + 1, total: sessions.length, sessionId: session.header.id };
+    let blocks;
     try {
-      const events = eventsForSession(session, settings.timeZone);
-      const lastUserEvent = events.findLast((event) => event.kind === "user intent");
-      const closingEvent = lastUserEvent || events.at(-1);
-      if (!closingEvent || (range.firstDate && (closingEvent.date < range.firstDate || closingEvent.date > range.lastDate))) {
-        sessionsSkipped++;
-        range.onProgress?.({ ...progress, phase: "skipped", status: closingEvent ? "outside date range" : "no journalable events" });
-        continue;
-      }
-
-      const journalSession = {
-        ...session,
-        date: closingEvent.date,
-        time: closingEvent.time,
-        timezone: settings.timeZone,
-        project: events[0].project || "unknown project",
-        events,
-        sourceFingerprint: session.fingerprint || fingerprintSession(session),
-      };
-      Object.assign(progress, { project: journalSession.project, date: journalSession.date, time: journalSession.time });
-      range.onProgress?.({ ...progress, phase: "checking", status: "checking saved summary" });
-      const cached = range.dryRun
-        ? await inspectSessionSummary(modelClient, settings.cacheDirectory, journalSession)
-        : await saveSessionSummary(modelClient, settings.cacheDirectory, journalSession, {
-          onGenerate: () => range.onProgress?.({ ...progress, phase: "summarizing", status: "summarizing with Pi; large sessions may take a few minutes" }),
-        });
-      if (cached.reused) summariesReused++;
-      else summariesCreated++;
-
-      const entry = {
-        date: journalSession.date,
-        time: journalSession.time,
-        project: journalSession.project,
-        sessionId: journalSession.header.id,
-        cacheFingerprint: cached.cacheFingerprint,
-        sessionPath: cached.sessionPath,
-        sourceFingerprint: journalSession.sourceFingerprint,
-        metrics: sessionMetrics(journalSession),
-        summaryLevel: settings.dailySummary,
-        summary: cached.summary?.[settings.dailySummary],
-      };
-      const dailyEntry = range.dryRun
-        ? await inspectDailyEntry(settings.dailyDirectory, settings.dailyHeader, entry)
-        : await appendDailyEntry(settings.dailyDirectory, settings.dailyHeader, entry);
-      if (dailyEntry.appended) entriesAppended++;
-      else entriesSkipped++;
-      dates.add(journalSession.date);
-      dailyPaths.add(dailyEntry.dailyPath);
-      range.onProgress?.({
-        ...progress,
-        phase: "complete",
-        sessionPath: cached.sessionPath,
-        dailyPath: dailyEntry.dailyPath,
-        status: range.dryRun
-          ? `${cached.reused ? "would reuse summary" : "would summarize with Pi"}, ${dailyEntry.appended ? "would append entry" : "entry already present"}`
-          : `${cached.reused ? "summary reused" : "summary created"}, ${dailyEntry.appended ? "entry appended" : "entry already present"}`,
-      });
+      blocks = workBlocksForSession(session, settings.timeZone);
     } catch (error) {
       errors.push(`${session.header.id}: ${error.message}`);
+      sessionResults.push({ sessionId: session.header.id, status: "error", error: error.message });
       range.onProgress?.({ ...progress, phase: "error", error: error.message });
+      continue;
+    }
+    const versions = journaledEntries.get(session.header.id) || [];
+    journaledEntries.set(session.header.id, versions);
+    assignLegacyBlocks(versions, blocks);
+    const selected = selectedBlockIndexes(blocks, versions, range);
+    if (!selected.size) {
+      sessionsSkipped++;
+      const reason = blocks.length ? "outside date range" : "no journalable events";
+      sessionResults.push({ sessionId: session.header.id, status: "skipped", reason });
+      range.onProgress?.({ ...progress, phase: "skipped", status: reason });
+      continue;
+    }
+
+    const plannedSnapshots = new Map();
+    for (const [blockIndex, block] of blocks.entries()) {
+      if (!selected.has(blockIndex)) continue;
+      const blockProgress = { ...progress, blockId: block.blockId, project: block.project, date: block.date, time: block.time };
+      try {
+        const previous = blocks[blockIndex - 1];
+        const continuationOf = previous
+          ? plannedSnapshots.get(previous.blockId) || await precedingSnapshot(modelClient, previous, versions, settings)
+          : undefined;
+        const journalBlock = { ...block, continuationOf };
+        const prerequisite = !blockInRange(block, range);
+        range.onProgress?.({ ...blockProgress, phase: "checking", status: "checking saved summary" });
+        const cached = range.dryRun
+          ? await inspectSessionSummary(modelClient, settings.cacheDirectory, journalBlock)
+          : await saveSessionSummary(modelClient, settings.cacheDirectory, journalBlock, {
+            onGenerate: () => range.onProgress?.({ ...blockProgress, phase: "summarizing", status: "summarizing with Pi; large sessions may take a few minutes" }),
+          });
+        if (cached.reused) summariesReused++;
+        else summariesCreated++;
+
+        const entry = {
+          date: block.date,
+          time: block.time,
+          project: block.project,
+          sessionId: session.header.id,
+          blockId: block.blockId,
+          blockStart: block.blockStart,
+          continuationOf,
+          cacheFingerprint: cached.cacheFingerprint,
+          sessionPath: cached.sessionPath,
+          sourceFingerprint: cached.sourceFingerprint,
+          metrics: sessionMetrics(block),
+          summaryLevel: settings.dailySummary,
+          summary: cached.summary?.[settings.dailySummary],
+        };
+        const dailyEntry = range.dryRun
+          ? await inspectDailyEntry(settings.dailyDirectory, settings.dailyHeader, entry, journaledEntries)
+          : await appendDailyEntry(settings.dailyDirectory, settings.dailyHeader, entry, journaledEntries);
+        if (dailyEntry.updated) entriesUpdated++;
+        else if (dailyEntry.appended) entriesAppended++;
+        else entriesSkipped++;
+        const entryId = dailyEntryId(entry, settings.dailyHeader);
+        plannedSnapshots.set(block.blockId, entryId);
+        sessionResults.push({
+          sessionId: session.header.id,
+          blockId: block.blockId,
+          project: block.project,
+          date: block.date,
+          time: block.time,
+          activityDates: block.activityDates,
+          prerequisite,
+          continuationOf,
+          entryPresent: !dailyEntry.appended && !dailyEntry.updated,
+          entryUpdated: Boolean(dailyEntry.updated),
+          legacyEntry: dailyEntry.legacyEntry,
+          summaryReused: cached.reused,
+          sourceFingerprint: cached.sourceFingerprint,
+          cacheFingerprint: cached.cacheFingerprint,
+          sessionPath: cached.sessionPath,
+          dailyPath: dailyEntry.dailyPath,
+        });
+        // Dry-run predictions stay in plannedSnapshots, never in the real index.
+        if (!range.dryRun && !versions.some((version) => version.id === entryId)) {
+          versions.push({ ...entry, id: entryId, summary: cached.summary });
+        }
+        dates.add(block.date);
+        dailyPaths.add(dailyEntry.dailyPath);
+        range.onProgress?.({
+          ...blockProgress,
+          phase: "complete",
+          prerequisite,
+          sessionPath: cached.sessionPath,
+          dailyPath: dailyEntry.dailyPath,
+          status: (range.dryRun
+            ? `${cached.reused ? "would reuse summary" : "would summarize with Pi"}, ${dailyEntry.updated ? "would update entry" : dailyEntry.appended ? "would append entry" : "entry already present"}`
+            : `${cached.reused ? "summary reused" : "summary created"}, ${dailyEntry.updated ? "entry updated" : dailyEntry.appended ? "entry appended" : "entry already present"}`) + (prerequisite ? " (earlier block needed for continuation link)" : ""),
+        });
+      } catch (error) {
+        errors.push(`${session.header.id}: ${block.date} ${block.time}: ${error.message}`);
+        sessionResults.push({ sessionId: session.header.id, blockId: block.blockId, status: "error", error: error.message });
+        range.onProgress?.({ ...blockProgress, phase: "error", error: error.message });
+      }
     }
   }
 
-  return { summariesCreated, summariesReused, entriesAppended, entriesSkipped, sessionsSkipped, dates: [...dates].sort(), dailyPaths: [...dailyPaths].sort(), errors };
+  return { summariesCreated, summariesReused, entriesAppended, entriesUpdated, entriesSkipped, sessionsSkipped, dates: [...dates].sort(), dailyPaths: [...dailyPaths].sort(), errors, sessionResults };
 }
 
-export function parseBackfillArgument(argument = "") {
+export function parseBackfillArgument(argument = "", command = "backfill") {
   const value = argument.trim().toLowerCase() || "3";
   if (value === "all") return { all: true };
   const days = Number(value);
   if (!/^\d+$/.test(value) || !Number.isInteger(days) || days < 1 || days > 3650) {
-    throw new Error("Usage: logdig backfill [number-of-days|all]. Choose 1 to 3650 days, or 'all'.");
+    throw new Error(`Usage: logdig ${command} [number-of-days|all]. Choose 1 to 3650 days, or 'all'.`);
   }
   return { days };
 }

package/src/settings.js

@@ -10,6 +10,7 @@ const ENVIRONMENT_SETTINGS = [
   ["PI_JOURNAL_DAILY_SUMMARY", "dailySummary"],
   ["PI_JOURNAL_TIMEZONE", "timeZone"],
   ["PI_JOURNAL_MODEL", "model"],
+  ["PI_JOURNAL_THINKING", "thinkingLevel"],
   ["PI_JOURNAL_PI_COMMAND", "piCommand"],
   ["PI_CODING_AGENT_SESSION_DIR", "sessionDirectory"],
 ];
@@ -85,6 +86,14 @@ export function validateSettings(settings, { requirePaths = false, home = homedi
     if (!provider || !modelId) throw new Error("model must use provider/model format");
     settings.model = `${provider}/${modelId}`;
   }
+  if (settings.thinkingLevel !== undefined) {
+    if (typeof settings.thinkingLevel !== "string") throw new Error("thinkingLevel must be default, off, minimal, low, medium, high, xhigh, or max");
+    const level = settings.thinkingLevel.trim().toLowerCase();
+    if (!["default", "off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(level)) {
+      throw new Error("thinkingLevel must be default, off, minimal, low, medium, high, xhigh, or max");
+    }
+    settings.thinkingLevel = level === "default" ? undefined : level;
+  }
   if (settings.autoCapture !== undefined && typeof settings.autoCapture !== "boolean") {
     throw new Error("autoCapture must be a boolean");
   }
@@ -144,6 +153,7 @@ export async function saveSettings(settings, filePath = settings.filePath || set
     piCommand: settings.piCommand || "pi",
     autoCapture: settings.autoCapture === true,
     ...(settings.model ? { model: settings.model } : {}),
+    ...(settings.thinkingLevel !== undefined ? { thinkingLevel: settings.thinkingLevel } : {}),
   };
   validateSettings(persisted, { requirePaths: true });
 

package/src/setup.js

@@ -76,14 +76,18 @@ export async function configureLogDig(settings, commandName = "logdig") {
     console.log("\n2. Pi and privacy");
     console.log(`History: ${settings.sessionDirectory}`);
     console.log(`Model: ${settings.model || "Pi's default (your active model for /journal)"}`);
-    const advanced = await ask("Change history folder, Pi executable, or model? (yes/no)", "no", yesNo);
-    let { sessionDirectory, piCommand, model } = settings;
+    console.log(`Thinking: ${settings.thinkingLevel || "default (no LogDig override)"}`);
+    const advanced = await ask("Change history folder, Pi executable, model, or thinking level? (yes/no)", "no", yesNo);
+    let { sessionDirectory, piCommand, model, thinkingLevel } = settings;
     if (advanced) {
       sessionDirectory = await ask("Pi session-history folder", sessionDirectory,
         (value) => folder("sessionDirectory", value, false));
       piCommand = await ask("Pi executable", piCommand, (value) => field("piCommand", value));
       model = await ask("Model (provider/model), or 'default'", model || "default",
         (value) => value.toLowerCase() === "default" ? undefined : field("model", value));
+      console.log("More thinking can help distinguish attempts from outcomes, but takes longer and may cost more. Support depends on the model.");
+      thinkingLevel = await ask("Thinking level (default/off/minimal/low/medium/high/xhigh/max)", thinkingLevel || "default",
+        (value) => field("thinkingLevel", value));
     }
     console.log("Summarizing sends selected, redacted history to your Pi model. Provider charges may apply.");
     console.log("Common secrets are redacted, but this is not a complete secret scanner. Pi keeps your credentials.");
@@ -91,7 +95,7 @@ export async function configureLogDig(settings, commandName = "logdig") {
     const autoCapture = await ask("Capture on Pi shutdown? (yes/no)", settings.autoCapture ? "yes" : "no", yesNo);
     installExtension = await ask("Install the Pi extension for /journal? (yes/no)", "no", yesNo);
 
-    nextSettings = { ...settings, cacheDirectory, dailyDirectory, dailyHeader, dailySummary, timeZone, sessionDirectory, piCommand, model, autoCapture };
+    nextSettings = { ...settings, cacheDirectory, dailyDirectory, dailyHeader, dailySummary, timeZone, sessionDirectory, piCommand, model, thinkingLevel, autoCapture };
     console.log([
       "",
       "Ready to save",
@@ -102,6 +106,7 @@ export async function configureLogDig(settings, commandName = "logdig") {
       `  History:     ${sessionDirectory}`,
       `  Pi:          ${piCommand}`,
       `  Model:       ${model || "Pi default"}`,
+      `  Thinking:    ${thinkingLevel || "default (no LogDig override)"}`,
       `  Auto-capture: ${autoCapture ? "on" : "off"}`,
       `  Extension:   ${installExtension ? "install now" : "leave unchanged"}`,
       "Missing note and cache folders will be created on your first real backfill.",

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;
+  }
+}