nemonix-cli 1.0.0

package/src/config/claude-code-config/scripts/auto-rename-session/src/index.ts

@@ -0,0 +1,113 @@
+import { join } from "node:path";
+import {
+	extractTextContent,
+	isRealUserMessage,
+	type TranscriptLine,
+} from "./shared";
+
+const SCRIPT_DIR = import.meta.dir;
+const LOG_FILE = join(SCRIPT_DIR, "..", "debug.log");
+
+async function log(message: string) {
+	const timestamp = new Date().toISOString();
+	const line = `[${timestamp}] ${message}\n`;
+	await Bun.write(
+		LOG_FILE,
+		(await Bun.file(LOG_FILE)
+			.text()
+			.catch(() => "")) + line,
+	);
+}
+
+interface HookInput {
+	session_id: string;
+	transcript_path: string;
+	hook_event_name: string;
+}
+
+async function main() {
+	await log("=== Hook triggered ===");
+
+	const input: HookInput = await Bun.stdin.json();
+	await log(
+		`Input: session_id=${input.session_id}, transcript_path=${input.transcript_path}`,
+	);
+
+	if (!input.transcript_path || !input.session_id) {
+		await log("Missing transcript_path or session_id, exiting");
+		process.exit(0);
+	}
+
+	const transcriptContent = await Bun.file(input.transcript_path).text();
+	const lines = transcriptContent.trim().split("\n");
+
+	let hasCustomTitle = false;
+	let firstUserMessage = "";
+	let firstAssistantResponse = "";
+	let foundUser = false;
+
+	for (const line of lines) {
+		try {
+			const parsed: TranscriptLine = JSON.parse(line);
+
+			if (parsed.type === "custom-title") {
+				hasCustomTitle = true;
+				break;
+			}
+
+			if (!firstUserMessage && parsed.message?.role === "user") {
+				const text = extractTextContent(parsed.message.content);
+				if (isRealUserMessage(text)) {
+					firstUserMessage = text;
+					foundUser = true;
+				}
+			}
+
+			if (
+				foundUser &&
+				!firstAssistantResponse &&
+				parsed.message?.role === "assistant"
+			) {
+				const text = extractTextContent(parsed.message.content);
+				if (text) {
+					firstAssistantResponse = text;
+				}
+			}
+		} catch {}
+	}
+
+	await log(
+		`hasCustomTitle=${hasCustomTitle}, firstUserMessage="${firstUserMessage.slice(0, 50)}..."`,
+	);
+
+	if (hasCustomTitle || !firstUserMessage) {
+		await log(
+			`Skipping: hasCustomTitle=${hasCustomTitle}, noFirstUserMessage=${!firstUserMessage}`,
+		);
+		process.exit(0);
+	}
+
+	await log(`Spawning worker with session_id=${input.session_id}`);
+
+	const workerPath = join(SCRIPT_DIR, "worker.ts");
+	Bun.spawn(
+		[
+			"bun",
+			workerPath,
+			input.session_id,
+			input.transcript_path,
+			firstUserMessage.slice(0, 400),
+			firstAssistantResponse.slice(0, 300),
+		],
+		{
+			stdio: ["ignore", "ignore", "ignore"],
+		},
+	);
+
+	await log("Worker spawned successfully");
+}
+
+main().catch(async (e) => {
+	await log(`Main error: ${e?.message || e}`);
+	process.exit(0);
+});

package/src/config/claude-code-config/scripts/auto-rename-session/src/rename-all.ts

@@ -0,0 +1,148 @@
+import { isAbsolute, join, sep } from "node:path";
+import { generateTextCC } from "../../claude-code-ai/claude";
+import { encodeProjectPath } from "../../claude-code-ai/helper";
+import {
+	buildPrompt,
+	createCustomTitleLine,
+	extractTextContent,
+	isRealUserMessage,
+	parseTitle,
+	type TranscriptLine,
+} from "./shared";
+
+function toClaudeProjectPath(inputPath: string): string {
+	const absolutePath = isAbsolute(inputPath)
+		? inputPath
+		: join(process.cwd(), inputPath);
+
+	return encodeProjectPath(absolutePath);
+}
+
+async function main() {
+	const args = process.argv.slice(2);
+	const override = args.includes("--override");
+	const inputPath = args.find((arg) => !arg.startsWith("--"));
+
+	if (!inputPath) {
+		console.error("Usage: bun run rename-all <project-path> [--override]");
+		console.error("Example: bun run rename-all /Users/melvynx/cc");
+		console.error("Example: bun run rename-all . --override");
+		console.error("\nFlags:");
+		console.error("  --override  Override existing titles");
+		process.exit(1);
+	}
+
+	const projectPath = toClaudeProjectPath(inputPath);
+	console.log(`Session folder: ${projectPath}`);
+	console.log(`Override mode: ${override ? "ON" : "OFF"}\n`);
+
+	const glob = new Bun.Glob("*.jsonl");
+	const files = await Array.fromAsync(glob.scan({ cwd: projectPath }));
+
+	const sessionFiles = files.filter((f) => !f.startsWith("agent-"));
+
+	console.log(`Found ${sessionFiles.length} sessions in ${projectPath}\n`);
+
+	let renamed = 0;
+	let skipped = 0;
+
+	for (const file of sessionFiles) {
+		const filePath = join(projectPath, file);
+		const content = await Bun.file(filePath).text();
+		const lines = content.trim().split("\n");
+
+		let hasCustomTitle = false;
+		let firstUserMessage = "";
+		let firstAssistantResponse = "";
+		let foundUser = false;
+		let sessionId = file.replace(".jsonl", "");
+
+		for (const line of lines) {
+			try {
+				const parsed: TranscriptLine = JSON.parse(line);
+
+				if (parsed.type === "custom-title") {
+					hasCustomTitle = true;
+					break;
+				}
+
+				if (parsed.sessionId) {
+					sessionId = parsed.sessionId;
+				}
+
+				if (!firstUserMessage && parsed.message?.role === "user") {
+					const text = extractTextContent(parsed.message.content);
+					if (isRealUserMessage(text)) {
+						firstUserMessage = text;
+						foundUser = true;
+					}
+				}
+
+				if (
+					foundUser &&
+					!firstAssistantResponse &&
+					parsed.message?.role === "assistant"
+				) {
+					const text = extractTextContent(parsed.message.content);
+					if (text) {
+						firstAssistantResponse = text;
+					}
+				}
+			} catch {}
+		}
+
+		if (hasCustomTitle && !override) {
+			skipped++;
+			continue;
+		}
+
+		if (!firstUserMessage) {
+			console.log(`⏭️  ${file} - No user message found`);
+			skipped++;
+			continue;
+		}
+
+		try {
+			const text = await generateTextCC({
+				prompt: buildPrompt(firstUserMessage, firstAssistantResponse),
+				model: "haiku",
+			});
+
+			const title = parseTitle(text);
+
+			if (title) {
+				// If overriding, we need to remove the old custom-title line first
+				let finalContent = content;
+				if (hasCustomTitle && override) {
+					const contentLines = content.trim().split("\n");
+					const filteredLines = contentLines.filter((line) => {
+						try {
+							const parsed = JSON.parse(line);
+							return parsed.type !== "custom-title";
+						} catch {
+							return true;
+						}
+					});
+					finalContent = filteredLines.join("\n") + "\n";
+				}
+
+				await Bun.write(
+					filePath,
+					`${finalContent + createCustomTitleLine(title, sessionId)}\n`,
+				);
+				const prefix = hasCustomTitle && override ? "🔄" : "✅";
+				console.log(`${prefix} ${file} → "${title}"`);
+				renamed++;
+			} else {
+				console.log(`⏭️  ${file} - No meaningful title`);
+				skipped++;
+			}
+		} catch (e) {
+			console.error(`❌ ${file} - Error: ${e}`);
+		}
+	}
+
+	console.log(`\nDone! Renamed: ${renamed}, Skipped: ${skipped}`);
+}
+
+main().catch(console.error);

package/src/config/claude-code-config/scripts/auto-rename-session/src/shared.ts

@@ -0,0 +1,157 @@
+export interface ContentBlock {
+	type: string;
+	text?: string;
+	thinking?: string;
+}
+
+export interface TranscriptLine {
+	type: string;
+	message?: {
+		role: string;
+		content: string | ContentBlock[];
+	};
+	sessionId?: string;
+}
+
+export function extractTextContent(content: string | ContentBlock[]): string {
+	if (typeof content === "string") return content;
+
+	for (const block of content) {
+		if (block.type === "text" && block.text) return block.text;
+	}
+	return "";
+}
+
+export function isRealUserMessage(content: string): boolean {
+	if (!content) return false;
+	if (content.startsWith("Caveat:")) return false;
+	if (content.startsWith("<command-")) return false;
+	if (content.startsWith("<local-command")) return false;
+	if (content.trim().length < 5) return false;
+
+	// Detect skill/workflow prompt expansions - these are NOT real user messages
+	if (content.startsWith("Base directory for this skill:")) return false;
+	if (content.includes("<objective>")) return false;
+	if (content.includes("<quick_start>")) return false;
+	if (content.includes("<parameters>")) return false;
+	if (content.includes("<workflow>")) return false;
+	if (content.includes("<step_files>")) return false;
+	if (content.includes("<execution_rules>")) return false;
+
+	return true;
+}
+
+export function buildPrompt(
+	userMessage: string,
+	assistantResponse: string,
+): string {
+	return `Generate a short title (2-5 words) for this Claude Code session.
+
+<rules>
+- Start with a verb (action word)
+- Be concise and descriptive
+- Always respond in English
+- CRITICAL: Focus ONLY on the user's ORIGINAL INTENT from their message
+- NEVER include workflow names, tool names, skill names, or methodology references in the title
+- The title should describe WHAT the user wants to accomplish, not HOW (not the method/tool used)
+- If the user's message mentions a workflow/skill, extract the actual goal behind it
+- If the user intent is UNCLEAR or you can only see workflow/skill instructions, respond with exactly: None
+</rules>
+
+<examples>
+<example>
+<user>Help me build a React component for user authentication</user>
+<title>Build React Auth Component</title>
+</example>
+<example>
+<user>I'm getting a TypeError when fetching from my API</user>
+<title>Debug API TypeError</title>
+</example>
+<example>
+<user>compte jusqu'à 10</user>
+<title>Count to Ten</title>
+</example>
+<example>
+<user>what is 2+2</user>
+<title>Calculate Simple Math</title>
+</example>
+<example>
+<user>explain how promises work</user>
+<title>Explain JavaScript Promises</title>
+</example>
+<example>
+<user>fix the bug in my code</user>
+<title>Fix Code Bug</title>
+</example>
+<example>
+<user>implement workflow conditions for ralph</user>
+<title>Implement Ralph Conditions</title>
+</example>
+<example>
+<user>/apex add dark mode toggle</user>
+<title>Add Dark Mode Toggle</title>
+</example>
+<example>
+<user>run /apex to refactor the authentication system</user>
+<title>Refactor Auth System</title>
+</example>
+<example>
+<user>Base directory for this skill: /path/to/skill... [skill prompt]</user>
+<title>None</title>
+</example>
+<example>
+<user><objective>Execute systematic implementation workflows...</objective></user>
+<title>None</title>
+</example>
+</examples>
+
+<user_message>
+${userMessage.slice(0, 400)}
+</user_message>
+
+${assistantResponse ? `<context>\n${assistantResponse.slice(0, 200)}\n</context>` : ""}
+
+IMPORTANT: Extract the user's actual goal from their message. If the message is a workflow/skill prompt or system instruction (not a real user request), respond with exactly "None".
+
+Title:`;
+}
+
+export function parseTitle(text: string): string | null {
+	const title = text
+		.trim()
+		.replace(/["'\n*_`#]/g, "")
+		.slice(0, 60);
+
+	if (!title || title.length <= 2) return null;
+
+	// Return null for "None" responses (intent unclear)
+	if (title.toLowerCase() === "none") return null;
+
+	// Filter out ANY title containing workflow/skill keywords - these are NOT user intent
+	const forbiddenKeywords = [
+		"apex",
+		"workflow",
+		"skill",
+		"brainstorm",
+		"subagent",
+		"hook",
+	];
+
+	const lowerTitle = title.toLowerCase();
+	for (const keyword of forbiddenKeywords) {
+		if (lowerTitle.includes(keyword)) return null;
+	}
+
+	return title;
+}
+
+export function createCustomTitleLine(
+	title: string,
+	sessionId: string,
+): string {
+	return JSON.stringify({
+		type: "custom-title",
+		customTitle: title,
+		sessionId: sessionId,
+	});
+}

package/src/config/claude-code-config/scripts/auto-rename-session/src/worker.ts

@@ -0,0 +1,58 @@
+import { join } from "node:path";
+import { generateTextCC } from "../../claude-code-ai/claude";
+import { buildPrompt, createCustomTitleLine, parseTitle } from "./shared";
+
+const SCRIPT_DIR = import.meta.dir;
+const LOG_FILE = join(SCRIPT_DIR, "..", "debug.log");
+
+async function log(message: string) {
+	const timestamp = new Date().toISOString();
+	const line = `[${timestamp}] [worker] ${message}\n`;
+	await Bun.write(
+		LOG_FILE,
+		(await Bun.file(LOG_FILE)
+			.text()
+			.catch(() => "")) + line,
+	);
+}
+
+const [sessionId, transcriptPath, firstUserMessage, firstAssistantResponse] =
+	process.argv.slice(2);
+
+await log(`Worker started: sessionId=${sessionId}`);
+
+if (!sessionId || !transcriptPath || !firstUserMessage) {
+	await log("Missing args, exiting");
+	process.exit(0);
+}
+
+async function main() {
+	await log(`firstUserMessage: "${firstUserMessage}"`);
+	await log(`firstAssistantResponse: "${firstAssistantResponse}"`);
+	await log("Calling Anthropic API...");
+
+	const text = await generateTextCC({
+		prompt: buildPrompt(firstUserMessage, firstAssistantResponse),
+		model: "haiku",
+	});
+	await log(`API response: "${text}"`);
+
+	const title = parseTitle(text);
+
+	if (title) {
+		await log(`Writing title "${title}" to transcript`);
+		const transcriptContent = await Bun.file(transcriptPath).text();
+		await Bun.write(
+			transcriptPath,
+			`${transcriptContent + createCustomTitleLine(title, sessionId)}\n`,
+		);
+		await log("Title written successfully");
+	} else {
+		await log(`Skipping: title too short or empty`);
+	}
+}
+
+main().catch(async (e) => {
+	await log(`Worker error: ${e?.message || e}`);
+	process.exit(0);
+});

package/src/config/claude-code-config/scripts/biome.json

@@ -0,0 +1,37 @@
+{
+	"$schema": "https://biomejs.dev/schemas/2.3.11/schema.json",
+	"vcs": {
+		"enabled": true,
+		"clientKind": "git",
+		"useIgnoreFile": true
+	},
+	"files": {
+		"ignoreUnknown": false
+	},
+	"formatter": {
+		"enabled": true,
+		"indentStyle": "tab"
+	},
+	"linter": {
+		"enabled": true,
+		"rules": {
+			"recommended": true,
+			"suspicious": {
+				"noControlCharactersInRegex": "off"
+			}
+		}
+	},
+	"javascript": {
+		"formatter": {
+			"quoteStyle": "double"
+		}
+	},
+	"assist": {
+		"enabled": true,
+		"actions": {
+			"source": {
+				"organizeImports": "on"
+			}
+		}
+	}
+}

package/src/config/claude-code-config/scripts/claude-code-ai/CLAUDE.md

@@ -0,0 +1,84 @@
+# Claude Code AI - Project Memory
+
+Shared utilities for accessing Claude API using Claude Code's OAuth credentials.
+
+## Purpose
+
+Provides a unified way to:
+1. Retrieve Claude Code OAuth tokens (cross-platform)
+2. Make authenticated API calls to Claude models
+3. Handle common path operations for Claude config
+
+## Files
+
+```
+claude-code-ai/
+├── claude.ts           # Main API: generateTextCC()
+├── helper/
+│   ├── credentials.ts  # getClaudeCodeToken(), getClaudeCodeTokenSafe()
+│   ├── paths.ts        # getHomeDir(), getClaudeConfigDir(), encodeProjectPath()
+│   └── index.ts        # Re-exports all helpers
+└── __tests__/
+    ├── claude.test.ts  # Integration tests (real API calls)
+    └── paths.test.ts   # Unit tests for path helpers
+```
+
+## Usage
+
+### Generate Text with Claude
+
+```typescript
+import { generateTextCC } from "../claude-code-ai/claude";
+
+const response = await generateTextCC({
+  prompt: "Your prompt here",
+  model: "haiku",  // "haiku" | "sonnet" | "opus"
+  system: "Optional system prompt",
+});
+```
+
+### Get OAuth Token
+
+```typescript
+import { getClaudeCodeToken, getClaudeCodeTokenSafe } from "../claude-code-ai/helper";
+
+const token = await getClaudeCodeToken();     // Throws on error
+const token = await getClaudeCodeTokenSafe(); // Returns null on error
+```
+
+### Cross-Platform Paths
+
+```typescript
+import {
+  getHomeDir,
+  getClaudeConfigDir,
+  getClaudeProjectsDir,
+  encodeProjectPath
+} from "../claude-code-ai/helper";
+
+const home = getHomeDir();                    // Works on all platforms
+const configDir = getClaudeConfigDir();       // ~/.config/claude or ~/.claude
+const projectPath = encodeProjectPath("/Users/me/myproject");
+```
+
+## Credential Storage
+
+| Platform | Location |
+|----------|----------|
+| macOS | Keychain (`security find-generic-password -s "Claude Code-credentials"`) |
+| Linux | `~/.claude/.credentials.json` |
+| Windows | WSL required, uses Linux path |
+
+## Testing
+
+```bash
+bun run ai:test  # Runs all tests (includes real API calls, ~15s)
+```
+
+## Models
+
+| Model | ID |
+|-------|-----|
+| haiku | `claude-haiku-4-5-20251001` |
+| sonnet | `claude-sonnet-4-5-20250929` |
+| opus | `claude-opus-4-5-20251101` |

package/src/config/claude-code-config/scripts/claude-code-ai/__tests__/claude.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from "bun:test";
+import { generateTextCC, type Model } from "../claude";
+
+const models: Model[] = ["haiku", "sonnet", "opus"];
+
+describe("generateTextCC", () => {
+	for (const model of models) {
+		it(`should generate text with ${model}`, async () => {
+			const result = await generateTextCC({
+				prompt: "Hey",
+				model,
+			});
+
+			expect(result).toBeDefined();
+			expect(typeof result).toBe("string");
+			expect(result.length).toBeGreaterThan(0);
+		}, 30000);
+	}
+});

package/src/config/claude-code-config/scripts/claude-code-ai/__tests__/paths.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, it } from "bun:test";
+import { homedir } from "node:os";
+import { join, sep } from "node:path";
+import {
+	encodeProjectPath,
+	getClaudeConfigDir,
+	getClaudeCredentialsPath,
+	getClaudeProjectsDir,
+	getHomeDir,
+} from "../helper/paths";
+
+describe("getHomeDir", () => {
+	it("should return a non-empty string", () => {
+		const home = getHomeDir();
+		expect(home).toBeTruthy();
+		expect(typeof home).toBe("string");
+	});
+
+	it("should match os.homedir()", () => {
+		expect(getHomeDir()).toBe(homedir());
+	});
+});
+
+describe("getClaudeCredentialsPath", () => {
+	it("should return path in home directory", () => {
+		const credPath = getClaudeCredentialsPath();
+		expect(credPath).toContain(getHomeDir());
+		expect(credPath).toContain(".credentials.json");
+	});
+});
+
+describe("getClaudeProjectsDir", () => {
+	it("should return path with projects directory", () => {
+		const projectsDir = getClaudeProjectsDir();
+		expect(projectsDir).toContain("projects");
+	});
+});
+
+describe("encodeProjectPath", () => {
+	it("should encode forward slashes to dashes", () => {
+		const result = encodeProjectPath("/Users/test/myproject");
+		expect(result).toContain("-Users-test-myproject");
+	});
+
+	it("should encode dots to dashes", () => {
+		const result = encodeProjectPath("/path/to/.hidden");
+		expect(result).toContain("-hidden");
+	});
+
+	it("should handle Windows paths", () => {
+		const result = encodeProjectPath("C:\\Users\\test\\project");
+		expect(result).not.toContain("\\");
+		expect(result).not.toContain(":");
+	});
+
+	it("should return path as-is if already in projects directory", () => {
+		const home = getHomeDir();
+		const existingPath = join(home, ".claude", "projects", "my-project");
+		const result = encodeProjectPath(existingPath);
+		expect(result).toBe(existingPath);
+	});
+
+	it("should strip trailing slashes", () => {
+		const path1 = encodeProjectPath("/Users/test/project/");
+		const path2 = encodeProjectPath("/Users/test/project");
+		expect(path1).toBe(path2);
+	});
+});