@rol1n/memory-log 0.0.0-stage → 0.1.0

package/extensions/memory-log/ui/timeline.ts

@@ -0,0 +1,103 @@
+import type { Config } from "../config.ts";
+import {
+  entryIndexById,
+  foldLedger,
+  isObservationsRecordedEntry,
+  rawTokensAfterIndex,
+  rawTokensSinceObservationCoverage,
+  type Entry,
+} from "../ledger/index.ts";
+
+/** Glyphs for the timeline strip. */
+const GLYPH = {
+  consolidated: "▓", // observations promoted to .memory (long-term)
+  partial: "▚",      // chunk straddling the pool-target boundary (some obs promoted)
+  pool: "▒",         // observed, still in the short-term buffer
+  raw: "░",          // raw history not yet distilled into observations
+  cut: "┊",          // compaction cutoff (verbatim tail began here)
+  tip: "▶",          // live branch tip
+} as const;
+
+/** A committed observation chunk, in branch order. */
+type Chunk = { coversUpToIndex: number; timestamps: string[] };
+
+function fmtK(tokens: number): string {
+  if (tokens < 1000) return `${tokens}`;
+  return `${(tokens / 1000).toFixed(1)}k`;
+}
+
+function collectChunks(branch: Entry[]): Chunk[] {
+  const indexById = entryIndexById(branch);
+  const chunks: Chunk[] = [];
+  for (const entry of branch) {
+    if (!isObservationsRecordedEntry(entry)) continue;
+    const coversUpToIndex = indexById.get(entry.data.coversUpToId);
+    if (coversUpToIndex === undefined) continue;
+    chunks.push({ coversUpToIndex, timestamps: entry.data.observations.map((o) => o.timestamp) });
+  }
+  return chunks;
+}
+
+/** Branch indices of every compaction entry's `firstKeptEntryId` (the verbatim-tail cutoffs). */
+function compactionCutIndices(branch: Entry[]): number[] {
+  const indexById = entryIndexById(branch);
+  const cuts: number[] = [];
+  for (const entry of branch) {
+    if (entry.type !== "compaction") continue;
+    const idx = entry.firstKeptEntryId ? indexById.get(entry.firstKeptEntryId) : undefined;
+    if (idx !== undefined) cuts.push(idx);
+  }
+  return cuts;
+}
+
+function chunkGlyph(chunk: Chunk, dropped: Set<string>): string {
+  let droppedCount = 0;
+  for (const ts of chunk.timestamps) if (dropped.has(ts)) droppedCount++;
+  if (droppedCount === 0) return GLYPH.pool;
+  if (droppedCount === chunk.timestamps.length) return GLYPH.consolidated;
+  return GLYPH.partial;
+}
+
+function wrap(cells: string[], width: number): string {
+  if (cells.length === 0) return "";
+  const rows: string[] = [];
+  for (let i = 0; i < cells.length; i += width) rows.push(cells.slice(i, i + width).join(""));
+  return rows.join("\n");
+}
+
+/**
+ * Render the full session as a horizontal strip.
+ */
+export function renderTimeline(branch: Entry[], config: Config, width = 60): string {
+  const folded = foldLedger(branch);
+  const dropped = folded.droppedObservationTimestamps;
+  const chunks = collectChunks(branch);
+
+  const cells: string[] = chunks.map((chunk) => chunkGlyph(chunk, dropped));
+  const tailTokens = rawTokensSinceObservationCoverage(branch);
+  const tailCells = tailTokens > 0 ? Math.ceil(tailTokens / config.chunkTokens) : 0;
+  for (let i = 0; i < tailCells; i++) cells.push(GLYPH.raw);
+
+  const cutPositions = compactionCutIndices(branch)
+    .map((cutIdx) => {
+      let pos = 0;
+      for (const chunk of chunks) if (chunk.coversUpToIndex < cutIdx) pos++;
+      return Math.min(pos, cells.length);
+    })
+    .sort((a, b) => b - a);
+  for (const pos of cutPositions) cells.splice(pos, 0, GLYPH.cut);
+
+  const consolidatedChunks = chunks.filter((c) => chunkGlyph(c, dropped) === GLYPH.consolidated).length;
+  const poolChunks = chunks.filter((c) => chunkGlyph(c, dropped) === GLYPH.pool).length;
+  const rawTotal = rawTokensAfterIndex(branch, -1);
+  const compactions = cutPositions.length;
+
+  const strip = cells.length > 0 ? `${wrap(cells, width)}${GLYPH.tip}` : "(timeline empty)";
+
+  return [
+    `memory-log timeline · 1 cell ≈ ${fmtK(config.chunkTokens)} tok · cumulative ${fmtK(rawTotal)} raw · ${compactions} compaction${compactions === 1 ? "" : "s"}`,
+    strip,
+    ``,
+    `  ${GLYPH.consolidated} .memory (${consolidatedChunks})   ${GLYPH.pool} pool (${poolChunks})   ${GLYPH.raw} raw   ${GLYPH.cut} compaction cut   ${GLYPH.tip} tip`,
+  ].join("\n");
+}

package/package.json

@@ -1,6 +1,43 @@
 {
   "name": "@rol1n/memory-log",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "type": "module",
+  "description": "memory-log extension from pi-kit",
+  "keywords": [
+    "pi-package"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/RolinShmily/pi-kit.git",
+    "directory": "extensions/memory-log"
+  },
+  "homepage": "https://github.com/RolinShmily/pi-kit#readme",
+  "bugs": {
+    "url": "https://github.com/RolinShmily/pi-kit/issues"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "extensions/memory-log",
+    "extensions/memory-log/README.md"
+  ],
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-agent-core": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
+  },
+  "pi": {
+    "extensions": [
+      "./extensions/memory-log/index.ts"
+    ],
+    "skills": [],
+    "prompts": [],
+    "themes": []
+  }
+}