nemonix-cli 1.0.0

package/src/config/claude-code-config/hooks/hook-post-file.ts

@@ -0,0 +1,162 @@
+#!/usr/bin/env bun
+// @ts-nocheck
+
+interface HookInput {
+  session_id: string;
+  transcript_path: string;
+  cwd: string;
+  hook_event_name: string;
+  tool_name: string;
+  tool_input: {
+    file_path: string;
+    content: string;
+  };
+  tool_response: {
+    filePath: string;
+    success: boolean;
+  };
+}
+
+interface HookOutput {
+  hookSpecificOutput: {
+    hookEventName: string;
+    additionalContext: string;
+  };
+}
+
+// Check for debug mode
+const DEBUG = process.argv.includes("--debug");
+
+function log(message: string, ...args: unknown[]) {
+  if (DEBUG) {
+    console.log(message, ...args);
+  }
+}
+
+async function runCommand(
+  command: string[],
+): Promise<{ stdout: string; stderr: string; success: boolean }> {
+  try {
+    const proc = Bun.spawn(command, {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    const success = (await proc.exited) === 0;
+
+    return { stdout, stderr, success };
+  } catch (error) {
+    return { stdout: "", stderr: String(error), success: false };
+  }
+}
+
+async function main() {
+  log("Hook started for file processing");
+
+  // Lire l'input JSON depuis stdin
+  const input = await Bun.stdin.text();
+  log("Input received, length:", input.length);
+
+  let hookData: HookInput;
+  try {
+    hookData = JSON.parse(input);
+  } catch (error) {
+    log("Error parsing JSON input:", error);
+    process.exit(0);
+  }
+
+  const filePath = hookData.tool_input?.file_path;
+  if (!filePath) {
+    log("Unable to extract file path from input");
+    process.exit(0);
+  }
+
+  // Vérifier que c'est un fichier .ts ou .tsx uniquement
+  if (!filePath.endsWith(".ts") && !filePath.endsWith(".tsx")) {
+    log(`Skipping ${filePath}: not a TypeScript file`);
+    process.exit(0);
+  }
+
+  log("Processing file:", filePath);
+
+  // Vérifier que le fichier existe
+  const file = Bun.file(filePath);
+  if (!(await file.exists())) {
+    log("File not found:", filePath);
+    process.exit(1);
+  }
+
+  // 1. Exécuter Prettier
+  log("Running Prettier formatting");
+  const prettierResult = await runCommand([
+    "bun",
+    "x",
+    "prettier",
+    "--write",
+    filePath,
+  ]);
+  if (!prettierResult.success) {
+    log("Prettier failed:", prettierResult.stderr);
+  }
+
+  // 2. ESLint --fix
+  log("Running ESLint --fix");
+  await runCommand(["bun", "x", "eslint", "--fix", filePath]);
+
+  // 3. Run ESLint check and TypeScript check in parallel
+  log("Running ESLint and TypeScript checks in parallel");
+  const [eslintCheckResult, tscResult] = await Promise.all([
+    runCommand(["bun", "x", "eslint", filePath]),
+    runCommand(["bun", "x", "tsc", "--noEmit", "--pretty", "false"]),
+  ]);
+
+  const eslintErrors = (
+    eslintCheckResult.stdout + eslintCheckResult.stderr
+  ).trim();
+
+  const tsErrors = tscResult.stderr
+    .split("\n")
+    .filter((line) => line.includes(filePath))
+    .join("\n");
+
+  // Construire le message d'erreurs
+  let errorMessage = "";
+
+  if (tsErrors || eslintErrors) {
+    errorMessage = `Fix NOW the following errors AND warning detected in ${filePath
+      .split("/")
+      .pop()}:\\n`;
+
+    if (tsErrors) {
+      errorMessage += `\\n TypeScript errors:\\n${tsErrors}\\n`;
+    }
+
+    if (eslintErrors) {
+      errorMessage += `\\n ESLint errors:\\n${eslintErrors}\\n`;
+    }
+  }
+
+  log("Error message", errorMessage);
+
+  // Sortir le résultat
+  if (errorMessage) {
+    const output: HookOutput = {
+      hookSpecificOutput: {
+        hookEventName: "PostToolUse",
+        additionalContext: errorMessage,
+      },
+    };
+
+    log("Output", JSON.stringify(output, null, 2));
+    console.log(JSON.stringify(output, null, 2));
+  } else {
+    console.error(`No errors detected in ${filePath.split("/").pop()}`);
+  }
+}
+
+main().catch((error) => {
+  log("Error in hook:", error);
+  process.exit(1);
+});

package/src/config/claude-code-config/scripts/.claude/skills/fix-on-my-computer/SKILL.md

@@ -0,0 +1,81 @@
+---
+name: fix-on-my-computer
+description: Setup wizard - verify bun, install deps, run tests, fix until ALL pass
+allowed-tools: Bash, Read, Edit, Write, Glob, Grep
+---
+
+# Setup Wizard
+
+Make this scripts repository work PERFECTLY on this machine.
+
+Relentless setup wizard. Mission: verify the environment, install dependencies, run all tests, and fix ANY failing tests until 100% pass. NEVER give up until every single test is green.
+
+## Context
+
+Current OS: !`uname -s`
+Current directory: !`pwd`
+Bun version: !`bun --version 2>&1 || echo "NOT_INSTALLED"`
+
+## Process
+
+### Phase 1: Environment Check
+
+1. Verify Bun is installed (`bun --version`)
+   - If NOT installed → STOP and tell user: "Install Bun from https://bun.sh"
+2. Verify in correct directory (must have package.json with "test" script)
+3. Check OS: macOS/Linux (full support), Windows (needs WSL)
+
+### Phase 2: Install Dependencies
+
+4. Run `bun install`
+   - If fails: Delete `bun.lockb` and retry
+   - If still fails: Report specific error to user
+
+### Phase 3: Run Tests
+
+5. Run `bun run test`
+6. Record output - note which tests pass/fail
+
+### Phase 4: Fix Loop (NEVER STOP UNTIL GREEN)
+
+7. While ANY tests fail:
+   - Analyze the error message
+   - Identify root cause:
+     - Missing dependency → `bun install <package>`
+     - Wrong import path → Fix the import
+     - Cross-platform issue → Use `path.join()`, `os.homedir()`
+     - Missing credentials → Check `~/.claude/.credentials.json`
+     - File not found → Verify path exists
+     - Type error → Fix TypeScript
+   - Apply minimal fix
+   - Re-run `bun run test`
+   - **REPEAT until 100% green**
+
+### Phase 5: Final Verification
+
+8. Run `bun run test` one final time
+9. Run `bun run lint` (fix if needed)
+
+### Phase 6: Victory Report
+
+10. Report to user:
+    - Total tests passed
+    - Fixes applied (list each one)
+    - Status: READY TO USE
+
+## Testing Commands
+
+```bash
+bun install
+bun run test
+bun run lint
+```
+
+## Success Criteria
+
+Before declaring success:
+- `bun run test` exits with code 0
+- ALL 186+ tests pass
+- No lint errors
+- All package.json scripts work
+- Repository is READY TO USE

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

@@ -0,0 +1,50 @@
+# Scripts - Project Memory
+
+Monorepo containing Claude Code utilities and extensions.
+
+## Structure
+
+```
+scripts/
+├── auto-rename-session/  # Auto-generates session titles via AI
+├── claude-code-ai/       # Shared Claude API helpers
+├── command-validator/    # Security validation for bash commands
+├── statusline/           # Custom statusline for Claude Code
+└── package.json          # Root package with all scripts
+```
+
+## Commands
+
+```bash
+bun run test              # Run ALL tests (186 tests)
+bun run lint              # Lint all packages
+```
+
+### Per-Package Commands
+
+| Package | Test | Start |
+|---------|------|-------|
+| auto-rename-session | `bun run auto-rename:test` | `bun run auto-rename:start` |
+| claude-code-ai | `bun run ai:test` | - |
+| command-validator | `bun run validator:test` | `bun run validator:cli` |
+| statusline | `bun run statusline:test` | `bun run statusline:start` |
+
+## Cross-Platform Support
+
+All packages support macOS, Linux, and Windows (via WSL):
+- Use `path.join()` instead of string concatenation
+- Use `os.homedir()` instead of `process.env.HOME`
+- Use `path.sep` or regex `[/\\]` for path splitting
+
+## Shared Dependencies
+
+- `@ai-sdk/anthropic` + `ai` - Claude API access
+- `picocolors` - Terminal colors
+- `@biomejs/biome` - Linting/formatting
+- `bun:test` - Testing
+
+## Credentials
+
+Claude Code OAuth tokens are retrieved via `claude-code-ai/helper/credentials.ts`:
+- macOS: Keychain (`security find-generic-password`)
+- Linux/Windows: `~/.claude/.credentials.json`

package/src/config/claude-code-config/scripts/auto-rename-session/CLAUDE.md

@@ -0,0 +1,59 @@
+# Auto-Rename Session - Project Memory
+
+Automatically generates meaningful titles for Claude Code sessions using AI.
+
+## How It Works
+
+1. **Hook Trigger**: Claude Code's `Stop` hook runs `index.ts`
+2. **Parse Transcript**: Extracts first user message and assistant response
+3. **Skip if Titled**: Checks for existing `custom-title` in transcript
+4. **Generate Title**: Calls Claude Haiku via `generateTextCC`
+5. **Write to Transcript**: Appends `{"type":"custom-title","customTitle":"..."}` line
+
+## Commands
+
+```bash
+bun run auto-rename:start      # Run the hook handler
+bun run auto-rename:rename-all # Batch rename all sessions in a project
+bun run auto-rename:test       # Run tests
+```
+
+## Files
+
+| File | Purpose |
+|------|---------|
+| `src/index.ts` | Hook entry point, spawns worker |
+| `src/worker.ts` | Calls AI, writes title to transcript |
+| `src/shared.ts` | `buildPrompt`, `parseTitle`, `extractTextContent` |
+| `src/rename-all.ts` | CLI to batch-rename old sessions |
+
+## Hook Configuration
+
+Add to `~/.claude/settings.json`:
+```json
+{
+  "hooks": {
+    "Stop": [{
+      "command": "bun /path/to/auto-rename-session/src/index.ts"
+    }]
+  }
+}
+```
+
+## Title Generation Rules
+
+- 2-5 words, starts with verb
+- Always in English (even for non-English input)
+- Examples: "Build React Auth", "Debug API Error", "Fix Code Bug"
+
+## Testing
+
+```bash
+bun test auto-rename-session/__tests__/shared.test.ts         # Unit tests
+bun test auto-rename-session/__tests__/title-generation.test.ts  # Integration (real API)
+```
+
+## Dependencies
+
+- Uses `../../claude-code-ai/claude.ts` for API calls
+- Uses `../../claude-code-ai/helper/paths.ts` for cross-platform paths

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

@@ -0,0 +1,185 @@
+import { describe, expect, it } from "bun:test";
+import {
+	buildPrompt,
+	createCustomTitleLine,
+	extractTextContent,
+	isRealUserMessage,
+	parseTitle,
+} from "../src/shared";
+
+describe("extractTextContent", () => {
+	it("should extract text from string content", () => {
+		const result = extractTextContent("Hello world");
+		expect(result).toBe("Hello world");
+	});
+
+	it("should extract text from content blocks array", () => {
+		const content = [
+			{ type: "thinking", thinking: "I'm thinking..." },
+			{ type: "text", text: "This is the response" },
+		];
+		const result = extractTextContent(content);
+		expect(result).toBe("This is the response");
+	});
+
+	it("should return empty string when no text block found", () => {
+		const content = [{ type: "thinking", thinking: "Just thinking" }];
+		const result = extractTextContent(content);
+		expect(result).toBe("");
+	});
+
+	it("should return empty string for empty array", () => {
+		const result = extractTextContent([]);
+		expect(result).toBe("");
+	});
+});
+
+describe("isRealUserMessage", () => {
+	it("should return true for valid user messages", () => {
+		expect(isRealUserMessage("Help me build a component")).toBe(true);
+		expect(isRealUserMessage("Fix the bug in my code")).toBe(true);
+	});
+
+	it("should return false for empty content", () => {
+		expect(isRealUserMessage("")).toBe(false);
+	});
+
+	it("should return false for messages starting with Caveat:", () => {
+		expect(isRealUserMessage("Caveat: This is a system message")).toBe(false);
+	});
+
+	it("should return false for command messages", () => {
+		expect(isRealUserMessage("<command-name>test</command-name>")).toBe(false);
+		expect(isRealUserMessage("<local-command>something</local-command>")).toBe(
+			false,
+		);
+	});
+
+	it("should return false for very short messages", () => {
+		expect(isRealUserMessage("hey")).toBe(false);
+		expect(isRealUserMessage("hi")).toBe(false);
+		expect(isRealUserMessage("    ")).toBe(false);
+	});
+
+	it("should return true for messages exactly 5 characters", () => {
+		expect(isRealUserMessage("hello")).toBe(true);
+	});
+
+	it("should return false for skill prompt expansions", () => {
+		expect(
+			isRealUserMessage("Base directory for this skill: /path/to/skill"),
+		).toBe(false);
+		expect(
+			isRealUserMessage(
+				"<objective>Execute systematic implementation workflows</objective>",
+			),
+		).toBe(false);
+		expect(
+			isRealUserMessage("Some text with <quick_start> in it"),
+		).toBe(false);
+		expect(
+			isRealUserMessage("<parameters>some params</parameters>"),
+		).toBe(false);
+		expect(
+			isRealUserMessage("Text containing <workflow> tag"),
+		).toBe(false);
+	});
+
+	it("should return true for real user messages that look like but are not skill prompts", () => {
+		expect(isRealUserMessage("Help me set up a workflow")).toBe(true);
+		expect(isRealUserMessage("Add a parameter to my function")).toBe(true);
+	});
+});
+
+describe("parseTitle", () => {
+	it("should parse a clean title", () => {
+		expect(parseTitle("Build React Auth")).toBe("Build React Auth");
+	});
+
+	it("should remove quotes and special characters", () => {
+		expect(parseTitle('"Debug API Error"')).toBe("Debug API Error");
+		expect(parseTitle("**Fix Bug**")).toBe("Fix Bug");
+		expect(parseTitle("`Code Review`")).toBe("Code Review");
+	});
+
+	it("should trim whitespace", () => {
+		expect(parseTitle("  Create Component  ")).toBe("Create Component");
+	});
+
+	it("should truncate long titles to 60 characters", () => {
+		const longTitle =
+			"This is a very long title that should be truncated because it exceeds sixty characters";
+		const result = parseTitle(longTitle);
+		expect(result?.length).toBeLessThanOrEqual(60);
+	});
+
+	it("should return null for empty or very short titles", () => {
+		expect(parseTitle("")).toBeNull();
+		expect(parseTitle("ab")).toBeNull();
+		expect(parseTitle("  ")).toBeNull();
+	});
+
+	it("should return null for None responses", () => {
+		expect(parseTitle("None")).toBeNull();
+		expect(parseTitle("none")).toBeNull();
+		expect(parseTitle("NONE")).toBeNull();
+	});
+
+	it("should return null for ANY title containing workflow/skill keywords", () => {
+		expect(parseTitle("Set Up APEX Skill")).toBeNull();
+		expect(parseTitle("Running Apex Workflow")).toBeNull();
+		expect(parseTitle("Execute Workflow Steps")).toBeNull();
+		expect(parseTitle("Start APEX")).toBeNull();
+		expect(parseTitle("Initialize Skill")).toBeNull();
+		expect(parseTitle("Loading APEX")).toBeNull();
+		expect(parseTitle("Build Approval Workflow")).toBeNull();
+		expect(parseTitle("Debug Skill System")).toBeNull();
+		expect(parseTitle("Add Workflow Feature")).toBeNull();
+		expect(parseTitle("Debug Brainstorm")).toBeNull();
+		expect(parseTitle("Create Subagent")).toBeNull();
+		expect(parseTitle("Setup Hook")).toBeNull();
+	});
+
+	it("should allow valid titles without forbidden keywords", () => {
+		expect(parseTitle("Build React Component")).toBe("Build React Component");
+		expect(parseTitle("Debug API Error")).toBe("Debug API Error");
+		expect(parseTitle("Add Authentication")).toBe("Add Authentication");
+	});
+});
+
+describe("buildPrompt", () => {
+	it("should include user message in prompt", () => {
+		const prompt = buildPrompt("Help me fix a bug", "");
+		expect(prompt).toContain("Help me fix a bug");
+		expect(prompt).toContain("<user_message>");
+	});
+
+	it("should include assistant response when provided", () => {
+		const prompt = buildPrompt("Fix bug", "I'll help you debug this issue");
+		expect(prompt).toContain("<context>");
+		expect(prompt).toContain("I'll help you debug this issue");
+	});
+
+	it("should not include context section when no assistant response", () => {
+		const prompt = buildPrompt("Fix bug", "");
+		expect(prompt).not.toContain("<context>");
+	});
+
+	it("should truncate long user messages", () => {
+		const longMessage = "a".repeat(500);
+		const prompt = buildPrompt(longMessage, "");
+		expect(prompt).toContain("a".repeat(400));
+		expect(prompt).not.toContain("a".repeat(500));
+	});
+});
+
+describe("createCustomTitleLine", () => {
+	it("should create valid JSON with custom-title type", () => {
+		const line = createCustomTitleLine("My Title", "session-123");
+		const parsed = JSON.parse(line);
+
+		expect(parsed.type).toBe("custom-title");
+		expect(parsed.customTitle).toBe("My Title");
+		expect(parsed.sessionId).toBe("session-123");
+	});
+});

package/src/config/claude-code-config/scripts/auto-rename-session/__tests__/title-generation.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from "bun:test";
+import { generateTextCC } from "../../claude-code-ai/claude";
+import { buildPrompt, parseTitle } from "../src/shared";
+
+describe("Title Generation (Integration)", () => {
+	it("should generate a valid title for a React component request", async () => {
+		const userMessage =
+			"Help me build a React component for user authentication";
+		const assistantResponse =
+			"I'll help you create an authentication component";
+
+		const prompt = buildPrompt(userMessage, assistantResponse);
+		const response = await generateTextCC({ prompt, model: "haiku" });
+		const title = parseTitle(response);
+
+		expect(title).toBeTruthy();
+		expect(title!.length).toBeGreaterThan(3);
+		expect(title!.length).toBeLessThanOrEqual(60);
+	}, 30000);
+
+	it("should generate a valid title for a bug fix request", async () => {
+		const userMessage = "I'm getting a TypeError when fetching from my API";
+		const assistantResponse = "Let me help you debug this issue";
+
+		const prompt = buildPrompt(userMessage, assistantResponse);
+		const response = await generateTextCC({ prompt, model: "haiku" });
+		const title = parseTitle(response);
+
+		expect(title).toBeTruthy();
+		expect(title!.length).toBeGreaterThan(3);
+	}, 30000);
+
+	it("should generate a title in English even for non-English input", async () => {
+		const userMessage = "Aide-moi à créer une fonction de tri";
+		const assistantResponse = "";
+
+		const prompt = buildPrompt(userMessage, assistantResponse);
+		const response = await generateTextCC({ prompt, model: "haiku" });
+		const title = parseTitle(response);
+
+		expect(title).toBeTruthy();
+		expect(title!.length).toBeGreaterThan(3);
+	}, 30000);
+});

package/src/config/claude-code-config/scripts/auto-rename-session/fixtures/sample-transcript.jsonl

@@ -0,0 +1,3 @@
+{"type":"file-history-snapshot","messageId":"409fe884-7ba8-4577-93e9-e3c8f090431f","snapshot":{"messageId":"409fe884-7ba8-4577-93e9-e3c8f090431f","trackedFileBackups":{},"timestamp":"2026-01-05T13:19:37.529Z"},"isSnapshotUpdate":false}
+{"parentUuid":null,"isSidechain":false,"userType":"external","cwd":"/Users/melvynx","sessionId":"test-session-123","version":"2.0.76","gitBranch":"main","type":"user","message":{"role":"user","content":"Help me build a React component for user authentication"},"uuid":"409fe884-7ba8-4577-93e9-e3c8f090431f","timestamp":"2026-01-05T13:19:37.521Z"}
+{"parentUuid":"409fe884-7ba8-4577-93e9-e3c8f090431f","isSidechain":false,"userType":"external","cwd":"/Users/melvynx","sessionId":"test-session-123","version":"2.0.76","gitBranch":"main","message":{"model":"claude-opus-4-5-20251101","id":"msg_01HLwb1d4WTJpgjWPKjP2sST","type":"message","role":"assistant","content":[{"type":"text","text":"I'll help you create a React authentication component. Let me start by setting up the basic structure."}],"stop_reason":"end_turn","usage":{"input_tokens":1000,"output_tokens":200}},"requestId":"req_011CWpJGYa1vqkZBsFWUEKUj","type":"assistant","uuid":"e8ee8f5d-b970-4313-bf82-283f46700754","timestamp":"2026-01-05T13:19:41.893Z"}

package/src/config/claude-code-config/scripts/auto-rename-session/fixtures/transcript-short-message.jsonl

@@ -0,0 +1,2 @@
+{"type":"file-history-snapshot","messageId":"def456","snapshot":{}}
+{"parentUuid":null,"isSidechain":false,"userType":"external","cwd":"/Users/melvynx","sessionId":"short-session","version":"2.0.76","gitBranch":"main","type":"user","message":{"role":"user","content":"hey"},"uuid":"def456","timestamp":"2026-01-05T13:19:37.521Z"}

package/src/config/claude-code-config/scripts/auto-rename-session/fixtures/transcript-with-title.jsonl

@@ -0,0 +1,3 @@
+{"type":"file-history-snapshot","messageId":"abc123","snapshot":{"messageId":"abc123","trackedFileBackups":{},"timestamp":"2026-01-05T13:19:37.529Z"},"isSnapshotUpdate":false}
+{"parentUuid":null,"isSidechain":false,"userType":"external","cwd":"/Users/melvynx","sessionId":"titled-session","version":"2.0.76","gitBranch":"main","type":"user","message":{"role":"user","content":"Fix the bug in my code"},"uuid":"abc123","timestamp":"2026-01-05T13:19:37.521Z"}
+{"type":"custom-title","customTitle":"Debug Code Issue","sessionId":"titled-session"}