ai-chat-cleaner 0.0.1 → 0.1.0

package/README.md

@@ -9,26 +9,34 @@ Clean and remove AI chat with an interactive terminal UI.
 
 ```sh
 npx ai-chat-cleaner
+npx ai-chat-cleaner --agent codex
 ```
 
-<p align='center'>
-<img src='./assets/screenshot.png' alt="screenshot" />
-</p>
-
 - Supported agents:
-  - `codex`
+  - Codex (`codex`)
+  - Claude Code (`claude-code`)
 
 > [!WARNING]
 > Please restart your AI coding tool after deletion.
 >
 > It is recommended to clean history while Codex is not running, to avoid duplicate writes.
 
+<p align='center'>
+<img src='./assets/screenshot.png' alt="screenshot" />
+</p>
+
 ## Why ?
 
 I am not entirely sure why `Codex` and `Claude Code` do not provide a way to delete a specific conversation history, perhaps to preserve context continuity.
 
 But in practice, one conversation that goes in the wrong direction can keep affecting later outputs, so I built this tool.
 
+## Credit
+
+The terminal interaction mode is inspired by [taze](https://github.com/antfu-collective/taze).
+
+Claude Code cleanup implementation references [claude-chats-delete](https://github.com/ataleckij/claude-chats-delete).
+
 ## License
 
 [MIT](./LICENSE) License © [jinghaihan](https://github.com/jinghaihan)

package/dist/cli.mjs

@@ -5,7 +5,7 @@ import { cac } from "cac";
 import { homedir } from "node:os";
 import readline from "node:readline";
 import { execFile } from "node:child_process";
-import { readFile, writeFile } from "node:fs/promises";
+import { readFile, readdir, stat, writeFile } from "node:fs/promises";
 import { promisify } from "node:util";
 import pLimit from "p-limit";
 import { basename, join } from "pathe";
@@ -129,7 +129,7 @@ function renderGroups(state, groups) {
 	const totalCount = groups.reduce((acc, group) => acc + group.items.length, 0);
 	process.stdout.write(`${c.gray(`${Y("↑↓")} select  ${Y("space")} toggle group  ${Y("→")} enter group`)}\n`);
 	process.stdout.write(`${c.gray(`${Y("enter")} confirm  ${Y("esc")} cancel  ${Y("a")} toggle all`)}\n\n`);
-	process.stdout.write(`selected ${c.red(`${selectedCount}/${totalCount}`)}\n\n`);
+	process.stdout.write(`${c.gray("selected")} ${c.red(`${selectedCount}/${totalCount}`)}\n\n`);
 	const labelWidth = Math.min(36, Math.max(12, ...groups.map((group) => group.label.length)));
 	const countWidth = Math.max(7, ...groups.map((group) => {
 		return `${countSelectedInGroup(group, state.selectedKeys)}/${group.items.length}`.length;
@@ -156,7 +156,7 @@ function renderItems(state, groups) {
 	const totalCount = groups.reduce((acc, item) => acc + item.items.length, 0);
 	process.stdout.write(`${c.gray(`${Y("↑↓")} select  ${Y("space")} toggle  ${Y("←")} back`)}\n`);
 	process.stdout.write(`${c.gray(`${Y("enter")} back  ${Y("esc")} back  ${Y("a")} toggle group`)}\n\n`);
-	process.stdout.write(`selected ${c.red(`${selectedCount}/${totalCount}`)}\n`);
+	process.stdout.write(`${c.gray("selected")} ${c.red(`${selectedCount}/${totalCount}`)}\n`);
 	process.stdout.write("\n");
 	process.stdout.write(`${c.green(group.label)} ${c.gray(group.path ? tildifyPath(group.path) : "(unknown cwd)")}\n\n`);
 	const { start, end } = getRenderWindow(group.items.length, state.itemIndex, 8);
@@ -249,12 +249,27 @@ function clearScreen() {
 //#region src/utils.ts
 const exec = promisify(execFile);
 async function readJSON(filepath) {
-	const content = await readFile(filepath, "utf-8");
-	return JSON.parse(content);
+	return parseJSON(await readFile(filepath, "utf-8"));
 }
 async function writeJSON(filepath, data) {
 	await writeFile(filepath, JSON.stringify(data, null, 2), "utf-8");
 }
+function parseJSON(value) {
+	try {
+		return JSON.parse(value);
+	} catch {
+		return null;
+	}
+}
+function toUnix(value) {
+	return Math.floor(value / 1e3);
+}
+function parseDateToUnix(value) {
+	if (!value) return 0;
+	const ts = Date.parse(value);
+	if (!Number.isFinite(ts)) return 0;
+	return Math.floor(ts / 1e3);
+}
 function formatRelativeTime(date) {
 	const diff = (/* @__PURE__ */ new Date(date * 1e3)).getTime() - Date.now();
 	const seconds = Math.round(diff / 1e3);
@@ -274,27 +289,296 @@ function formatRelativeTime(date) {
 function quoteSqlString(value) {
 	return `'${value.replaceAll("'", "''")}'`;
 }
+function normalizeInlineText(value) {
+	return value.replace(/\r?\n/g, " ").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+}
+function extractMessageText(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	const texts = [];
+	for (const item of content) {
+		if (typeof item === "string") {
+			texts.push(item);
+			continue;
+		}
+		if (!item || typeof item !== "object") continue;
+		if (typeof item.text === "string") texts.push(item.text);
+		else if (typeof item.content === "string") texts.push(item.content);
+	}
+	return texts.join(" ");
+}
+function isCommandTitle(title) {
+	return /^\/[\w-]+(?:\s+[\w-]+)?$/.test(title);
+}
+function isUUID(value) {
+	return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+}
 
 //#endregion
 //#region package.json
 var name = "ai-chat-cleaner";
-var version = "0.0.1";
+var version = "0.1.0";
 
 //#endregion
 //#region src/constants.ts
 const NAME = name;
 const VERSION = version;
 const DEFAULT_OPTIONS = {};
-const AGENTS = { codex: {
-	name: "codex",
-	path: join(homedir(), ".codex")
-} };
+const AGENTS_CHOICES = ["codex", "claude-code"];
+const AGENTS_CONFIG = {
+	"codex": {
+		name: "codex",
+		path: process.env.CODEX_HOME?.trim() || join(homedir(), ".codex")
+	},
+	"claude-code": {
+		name: "claude-code",
+		path: process.env.CLAUDE_CONFIG_DIR?.trim() || join(homedir(), ".claude")
+	}
+};
+
+//#endregion
+//#region src/claude-code/constants.ts
+const ROOT_PATH = AGENTS_CONFIG["claude-code"].path;
+const PROJECTS_PATH = join(ROOT_PATH, "projects");
+const DEBUG_PATH = join(ROOT_PATH, "debug");
+const TODOS_PATH = join(ROOT_PATH, "todos");
+const SESSION_ENV_PATH = join(ROOT_PATH, "session-env");
+const TASKS_PATH = join(ROOT_PATH, "tasks");
+const FILE_HISTORY_PATH = join(ROOT_PATH, "file-history");
+const PLANS_PATH = join(ROOT_PATH, "plans");
+const AGENTS_PATH = join(ROOT_PATH, "agents");
+
+//#endregion
+//#region src/claude-code/delete.ts
+async function deleteThreads$1(threads) {
+	const limit = pLimit(5);
+	await Promise.all(threads.map((thread) => limit(() => deleteThread$1(thread))));
+}
+async function deleteThread$1(thread) {
+	await rimraf(thread.path);
+	await rimraf(thread.path.replace(/\.jsonl$/i, ""));
+	await rimraf(join(DEBUG_PATH, `${thread.id}.txt`));
+	await rimraf(join(SESSION_ENV_PATH, thread.id));
+	await rimraf(join(TASKS_PATH, thread.id));
+	await rimraf(join(FILE_HISTORY_PATH, thread.id));
+	if (thread.slug) await rimraf(join(PLANS_PATH, `${thread.slug}.md`));
+	const todoFiles = await glob(`${thread.id}*.json`, {
+		cwd: TODOS_PATH,
+		absolute: true,
+		onlyFiles: true
+	});
+	await Promise.all(todoFiles.map((path) => rimraf(path)));
+	const agentIds = await readAgentIds(thread.path);
+	await Promise.all(agentIds.map((agentId) => rimraf(join(AGENTS_PATH, agentId, "memory-local.md"))));
+	await updateSessionsIndex(thread.project_dir, thread.id);
+}
+async function updateSessionsIndex(projectDir, threadId) {
+	const path = join(projectDir, "sessions-index.json");
+	const raw = await readFile(path, "utf8").catch(() => "");
+	if (!raw) return;
+	const data = parseJSON(raw);
+	if (!data || !Array.isArray(data.entries)) return;
+	const nextEntries = data.entries.filter((entry) => entry?.sessionId !== threadId);
+	if (nextEntries.length === data.entries.length) return;
+	data.entries = nextEntries;
+	await writeFile(path, `${JSON.stringify(data, null, 2)}\n`, "utf-8");
+}
+async function readAgentIds(path) {
+	const raw = await readFile(path, "utf8").catch(() => "");
+	if (!raw) return [];
+	const ids = /* @__PURE__ */ new Set();
+	const lines = raw.split("\n");
+	for (const line of lines) {
+		if (!line) continue;
+		const value = parseJSON(line)?.agent_id;
+		if (typeof value === "string" && value) ids.add(value);
+	}
+	return Array.from(ids);
+}
+
+//#endregion
+//#region src/claude-code/detect.ts
+async function detectClaudeCode(cwd = ROOT_PATH) {
+	const projectDirs = await readProjectDirs(join(cwd, "projects"));
+	const threads = [];
+	for (const projectDir of projectDirs) {
+		const sessions = await readSessionsIndex(projectDir);
+		const files = await glob("*.jsonl", {
+			cwd: projectDir,
+			absolute: true,
+			onlyFiles: true
+		});
+		for (const file of files) {
+			const id = basename(file, ".jsonl");
+			if (id.startsWith("agent-")) continue;
+			const info = await stat(file).catch(() => null);
+			if (!info) continue;
+			const session = sessions.get(id);
+			const meta = await readThreadMeta(file);
+			const updatedAt = parseDateToUnix(session?.modified) || toUnix(info.mtimeMs);
+			const createdAt = parseDateToUnix(session?.created) || toUnix(info.birthtimeMs || info.ctimeMs || info.mtimeMs);
+			const cwdPath = session?.projectPath || decodeProjectName(basename(projectDir));
+			const title = pickTitle([
+				session?.firstPrompt,
+				meta.title,
+				session?.summary
+			]);
+			if (!title) continue;
+			threads.push({
+				id,
+				title,
+				path: file,
+				project_dir: projectDir,
+				cwd: cwdPath,
+				created_at: createdAt,
+				updated_at: updatedAt,
+				slug: meta.slug
+			});
+		}
+	}
+	threads.sort((a, b) => b.updated_at - a.updated_at);
+	return { threads };
+}
+async function readProjectDirs(projectsPath) {
+	return (await readdir(projectsPath, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory()).map((entry) => join(projectsPath, entry.name));
+}
+async function readSessionsIndex(projectDir) {
+	const raw = await readFile(join(projectDir, "sessions-index.json"), "utf8").catch(() => "");
+	if (!raw) return /* @__PURE__ */ new Map();
+	const data = parseJSON(raw);
+	const rows = Array.isArray(data?.entries) ? data.entries : [];
+	return new Map(rows.map((entry) => [entry.sessionId, entry]));
+}
+async function readThreadMeta(path) {
+	const lines = (await readFile(path, "utf8").catch(() => "")).split("\n").filter(Boolean);
+	let userTitle = "";
+	let summaryTitle = "";
+	let slug = "";
+	for (const line of lines) {
+		const row = parseJSON(line);
+		if (!row) continue;
+		if (!slug && typeof row.slug === "string") slug = row.slug;
+		if (!summaryTitle && row.type === "summary" && typeof row.summary === "string") summaryTitle = normalizeIfValidTitle(row.summary);
+		if (!userTitle && row.type === "user" && row.isMeta !== true) {
+			if (!isCommandEvent(row.message?.content)) userTitle = normalizeIfValidTitle(extractMessageText(row.message?.content));
+		}
+		if (userTitle && summaryTitle && slug) break;
+	}
+	return {
+		title: userTitle || summaryTitle,
+		slug: slug || void 0
+	};
+}
+function pickTitle(values) {
+	for (const value of values) {
+		const normalized = normalizeIfValidTitle(value);
+		if (normalized) return normalized;
+	}
+	return "";
+}
+function normalizeIfValidTitle(value) {
+	if (typeof value !== "string") return "";
+	const normalized = normalizeInlineText(value);
+	if (!normalized) return "";
+	if (normalized.toLowerCase() === "no prompt") return "";
+	if (isUUID(normalized)) return "";
+	if (isCommandTitle(normalized)) return "";
+	return normalized;
+}
+function isCommandEvent(content) {
+	const source = extractMessageText(content);
+	if (!source) return false;
+	return source.includes("<command-name>") || source.includes("<command-message>") || source.includes("<local-command-stdout>") || source.includes("<local-command-caveat>");
+}
+function decodeProjectName(projectName) {
+	if (!projectName) return "";
+	if (projectName.startsWith("-")) return `/${projectName.slice(1).replaceAll("-", "/")}`;
+	return projectName.replaceAll("-", "/");
+}
+
+//#endregion
+//#region src/claude-code/group.ts
+function groupClaudeCodeThreads(threads) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const thread of threads) {
+		const cwd = thread.cwd || "";
+		const id = cwd || "(unknown)";
+		const label = cwd ? basename(cwd) : "(unknown)";
+		const group = grouped.get(id);
+		if (group) {
+			group.threads.push(thread);
+			group.updatedAt = Math.max(group.updatedAt, thread.updated_at || thread.created_at || 0);
+			continue;
+		}
+		grouped.set(id, {
+			id,
+			label,
+			cwd,
+			threads: [thread],
+			updatedAt: thread.updated_at || thread.created_at || 0
+		});
+	}
+	const groups = Array.from(grouped.values());
+	for (const group of groups) group.threads.sort((a, b) => (b.updated_at || b.created_at || 0) - (a.updated_at || a.created_at || 0));
+	groups.sort((a, b) => {
+		const diff = b.updatedAt - a.updatedAt;
+		if (diff !== 0) return diff;
+		return a.label.localeCompare(b.label);
+	});
+	return groups;
+}
+
+//#endregion
+//#region src/claude-code/index.ts
+async function promptClaudeCode(_options) {
+	const spinner = p.spinner();
+	spinner.start("detecting claude-code threads...");
+	const { threads } = await detectClaudeCode();
+	spinner.stop(`detected ${c.yellow`${threads.length}`} threads`);
+	if (threads.length === 0) {
+		p.outro(c.yellow("no threads found"));
+		process.exit(0);
+	}
+	const resolved = await promptGroupedMultiSelect(formatThreadGroupOptions$1(groupClaudeCodeThreads(threads)));
+	if (resolved === null || resolved.length === 0) {
+		p.outro(c.red("aborting"));
+		process.exit(1);
+	}
+	const confirmed = await p.confirm({
+		message: `selected ${c.yellow`${resolved.length}`} records, continue?`,
+		initialValue: true
+	});
+	if (p.isCancel(confirmed) || !confirmed) {
+		p.outro(c.red("aborting"));
+		process.exit(1);
+	}
+	await deleteThreads$1(resolved);
+	p.outro(`cleaned ${c.yellow`${resolved.length}`} threads`);
+}
+function formatThreadGroupOptions$1(grouped) {
+	return grouped.map((group) => ({
+		id: group.id,
+		label: group.label,
+		path: group.cwd,
+		items: group.threads.map((thread) => ({
+			id: thread.id,
+			label: thread.title,
+			hint: formatThreadHint$1(thread),
+			value: thread
+		}))
+	}));
+}
+function formatThreadHint$1(thread) {
+	const updatedAt = thread.updated_at || thread.created_at;
+	const createdAt = thread.created_at || updatedAt;
+	return `updated ${formatRelativeTime(updatedAt)} · created ${formatRelativeTime(createdAt)}`;
+}
 
 //#endregion
 //#region src/codex/constants.ts
-const GLOBAL_STATE_PATH = join(AGENTS.codex.path, ".codex-global-state.json");
-const HISTORY_FILE_PATH = join(AGENTS.codex.path, "history.jsonl");
-const SHELL_SNAPSHOTS_PATH = join(AGENTS.codex.path, "shell_snapshots");
+const GLOBAL_STATE_PATH = join(AGENTS_CONFIG.codex.path, ".codex-global-state.json");
+const HISTORY_FILE_PATH = join(AGENTS_CONFIG.codex.path, "history.jsonl");
+const SHELL_SNAPSHOTS_PATH = join(AGENTS_CONFIG.codex.path, "shell_snapshots");
 
 //#endregion
 //#region src/codex/db.ts
@@ -304,7 +588,7 @@ async function readSQLite(filepath) {
 		filepath,
 		"SELECT * FROM threads;"
 	]);
-	return JSON.parse(stdout.trim());
+	return parseJSON(stdout.trim());
 }
 async function writeSQLite(filepath, ids) {
 	if (ids.length === 0) return;
@@ -346,13 +630,13 @@ async function updateGlobalState(threadIds, globalState) {
 }
 async function updateHistory(path, ids) {
 	const remove = new Set(ids);
-	const rows = (await readFile(path, "utf8")).split("\n").filter(Boolean).map((line) => JSON.parse(line)).filter((row) => !remove.has(row?.session_id));
+	const rows = (await readFile(path, "utf8")).split("\n").filter(Boolean).map((line) => parseJSON(line)).filter((row) => !remove.has(row?.session_id));
 	await writeFile(HISTORY_FILE_PATH, rows.length > 0 ? `${rows.map((row) => JSON.stringify(row)).join("\n")}\n` : "", "utf-8");
 }
 
 //#endregion
 //#region src/codex/detect.ts
-async function detectCodex(cwd = AGENTS.codex.path) {
+async function detectCodex(cwd = AGENTS_CONFIG.codex.path) {
 	const globalState = await readJSON(GLOBAL_STATE_PATH);
 	const sqlitePath = await getDatabasePath(cwd);
 	const data = sqlitePath ? await readSQLite(sqlitePath) : [];
@@ -370,7 +654,7 @@ async function detectCodex(cwd = AGENTS.codex.path) {
 	};
 }
 function normalizeTitle(thread) {
-	return thread.title.replace(/\n/g, " ").replace(thread.cwd, "").replace(AGENTS.codex.path, "").trim();
+	return thread.title.replace(/\n/g, " ").replace(thread.cwd, "").replace(AGENTS_CONFIG.codex.path, "").trim();
 }
 
 //#endregion
@@ -408,18 +692,21 @@ function groupCodexThreads(threads) {
 //#endregion
 //#region src/codex/index.ts
 async function promptCodex(_options) {
+	const spinner = p.spinner();
+	spinner.start("detecting codex threads...");
 	const { threads, globalState, sqlitePath } = await detectCodex();
+	spinner.stop(`detected ${c.yellow`${threads.length}`} threads`);
+	if (threads.length === 0) {
+		p.outro(c.yellow("no threads found"));
+		process.exit(0);
+	}
 	const resolved = await promptGroupedMultiSelect(formatThreadGroupOptions(groupCodexThreads(threads)));
-	if (resolved === null) {
+	if (resolved === null || resolved.length === 0) {
 		p.outro(c.red("aborting"));
 		process.exit(1);
 	}
-	if (resolved.length === 0) {
-		p.outro(c.yellow("no threads selected"));
-		return;
-	}
 	const confirmed = await p.confirm({
-		message: `Selected ${c.yellow`${resolved.length}`} records, continue?`,
+		message: `selected ${c.yellow`${resolved.length}`} records, continue?`,
 		initialValue: true
 	});
 	if (p.isCancel(confirmed) || !confirmed) {
@@ -461,21 +748,49 @@ function normalizeConfig(options) {
 async function resolveConfig(options) {
 	const defaults = structuredClone(DEFAULT_OPTIONS);
 	options = normalizeConfig(options);
-	return {
+	const merged = {
 		...defaults,
 		...options
 	};
+	const agents = AGENTS_CHOICES.find((agent) => agent === options.agents);
+	if (agents) merged.agents = agents;
+	else merged.agents = await resolveAgent();
+	return merged;
+}
+async function resolveAgent() {
+	const selected = await p.select({
+		message: "select agent to clean",
+		options: AGENTS_CHOICES.map((agent) => ({
+			value: agent,
+			label: AGENTS_CONFIG[agent].name,
+			hint: AGENTS_CONFIG[agent].path
+		}))
+	});
+	if (p.isCancel(selected)) {
+		p.outro(c.red("aborting"));
+		process.exit(1);
+	}
+	return selected;
 }
 
 //#endregion
 //#region src/cli.ts
 try {
 	const cli = cac(NAME);
-	cli.command("", "Clean and remove AI chat with an interactive terminal UI").allowUnknownOptions().action(async (options) => {
+	cli.command("", "Clean and remove AI chat with an interactive terminal UI").option("--agent, -a <agent>", "Agent to clean").allowUnknownOptions().action(async (options) => {
 		p.intro(`${c.yellow`${NAME} `}${c.dim`v${VERSION}`}`);
 		const config = await resolveConfig(options);
-		p.log.info(`start detecting ${c.yellow`Codex`} threads...`);
-		await promptCodex(config);
+		switch (config.agents) {
+			case "codex":
+				await promptCodex(config);
+				break;
+			case "claude-code":
+				await promptClaudeCode(config);
+				break;
+			default:
+				p.outro(`unknown agent: ${c.red(config.agents)}`);
+				process.exit(1);
+		}
 	});
 	cli.help();
 	cli.version(VERSION);

package/dist/index.d.mts

@@ -1,10 +1,11 @@
 //#region src/constants.d.ts
-declare const AGENTS_CHOICES: readonly ["codex"];
+declare const AGENTS_CHOICES: readonly ["codex", "claude-code"];
 //#endregion
 //#region src/types.d.ts
 interface CommandOptions {
-  cwd?: string;
+  agents?: AgentType;
 }
+interface Options extends Required<CommandOptions> {}
 type AgentType = typeof AGENTS_CHOICES[number];
 interface AgentConfig {
   name: string;
@@ -14,4 +15,4 @@ interface AgentConfig {
 //#region src/index.d.ts
 declare function defineConfig(config: Partial<CommandOptions>): Partial<CommandOptions>;
 //#endregion
-export { AgentConfig, AgentType, CommandOptions, defineConfig };
+export { AgentConfig, AgentType, CommandOptions, Options, defineConfig };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ai-chat-cleaner",
   "type": "module",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Clean and remove AI chat with an interactive terminal UI.",
   "author": "jinghaihan",
   "license": "MIT",
@@ -13,7 +13,14 @@
   "bugs": {
     "url": "https://github.com/jinghaihan/ai-chat-cleaner/issues"
   },
-  "keywords": [],
+  "keywords": [
+    "codex",
+    "claude-code",
+    "conversation",
+    "threads",
+    "history",
+    "cleaner"
+  ],
   "exports": {
     ".": "./dist/index.mjs",
     "./cli": "./dist/cli.mjs",