@fclef819/cdx 0.1.0 → 0.1.1

package/README.md

@@ -30,9 +30,16 @@ Each line is:
 
 - `cdx` to select or create a session
 - `cdx here` to use `.cdx` from the current directory without parent search
+- `cdx new` to create a new session without the selection UI
+- `cdx new here` or `cdx here new` to create a new session using `.cdx` from the current directory
 - `cdx rm` to remove a session from `.cdx`
-- `cdx rm here` or `cdx here rm` to remove a session from `.cdx` in the current directory
+- `cdx init` to create an empty `.cdx` in the current directory
+- `cdx add <uuid> <label>` to add a session to `.cdx`
+- `cdx add <uuid>` to add a session and prompt for the label
+- `cdx add` to add a session and prompt for uuid and label
 - `cdx -h`, `cdx --help`, or `cdx help` to show help
+- `cdx -V` or `cdx --version` to show version
+- `cdx -v` or `cdx --verbose` to show verbose logs
 
 ## Install (npm)
 

package/bin/cdx.js

@@ -11,11 +11,16 @@ const CODEX_HOME = path.join(process.env.HOME || "", ".codex");
 const HISTORY_PATH = path.join(CODEX_HOME, "history.jsonl");
 const SESSIONS_DIR = path.join(CODEX_HOME, "sessions");
 
-function findCdxFile(startDir) {
+function logVerbose(message, enabled) {
+  if (enabled) console.log(message);
+}
+
+function findCdxFile(startDir, verbose) {
   let dir = path.resolve(startDir);
   while (true) {
     const candidate = path.join(dir, CDX_FILENAME);
     if (fs.existsSync(candidate)) {
+      logVerbose(`Found .cdx at: ${candidate}`, verbose);
       return { dir, filePath: candidate };
     }
     const parent = path.dirname(dir);
@@ -46,16 +51,19 @@ function sanitizeLabel(label) {
   return label.replace(/[\t\n\r]+/g, " ").trim();
 }
 
-function appendEntry(filePath, entry) {
+function appendEntry(filePath, entry, verbose) {
   const line = `${entry.uuid}\t${entry.label}\n`;
+  logVerbose(`Appending entry to ${filePath}`, verbose);
   fs.appendFileSync(filePath, line, "utf8");
 }
 
-function writeEntries(filePath, entries) {
+function writeEntries(filePath, entries, verbose) {
   if (!entries.length) {
+    logVerbose(`Removing empty .cdx at ${filePath}`, verbose);
     if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
     return;
   }
+  logVerbose(`Writing ${entries.length} entries to ${filePath}`, verbose);
   const content = entries.map((e) => `${e.uuid}\t${e.label}`).join("\n") + "\n";
   fs.writeFileSync(filePath, content, "utf8");
 }
@@ -95,17 +103,18 @@ function readSessionIdFromFile(filePath) {
   return extractIdFromFilename(filePath);
 }
 
-function getLatestSessionSnapshot() {
+function getLatestSessionSnapshot(verbose) {
   const files = [];
   collectSessionFiles(SESSIONS_DIR, files);
   if (!files.length) return null;
   files.sort((a, b) => a.mtimeMs - b.mtimeMs);
   const latest = files[files.length - 1];
   const id = readSessionIdFromFile(latest.path);
+  logVerbose(`Latest session file: ${latest.path}`, verbose);
   return { id, mtimeMs: latest.mtimeMs, path: latest.path };
 }
 
-function getLastHistorySessionId() {
+function getLastHistorySessionId(verbose) {
   if (!fs.existsSync(HISTORY_PATH)) return null;
   const lines = fs.readFileSync(HISTORY_PATH, "utf8").trim().split("\n");
   for (let i = lines.length - 1; i >= 0; i -= 1) {
@@ -116,10 +125,11 @@ function getLastHistorySessionId() {
       // ignore malformed lines
     }
   }
+  logVerbose("No session_id found in history.jsonl", verbose);
   return null;
 }
 
-function getNewestHistorySessionIdSince(previousId) {
+function getNewestHistorySessionIdSince(previousId, verbose) {
   if (!fs.existsSync(HISTORY_PATH)) return null;
   const lines = fs.readFileSync(HISTORY_PATH, "utf8").trim().split("\n");
   for (let i = lines.length - 1; i >= 0; i -= 1) {
@@ -132,10 +142,12 @@ function getNewestHistorySessionIdSince(previousId) {
       // ignore malformed lines
     }
   }
+  logVerbose("No new session_id found in history.jsonl", verbose);
   return null;
 }
 
-function runCodex(args, cwd) {
+function runCodex(args, cwd, verbose) {
+  logVerbose(`Running codex ${args.join(" ")}`.trim(), verbose);
   const check = spawnSync("codex", ["--version"], { stdio: "ignore" });
   if (check.error && check.error.code === "ENOENT") {
     console.error(
@@ -180,24 +192,36 @@ async function promptLabel() {
   return response.label;
 }
 
+async function promptUuid() {
+  const response = await prompts({
+    type: "text",
+    name: "uuid",
+    message: "Session UUID",
+    validate: (value) => (value && value.trim() ? true : "UUID is required")
+  });
+  return response.uuid;
+}
+
 async function runDefault(startDir, options) {
-  const found = options.here ? null : findCdxFile(startDir);
+  const found = options.here ? null : findCdxFile(startDir, options.verbose);
   const workDir = found ? found.dir : startDir;
   const cdxPath = found ? found.filePath : path.join(startDir, CDX_FILENAME);
   const entries = loadEntries(found?.filePath);
 
   console.log(`.cdx: ${cdxPath}`);
-  const selection = await selectSession(entries);
+  const selection = options.forceNew
+    ? { type: "new" }
+    : await selectSession(entries);
   if (!selection) return;
 
   if (selection.type === "new") {
     const labelInput = await promptLabel();
     if (!labelInput) return;
     const label = sanitizeLabel(labelInput);
-    const previousHistoryId = getLastHistorySessionId();
-    const previousSession = getLatestSessionSnapshot();
-    runCodex([], workDir);
-    const latestSession = getLatestSessionSnapshot();
+    const previousHistoryId = getLastHistorySessionId(options.verbose);
+    const previousSession = getLatestSessionSnapshot(options.verbose);
+    runCodex([], workDir, options.verbose);
+    const latestSession = getLatestSessionSnapshot(options.verbose);
     let newId = null;
     if (
       latestSession &&
@@ -208,31 +232,28 @@ async function runDefault(startDir, options) {
     ) {
       newId = latestSession.id;
     } else if (previousHistoryId) {
-      newId = getNewestHistorySessionIdSince(previousHistoryId);
+      newId = getNewestHistorySessionIdSince(previousHistoryId, options.verbose);
     }
     if (!newId) {
       console.error("Could not determine new session UUID; not updating .cdx.");
       return;
     }
-    appendEntry(cdxPath, { uuid: newId, label });
+    appendEntry(cdxPath, { uuid: newId, label }, options.verbose);
     return;
   }
 
   if (selection.type === "resume") {
-    runCodex(["resume", selection.entry.uuid], workDir);
+    runCodex(["resume", selection.entry.uuid], workDir, options.verbose);
   }
 }
 
-async function runRemove(startDir, options) {
-  const found = options.here ? null : findCdxFile(startDir);
-  const targetPath = found ? found.filePath : path.join(startDir, CDX_FILENAME);
-  const targetDir = found ? found.dir : startDir;
+async function runRemove(startDir, verbose) {
+  const found = findCdxFile(startDir, verbose);
   if (!found) {
-    if (!fs.existsSync(targetPath)) {
-      console.log("No .cdx file found.");
-      return;
-    }
+    console.log("No .cdx file found.");
+    return;
   }
+  const targetPath = found.filePath;
   const entries = loadEntries(targetPath);
   if (!entries.length) {
     console.log("No sessions to remove.");
@@ -252,7 +273,48 @@ async function runRemove(startDir, options) {
 
   if (!response.selection) return;
   const remaining = entries.filter((entry) => entry.uuid !== response.selection);
-  writeEntries(targetPath, remaining);
+  writeEntries(targetPath, remaining, verbose);
+}
+
+function printAddHelp() {
+  console.log(`Usage:
+  cdx add <uuid> <label>
+  cdx add <uuid>
+  cdx add`);
+}
+
+function runInit(startDir, verbose) {
+  const cdxPath = path.join(startDir, CDX_FILENAME);
+  if (fs.existsSync(cdxPath)) {
+    console.log(".cdx already exists in the current directory.");
+    return;
+  }
+  fs.writeFileSync(cdxPath, "", "utf8");
+  logVerbose(`Created .cdx at ${cdxPath}`, verbose);
+}
+
+async function runAdd(startDir, args, verbose) {
+  if (args.length > 3 || (args.length === 2 && args[1] === "")) {
+    printAddHelp();
+    return;
+  }
+
+  const found = findCdxFile(startDir, verbose);
+  const cdxPath = found ? found.filePath : path.join(startDir, CDX_FILENAME);
+  let uuid = args[1];
+  let label = args[2];
+
+  if (!uuid) {
+    uuid = await promptUuid();
+  }
+  if (!uuid) return;
+
+  if (!label) {
+    label = await promptLabel();
+  }
+  if (!label) return;
+
+  appendEntry(cdxPath, { uuid: uuid.trim(), label: sanitizeLabel(label) }, verbose);
 }
 
 function printHelp() {
@@ -261,16 +323,37 @@ function printHelp() {
 Usage:
   cdx
   cdx here
+  cdx new
+  cdx new here
+  cdx here new
   cdx rm
-  cdx rm here
-  cdx here rm
+  cdx init
+  cdx add <uuid> <label>
+  cdx add <uuid>
+  cdx add
+  cdx -V
+  cdx --version
+  cdx -v
+  cdx --verbose
 
 Notes:
   - "here" skips parent directory search and uses .cdx in the current directory
   - the selected .cdx path is shown before session selection
+  - use -h, --help, or help to show this message
+  - use -v or --verbose to show debug logs
 `);
 }
 
+function printVersion() {
+  try {
+    const pkgPath = path.join(__dirname, "..", "package.json");
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    console.log(pkg.version || "unknown");
+  } catch {
+    console.log("unknown");
+  }
+}
+
 async function main() {
   const args = process.argv.slice(2);
   const subcommand = args[0];
@@ -280,23 +363,45 @@ async function main() {
     args.includes("-h") ||
     args.includes("--help") ||
     args.includes("help");
+  const wantsVersion = args.includes("-V") || args.includes("--version");
+  const verbose = args.includes("-v") || args.includes("--verbose");
 
   if (wantsHelp) {
     printHelp();
     return;
   }
 
-  if (subcommand === "rm" || (here && args.includes("rm"))) {
-    await runRemove(startDir, { here });
+  if (wantsVersion) {
+    printVersion();
+    return;
+  }
+
+  if (subcommand === "rm") {
+    await runRemove(startDir, verbose);
+    return;
+  }
+
+  if (subcommand === "add") {
+    await runAdd(startDir, args, verbose);
+    return;
+  }
+
+  if (subcommand === "init") {
+    runInit(startDir, verbose);
+    return;
+  }
+
+  if (subcommand === "new" || (here && args.includes("new"))) {
+    await runDefault(startDir, { here, forceNew: true, verbose });
     return;
   }
 
   if (subcommand === "here" || here) {
-    await runDefault(startDir, { here: true });
+    await runDefault(startDir, { here: true, verbose });
     return;
   }
 
-  await runDefault(startDir, { here: false });
+  await runDefault(startDir, { here: false, verbose });
 }
 
 main().catch((err) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fclef819/cdx",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Codex session wrapper",
   "keywords": [
     "codex",