sidekick-shared 0.27.6 → 0.28.0

package/dist/esm/parsers/changelogParser.js

@@ -0,0 +1,71 @@
+/**
+ * Parser for Keep a Changelog format markdown files.
+ *
+ * Extracts structured changelog entries with version, date, section headings,
+ * and bullet items from standard changelog markdown.
+ */
+const VERSION_HEADING_RE = /^## \[(\d+\.\d+\.\d+)\] - (\d{4}-\d{2}-\d{2})/;
+const SECTION_HEADING_RE = /^### (.+)/;
+const BULLET_RE = /^- /;
+/**
+ * Parse a Keep a Changelog markdown string into structured entries.
+ *
+ * @param markdown - Raw changelog markdown content
+ * @param limit - Maximum number of version entries to return (default 5)
+ * @returns Array of parsed changelog entries, newest first
+ */
+export function parseChangelog(markdown, limit = 5) {
+    const lines = markdown.split('\n');
+    const entries = [];
+    let current = null;
+    let currentSection = null;
+    for (const line of lines) {
+        // Check for version heading
+        const versionMatch = line.match(VERSION_HEADING_RE);
+        if (versionMatch) {
+            if (current) {
+                if (currentSection && currentSection.items.length > 0) {
+                    current.sections.push(currentSection);
+                }
+                entries.push(current);
+                if (entries.length >= limit)
+                    break;
+            }
+            current = { version: versionMatch[1], date: versionMatch[2], sections: [] };
+            currentSection = null;
+            continue;
+        }
+        if (!current)
+            continue;
+        // Check for section heading (### Added, ### Fixed, etc.)
+        const sectionMatch = line.match(SECTION_HEADING_RE);
+        if (sectionMatch) {
+            if (currentSection && currentSection.items.length > 0) {
+                current.sections.push(currentSection);
+            }
+            currentSection = { heading: sectionMatch[1], items: [] };
+            continue;
+        }
+        if (!currentSection)
+            continue;
+        // Bullet item
+        if (BULLET_RE.test(line)) {
+            currentSection.items.push(line.slice(2).trim());
+            continue;
+        }
+        // Continuation line (indented sub-bullet or wrapped text) — append to last item
+        if (line.startsWith('  ') && currentSection.items.length > 0) {
+            currentSection.items[currentSection.items.length - 1] += ' ' + line.trim();
+        }
+    }
+    // Flush final entry
+    if (current) {
+        if (currentSection && currentSection.items.length > 0) {
+            current.sections.push(currentSection);
+        }
+        if (entries.length < limit) {
+            entries.push(current);
+        }
+    }
+    return entries;
+}

package/dist/esm/parsers/codexHistory.js

@@ -0,0 +1,89 @@
+/**
+ * Reader for Codex's append-only `~/.codex/history.jsonl` (Node-only).
+ *
+ * Each line is `{"session_id","ts","text"}` — one entry per user prompt. The
+ * file grows without bound, so this reader takes a bounded tail instead of the
+ * whole file, drops the leading partial line, and parses tolerantly. Pair an
+ * entry with {@link findCodexRolloutFile} (providers/codex) to jump from a
+ * history row to its full rollout transcript.
+ *
+ * @module codexHistory
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { getSystemCodexHome } from '../codexPaths';
+const DEFAULT_LIMIT = 100;
+const DEFAULT_TAIL_BYTES = 512 * 1024;
+/**
+ * Returns the newest history entries, newest first. A missing or unreadable
+ * file yields `[]`; malformed lines are skipped. Never throws.
+ */
+export function readCodexHistory(options = {}) {
+    const limit = Math.max(0, options.limit ?? DEFAULT_LIMIT);
+    if (limit === 0)
+        return [];
+    const maxTailBytes = Math.max(1, options.maxTailBytes ?? Math.max(DEFAULT_TAIL_BYTES, limit * 4096));
+    const historyPath = path.join(options.codexHome ?? getSystemCodexHome(), 'history.jsonl');
+    let descriptor;
+    try {
+        descriptor = fs.openSync(historyPath, 'r');
+    }
+    catch {
+        return [];
+    }
+    try {
+        const size = fs.fstatSync(descriptor).size;
+        const readBytes = Math.min(size, maxTailBytes);
+        const buffer = Buffer.alloc(readBytes);
+        fs.readSync(descriptor, buffer, 0, readBytes, size - readBytes);
+        let content = buffer.toString('utf8');
+        if (readBytes < size) {
+            // The tail almost certainly starts mid-line; a multibyte character
+            // straddling the boundary decodes as replacement garbage inside that
+            // same partial line, so dropping through the first newline handles both.
+            const firstNewline = content.indexOf('\n');
+            content = firstNewline === -1 ? '' : content.slice(firstNewline + 1);
+        }
+        const entries = [];
+        for (const line of content.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(trimmed);
+            }
+            catch {
+                continue;
+            }
+            if (typeof parsed.session_id !== 'string' ||
+                typeof parsed.ts !== 'number' ||
+                // JSON.parse('1e400') yields Infinity, which would later RangeError
+                // out of Date serialization in consumers.
+                !Number.isFinite(parsed.ts) ||
+                typeof parsed.text !== 'string') {
+                continue;
+            }
+            entries.push({
+                sessionId: parsed.session_id,
+                ts: parsed.ts,
+                tsMs: parsed.ts * 1000,
+                text: parsed.text,
+            });
+        }
+        // The file is append-only, so on-disk order is oldest first.
+        entries.reverse();
+        return entries.slice(0, limit);
+    }
+    catch {
+        return [];
+    }
+    finally {
+        try {
+            fs.closeSync(descriptor);
+        }
+        catch {
+            // Already closed or invalid; nothing to release.
+        }
+    }
+}