hammadev 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2026 xayrullonematov
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,226 @@
+# HammaDev
+
+**Persistent memory and handoff layer for AI coding agents.**
+
+HammaDev reads a Codex CLI or Claude Code session and produces a compact,
+structured handoff package another supported agent can pick up and continue
+from — with no shared cloud service and no changes to the source agent's files.
+
+> **Status:** v0.1-alpha. Local-only CLI. Codex ↔ Claude handoff.
+
+---
+
+## The problem
+
+Each AI coding CLI keeps its own conversation history in its own format.
+When you switch agents mid-task — because you hit a context limit, want a
+second opinion, or one tool is better at the next step — the new agent has
+no idea what has already been tried, decided, or ruled out.
+
+You either:
+
+- Re-paste large chunks of the previous transcript by hand, or
+- Give a vague "continue from before" prompt and watch the new agent
+  redo work that's already done.
+
+HammaDev is a small tool that reads the source agent's native session file,
+extracts what actually matters (goal, task ledger, verification signals,
+current repo state, known risks), redacts obvious secrets, and writes a
+short `handoff.md` plus supporting artifacts to a local `.hamma/` directory
+in your project. The next agent reads that file and continues.
+
+---
+
+## Current alpha capabilities
+
+- **Source adapter — Codex CLI.** Discovers rollouts under
+  `~/.codex/sessions/**/rollout-*.jsonl` and parses them into a normalized
+  `HammaSession` model.
+- **Source adapter — Claude Code.** Discovers Claude JSONL sessions and conservatively parses visible user/assistant text while excluding internal, system, thinking, and tool records.
+- **Handoff generator — targets `claude` and `codex`.** Produces a `.hamma/tasks/<id>/`
+  directory containing:
+  - `handoff.md` — a size-guarded (~15 KB target, 20 KB hard cap) markdown
+    brief with next action, current state, completed vs. remaining tasks,
+    verification signals, `git status --short` / `git diff --stat`, and
+    known risks.
+  - `state.json` — the structured task state the markdown was rendered from.
+  - `session.json` — the full normalized session (for archival / debugging).
+  - `timeline.md` — an importance-filtered chronological view.
+  - `commands.md` — bucketed summary of shell/tool invocations observed.
+  - `redaction-report.md` — count and warnings from secret redaction.
+- **Secret redaction.** Regex-based scrub of common API-key shapes
+  (OpenAI, Anthropic, GitHub, Google, Slack, generic `api_key=...`).
+- **Non-destructive.** Never writes to the source agent's session files.
+  Optionally appends `.hamma/` to your project's `.gitignore`.
+- **Project status.** Reports local Git state, handoff history, session counts,
+  and `.hamma/` ignore coverage without printing transcripts.
+
+---
+
+## Demo flow
+
+```bash
+# 1. See what Codex sessions exist on this machine
+pnpm dev list codex
+
+# 2. Inspect the most recent Codex session (summarized JSON)
+pnpm dev inspect codex:last --summary
+
+# 2b. Inspect a specific session by conversationId (exact or unique prefix)
+pnpm dev inspect codex:019f18df-4e55-73a1-91d9-83551639edbf --summary
+
+# 2c. Inspect a rollout file directly by path
+pnpm dev inspect /home/you/.codex/sessions/2026/06/30/rollout-2026-06-30T14-22-05-019f18df-4e55-73a1-91d9-83551639edbf.jsonl --summary
+
+# 3. Create a handoff package for Claude Code to pick up
+pnpm dev handoff codex:last --to claude
+
+# 3b. Same, but selecting a specific session
+pnpm dev handoff codex:019f18df-4e55-73a1-91d9-83551639edbf --to claude
+
+# 4. Inspect the most recent Claude session
+pnpm dev inspect claude:last --summary
+
+# 5. Hand the Claude session to Codex (last, exact ID, or unique prefix)
+pnpm dev handoff claude:last --to codex
+pnpm dev handoff claude:aaaaaaaa-1111-4aaa-8aaa-aaaaaaaaaaaa --to codex
+
+# 6. List this project's local handoffs (newest first)
+pnpm dev log
+
+# 6b. List handoffs from another project
+pnpm dev log --project /path/to/project
+
+# 7. Print the latest or a specific handoff brief
+pnpm dev show latest
+pnpm dev show <task-id>
+
+# 8. Show an overview for this project or another project
+pnpm dev status
+pnpm dev status --project /path/to/project
+```
+
+Handoffs are written under the source session's project directory as either
+`.hamma/tasks/<timestamp>-codex-to-claude/` or
+`.hamma/tasks/<timestamp>-claude-to-codex/`. The CLI then prints a suggested
+command, for example:
+
+```
+codex "Read .hamma/tasks/<id>/handoff.md and continue the task from the current repo state."
+```
+
+---
+
+## Install / dev setup
+
+Requirements: Node.js 20+ and [pnpm](https://pnpm.io/) 10+.
+
+```bash
+git clone https://github.com/<you>/hammadev.git
+cd hammadev
+pnpm install
+
+# Run the CLI directly via tsx (no build step needed for dev)
+pnpm dev --help
+```
+
+Typecheck:
+
+```bash
+pnpm typecheck
+```
+
+Build the compiled JS (`dist/`):
+
+```bash
+pnpm build
+```
+
+---
+
+## Commands
+
+| Command | Purpose |
+| --- | --- |
+| `hamma doctor` | Preflight check: Node version, `git` availability, Codex session presence, `projectPath` detection, and `.gitignore` safety. Exits non-zero on any failure. |
+| `hamma status [--project <path>]` | Show a read-only overview for the current or selected project: Git state, handoff count/latest route, Codex and Claude session counts, and whether `.hamma/` is ignored. |
+| `hamma list codex` | List Codex sessions found on this machine (newest first). |
+| `hamma list claude` | List candidate Claude Code session files found under `~/.claude`, `~/.config/claude`, and `~/.local/share/claude`. Claude files are never modified. |
+| `hamma inspect claude:last --shape` (also `claude:<sessionId>`) | **Experimental / read-only shape probe.** Reads a Claude Code `.jsonl` line-by-line and prints only structural stats — file size, line counts, top-level key frequency, `type`/role tallies, per-type field shapes, and any `cwd`/`projectPath` values. **No message text, prompt text, tool inputs, tool outputs, or file contents are ever printed.** Used to design the Claude parser without leaking session content. |
+| `hamma inspect claude:<target> [--summary]` | **Experimental conservative parser (v0.1).** Normalizes a Claude session into `HammaSession`. Only visible user/assistant text messages are included — `system`, `permission-mode`, `mode`, `file-history-snapshot`, `ai-title`, `last-prompt`, and `attachment` records are ignored, and assistant `thinking`/`tool_use` and user `tool_result` blocks are dropped. All emitted message content passes through the same secret redaction used for Codex. No Claude files are modified. |
+| `hamma inspect <target> [--summary]` | Print the normalized session as JSON. `<target>` accepts `codex:last`, `codex:<conversationId>`, `claude:last`, `claude:<sessionId>` (exact or unique prefix), a Codex rollout path, or an absolute UUID-named Claude session path. |
+| `hamma handoff codex:<target> --to claude [--no-gitignore]` | Generate a Codex → Claude handoff under the source project's `.hamma/tasks/`. |
+| `hamma handoff claude:<target> --to codex [--no-gitignore]` | Generate a Claude → Codex handoff under the Claude session's `projectPath`. The conservative parser excludes Claude internal/system/tool/thinking records. |
+| `hamma log [--project <path>]` | List local handoffs newest first for the current directory, or for the selected project. Shows task ID, agents, created time, `handoff.md` path, and the continue-from-here line when present. |
+| `hamma show latest` | Print the newest local `handoff.md` from the current directory. |
+| `hamma show <task-id>` | Print one local `handoff.md` by task ID from the current directory. |
+
+In dev, invoke via `pnpm dev <command>`. The `bin` entry is `hamma`, so once
+published/linked it can be invoked directly.
+
+---
+
+## Generated files
+
+Handoff artifacts are written under the *source project's* directory (the
+project Codex or Claude was working in), not this repo:
+
+```
+<project>/.hamma/tasks/<ISO-timestamp>-<source>-to-<target>/
+├── handoff.md            # short markdown brief for the target agent
+├── state.json            # structured task state
+├── session.json          # full normalized session
+├── timeline.md           # importance-filtered chronological view
+├── commands.md           # bucketed shell/tool command summary
+└── redaction-report.md   # secret-redaction summary
+```
+
+By default, HammaDev appends `.hamma/` to that project's `.gitignore` so
+handoff artifacts stay local. Pass `--no-gitignore` to skip.
+
+`hamma status`, `hamma log`, and `hamma show` are read-only. Status reads only
+project/Git metadata plus handoff or state metadata; these commands do not
+print `session.json` or raw transcript data.
+
+---
+
+## Security model
+
+- **Local only.** All parsing, redaction, and file writes happen on your
+  machine. There is no network call, no backend, no telemetry.
+- **Read-only against source sessions.** HammaDev never modifies Codex rollout
+  files or Claude session JSONL files.
+- **Best-effort secret redaction.** Common API-key patterns (OpenAI,
+  Anthropic, GitHub, Google, Slack, generic `key/token/secret/password = …`)
+  are replaced with `[REDACTED_SECRET]` in the emitted artifacts, and
+  counted in `redaction-report.md`. Redaction is regex-based and is *not*
+  a substitute for reviewing the handoff before sharing it.
+- **System / developer prompts omitted** from the handoff brief; the full
+  transcript still lives in `session.json` for local inspection.
+- **`.hamma/` is treated as local scratch.** It is gitignored in this repo
+  and auto-added to the source project's `.gitignore` on handoff.
+
+---
+
+## Roadmap
+
+Near-term:
+
+- Additional source adapters: Gemini CLI, opencode, Antigravity.
+- Richer task-ledger extraction (fewer parser warnings, better dedup).
+- More history filters and handoff retention controls.
+
+Later:
+
+- Optional backend for cross-machine handoff and team-shared memory.
+- Durable storage layer (CockroachDB) for multi-user deployments.
+- Editor / IDE integrations.
+
+Backend and CockroachDB are intentionally **not** part of the alpha — the
+current design is a local CLI you can audit end-to-end.
+
+---
+
+## License
+
+ISC. See `package.json`.

package/dist/adapters/claude/discover.js

@@ -0,0 +1,91 @@
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import readline from "node:readline";
+import fg from "fast-glob";
+import { candidateClaudeHomes, claudeProjectsGlobs, sessionIdFromFilename } from "./paths.js";
+const PEEK_MAX_LINES = 8;
+async function pathExists(p) {
+    try {
+        await fsp.access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function peekMetadata(filePath) {
+    const result = {};
+    let stream;
+    try {
+        stream = fs.createReadStream(filePath, { encoding: "utf8" });
+        const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+        let seen = 0;
+        for await (const line of rl) {
+            seen += 1;
+            if (!line.trim())
+                continue;
+            let obj;
+            try {
+                obj = JSON.parse(line);
+            }
+            catch {
+                if (seen >= PEEK_MAX_LINES)
+                    break;
+                continue;
+            }
+            if (!result.sessionId && typeof obj?.sessionId === "string") {
+                result.sessionId = obj.sessionId;
+            }
+            if (!result.projectPathHint && typeof obj?.cwd === "string") {
+                result.projectPathHint = obj.cwd;
+            }
+            if (result.sessionId && result.projectPathHint)
+                break;
+            if (seen >= PEEK_MAX_LINES)
+                break;
+        }
+    }
+    catch {
+        // Peek is best-effort; ignore read errors.
+    }
+    finally {
+        stream?.destroy();
+    }
+    return result;
+}
+export async function discoverClaudeSessions(claudeHomes = candidateClaudeHomes()) {
+    const refs = [];
+    for (const home of claudeHomes) {
+        if (!(await pathExists(home)))
+            continue;
+        const patterns = claudeProjectsGlobs(home);
+        const files = await fg(patterns, { onlyFiles: true, dot: true });
+        for (const file of files) {
+            let stat;
+            try {
+                stat = await fsp.stat(file);
+            }
+            catch {
+                continue;
+            }
+            if (!stat.isFile())
+                continue;
+            const { sessionId: peekedId, projectPathHint } = await peekMetadata(file);
+            const sessionId = peekedId ?? sessionIdFromFilename(file);
+            refs.push({
+                sourceCli: "claude",
+                path: file,
+                sizeBytes: stat.size,
+                lastUpdatedAt: stat.mtime.toISOString(),
+                sessionId,
+                projectPathHint,
+                claudeHome: home
+            });
+        }
+    }
+    return refs.sort((a, b) => {
+        const at = new Date(a.lastUpdatedAt).getTime();
+        const bt = new Date(b.lastUpdatedAt).getTime();
+        return bt - at;
+    });
+}

package/dist/adapters/claude/index.js

@@ -0,0 +1,18 @@
+import { discoverClaudeSessions } from "./discover.js";
+import { resolveClaudeTarget } from "./resolve.js";
+import { inspectClaudeShape } from "./shape.js";
+import { parseClaudeSession } from "./parse.js";
+export const ClaudeAdapter = {
+    async list(claudeHomes) {
+        return discoverClaudeSessions(claudeHomes);
+    },
+    async resolve(target, claudeHomes) {
+        return resolveClaudeTarget(target, { claudeHomes });
+    },
+    async inspectShape(filePath) {
+        return inspectClaudeShape(filePath);
+    },
+    async inspect(filePath) {
+        return parseClaudeSession(filePath);
+    }
+};

package/dist/adapters/claude/parse.js

@@ -0,0 +1,130 @@
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import readline from "node:readline";
+import { redactText } from "../../core/redact.js";
+import { sessionIdFromFilename } from "./paths.js";
+const IGNORED_TOP_TYPES = new Set([
+    "system",
+    "permission-mode",
+    "mode",
+    "file-history-snapshot",
+    "ai-title",
+    "last-prompt",
+    "attachment"
+]);
+function extractText(message) {
+    if (!message)
+        return undefined;
+    if (typeof message.content === "string") {
+        return message.content;
+    }
+    if (Array.isArray(message.content)) {
+        const parts = [];
+        for (const block of message.content) {
+            if (!block || typeof block !== "object")
+                continue;
+            if (block.type === "text" && typeof block.text === "string") {
+                parts.push(block.text);
+            }
+            // Deliberately skip: thinking, tool_use, tool_result, image, etc.
+        }
+        return parts.length > 0 ? parts.join("\n") : undefined;
+    }
+    return undefined;
+}
+function redactInto(session, text) {
+    const r = redactText(text);
+    session.security.redactionCount += r.count;
+    if (r.count > 0)
+        session.security.redacted = true;
+    return r.text;
+}
+export async function parseClaudeSession(sessionPath) {
+    try {
+        await fsp.access(sessionPath, fs.constants.R_OK);
+    }
+    catch {
+        throw new Error(`Claude session file is missing or not readable: ${sessionPath}`);
+    }
+    const session = {
+        meta: {
+            sourceCli: "claude",
+            sourceSessionId: sessionIdFromFilename(sessionPath) ?? "",
+            sourcePath: sessionPath
+        },
+        messages: [],
+        shellCommands: [],
+        parserWarnings: [],
+        security: {
+            redacted: false,
+            redactionCount: 0,
+            warnings: []
+        }
+    };
+    const stream = fs.createReadStream(sessionPath, { encoding: "utf8" });
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    let earliestTs;
+    let latestTs;
+    for await (const line of rl) {
+        if (!line.trim())
+            continue;
+        let obj;
+        try {
+            obj = JSON.parse(line);
+        }
+        catch {
+            session.parserWarnings.push("Skipped malformed JSONL line.");
+            continue;
+        }
+        if (obj === null || typeof obj !== "object" || Array.isArray(obj)) {
+            session.parserWarnings.push("Skipped non-object JSONL line.");
+            continue;
+        }
+        const type = typeof obj.type === "string" ? obj.type : "";
+        if (IGNORED_TOP_TYPES.has(type))
+            continue;
+        // Seed session id / project path from any record that carries them.
+        if (!session.meta.sourceSessionId && typeof obj.sessionId === "string") {
+            session.meta.sourceSessionId = obj.sessionId;
+        }
+        if (!session.meta.projectPath && typeof obj.cwd === "string") {
+            session.meta.projectPath = obj.cwd;
+        }
+        if (!session.meta.projectPath && typeof obj.projectPath === "string") {
+            session.meta.projectPath = obj.projectPath;
+        }
+        const timestamp = typeof obj.timestamp === "string" ? obj.timestamp : undefined;
+        if (timestamp) {
+            if (!earliestTs || timestamp < earliestTs)
+                earliestTs = timestamp;
+            if (!latestTs || timestamp > latestTs)
+                latestTs = timestamp;
+        }
+        if (type === "user" && obj.message?.role === "user") {
+            const raw = extractText(obj.message);
+            if (raw && raw.trim().length > 0) {
+                session.messages.push({
+                    role: "user",
+                    content: redactInto(session, raw),
+                    timestamp
+                });
+            }
+            continue;
+        }
+        if (type === "assistant" && obj.message?.role === "assistant") {
+            const raw = extractText(obj.message);
+            if (raw && raw.trim().length > 0) {
+                session.messages.push({
+                    role: "assistant",
+                    content: redactInto(session, raw),
+                    timestamp
+                });
+            }
+            continue;
+        }
+    }
+    if (earliestTs)
+        session.meta.startedAt = earliestTs;
+    session.meta.lastUpdatedAt = latestTs ?? new Date().toISOString();
+    return session;
+}

package/dist/adapters/claude/paths.js

@@ -0,0 +1,26 @@
+import os from "node:os";
+import path from "node:path";
+export function defaultClaudeHome() {
+    return path.join(os.homedir(), ".claude");
+}
+export function candidateClaudeHomes() {
+    const home = os.homedir();
+    return [
+        path.join(home, ".claude"),
+        path.join(home, ".config", "claude"),
+        path.join(home, ".local", "share", "claude")
+    ];
+}
+export function claudeProjectsGlobs(claudeHome) {
+    return [
+        path.join(claudeHome, "projects", "**", "*.jsonl"),
+        path.join(claudeHome, "sessions", "**", "*.jsonl"),
+        path.join(claudeHome, "history", "**", "*.jsonl")
+    ];
+}
+const UUID_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+export function sessionIdFromFilename(filePath) {
+    const base = path.basename(filePath, path.extname(filePath));
+    const match = base.match(UUID_RE);
+    return match ? match[0] : undefined;
+}

package/dist/adapters/claude/resolve.js

@@ -0,0 +1,34 @@
+import { discoverClaudeSessions } from "./discover.js";
+const CLAUDE_PREFIX = "claude:";
+export async function resolveClaudeTarget(target, options = {}) {
+    if (!target.startsWith(CLAUDE_PREFIX)) {
+        throw new Error(`Invalid Claude target '${target}'. Expected 'claude:last' or 'claude:<sessionId>'.`);
+    }
+    const rest = target.slice(CLAUDE_PREFIX.length);
+    if (!rest) {
+        throw new Error(`Invalid Claude target '${target}'. Expected 'claude:last' or 'claude:<sessionId>'.`);
+    }
+    const sessions = await discoverClaudeSessions(options.claudeHomes);
+    if (sessions.length === 0) {
+        throw new Error("No Claude Code session files found. Looked under ~/.claude, ~/.config/claude, and ~/.local/share/claude.");
+    }
+    if (rest === "last")
+        return sessions[0].path;
+    return resolveBySessionId(rest, sessions);
+}
+function resolveBySessionId(id, sessions) {
+    const withIds = sessions.filter((s) => !!s.sessionId);
+    const exact = withIds.find((s) => s.sessionId === id);
+    if (exact)
+        return exact.path;
+    const prefixMatches = withIds.filter((s) => s.sessionId.startsWith(id));
+    if (prefixMatches.length === 1)
+        return prefixMatches[0].path;
+    if (prefixMatches.length > 1) {
+        const list = prefixMatches
+            .map((s) => `  - ${s.sessionId} (${s.path})`)
+            .join("\n");
+        throw new Error(`Ambiguous Claude sessionId prefix '${id}'. Matches ${prefixMatches.length} sessions:\n${list}`);
+    }
+    throw new Error(`No Claude session found with sessionId matching '${id}'.`);
+}

package/dist/adapters/claude/shape.js

@@ -0,0 +1,86 @@
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import readline from "node:readline";
+function jsType(v) {
+    if (v === null)
+        return "null";
+    if (Array.isArray(v))
+        return "array";
+    return typeof v;
+}
+function mergeType(existing, next) {
+    if (!existing)
+        return next;
+    if (existing === next)
+        return existing;
+    const parts = new Set(existing.split("|"));
+    parts.add(next);
+    return Array.from(parts).sort().join("|");
+}
+export async function inspectClaudeShape(filePath) {
+    const stat = await fsp.stat(filePath);
+    const report = {
+        path: filePath,
+        sizeBytes: stat.size,
+        totalLines: 0,
+        parsedLines: 0,
+        malformedLines: 0,
+        topLevelKeyFrequency: {},
+        typeCounts: {},
+        roleCounts: {},
+        shapeByType: {},
+        cwdValues: [],
+        projectPathValues: []
+    };
+    const cwdSet = new Set();
+    const projectPathSet = new Set();
+    const stream = fs.createReadStream(filePath, { encoding: "utf8" });
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    for await (const line of rl) {
+        if (!line.trim())
+            continue;
+        report.totalLines += 1;
+        let obj;
+        try {
+            obj = JSON.parse(line);
+        }
+        catch {
+            report.malformedLines += 1;
+            continue;
+        }
+        if (obj === null || typeof obj !== "object" || Array.isArray(obj)) {
+            report.malformedLines += 1;
+            continue;
+        }
+        report.parsedLines += 1;
+        const typeLabel = typeof obj.type === "string" && obj.type.length > 0
+            ? obj.type
+            : "<no-type>";
+        report.typeCounts[typeLabel] = (report.typeCounts[typeLabel] ?? 0) + 1;
+        const role = typeof obj?.message?.role === "string"
+            ? obj.message.role
+            : typeof obj?.role === "string"
+                ? obj.role
+                : undefined;
+        if (role) {
+            report.roleCounts[role] = (report.roleCounts[role] ?? 0) + 1;
+        }
+        for (const key of Object.keys(obj)) {
+            report.topLevelKeyFrequency[key] =
+                (report.topLevelKeyFrequency[key] ?? 0) + 1;
+        }
+        const shape = (report.shapeByType[typeLabel] ??= {});
+        for (const [k, v] of Object.entries(obj)) {
+            shape[k] = mergeType(shape[k], jsType(v));
+        }
+        if (typeof obj.cwd === "string" && obj.cwd.length > 0) {
+            cwdSet.add(obj.cwd);
+        }
+        if (typeof obj.projectPath === "string" && obj.projectPath.length > 0) {
+            projectPathSet.add(obj.projectPath);
+        }
+    }
+    report.cwdValues = Array.from(cwdSet).sort();
+    report.projectPathValues = Array.from(projectPathSet).sort();
+    return report;
+}

package/dist/adapters/codex/discover.js

@@ -0,0 +1,27 @@
+import fs from "node:fs/promises";
+import fg from "fast-glob";
+import { codexSessionsGlob, defaultCodexHome, parseRolloutFilename } from "./paths.js";
+export async function discoverCodexSessions(codexHome = defaultCodexHome()) {
+    const pattern = codexSessionsGlob(codexHome);
+    const files = await fg(pattern, { onlyFiles: true, dot: true });
+    const sessions = [];
+    for (const file of files) {
+        const parsed = parseRolloutFilename(file);
+        if (!parsed)
+            continue;
+        const stat = await fs.stat(file);
+        sessions.push({
+            sourceCli: "codex",
+            conversationId: parsed.conversationId,
+            path: file,
+            startedAt: parsed.startedAt,
+            lastUpdatedAt: stat.mtime.toISOString(),
+            sizeBytes: stat.size
+        });
+    }
+    return sessions.sort((a, b) => {
+        const at = a.lastUpdatedAt ? new Date(a.lastUpdatedAt).getTime() : 0;
+        const bt = b.lastUpdatedAt ? new Date(b.lastUpdatedAt).getTime() : 0;
+        return bt - at;
+    });
+}

package/dist/adapters/codex/index.js

@@ -0,0 +1,18 @@
+import { discoverCodexSessions } from "./discover.js";
+import { parseCodexRollout } from "./rollout.js";
+import { resolveCodexTarget } from "./resolve.js";
+export const CodexAdapter = {
+    async list() {
+        return discoverCodexSessions();
+    },
+    async latest() {
+        const sessions = await discoverCodexSessions();
+        return sessions[0] ?? null;
+    },
+    async resolve(target, codexHome) {
+        return resolveCodexTarget(target, { codexHome });
+    },
+    async inspect(sessionPath) {
+        return parseCodexRollout(sessionPath);
+    }
+};