@everme/codex 0.4.0

package/README.md

@@ -0,0 +1,27 @@
+# @everme/codex
+
+Native EverMe lifecycle hook runner for Codex. It is invoked by the EverMe
+Codex marketplace plugin and uses the stable `/api/v1/mem/*` BFF contract.
+
+## Lifecycle
+
+- `SessionStart`: inject the EverMe profile snapshot.
+- `UserPromptSubmit`: sanitize the prompt, search top 10 memories, and inject
+  recall without passive profile rows by default.
+- `Stop`: stream the Codex rollout, save only the latest user turn, and flush
+  extraction every five turns.
+- `PreCompact`: send a flush-only request.
+
+All hook failures are fail-open and credentials are redacted from diagnostics.
+`evercli plugin install codex` writes credentials to `~/.codex/everme.env`
+with mode `0600`; the user reviews and trusts the commands in `/hooks`.
+
+## Configuration
+
+The shared hook knobs are `EVERME_INJECT_TOPK`, `EVERME_INJECT_PROFILE`,
+`EVERME_INJECT_MIN_SCORE`, `EVERME_FLUSH_EVERY_TURNS`,
+`EVERME_FLUSH_MODE`, and `EVERME_STATE_DIR`.
+
+## License
+
+Apache-2.0.

package/bin/hook.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+
+import { redactError, runHook } from "@everme/agent-sdk";
+import { codexAdapter } from "../src/adapter.js";
+
+main().catch((error) => {
+  const reason = redactError(error).replace(/\s+/g, " ").trim();
+  process.stderr.write(`EverMe Codex hook degraded: ${reason}\n`);
+  process.exitCode = 0;
+});
+
+async function main() {
+  const [, , command, event] = process.argv;
+  if (command !== "hook" || !event) return;
+  const input = await readStdinJSON();
+  const output = await runHook(event, input, codexAdapter);
+  if (output && Object.keys(output).length) {
+    process.stdout.write(JSON.stringify(output));
+  }
+}
+
+async function readStdinJSON() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  if (!chunks.length) return {};
+  try {
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  } catch {
+    return {};
+  }
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@everme/codex",
+  "version": "0.4.0",
+  "type": "module",
+  "description": "Native EverMe lifecycle hooks for Codex.",
+  "license": "Apache-2.0",
+  "bin": {
+    "everme-codex": "./bin/hook.js"
+  },
+  "files": [
+    "bin/",
+    "src/"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "test": "node --test tests/transcript.test.js tests/adapter.test.js tests/hook.test.js"
+  },
+  "keywords": [
+    "evermind",
+    "everme",
+    "codex",
+    "memory",
+    "hooks"
+  ],
+  "homepage": "https://everme.evermind.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/EverMind-AI/EverMe.git",
+    "directory": "plugins/codex"
+  },
+  "bugs": {
+    "url": "https://github.com/EverMind-AI/EverMe/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "dependencies": {
+    "@everme/agent-sdk": "^0.4.0"
+  }
+}

package/src/adapter.js

@@ -0,0 +1,41 @@
+import os from "node:os";
+import path from "node:path";
+import { readLastTurn } from "./transcript.js";
+
+const CONTEXT_EVENTS = new Set(["SessionStart", "UserPromptSubmit"]);
+
+export const codexAdapter = {
+  platform: "codex",
+
+  envFile() {
+    return process.env.EVERME_ENV_FILE_PATH || path.join(os.homedir(), ".codex", "everme.env");
+  },
+
+  normalizeInput(rawInput) {
+    return {
+      // No session_id → empty (writes are skipped downstream), like
+      // cursor/devin: a constant fallback would merge unrelated sessions
+      // into one conversation on the backend.
+      sessionId: rawInput?.session_id || "",
+      transcriptPath: rawInput?.transcript_path || "",
+      cwd: rawInput?.cwd || "",
+      prompt: rawInput?.prompt || "",
+      turnId: rawInput?.turn_id || "",
+      source: rawInput?.source || "",
+    };
+  },
+
+  readLastTurn(input) {
+    return readLastTurn(input?.transcriptPath);
+  },
+
+  formatOutput(event, { block = "" } = {}) {
+    if (!CONTEXT_EVENTS.has(event) || !block) return {};
+    return {
+      hookSpecificOutput: {
+        hookEventName: event,
+        additionalContext: block,
+      },
+    };
+  },
+};

package/src/transcript.js

@@ -0,0 +1,108 @@
+import { createReadStream } from "node:fs";
+import { createInterface } from "node:readline";
+import { capRunes } from "@everme/agent-sdk";
+
+export async function readLastTurn(transcriptPath) {
+  if (!transcriptPath) return [];
+  const lines = createInterface({
+    input: createReadStream(transcriptPath, { encoding: "utf8" }),
+    crlfDelay: Infinity,
+  });
+  let delta = [];
+  let foundUser = false;
+
+  for await (const line of lines) {
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (event?.type !== "response_item" || !event.payload) continue;
+    const message = mapPayload(event.payload, event.timestamp);
+    if (!message) continue;
+
+    if (message.role === "user") {
+      delta = [message];
+      foundUser = true;
+    } else if (foundUser) {
+      delta.push(message);
+    }
+  }
+  return foundUser ? delta : [];
+}
+
+function mapPayload(payload, timestampValue) {
+  const timestamp = normalizeTimestamp(timestampValue);
+  if (payload.type === "message") {
+    if (payload.role !== "user" && payload.role !== "assistant") return null;
+    const content = contentText(payload.content);
+    if (!content) return null;
+    return { role: payload.role, ...stamp(timestamp), content };
+  }
+  if (payload.type === "function_call") {
+    return {
+      role: "assistant",
+      ...stamp(timestamp),
+      toolCalls: [{
+        id: payload.call_id || `codex_tool_${timestamp ?? "untimed"}`,
+        type: "function",
+        name: payload.name || "unknown",
+        arguments: argumentText(payload.arguments),
+      }],
+    };
+  }
+  if (payload.type === "function_call_output" && payload.call_id) {
+    return {
+      role: "tool",
+      ...stamp(timestamp),
+      toolCallId: payload.call_id,
+      content: capText(payload.output || "tool result"),
+    };
+  }
+  return null;
+}
+
+function stamp(timestamp) {
+  return timestamp === undefined ? {} : { timestamp };
+}
+
+function contentText(content) {
+  if (typeof content === "string") return capText(content);
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const item of content) {
+    if (typeof item === "string") {
+      parts.push(item);
+    } else if (["input_text", "output_text", "text"].includes(item?.type) && typeof item.text === "string") {
+      parts.push(item.text);
+    }
+  }
+  return capText(parts.join("\n"));
+}
+
+function argumentText(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value ?? {});
+  } catch {
+    return "{}";
+  }
+}
+
+function normalizeTimestamp(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value > 10_000_000_000 ? Math.trunc(value) : Math.trunc(value * 1000);
+  }
+  const parsed = Date.parse(value);
+  // undefined — never 0: 0 is a finite epoch (1970) that the SDK would ship
+  // as-is, while a missing timestamp makes the SDK stamp Date.now() instead,
+  // keeping the epoch-ms wire contract honest.
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+// SDK capRunes keeps head AND tail (0.7 head ratio) so the end of a long
+// tool output — exit status, root-cause line — survives truncation.
+function capText(value) {
+  return capRunes(String(value || "").trim());
+}