reclaude 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dongwook-chan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,79 @@
+# total-reclaude
+
+Interactive CLI session picker for [Claude Code](https://docs.anthropic.com/en/docs/claude-code). Browse, filter, rename, and resume all your sessions from the terminal.
+
+## Installation
+
+```bash
+npx total-reclaude
+```
+
+Or install globally:
+
+```bash
+npm install -g total-reclaude
+total-reclaude
+```
+
+### Prerequisites
+
+- [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code) must be installed and on your PATH
+- Node.js >= 14
+
+## Screenshot
+
+```
+  Claude Code Sessions
+  ─────────────────────────────────────────────────────────────
+
+       Title                                Project               Modified          Session
+
+  >  1  minimize-sys-prompt                  my-project            03/07/2026, 17:06  6566b87b
+     2  debug-auth-flow                      my-app                03/07/2026, 15:51  eec06353
+     3  refactor-api-layer                   backend               03/07/2026, 15:41  d8d86cb2
+     4  add-dark-mode                        frontend              03/07/2026, 15:41  69b5fb55
+     5  how do I fix this bug?               server                03/07/2026, 15:41  5ec54a4c
+
+  Page 1/1  ←/→ page  |  ↑/↓ select  |  Enter resume  |  r rename  |  / name  |  p path  |  s settings  |  q quit
+```
+
+- **Bold** titles = named sessions (with custom title)
+- *Dim italic* titles = unnamed sessions (showing first user message)
+
+## Keybindings
+
+| Key | Action |
+|-----|--------|
+| `↑` / `↓` | Move cursor |
+| `Enter` | Resume selected session |
+| `r` | Rename selected session |
+| `/` | Filter sessions by name |
+| `p` | Filter sessions by project path |
+| `s` | Open settings |
+| `←` / `→` | Navigate pages |
+| `ESC` | Cancel / go back |
+| `q` | Quit |
+| `Ctrl+C` | Quit |
+
+## Settings
+
+Press `s` to open the settings panel:
+
+| Setting | Description |
+|---------|-------------|
+| Full directory path | Show full `cwd` instead of short project name |
+| Full session ID | Show complete session ID instead of first 8 characters |
+| Page size | Number of sessions per page (5-50, adjustable with `-`/`+`) |
+| Locale | Date format locale (e.g. `en-US`, `ko-KR`, `sv-SE`) |
+
+Settings are saved to `~/.config/total-reclaude/config.json`.
+
+## How it works
+
+total-reclaude scans `~/.claude/projects/` for session files (`.jsonl`). Sessions with a custom title are shown in bold; unnamed sessions display the first user message in dim italic as a fallback title. All sessions are sorted by last modified time, with caching (`~/.cache/total-reclaude/sessions.json`) for fast startup.
+
+When you select a session, it runs `claude --resume <session-id>` to resume it.
+
+## License
+
+[MIT](LICENSE)

package/index.js

@@ -0,0 +1,964 @@
+#!/usr/bin/env node
+// Interactive Claude Code session picker with pagination and filtering
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { spawnSync } = require("child_process");
+
+const CONFIG_PATH = path.join(
+  os.homedir(),
+  ".config",
+  "total-reclaude",
+  "config.json"
+);
+
+// Column definitions: id → { label, width, get(session, config) }
+const COLUMN_DEFS = {
+  title:        { label: "Title",         width: 35, get: (s) => s.title || s.firstMessage },
+  firstMessage: { label: "First Message", width: 35, get: (s) => s.firstMessage },
+  project:      { label: "Project",       width: 20, get: (s) => s.proj },
+  path:         { label: "Directory",     width: 40, get: (s) => s.cwd },
+  modified:     { label: "Modified",      width: 20, get: (s, cfg) => formatDate(s.mtime, cfg) },
+  sid:          { label: "Session",       width: 8,  get: (s) => s.sid.slice(0, 8) },
+  sid_full:     { label: "Session ID",    width: 36, get: (s) => s.sid },
+};
+const ALL_COLUMN_IDS = Object.keys(COLUMN_DEFS);
+const DEFAULT_COLUMNS = ["title", "project", "modified", "sid"];
+
+const DEFAULT_CONFIG = {
+  pageSize: 10,
+  locale: "",
+  columns: DEFAULT_COLUMNS,
+};
+
+function formatDate(mtime, config) {
+  return new Date(mtime).toLocaleString(config.locale || undefined, {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false,
+  });
+}
+
+function loadConfig() {
+  try {
+    const raw = { ...DEFAULT_CONFIG, ...JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8")) };
+    raw.pageSize = Math.max(5, Math.min(50, parseInt(raw.pageSize, 10) || 10));
+    raw.locale = typeof raw.locale === "string" ? raw.locale : "";
+    // Validate columns
+    if (!Array.isArray(raw.columns) || raw.columns.length === 0) {
+      raw.columns = DEFAULT_COLUMNS.slice();
+    } else {
+      raw.columns = raw.columns.filter((c) => ALL_COLUMN_IDS.includes(c));
+      if (raw.columns.length === 0) raw.columns = DEFAULT_COLUMNS.slice();
+    }
+    return raw;
+  } catch {
+    return { ...DEFAULT_CONFIG, columns: DEFAULT_COLUMNS.slice() };
+  }
+}
+
+function saveConfig(config) {
+  const dir = path.dirname(CONFIG_PATH);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
+}
+
+const CACHE_PATH = path.join(
+  os.homedir(),
+  ".cache",
+  "total-reclaude",
+  "sessions.json"
+);
+
+function loadCache() {
+  try {
+    return JSON.parse(fs.readFileSync(CACHE_PATH, "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+function saveCache(cache) {
+  const dir = path.dirname(CACHE_PATH);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(CACHE_PATH, JSON.stringify(cache));
+}
+
+function extractProjName(projDir) {
+  const homePrefix = os.homedir().replace(/\//g, "-");
+  if (projDir.startsWith(homePrefix)) {
+    const rest = projDir.slice(homePrefix.length).replace(/^-/, "");
+    return rest || "~";
+  }
+  return projDir;
+}
+
+function extractFirstUserMessage(lines) {
+  for (const line of lines) {
+    if (!line || !line.includes('"user"')) continue;
+    try {
+      const d = JSON.parse(line);
+      if (d.type !== "user") continue;
+      const content = d.message && d.message.content;
+      if (!content) continue;
+      let text = "";
+      if (typeof content === "string") {
+        text = content;
+      } else if (Array.isArray(content)) {
+        for (const c of content) {
+          if (c && c.type === "text" && c.text) {
+            text = c.text;
+            break;
+          }
+        }
+      }
+      text = text.trim().split("\n")[0].trim();
+      if (text && !text.startsWith("[")) return text;
+    } catch {} // malformed JSONL lines are expected, skip
+  }
+  return "";
+}
+
+function parseSessionFile(fpath) {
+  const content = fs.readFileSync(fpath, "utf8");
+  const lines = content.split("\n");
+
+  const titles = [];
+  let cwd = null;
+  let sid = null;
+
+  for (const line of lines) {
+    if (!line) continue;
+    if (line.includes('"custom-title"')) {
+      try {
+        const d = JSON.parse(line);
+        if (d.type === "custom-title") titles.push(d);
+      } catch {} // malformed JSONL lines are expected, skip
+    }
+    if (!cwd && line.includes('"cwd"')) {
+      try {
+        const d = JSON.parse(line);
+        if (d.cwd) cwd = d.cwd;
+      } catch {} // malformed JSONL lines are expected, skip
+    }
+    if (!sid && line.includes('"sessionId"')) {
+      try {
+        const d = JSON.parse(line);
+        if (d.sessionId) sid = d.sessionId;
+      } catch {} // malformed JSONL lines are expected, skip
+    }
+  }
+
+  let title = "";
+  let sessionId = sid || "";
+
+  if (titles.length > 0) {
+    const last = titles[titles.length - 1];
+    title = last.customTitle || "";
+    sessionId = last.sessionId || sessionId;
+  }
+
+  const firstMessage = extractFirstUserMessage(lines);
+  if (!title && !firstMessage) return null;
+
+  return {
+    sid: sessionId,
+    title,
+    firstMessage,
+    cwd: cwd || "",
+  };
+}
+
+function getSessions() {
+  const projectsDir = path.join(os.homedir(), ".claude", "projects");
+  if (!fs.existsSync(projectsDir)) return [];
+
+  const cache = loadCache();
+  const cachedDirs = cache.dirs || {};
+  const newDirs = {};
+  const sessions = [];
+  let dirty = false;
+
+  for (const projDir of fs.readdirSync(projectsDir)) {
+    const projPath = path.join(projectsDir, projDir);
+    let dirStat;
+    try {
+      dirStat = fs.statSync(projPath);
+    } catch {
+      continue;
+    }
+    if (!dirStat.isDirectory()) continue;
+
+    const dirMtime = dirStat.mtimeMs;
+    const cachedDir = cachedDirs[projDir];
+    const proj = extractProjName(projDir);
+
+    if (cachedDir && cachedDir.dmtime === dirMtime) {
+      newDirs[projDir] = cachedDir;
+      const files = cachedDir.files || {};
+      for (const [fname, entry] of Object.entries(files)) {
+        sessions.push({ mtime: entry.mtime, proj, ...entry.data, fpath: path.join(projPath, fname) });
+      }
+      continue;
+    }
+
+    dirty = true;
+    const cachedFiles = (cachedDir && cachedDir.files) || {};
+    const newFiles = {};
+
+    let files;
+    try {
+      files = fs.readdirSync(projPath).filter((f) => f.endsWith(".jsonl"));
+    } catch {
+      continue;
+    }
+
+    for (const file of files) {
+      if (file.includes("subagents")) continue;
+      const fpath = path.join(projPath, file);
+
+      let mtime;
+      try {
+        mtime = fs.statSync(fpath).mtimeMs;
+      } catch {
+        continue;
+      }
+
+      const cachedFile = cachedFiles[file];
+      if (cachedFile && cachedFile.mtime === mtime) {
+        newFiles[file] = cachedFile;
+        sessions.push({ mtime, proj, ...cachedFile.data, fpath });
+        continue;
+      }
+
+      try {
+        const result = parseSessionFile(fpath);
+        if (!result) continue;
+        newFiles[file] = { mtime, data: result };
+        sessions.push({ mtime, proj, ...result, fpath });
+      } catch {
+        continue;
+      }
+    }
+
+    newDirs[projDir] = { dmtime: dirMtime, files: newFiles };
+  }
+
+  if (dirty || Object.keys(newDirs).length !== Object.keys(cachedDirs).length) {
+    saveCache({ dirs: newDirs });
+  }
+
+  sessions.sort((a, b) => b.mtime - a.mtime);
+  return sessions;
+}
+
+// East Asian wide character width calculation
+function charWidth(code) {
+  if (
+    (code >= 0x1100 && code <= 0x115f) ||
+    (code >= 0x2e80 && code <= 0x303e) ||
+    (code >= 0x3040 && code <= 0x33bf) ||
+    (code >= 0x3400 && code <= 0x4dbf) ||
+    (code >= 0x4e00 && code <= 0xa4cf) ||
+    (code >= 0xac00 && code <= 0xd7af) ||
+    (code >= 0xf900 && code <= 0xfaff) ||
+    (code >= 0xfe30 && code <= 0xfe6f) ||
+    (code >= 0xff01 && code <= 0xff60) ||
+    (code >= 0xffe0 && code <= 0xffe6) ||
+    (code >= 0x20000 && code <= 0x2fffd) ||
+    (code >= 0x30000 && code <= 0x3fffd)
+  ) {
+    return 2;
+  }
+  return 1;
+}
+
+function strWidth(str) {
+  let w = 0;
+  for (const ch of str) {
+    w += charWidth(ch.codePointAt(0));
+  }
+  return w;
+}
+
+function sliceByWidth(str, maxWidth) {
+  let w = 0;
+  let i = 0;
+  for (const ch of str) {
+    const cw = charWidth(ch.codePointAt(0));
+    if (w + cw > maxWidth) break;
+    w += cw;
+    i += ch.length;
+  }
+  return str.slice(0, i);
+}
+
+function padEndByWidth(str, targetWidth) {
+  const w = strWidth(str);
+  if (w >= targetWidth) return str;
+  return str + " ".repeat(targetWidth - w);
+}
+
+function renderColumnValue(colId, session, config) {
+  const def = COLUMN_DEFS[colId];
+  const raw = def.get(session, config);
+  const sliced = sliceByWidth(raw, def.width);
+  return padEndByWidth(sliced, def.width);
+}
+
+function render(filtered, page, inputBuf, mode, config, cursor) {
+  const cols = config.columns;
+  const total = filtered.length;
+  const totalPages = Math.max(1, Math.ceil(total / config.pageSize));
+  page = Math.max(0, Math.min(page, totalPages - 1));
+  const start = page * config.pageSize;
+  const end = Math.min(start + config.pageSize, total);
+
+  process.stdout.write("\x1b[2J\x1b[H");
+  console.log();
+  console.log("  \x1b[1mClaude Code Sessions\x1b[0m");
+  console.log(
+    "  \x1b[2m─────────────────────────────────────────────────────────────\x1b[0m"
+  );
+  if (mode === "filter_name") {
+    console.log(`  \x1b[33mName filter: ${inputBuf}\x1b[0m`);
+  } else if (mode === "filter_path") {
+    console.log(`  \x1b[33mPath filter: ${inputBuf}\x1b[0m`);
+  }
+  console.log();
+
+  if (total === 0) {
+    console.log("  \x1b[2mNo matching sessions.\x1b[0m");
+  } else {
+    // Header
+    const headerParts = cols.map((c) => COLUMN_DEFS[c].label.padEnd(COLUMN_DEFS[c].width));
+    console.log(`  \x1b[2m       ${headerParts.join("  ")}\x1b[0m`);
+    console.log();
+
+    for (let i = start; i < end; i++) {
+      const s = filtered[i];
+      const isCursor = i === cursor;
+      const pointer = isCursor ? "\x1b[1;33m>\x1b[0m" : " ";
+
+      // Build column values
+      const colValues = cols.map((c) => renderColumnValue(c, s, config));
+
+      // Title column gets special styling; others are dim
+      const titleIdx = cols.indexOf("title");
+      let line = "";
+      for (let ci = 0; ci < cols.length; ci++) {
+        if (ci > 0) line += "  ";
+        if (ci === titleIdx) {
+          // Title column: styled based on named/cursor
+          if (s.title) {
+            const hl = isCursor ? "\x1b[1;33m" : "\x1b[1m";
+            line += `${hl}${colValues[ci]}\x1b[0m`;
+          } else {
+            const hl = isCursor ? "\x1b[33m" : "\x1b[2;3m";
+            line += `${hl}${colValues[ci]}\x1b[0m`;
+          }
+        } else {
+          line += `\x1b[2m${colValues[ci]}\x1b[0m`;
+        }
+      }
+
+      const num = String(i + 1).padStart(3);
+      const numStyle = s.title ? "\x1b[1;36m" : "\x1b[2m";
+      console.log(`  ${pointer} ${numStyle}${num}\x1b[0m  ${line}`);
+    }
+  }
+
+  console.log();
+  console.log(
+    `  \x1b[2mPage ${page + 1}/${totalPages}  \u2190/\u2192 page  |  \u2191/\u2193 select  |  Enter resume  |  r rename  |  / name  |  p path  |  s settings  |  q quit\x1b[0m`
+  );
+  console.log();
+
+  return { page, totalPages };
+}
+
+function renderSettings(config, settingsCursor) {
+  process.stdout.write("\x1b[2J\x1b[H");
+  console.log();
+  console.log("  \x1b[1mSettings\x1b[0m");
+  console.log(
+    "  \x1b[2m─────────────────────────────────────────────────────────────\x1b[0m"
+  );
+  console.log();
+
+  const items = [
+    { label: `Page size: \x1b[1m${config.pageSize}\x1b[0m  \x1b[2m(-/+ to adjust)\x1b[0m`, type: "pageSize" },
+    { label: `Locale: \x1b[1m${config.locale || "system default"}\x1b[0m  \x1b[2m(Enter to edit)\x1b[0m`, type: "locale" },
+    { label: "", type: "separator" },
+    { label: "\x1b[1mColumns\x1b[0m  \x1b[2m(Space toggle, Shift+↑/↓ reorder)\x1b[0m", type: "header" },
+  ];
+
+  // Add column items
+  for (const colId of ALL_COLUMN_IDS) {
+    const enabled = config.columns.includes(colId);
+    const def = COLUMN_DEFS[colId];
+    const orderNum = enabled ? config.columns.indexOf(colId) + 1 : "-";
+    items.push({ label: def.label, type: "column", colId, enabled, orderNum });
+  }
+
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    if (item.type === "separator") {
+      console.log();
+      continue;
+    }
+    if (item.type === "header") {
+      console.log(`       ${item.label}`);
+      console.log();
+      continue;
+    }
+
+    const pointer = i === settingsCursor ? "\x1b[1;33m>\x1b[0m" : " ";
+
+    if (item.type === "column") {
+      const check = item.enabled ? "\x1b[1;32m[x]\x1b[0m" : "\x1b[2m[ ]\x1b[0m";
+      const order = item.enabled ? `\x1b[1;36m${String(item.orderNum).padStart(2)}\x1b[0m` : "\x1b[2m -\x1b[0m";
+      console.log(`  ${pointer}  ${check}  ${order}  ${item.label}`);
+    } else {
+      console.log(`  ${pointer}     ${item.label}`);
+    }
+  }
+
+  console.log();
+  console.log(
+    "  \x1b[2m\u2191/\u2193 navigate  |  Space toggle  |  Shift+\u2191/\u2193 reorder  |  -/+ page size  |  q/ESC back\x1b[0m"
+  );
+  console.log();
+
+  return items;
+}
+
+function renderLocaleEditor(_config, localeBuf) {
+  process.stdout.write("\x1b[2J\x1b[H");
+  console.log();
+  console.log("  \x1b[1mSet Date Locale\x1b[0m");
+  console.log(
+    "  \x1b[2m─────────────────────────────────────────────────────────────\x1b[0m"
+  );
+  console.log();
+  console.log(`  \x1b[33mLocale: ${localeBuf || "(empty = system default)"}\x1b[0m`);
+  console.log();
+
+  const preview = new Date().toLocaleString(localeBuf || undefined, {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false,
+  });
+  console.log(`  \x1b[2mPreview: ${preview}\x1b[0m`);
+  console.log();
+  console.log(
+    "  \x1b[2mType locale (e.g. en-US, ko-KR, sv-SE)  |  Enter confirm  |  ESC cancel\x1b[0m"
+  );
+  console.log();
+}
+
+function renderRename(session, renameBuf) {
+  process.stdout.write("\x1b[2J\x1b[H");
+  console.log();
+  console.log("  \x1b[1mRename Session\x1b[0m");
+  console.log(
+    "  \x1b[2m─────────────────────────────────────────────────────────────\x1b[0m"
+  );
+  console.log();
+  const displayName = session.title || session.firstMessage;
+  console.log(`  \x1b[2mCurrent:\x1b[0m  \x1b[1m${displayName}\x1b[0m`);
+  console.log(`  \x1b[33mNew title: ${renameBuf}\x1b[0m  \x1b[2m(max 100 chars)\x1b[0m`);
+  console.log();
+  console.log(
+    "  \x1b[2mEnter confirm  |  ESC cancel\x1b[0m"
+  );
+  console.log();
+}
+
+function renameSession(session, newTitle) {
+  const cleaned = newTitle.replace(/[\x00-\x1f\x7f]/g, "").slice(0, 100);
+  if (!cleaned) return false;
+  const entry = {
+    type: "custom-title",
+    sessionId: session.sid,
+    customTitle: cleaned,
+  };
+  fs.appendFileSync(session.fpath, "\n" + JSON.stringify(entry));
+  session.title = cleaned;
+  return true;
+}
+
+function resumeSession(s) {
+  process.stdout.write("\x1b[2J\x1b[H");
+  console.log(`\n  Resuming: ${s.title || s.firstMessage} (${s.sid.slice(0, 8)})\n`);
+
+  const cwd = s.cwd && fs.existsSync(s.cwd) ? s.cwd : process.cwd();
+  process.stdin.setRawMode(false);
+  const useShell = process.platform === "win32";
+  spawnSync("claude", ["--resume", s.sid], {
+    stdio: "inherit",
+    cwd,
+    shell: useShell,
+  });
+  process.exit(0);
+}
+
+function parseKey(buf) {
+  if (buf[0] === 0x1b) {
+    if (buf.length === 1) return "escape";
+    if (buf[1] === 0x5b) {
+      if (buf[2] === 0x44) return "left";
+      if (buf[2] === 0x43) return "right";
+      if (buf[2] === 0x41) return "up";
+      if (buf[2] === 0x42) return "down";
+      // Shift+Up: ESC [ 1 ; 2 A
+      if (buf[2] === 0x31 && buf[3] === 0x3b && buf[4] === 0x32) {
+        if (buf[5] === 0x41) return "shift_up";
+        if (buf[5] === 0x42) return "shift_down";
+      }
+      return null;
+    }
+    return null;
+  }
+  if (buf[0] === 0x03) return "quit"; // Ctrl+C
+  if (buf[0] === 0x0d || buf[0] === 0x0a) return "enter";
+  if (buf[0] === 0x7f) return "backspace";
+  const ch = buf.toString("utf8");
+  if (ch.length === 1 && ch.charCodeAt(0) >= 32) return ch;
+  return null;
+}
+
+const SPLASH = [
+  "",
+  "  \x1b[1;38;2;200;235;255m              ████████  ████████  ████████     ██     ██      \x1b[0m",
+  "  \x1b[1;38;2;175;225;248m                 ██     ██    ██     ██        ██     ██      \x1b[0m",
+  "  \x1b[1;38;2;150;215;240m                 ██     ██    ██     ██       ████    ██      \x1b[0m",
+  "  \x1b[1;38;2;125;200;230m                 ██     ██    ██     ██       ████    ██      \x1b[0m",
+  "  \x1b[1;38;2;100;185;220m                 ██     ██    ██     ██      ██  ██   ██      \x1b[0m",
+  "  \x1b[1;38;2;75;165;210m                 ██     ██    ██     ██      ██  ██   ██      \x1b[0m",
+  "  \x1b[1;38;2;55;150;200m                 ██     ██    ██     ██     ████████  ██      \x1b[0m",
+  "  \x1b[1;38;2;35;130;185m                 ██     ████████     ██     ██    ██  ████████\x1b[0m",
+  "",
+  "  \x1b[1;38;2;200;235;255m███████   ████████  ████████  ██           ██     ██    ██  ███████   ████████\x1b[0m",
+  "  \x1b[1;38;2;175;225;248m██    ██  ██        ██        ██           ██     ██    ██  ██    ██  ██      \x1b[0m",
+  "  \x1b[1;38;2;150;215;240m██    ██  ██        ██        ██          ████    ██    ██  ██    ██  ██      \x1b[0m",
+  "  \x1b[1;38;2;125;200;230m███████   ███████   ██        ██          ████    ██    ██  ██    ██  ████████\x1b[0m",
+  "  \x1b[1;38;2;100;185;220m██ ██     ██        ██        ██         ██  ██   ██    ██  ██    ██  ██      \x1b[0m",
+  "  \x1b[1;38;2;75;165;210m██  ██    ██        ██        ██         ██  ██   ██    ██  ██    ██  ██      \x1b[0m",
+  "  \x1b[1;38;2;55;150;200m██   ██   ██        ██        ██        ████████  ██    ██  ██    ██  ██      \x1b[0m",
+  "  \x1b[1;38;2;35;130;185m██    ██  ████████  ████████  ████████  ██    ██  ████████  ███████   ████████\x1b[0m",
+  "",
+  "  \x1b[38;2;120;160;180m                  GET READY FOR THE RESUME OF YOUR SESSIONS\x1b[0m",
+  "",
+  "  \x1b[2;3m                              Loading sessions...\x1b[0m",
+  "",
+].join("\n");
+
+function showSplash() {
+  process.stdout.write("\x1b[2J\x1b[H");
+  process.stdout.write(SPLASH + "\n");
+}
+
+const REPO = "dongwook-chan/total-reclaude";
+
+function isRepoStarred() {
+  try {
+    const res = spawnSync("gh", ["api", `user/starred/${REPO}`], { encoding: "utf8", timeout: 5000 });
+    return res.status === 0; // 204 (exit 0) = starred, 404 (exit 1) = not
+  } catch {
+    return true; // if gh fails, assume starred (don't bother user)
+  }
+}
+
+function starRepo() {
+  try {
+    spawnSync("gh", ["api", "-X", "PUT", `user/starred/${REPO}`], { encoding: "utf8", timeout: 5000 });
+  } catch {} // best effort
+}
+
+function showStarPrompt() {
+  try {
+    // Check if gh is available
+    const which = spawnSync("which", ["gh"], { encoding: "utf8" });
+    if (which.status !== 0) return;
+
+    if (isRepoStarred()) return;
+
+    process.stdout.write(`\x1b[33m  \u2605 Enjoy total-reclaude? Star it on GitHub! (y/n) \x1b[0m`);
+
+    // Single keypress without Enter via bash read -n1
+    const result = spawnSync("bash", ["-c", 'read -rsn1 key < /dev/tty; echo -n "$key"'], { encoding: "utf8", timeout: 10000 });
+    const key = (result.stdout || "").trim();
+
+    if (key === "y" || key === "Y") {
+      starRepo();
+      console.log(`\x1b[32m Thank you! \u2605\x1b[0m`);
+    } else {
+      console.log();
+    }
+  } catch {} // never let this break the exit flow
+}
+
+function cleanup() {
+  try { process.stdin.setRawMode(false); } catch {}
+  process.stdout.write("\x1b[2J\x1b[H");
+}
+
+function main() {
+  if (process.argv.includes("--help") || process.argv.includes("-h")) {
+    console.log("Usage: total-reclaude\n");
+    console.log("Interactive Claude Code session picker: filter, rename, and resume sessions.\n");
+    console.log("Keybindings:");
+    console.log("  Up/Down    Move cursor");
+    console.log("  Enter      Resume selected session");
+    console.log("  r          Rename selected session");
+    console.log("  /          Filter by name");
+    console.log("  p          Filter by path");
+    console.log("  s          Settings (columns, page size, locale)");
+    console.log("  Left/Right Page navigation");
+    console.log("  q, Ctrl+C  Quit");
+    console.log("  ESC        Cancel / back\n");
+    console.log("Available columns: " + ALL_COLUMN_IDS.join(", "));
+    console.log("Config: " + CONFIG_PATH);
+    return;
+  }
+  if (process.argv.includes("--version") || process.argv.includes("-v")) {
+    console.log(require("./package.json").version);
+    return;
+  }
+
+  if (!process.stdin.isTTY) {
+    console.error("total-reclaude requires an interactive terminal.");
+    process.exit(1);
+  }
+
+  showSplash();
+  showStarPrompt();
+  const { execSync } = require("child_process");
+  execSync("sleep 1");
+  const allSessions = getSessions();
+  if (allSessions.length === 0) {
+    console.log("No sessions found.");
+    return;
+  }
+
+  let config = loadConfig();
+  let page = 0;
+  let totalPages = 1;
+  let inputBuf = "";
+  let mode = "normal";
+  let cursor = 0;
+  let settingsCursor = 0;
+  let settingsItems = [];
+  let settingsDirty = false;
+  let filtered = allSessions.slice();
+
+  process.on("exit", cleanup);
+  process.on("uncaughtException", (err) => {
+    cleanup();
+    console.error(err);
+    process.exit(1);
+  });
+
+  ({ page, totalPages } = render(filtered, page, inputBuf, mode, config, cursor));
+
+  function applyFilter() {
+    const q = inputBuf.toLowerCase();
+    if (!q) return allSessions.slice();
+    if (mode === "filter_name") {
+      return allSessions.filter((s) => s.title.toLowerCase().includes(q) || s.firstMessage.toLowerCase().includes(q));
+    } else if (mode === "filter_path") {
+      return allSessions.filter(
+        (s) =>
+          s.proj.toLowerCase().includes(q) || s.cwd.toLowerCase().includes(q)
+      );
+    }
+    return allSessions.slice();
+  }
+
+  function rerender() {
+    if (filtered.length > 0) {
+      cursor = Math.max(0, Math.min(cursor, filtered.length - 1));
+    } else {
+      cursor = 0;
+    }
+    const cursorPage = Math.floor(cursor / config.pageSize);
+    page = cursorPage;
+    ({ page, totalPages } = render(filtered, page, inputBuf, mode, config, cursor));
+  }
+
+  // Settings helpers
+  function isSelectableSettingsItem(idx) {
+    const item = settingsItems[idx];
+    return item && item.type !== "separator" && item.type !== "header";
+  }
+
+  function moveSettingsCursor(dir) {
+    let next = settingsCursor + dir;
+    while (next >= 0 && next < settingsItems.length && !isSelectableSettingsItem(next)) {
+      next += dir;
+    }
+    if (next >= 0 && next < settingsItems.length) {
+      settingsCursor = next;
+    }
+  }
+
+  function rerenderSettings() {
+    settingsItems = renderSettings(config, settingsCursor);
+  }
+
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+
+  process.stdin.on("data", (buf) => {
+    const key = parseKey(buf);
+    if (key === null) return;
+
+    if (key === "quit") {
+      process.stdout.write("\x1b[2J\x1b[H");
+      process.stdin.setRawMode(false);
+      process.exit(0);
+    }
+
+    // Settings mode
+    if (mode === "settings") {
+      if (key === "q" || key === "escape") {
+        if (settingsDirty) {
+          saveConfig(config);
+          settingsDirty = false;
+        }
+        mode = "normal";
+        rerender();
+        return;
+      }
+
+      if (key === "up") {
+        moveSettingsCursor(-1);
+        rerenderSettings();
+        return;
+      }
+      if (key === "down") {
+        moveSettingsCursor(1);
+        rerenderSettings();
+        return;
+      }
+
+      const currentItem = settingsItems[settingsCursor];
+
+      if (key === "-") {
+        config.pageSize = Math.max(5, config.pageSize - 5);
+        settingsDirty = true;
+        rerenderSettings();
+        return;
+      }
+      if (key === "=" || key === "+") {
+        config.pageSize = Math.min(50, config.pageSize + 5);
+        settingsDirty = true;
+        rerenderSettings();
+        return;
+      }
+
+      if (currentItem && currentItem.type === "locale" && key === "enter") {
+        if (settingsDirty) {
+          saveConfig(config);
+          settingsDirty = false;
+        }
+        mode = "settings_locale";
+        inputBuf = config.locale || "";
+        renderLocaleEditor(config, inputBuf);
+        return;
+      }
+
+      if (currentItem && currentItem.type === "column") {
+        if (key === " ") {
+          // Toggle column
+          const colId = currentItem.colId;
+          const idx = config.columns.indexOf(colId);
+          if (idx >= 0) {
+            // Don't allow removing last column
+            if (config.columns.length > 1) {
+              config.columns.splice(idx, 1);
+            }
+          } else {
+            config.columns.push(colId);
+          }
+          settingsDirty = true;
+          rerenderSettings();
+          return;
+        }
+
+        if (key === "shift_up" || key === "shift_down") {
+          const colId = currentItem.colId;
+          const idx = config.columns.indexOf(colId);
+          if (idx < 0) return; // not enabled, can't reorder
+          const newIdx = key === "shift_up" ? idx - 1 : idx + 1;
+          if (newIdx < 0 || newIdx >= config.columns.length) return;
+          // Swap
+          [config.columns[idx], config.columns[newIdx]] = [config.columns[newIdx], config.columns[idx]];
+          settingsDirty = true;
+          rerenderSettings();
+          return;
+        }
+      }
+
+      return;
+    }
+
+    // Rename input mode
+    if (mode === "rename_input") {
+      if (key === "escape") {
+        mode = "normal";
+        inputBuf = "";
+        rerender();
+      } else if (key === "enter" && inputBuf) {
+        renameSession(filtered[cursor], inputBuf);
+        mode = "normal";
+        inputBuf = "";
+        rerender();
+      } else if (key === "backspace") {
+        inputBuf = inputBuf.slice(0, -1);
+        renderRename(filtered[cursor], inputBuf);
+      } else if (key.length === 1 && key.charCodeAt(0) >= 32) {
+        if (inputBuf.length < 100) {
+          inputBuf += key;
+        }
+        renderRename(filtered[cursor], inputBuf);
+      }
+      return;
+    }
+
+    // Locale editor mode
+    if (mode === "settings_locale") {
+      if (key === "escape") {
+        mode = "settings";
+        inputBuf = "";
+        rerenderSettings();
+      } else if (key === "enter") {
+        config.locale = inputBuf;
+        settingsDirty = true;
+        mode = "settings";
+        inputBuf = "";
+        rerenderSettings();
+      } else if (key === "backspace") {
+        inputBuf = inputBuf.slice(0, -1);
+        renderLocaleEditor(config, inputBuf);
+      } else if (key.length === 1 && key.charCodeAt(0) >= 32) {
+        inputBuf += key;
+        renderLocaleEditor(config, inputBuf);
+      }
+      return;
+    }
+
+    // Arrow navigation
+    if (key === "up") {
+      if (cursor > 0) {
+        cursor -= 1;
+        rerender();
+      }
+      return;
+    }
+    if (key === "down") {
+      if (cursor < filtered.length - 1) {
+        cursor += 1;
+        rerender();
+      }
+      return;
+    }
+    if (key === "left") {
+      if (page > 0) {
+        page -= 1;
+        cursor = page * config.pageSize;
+        rerender();
+      }
+      return;
+    }
+    if (key === "right") {
+      if (page < totalPages - 1) {
+        page += 1;
+        cursor = page * config.pageSize;
+        rerender();
+      }
+      return;
+    }
+
+    if (key === "escape") {
+      if (mode !== "normal") {
+        mode = "normal";
+        inputBuf = "";
+        filtered = allSessions.slice();
+        cursor = 0;
+        page = 0;
+        rerender();
+      }
+      return;
+    }
+
+    if (key === "enter") {
+      if (filtered.length > 0) {
+        resumeSession(filtered[cursor]);
+      }
+      return;
+    }
+
+    if (mode === "normal") {
+      if (key === "q") {
+        process.stdout.write("\x1b[2J\x1b[H");
+        process.stdin.setRawMode(false);
+        process.exit(0);
+      } else if (key === "/") {
+        mode = "filter_name";
+        inputBuf = "";
+        cursor = 0;
+        page = 0;
+        rerender();
+      } else if (key === "p") {
+        mode = "filter_path";
+        inputBuf = "";
+        cursor = 0;
+        page = 0;
+        rerender();
+      } else if (key === "r") {
+        if (filtered.length > 0) {
+          mode = "rename_input";
+          inputBuf = "";
+          renderRename(filtered[cursor], inputBuf);
+        }
+      } else if (key === "s") {
+        mode = "settings";
+        settingsDirty = false;
+        settingsCursor = 0;
+        settingsItems = renderSettings(config, settingsCursor);
+      }
+      return;
+    }
+
+    // Filter mode
+    if (key === "backspace") {
+      if (inputBuf) {
+        inputBuf = inputBuf.slice(0, -1);
+        filtered = inputBuf ? applyFilter() : allSessions.slice();
+      } else {
+        mode = "normal";
+        filtered = allSessions.slice();
+      }
+      cursor = 0;
+      page = 0;
+      rerender();
+    } else if (key.length === 1 && key.charCodeAt(0) >= 32) {
+      inputBuf += key;
+      filtered = applyFilter();
+      cursor = 0;
+      page = 0;
+      rerender();
+    }
+  });
+}
+
+main();

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "reclaude",
+  "version": "1.0.0",
+  "description": "Interactive Claude Code session picker: filter, rename, and resume sessions from your terminal",
+  "main": "index.js",
+  "bin": {
+    "reclaude": "./index.js"
+  },
+  "files": ["index.js", "LICENSE"],
+  "engines": {
+    "node": ">=14"
+  },
+  "keywords": ["claude", "claude-code", "session", "picker", "cli", "resume", "rename"],
+  "author": "dongwook-chan",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dongwook-chan/total-reclaude.git"
+  }
+}