codex-session-manager 0.1.0

package/dist/src/preview.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractMessageText = extractMessageText;
+exports.extractPreviewFromLine = extractPreviewFromLine;
+exports.readMessagePreviews = readMessagePreviews;
+const node_fs_1 = require("node:fs");
+const node_readline_1 = __importDefault(require("node:readline"));
+function normalizeWhitespace(text) {
+    return text.replace(/\s+/g, " ").trim();
+}
+function extractMessageText(payload) {
+    if (!payload || payload.type !== "message") {
+        return "";
+    }
+    const content = payload.content;
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    const parts = [];
+    for (const part of content) {
+        if (!part || typeof part !== "object") {
+            continue;
+        }
+        const text = typeof part.text === "string"
+            ? part.text
+            : typeof part.input_text === "string"
+                ? part.input_text
+                : typeof part.output_text === "string"
+                    ? part.output_text
+                    : "";
+        if (text) {
+            parts.push(text);
+        }
+    }
+    return normalizeWhitespace(parts.join(" "));
+}
+function extractPreviewFromLine(line) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed.payload || typeof parsed.payload !== "object") {
+        return null;
+    }
+    const text = extractMessageText(parsed.payload);
+    if (!text) {
+        return null;
+    }
+    return text;
+}
+function truncate(text, maxChars) {
+    if (text.length <= maxChars) {
+        return text;
+    }
+    if (maxChars <= 3) {
+        return text.slice(0, maxChars);
+    }
+    return `${text.slice(0, maxChars - 3)}...`;
+}
+async function readMessagePreviews(filePath, maxChars) {
+    const stream = (0, node_fs_1.createReadStream)(filePath, { encoding: "utf8" });
+    const rl = node_readline_1.default.createInterface({ input: stream, crlfDelay: Infinity });
+    let first = null;
+    let last = null;
+    try {
+        for await (const line of rl) {
+            const preview = extractPreviewFromLine(line);
+            if (!preview) {
+                continue;
+            }
+            if (!first) {
+                first = preview;
+            }
+            last = preview;
+        }
+    }
+    finally {
+        rl.close();
+        stream.destroy();
+    }
+    if (!first) {
+        return null;
+    }
+    const safeLast = last ?? first;
+    return {
+        first: truncate(first, maxChars),
+        last: truncate(safeLast, maxChars),
+    };
+}

package/dist/src/session-store.js

@@ -0,0 +1,364 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultPaths = getDefaultPaths;
+exports.loadSessions = loadSessions;
+exports.filterSessions = filterSessions;
+exports.parseTagsInput = parseTagsInput;
+exports.sortSessionsByDate = sortSessionsByDate;
+exports.updateSessionMetadata = updateSessionMetadata;
+exports.setArchiveStatus = setArchiveStatus;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_readline_1 = __importDefault(require("node:readline"));
+function getDefaultPaths() {
+    const codexDir = node_path_1.default.join(node_os_1.default.homedir(), ".codex");
+    return {
+        codexDir,
+        sessionsDir: node_path_1.default.join(codexDir, "sessions"),
+        archivedDir: node_path_1.default.join(codexDir, "archived_sessions"),
+    };
+}
+async function collectJsonlFiles(dir) {
+    const results = [];
+    let entries;
+    try {
+        entries = await promises_1.default.readdir(dir, { withFileTypes: true });
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "ENOENT") {
+            return results;
+        }
+        throw err;
+    }
+    for (const entry of entries) {
+        const fullPath = node_path_1.default.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...(await collectJsonlFiles(fullPath)));
+            continue;
+        }
+        if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+            results.push(fullPath);
+        }
+    }
+    return results;
+}
+async function readFirstLine(filePath) {
+    const stream = (0, node_fs_1.createReadStream)(filePath, { encoding: "utf8" });
+    const rl = node_readline_1.default.createInterface({ input: stream, crlfDelay: Infinity });
+    return new Promise((resolve, reject) => {
+        let done = false;
+        rl.on("line", (line) => {
+            if (done) {
+                return;
+            }
+            done = true;
+            rl.close();
+            stream.destroy();
+            resolve(line);
+        });
+        rl.on("close", () => {
+            if (!done) {
+                resolve(null);
+            }
+        });
+        rl.on("error", (err) => {
+            if (!done) {
+                reject(err);
+            }
+        });
+        stream.on("error", (err) => {
+            if (!done) {
+                reject(err);
+            }
+        });
+    });
+}
+function normalizeTags(value) {
+    if (value == null) {
+        return [];
+    }
+    let raw = [];
+    if (Array.isArray(value)) {
+        raw = value.filter((item) => typeof item === "string");
+    }
+    else if (typeof value === "string") {
+        raw = value.split(/[\s,]+/);
+    }
+    return uniqueTags(raw.map((tag) => tag.trim()).filter(Boolean));
+}
+function uniqueTags(tags) {
+    const seen = new Set();
+    const result = [];
+    for (const tag of tags) {
+        const key = tag.toLowerCase();
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        result.push(tag);
+    }
+    return result;
+}
+function parseTimestamp(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const parsed = Date.parse(value);
+    if (Number.isNaN(parsed)) {
+        return null;
+    }
+    return new Date(parsed);
+}
+function parseDateFromFilename(fileName) {
+    const match = fileName.match(/(20\d{2})-(\d{2})-(\d{2})T(\d{2})-(\d{2})-(\d{2})/);
+    if (!match) {
+        return null;
+    }
+    const [, year, month, day, hour, minute, second] = match;
+    return new Date(`${year}-${month}-${day}T${hour}:${minute}:${second}Z`);
+}
+function formatDateLabel(date) {
+    if (!date || Number.isNaN(date.valueOf())) {
+        return undefined;
+    }
+    return date.toISOString().slice(0, 10);
+}
+function pickTitle(payload) {
+    const title = typeof payload.title === "string" ? payload.title.trim() : "";
+    if (title) {
+        return title;
+    }
+    const name = typeof payload.name === "string" ? payload.name.trim() : "";
+    if (name) {
+        return name;
+    }
+    return undefined;
+}
+function deriveDisplayName(payload, fileName) {
+    const title = pickTitle(payload);
+    if (title) {
+        return title;
+    }
+    const cwd = typeof payload.cwd === "string" ? payload.cwd.trim() : "";
+    if (cwd) {
+        return node_path_1.default.basename(cwd);
+    }
+    return fileName.replace(/\.jsonl$/, "");
+}
+function parseGit(payload) {
+    const git = payload.git;
+    if (!git || typeof git !== "object") {
+        return undefined;
+    }
+    const repositoryUrl = typeof git.repository_url === "string" ? git.repository_url : undefined;
+    const branch = typeof git.branch === "string" ? git.branch : undefined;
+    const commitHash = typeof git.commit_hash === "string" ? git.commit_hash : undefined;
+    if (!repositoryUrl && !branch && !commitHash) {
+        return undefined;
+    }
+    return { repositoryUrl, branch, commitHash };
+}
+async function parseSessionFile(filePath, archived) {
+    const firstLine = await readFirstLine(filePath);
+    if (!firstLine) {
+        return null;
+    }
+    let meta;
+    try {
+        meta = JSON.parse(firstLine);
+    }
+    catch {
+        return null;
+    }
+    if (meta.type !== "session_meta" || !meta.payload) {
+        return null;
+    }
+    const payload = meta.payload;
+    const timestamp = typeof payload.timestamp === "string" ? payload.timestamp : undefined;
+    const fileName = node_path_1.default.basename(filePath);
+    const stat = await promises_1.default.stat(filePath);
+    const sortDate = parseTimestamp(timestamp) ||
+        parseDateFromFilename(fileName) ||
+        stat.mtime ||
+        null;
+    return {
+        id: typeof payload.id === "string" ? payload.id : undefined,
+        filePath,
+        fileName,
+        archived,
+        cwd: typeof payload.cwd === "string" ? payload.cwd : undefined,
+        title: pickTitle(payload),
+        tags: normalizeTags(payload.tags),
+        timestamp,
+        dateLabel: formatDateLabel(sortDate),
+        displayName: deriveDisplayName(payload, fileName),
+        sortKey: sortDate ? sortDate.getTime() : 0,
+        originator: typeof payload.originator === "string" ? payload.originator : undefined,
+        cliVersion: typeof payload.cli_version === "string" ? payload.cli_version : undefined,
+        source: typeof payload.source === "string" ? payload.source : undefined,
+        modelProvider: typeof payload.model_provider === "string"
+            ? payload.model_provider
+            : undefined,
+        git: parseGit(payload),
+    };
+}
+async function loadSessions(paths) {
+    const [activeFiles, archivedFiles] = await Promise.all([
+        collectJsonlFiles(paths.sessionsDir),
+        collectJsonlFiles(paths.archivedDir),
+    ]);
+    const sessions = [];
+    for (const filePath of activeFiles) {
+        const session = await parseSessionFile(filePath, false);
+        if (session) {
+            sessions.push(session);
+        }
+    }
+    for (const filePath of archivedFiles) {
+        const session = await parseSessionFile(filePath, true);
+        if (session) {
+            sessions.push(session);
+        }
+    }
+    return sessions;
+}
+function filterSessions(sessions, query, archiveFilter) {
+    const trimmed = query.trim().toLowerCase();
+    return sessions.filter((session) => {
+        if (archiveFilter === "archived" && !session.archived) {
+            return false;
+        }
+        if (archiveFilter === "active" && session.archived) {
+            return false;
+        }
+        if (!trimmed) {
+            return true;
+        }
+        const name = session.displayName.toLowerCase();
+        const tags = session.tags.join(" ").toLowerCase();
+        return name.includes(trimmed) || tags.includes(trimmed);
+    });
+}
+function parseTagsInput(input) {
+    if (!input.trim()) {
+        return [];
+    }
+    return uniqueTags(input
+        .split(/[\s,]+/)
+        .map((tag) => tag.trim())
+        .filter(Boolean));
+}
+function sortSessionsByDate(sessions, order) {
+    const sorted = [...sessions];
+    if (order === "asc") {
+        sorted.sort((a, b) => a.sortKey - b.sortKey);
+        return sorted;
+    }
+    sorted.sort((a, b) => b.sortKey - a.sortKey);
+    return sorted;
+}
+async function updateSessionMetadata(filePath, updates) {
+    const content = await promises_1.default.readFile(filePath, "utf8");
+    const lines = content.split("\n");
+    if (!lines[0]) {
+        throw new Error("Session file is empty.");
+    }
+    let meta;
+    try {
+        meta = JSON.parse(lines[0]);
+    }
+    catch {
+        throw new Error("Failed to parse session metadata.");
+    }
+    if (meta.type !== "session_meta" || !meta.payload) {
+        throw new Error("First line is not session metadata.");
+    }
+    const payload = meta.payload;
+    if (updates.title !== undefined) {
+        const cleaned = updates.title.trim();
+        if (cleaned) {
+            payload.title = cleaned;
+            payload.name = cleaned;
+        }
+        else {
+            delete payload.title;
+            delete payload.name;
+        }
+    }
+    if (updates.tags !== undefined) {
+        const cleanedTags = uniqueTags(updates.tags.map((tag) => tag.trim()).filter(Boolean));
+        if (cleanedTags.length) {
+            payload.tags = cleanedTags;
+        }
+        else {
+            delete payload.tags;
+        }
+    }
+    meta.payload = payload;
+    lines[0] = JSON.stringify(meta);
+    await promises_1.default.writeFile(filePath, lines.join("\n"), "utf8");
+}
+async function moveFile(source, destination) {
+    try {
+        await promises_1.default.rename(source, destination);
+    }
+    catch (error) {
+        const err = error;
+        if (err.code !== "EXDEV") {
+            throw err;
+        }
+        await promises_1.default.copyFile(source, destination);
+        await promises_1.default.unlink(source);
+    }
+}
+function resolveActivePath(fileName, timestamp, fallbackTime, paths) {
+    const date = parseTimestamp(timestamp) || parseDateFromFilename(fileName) || fallbackTime;
+    const dateLabel = formatDateLabel(date);
+    if (!dateLabel) {
+        throw new Error("Unable to determine session date.");
+    }
+    const [year, month, day] = dateLabel.split("-");
+    return node_path_1.default.join(paths.sessionsDir, year, month, day, fileName);
+}
+async function setArchiveStatus(session, targetArchived, paths) {
+    if (session.archived === targetArchived) {
+        return session.filePath;
+    }
+    if (targetArchived) {
+        const destination = node_path_1.default.join(paths.archivedDir, session.fileName);
+        await promises_1.default.mkdir(paths.archivedDir, { recursive: true });
+        try {
+            await promises_1.default.access(destination);
+            throw new Error("Archived session already exists.");
+        }
+        catch (error) {
+            const err = error;
+            if (err.code !== "ENOENT") {
+                throw err;
+            }
+        }
+        await moveFile(session.filePath, destination);
+        return destination;
+    }
+    const stat = await promises_1.default.stat(session.filePath);
+    const destination = resolveActivePath(session.fileName, session.timestamp, stat.mtime, paths);
+    await promises_1.default.mkdir(node_path_1.default.dirname(destination), { recursive: true });
+    try {
+        await promises_1.default.access(destination);
+        throw new Error("Active session already exists.");
+    }
+    catch (error) {
+        const err = error;
+        if (err.code !== "ENOENT") {
+            throw err;
+        }
+    }
+    await moveFile(session.filePath, destination);
+    return destination;
+}

package/dist/src/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/ui-utils.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTagIndex = buildTagIndex;
+exports.getTagFragment = getTagFragment;
+exports.getTagSuggestions = getTagSuggestions;
+exports.applyTagSuggestion = applyTagSuggestion;
+const session_store_1 = require("./session-store");
+function buildTagIndex(sessions) {
+    const seen = new Set();
+    const result = [];
+    for (const session of sessions) {
+        for (const tag of session.tags) {
+            const key = tag.toLowerCase();
+            if (seen.has(key)) {
+                continue;
+            }
+            seen.add(key);
+            result.push(tag);
+        }
+    }
+    result.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+    return result;
+}
+function getTagFragment(input) {
+    const match = input.match(/^(.*?)([^,\s]*)$/);
+    if (!match) {
+        return { prefix: input, fragment: "" };
+    }
+    return { prefix: match[1], fragment: match[2] };
+}
+function getTagSuggestions(input, allTags, limit) {
+    if (!allTags.length) {
+        return [];
+    }
+    const { fragment } = getTagFragment(input);
+    const fragmentLower = fragment.toLowerCase();
+    const used = (0, session_store_1.parseTagsInput)(input);
+    const usedSet = new Set(used.map((tag) => tag.toLowerCase()));
+    if (fragmentLower) {
+        usedSet.delete(fragmentLower);
+    }
+    const matches = allTags.filter((tag) => {
+        const lower = tag.toLowerCase();
+        if (usedSet.has(lower)) {
+            return false;
+        }
+        if (!fragmentLower) {
+            return true;
+        }
+        return lower.startsWith(fragmentLower);
+    });
+    matches.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+    return matches.slice(0, limit);
+}
+function applyTagSuggestion(input, suggestion) {
+    const { prefix } = getTagFragment(input);
+    return `${prefix}${suggestion}`;
+}

package/dist/tests/preview.test.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const promises_1 = require("node:fs/promises");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_test_1 = __importDefault(require("node:test"));
+const preview_1 = require("../src/preview");
+(0, node_test_1.default)("extractMessageText joins message parts", () => {
+    const text = (0, preview_1.extractMessageText)({
+        type: "message",
+        content: [{ text: "Hello" }, { input_text: "world" }],
+    });
+    strict_1.default.equal(text, "Hello world");
+});
+(0, node_test_1.default)("extractPreviewFromLine returns message preview", () => {
+    const line = JSON.stringify({
+        payload: {
+            type: "message",
+            content: [{ text: "Preview text" }],
+        },
+    });
+    strict_1.default.equal((0, preview_1.extractPreviewFromLine)(line), "Preview text");
+});
+(0, node_test_1.default)("readMessagePreviews returns first and last messages", async () => {
+    const dir = await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), "codex-preview-"));
+    const filePath = node_path_1.default.join(dir, "session.jsonl");
+    const lines = [
+        JSON.stringify({ type: "session_meta", payload: { id: "1" } }),
+        JSON.stringify({ payload: { type: "event", content: [] } }),
+        JSON.stringify({ payload: { type: "message", content: [{ text: "Hello world" }] } }),
+        JSON.stringify({ payload: { type: "message", content: [{ text: "Later message" }] } }),
+    ];
+    await (0, promises_1.writeFile)(filePath, `${lines.join("\n")}\n`, "utf8");
+    const previews = await (0, preview_1.readMessagePreviews)(filePath, 20);
+    strict_1.default.deepEqual(previews, {
+        first: "Hello world",
+        last: "Later message",
+    });
+});
+(0, node_test_1.default)("readMessagePreviews returns same first and last for single message", async () => {
+    const dir = await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), "codex-preview-single-"));
+    const filePath = node_path_1.default.join(dir, "session.jsonl");
+    const lines = [
+        JSON.stringify({ type: "session_meta", payload: { id: "1" } }),
+        JSON.stringify({ payload: { type: "message", content: [{ text: "Only message" }] } }),
+    ];
+    await (0, promises_1.writeFile)(filePath, `${lines.join("\n")}\n`, "utf8");
+    const previews = await (0, preview_1.readMessagePreviews)(filePath, 50);
+    strict_1.default.deepEqual(previews, {
+        first: "Only message",
+        last: "Only message",
+    });
+});
+(0, node_test_1.default)("readMessagePreviews returns null when no messages", async () => {
+    const dir = await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), "codex-preview-empty-"));
+    const filePath = node_path_1.default.join(dir, "session.jsonl");
+    const lines = [
+        JSON.stringify({ type: "session_meta", payload: { id: "1" } }),
+        JSON.stringify({ payload: { type: "event", content: [] } }),
+    ];
+    await (0, promises_1.writeFile)(filePath, `${lines.join("\n")}\n`, "utf8");
+    const previews = await (0, preview_1.readMessagePreviews)(filePath, 50);
+    strict_1.default.equal(previews, null);
+});