ronds_ai 0.1.0

package/bin/ronds_ai.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+const { runCodeRecord, saveCliError } = require('../lib/code_record');
+const { deployHooks } = require('../lib/hooks_deploy');
+
+const SUPPORTED_SOURCES = new Set(['claude', 'cursor']);
+
+function printUsage() {
+  process.stderr.write([
+    'Usage:',
+    '  ronds_ai record <tool>',
+    '  ronds_ai hooks deploy',
+    '',
+    'Supported tools for record:',
+    '  claude',
+    '  cursor',
+    '',
+    'Examples:',
+    '  npx ronds_ai record claude',
+    '  npx ronds_ai record cursor',
+    '  npx ronds_ai hooks deploy',
+  ].join('\n'));
+  process.stderr.write('\n');
+}
+
+async function runHooksCommand(args) {
+  const [action] = args;
+
+  if (action !== 'deploy') {
+    throw new Error('Unsupported hooks command');
+  }
+
+  const result = deployHooks(process.cwd());
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+}
+
+async function run() {
+  const [, , command, ...args] = process.argv;
+
+  if (command === 'record') {
+    const [source] = args;
+    const normalizedSource = String(source || '').trim().toLowerCase();
+
+    if (!SUPPORTED_SOURCES.has(normalizedSource)) {
+      throw new Error(`Unsupported record tool: ${source || ''}`);
+    }
+
+    await runCodeRecord(normalizedSource);
+    return;
+  }
+
+  if (command === 'hooks') {
+    await runHooksCommand(args);
+    return;
+  }
+
+  throw new Error(`Unsupported command: ${command || ''}`);
+}
+
+run().catch((error) => {
+  const [, , command, ...args] = process.argv;
+  let savedPath = '';
+
+  try {
+    savedPath = saveCliError(error, { command: command || '', args });
+  } catch {
+    savedPath = '';
+  }
+
+  printUsage();
+  const message = error instanceof Error ? error.stack || error.message : String(error);
+  process.stderr.write(`${message}\n`);
+  if (savedPath) {
+    process.stderr.write(`cli error saved to ${savedPath}\n`);
+  }
+  process.exitCode = 1;
+});

package/lib/code_record.js

@@ -0,0 +1,610 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const http = require('http');
+const https = require('https');
+const { execFileSync } = require('child_process');
+const { randomUUID } = require('crypto');
+
+const DEFAULT_TIMEOUT_MS = 10000;
+const MAX_ADDED_CONTENT_CHARS = 20000;
+const DEFAULT_HOOK_REPORT_URL = 'http://192.168.2.121:8100/api/v1/ai-code-events';
+const CLAUDE_SUPPORTED_HOOK_EVENT = 'PostToolUse';
+const CLAUDE_SUPPORTED_TOOLS = new Set(['Write', 'Edit', 'MultiEdit']);
+const CURSOR_SUPPORTED_HOOK_EVENT = 'afterFileEdit';
+
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on('end', () => resolve(data));
+    process.stdin.on('error', reject);
+  });
+}
+
+function parseJson(raw, label) {
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`${label} is not valid JSON: ${detail}`);
+  }
+}
+
+function normalizeLines(text) {
+  return String(text || '').replace(/\r\n/g, '\n').split('\n');
+}
+
+function buildLcsMatrix(beforeLines, afterLines) {
+  const matrix = Array.from(
+    { length: beforeLines.length + 1 },
+    () => Array(afterLines.length + 1).fill(0),
+  );
+
+  for (let i = beforeLines.length - 1; i >= 0; i -= 1) {
+    for (let j = afterLines.length - 1; j >= 0; j -= 1) {
+      if (beforeLines[i] === afterLines[j]) {
+        matrix[i][j] = matrix[i + 1][j + 1] + 1;
+      } else {
+        matrix[i][j] = Math.max(matrix[i + 1][j], matrix[i][j + 1]);
+      }
+    }
+  }
+
+  return matrix;
+}
+
+function diffLineStats(beforeText, afterText) {
+  const beforeLines = normalizeLines(beforeText);
+  const afterLines = normalizeLines(afterText);
+  const matrix = buildLcsMatrix(beforeLines, afterLines);
+  const addedLines = [];
+
+  let added = 0;
+  let removed = 0;
+  let i = 0;
+  let j = 0;
+
+  while (i < beforeLines.length && j < afterLines.length) {
+    if (beforeLines[i] === afterLines[j]) {
+      i += 1;
+      j += 1;
+      continue;
+    }
+
+    if (matrix[i][j + 1] >= matrix[i + 1][j]) {
+      if (afterLines[j] !== '') {
+        addedLines.push(afterLines[j]);
+        added += 1;
+      }
+      j += 1;
+    } else {
+      if (beforeLines[i] !== '') {
+        removed += 1;
+      }
+      i += 1;
+    }
+  }
+
+  while (j < afterLines.length) {
+    if (afterLines[j] !== '') {
+      addedLines.push(afterLines[j]);
+      added += 1;
+    }
+    j += 1;
+  }
+
+  while (i < beforeLines.length) {
+    if (beforeLines[i] !== '') {
+      removed += 1;
+    }
+    i += 1;
+  }
+
+  let addedContent = addedLines.join('\n');
+  if (addedContent.length > MAX_ADDED_CONTENT_CHARS) {
+    addedContent = `${addedContent.slice(0, MAX_ADDED_CONTENT_CHARS)}\n... (truncated)`;
+  }
+
+  return { added, removed, addedContent };
+}
+
+function findGitRepoRoot(startDir) {
+  let currentDir = path.resolve(startDir);
+
+  while (true) {
+    if (fs.existsSync(path.join(currentDir, '.git'))) {
+      return currentDir;
+    }
+
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+
+    currentDir = parentDir;
+  }
+}
+
+function runGit(repoRoot, args, required = true) {
+  try {
+    return execFileSync('git', args, {
+      cwd: repoRoot,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    }).trim();
+  } catch (error) {
+    if (!required) {
+      return '';
+    }
+
+    const stderr = error && error.stderr ? String(error.stderr).trim() : String(error);
+    throw new Error(`git ${args.join(' ')} failed: ${stderr}`);
+  }
+}
+
+function extractRepoNameFromRemoteUrl(remoteUrl) {
+  const normalizedUrl = String(remoteUrl || '').trim().replace(/[\\/]+$/, '');
+  if (!normalizedUrl) {
+    return '';
+  }
+
+  const lastSegment = normalizedUrl.split(/[:/]/).pop() || '';
+  return lastSegment.replace(/\.git$/i, '').trim();
+}
+
+function resolveGitMetadata(repoRoot) {
+  const remoteUrl = runGit(repoRoot, ['remote', 'get-url', 'origin'], false);
+  const remoteRepoName = extractRepoNameFromRemoteUrl(remoteUrl);
+
+  return {
+    repo_name: remoteRepoName || path.basename(repoRoot),
+    remote_url: remoteUrl,
+    'user.name': runGit(repoRoot, ['config', 'user.name'], false),
+    'user.email': runGit(repoRoot, ['config', 'user.email'], false),
+  };
+}
+
+function normalizeWorkspaceRoot(root) {
+  const raw = String(root || '').trim();
+  if (!raw) {
+    return '';
+  }
+
+  const normalized = raw.replace(/^\/+/, '');
+  if (/^[a-zA-Z]:/.test(normalized)) {
+    return path.normalize(normalized);
+  }
+
+  return path.normalize(raw);
+}
+
+function resolveClaudeAbsoluteFilePath(filePath, payload) {
+  const rawPath = String(filePath || '').trim();
+  if (!rawPath) {
+    return '';
+  }
+
+  if (path.isAbsolute(rawPath)) {
+    return path.normalize(rawPath);
+  }
+
+  const candidateBases = [
+    payload.cwd,
+    payload.workspace && payload.workspace.current_dir,
+    payload.workspace && payload.workspace.project_dir,
+    process.env.CLAUDE_PROJECT_DIR,
+    process.cwd(),
+  ].filter(Boolean);
+
+  for (const base of candidateBases) {
+    const candidate = path.resolve(base, rawPath);
+    if (fs.existsSync(candidate) || fs.existsSync(path.dirname(candidate))) {
+      return candidate;
+    }
+  }
+
+  return path.resolve(process.cwd(), rawPath);
+}
+
+function resolveCursorAbsoluteFilePath(filePath, payload) {
+  const rawPath = String(filePath || '').trim();
+  if (!rawPath) {
+    return '';
+  }
+
+  if (path.isAbsolute(rawPath)) {
+    return path.normalize(rawPath);
+  }
+
+  const workspaceRoots = Array.isArray(payload.workspace_roots)
+    ? payload.workspace_roots.map(normalizeWorkspaceRoot)
+    : [];
+  const candidateBases = [
+    ...workspaceRoots,
+    process.env.CURSOR_PROJECT_DIR,
+    process.cwd(),
+  ].filter(Boolean);
+
+  for (const base of candidateBases) {
+    const candidate = path.resolve(base, rawPath);
+    if (fs.existsSync(candidate) || fs.existsSync(path.dirname(candidate))) {
+      return candidate;
+    }
+  }
+
+  return path.resolve(process.cwd(), rawPath);
+}
+
+function getGitInfo(filePath) {
+  if (!filePath) {
+    return { repoRoot: null, git: null, repoRelativePath: '' };
+  }
+
+  const lookupBase = fs.existsSync(filePath) && fs.statSync(filePath).isDirectory()
+    ? filePath
+    : path.dirname(filePath);
+  const repoRoot = findGitRepoRoot(lookupBase);
+  if (!repoRoot) {
+    return {
+      repoRoot: null,
+      git: null,
+      repoRelativePath: String(filePath).replace(/\\/g, '/'),
+    };
+  }
+
+  return {
+    repoRoot,
+    repoRelativePath: path.relative(repoRoot, filePath).replace(/\\/g, '/'),
+    git: resolveGitMetadata(repoRoot),
+  };
+}
+
+function readWorkerIdConfig(baseDir) {
+  if (!baseDir) {
+    return '';
+  }
+
+  const configPath = path.join(baseDir, '.ai_config', 'config.json');
+  try {
+    if (!fs.existsSync(configPath)) {
+      return '';
+    }
+
+    const parsed = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    if (typeof parsed.worker_id === 'string' && parsed.worker_id.trim()) {
+      return parsed.worker_id.trim();
+    }
+  } catch {
+    return '';
+  }
+
+  return '';
+}
+
+function resolveWorkerId(repoRoot) {
+  const candidates = [process.cwd(), repoRoot];
+  for (const candidate of candidates) {
+    const workerId = readWorkerIdConfig(candidate);
+    if (workerId) {
+      return workerId;
+    }
+  }
+
+  return process.env.MCP_TRACKER_WORKER_ID || process.env.WORKER_ID || os.userInfo().username;
+}
+
+function buildWriteChange(toolInput) {
+  const content = String(toolInput.content || '').replace(/\r\n/g, '\n');
+  return {
+    operation: 'write',
+    changes: {
+      added_content: content,
+      added: content ? content.split('\n').filter((line) => line !== '').length : 0,
+      removed: 0,
+    },
+  };
+}
+
+function buildEditChange(toolInput) {
+  const diff = diffLineStats(toolInput.old_string || '', toolInput.new_string || '');
+  return {
+    operation: 'edit',
+    changes: {
+      added_content: diff.addedContent,
+      added: diff.added,
+      removed: diff.removed,
+    },
+  };
+}
+
+function buildMultiEditChange(toolInput) {
+  const edits = Array.isArray(toolInput.edits) ? toolInput.edits : [];
+  const aggregate = {
+    added_content: [],
+    added: 0,
+    removed: 0,
+  };
+
+  for (const edit of edits) {
+    const diff = diffLineStats(edit && edit.old_string, edit && edit.new_string);
+    if (diff.addedContent) {
+      aggregate.added_content.push(diff.addedContent);
+    }
+    aggregate.added += diff.added;
+    aggregate.removed += diff.removed;
+  }
+
+  return {
+    operation: 'edit',
+    changes: {
+      added_content: aggregate.added_content.join('\n'),
+      added: aggregate.added,
+      removed: aggregate.removed,
+    },
+  };
+}
+
+function buildCursorChange(payload) {
+  const edits = Array.isArray(payload.edits) ? payload.edits : [];
+  const aggregate = {
+    added_content: [],
+    added: 0,
+    removed: 0,
+  };
+
+  for (const edit of edits) {
+    const diff = diffLineStats(edit && edit.old_string, edit && edit.new_string);
+    if (diff.addedContent) {
+      aggregate.added_content.push(diff.addedContent);
+    }
+    aggregate.added += diff.added;
+    aggregate.removed += diff.removed;
+  }
+
+  return {
+    operation: 'edit',
+    changes: {
+      added_content: aggregate.added_content.join('\n'),
+      added: aggregate.added,
+      removed: aggregate.removed,
+    },
+  };
+}
+
+function buildClaudeEvent(payload, source) {
+  const hookEvent = payload.hook_event_name || payload.hookEvent;
+  const toolName = payload.tool_name || payload.toolName;
+  if (hookEvent !== CLAUDE_SUPPORTED_HOOK_EVENT || !CLAUDE_SUPPORTED_TOOLS.has(toolName)) {
+    return null;
+  }
+
+  const toolInput = payload.tool_input || payload.toolInput || {};
+  const absoluteFilePath = resolveClaudeAbsoluteFilePath(toolInput.file_path, payload);
+  const { repoRoot, git, repoRelativePath } = getGitInfo(absoluteFilePath);
+  const workerId = resolveWorkerId(repoRoot);
+
+  let changeInfo;
+  if (toolName === 'Write') {
+    changeInfo = buildWriteChange(toolInput);
+  } else if (toolName === 'Edit') {
+    changeInfo = buildEditChange(toolInput);
+  } else {
+    changeInfo = buildMultiEditChange(toolInput);
+  }
+
+  return {
+    event_id: randomUUID(),
+    timestamp: new Date().toISOString(),
+    source,
+    worker_id: workerId,
+    git,
+    file: {
+      path: repoRelativePath || String(toolInput.file_path || ''),
+      operation: changeInfo.operation,
+    },
+    changes: changeInfo.changes,
+  };
+}
+
+function buildCursorEvent(payload, source) {
+  const hookEvent = payload.hook_event_name || payload.hookEvent;
+  if (hookEvent !== CURSOR_SUPPORTED_HOOK_EVENT) {
+    return null;
+  }
+
+  const absoluteFilePath = resolveCursorAbsoluteFilePath(payload.file_path, payload);
+  const { repoRoot, git, repoRelativePath } = getGitInfo(absoluteFilePath);
+  const workerId = resolveWorkerId(repoRoot);
+  const changeInfo = buildCursorChange(payload);
+
+  return {
+    event_id: randomUUID(),
+    timestamp: new Date().toISOString(),
+    source,
+    worker_id: workerId,
+    git,
+    file: {
+      path: repoRelativePath || String(payload.file_path || ''),
+      operation: changeInfo.operation,
+    },
+    changes: changeInfo.changes,
+  };
+}
+
+function loadRequestConfig() {
+  const url = process.env.HOOK_REPORT_URL || process.env.CHANGE_REPORT_URL || DEFAULT_HOOK_REPORT_URL;
+  const timeoutMs = Number(process.env.HOOK_REPORT_TIMEOUT_MS || DEFAULT_TIMEOUT_MS);
+  const token = process.env.HOOK_REPORT_TOKEN || '';
+
+  let extraHeaders = {};
+  if (process.env.HOOK_REPORT_HEADERS) {
+    extraHeaders = parseJson(process.env.HOOK_REPORT_HEADERS, 'HOOK_REPORT_HEADERS');
+  }
+
+  return { url, timeoutMs, token, extraHeaders };
+}
+
+function formatDateStamp(timestamp) {
+  const iso = String(timestamp || '');
+  const match = iso.match(/^(\d{4})-(\d{2})-(\d{2})/);
+  if (match) {
+    return `${match[1]}${match[2]}${match[3]}`;
+  }
+
+  const date = new Date();
+  const year = String(date.getFullYear());
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  return `${year}${month}${day}`;
+}
+
+function getFailedEventDir() {
+  return path.join(os.homedir(), '.ronds_ai', 'failed-events');
+}
+
+function getFailedEventFilePath(source, timestamp) {
+  const fileName = `${formatDateStamp(timestamp)}-${source}-error.jsonl`;
+  return path.join(getFailedEventDir(), fileName);
+}
+
+function appendFailedRecord(source, record, timestamp) {
+  const failedEventDir = getFailedEventDir();
+  fs.mkdirSync(failedEventDir, { recursive: true });
+  const filePath = getFailedEventFilePath(source, timestamp);
+  fs.appendFileSync(filePath, `${JSON.stringify(record)}\n`, 'utf8');
+  return filePath;
+}
+
+function saveFailedEvent(event, error) {
+  const errorMessage = error instanceof Error ? error.message : String(error || '');
+  const record = {
+    timestamp: event.timestamp,
+    event_id: event.event_id,
+    source: event.source,
+    error: errorMessage,
+    event,
+  };
+  return appendFailedRecord(event.source, record, event.timestamp);
+}
+
+function saveCliError(error, context = {}) {
+  const timestamp = new Date().toISOString();
+  const errorMessage = error instanceof Error ? error.message : String(error || '');
+  const record = {
+    timestamp,
+    source: 'cli',
+    error: errorMessage,
+    context,
+  };
+  return appendFailedRecord('cli', record, timestamp);
+}
+
+function sendJsonRequest(event, config) {
+  if (process.env.HOOK_REQUEST_DRY_RUN === '1') {
+    process.stdout.write(`${JSON.stringify(event, null, 2)}\n`);
+    return Promise.resolve({ statusCode: 0, body: 'dry-run', dryRun: true });
+  }
+
+  if (!config.url) {
+    return Promise.reject(new Error('Missing request URL'));
+  }
+
+  const target = new URL(config.url);
+  const body = JSON.stringify(event);
+  const transport = target.protocol === 'https:' ? https : http;
+  const headers = {
+    'content-type': 'application/json',
+    'content-length': Buffer.byteLength(body),
+    ...config.extraHeaders,
+  };
+
+  if (config.token) {
+    headers.authorization = `Bearer ${config.token}`;
+  }
+
+  return new Promise((resolve, reject) => {
+    const request = transport.request({
+      protocol: target.protocol,
+      hostname: target.hostname,
+      port: target.port || undefined,
+      path: `${target.pathname}${target.search}`,
+      method: 'POST',
+      headers,
+      timeout: config.timeoutMs,
+    }, (response) => {
+      let responseBody = '';
+      response.setEncoding('utf8');
+      response.on('data', (chunk) => {
+        responseBody += chunk;
+      });
+      response.on('end', () => {
+        const statusCode = response.statusCode || 0;
+        if (statusCode >= 200 && statusCode < 300) {
+          resolve({ statusCode, body: responseBody });
+          return;
+        }
+
+        reject(new Error(`Request failed with status ${statusCode}: ${responseBody}`));
+      });
+    });
+
+    request.on('timeout', () => {
+      request.destroy(new Error(`Request timed out after ${config.timeoutMs}ms`));
+    });
+    request.on('error', reject);
+    request.write(body);
+    request.end();
+  });
+}
+
+function buildEvent(payload, source) {
+  if (source === 'claude') {
+    return buildClaudeEvent(payload, source);
+  }
+
+  if (source === 'cursor') {
+    return buildCursorEvent(payload, source);
+  }
+
+  throw new Error(`Unsupported source: ${source}`);
+}
+
+async function runCodeRecord(source) {
+  const raw = (await readStdin()).trim();
+  if (!raw) {
+    return;
+  }
+
+  const payload = parseJson(raw, 'Hook payload');
+  const event = buildEvent(payload, source);
+  if (!event) {
+    return;
+  }
+
+  const config = loadRequestConfig();
+
+  try {
+    const result = await sendJsonRequest(event, config);
+    process.stdout.write(`${JSON.stringify({
+      status: result.dryRun ? 'dry-run' : 'sent',
+      event_id: event.event_id,
+      response_status: result.statusCode,
+    })}\n`);
+  } catch (error) {
+    const savedPath = saveFailedEvent(event, error);
+    process.stdout.write(`${JSON.stringify({
+      status: 'saved',
+      event_id: event.event_id,
+      saved_path: savedPath,
+    })}\n`);
+  }
+}
+
+module.exports = {
+  runCodeRecord,
+  saveCliError,
+};

package/lib/hooks_deploy.js

@@ -0,0 +1,245 @@
+const fs = require('fs');
+const path = require('path');
+
+const CURSOR_COMMAND = 'npx ronds_ai@latest record cursor';
+const CLAUDE_COMMAND = 'npx ronds_ai@latest record claude';
+const CURSOR_OLD_COMMAND = 'node .cursor/hooks/cursor_hook_request.cjs';
+const CLAUDE_OLD_COMMAND = 'node .claude/hooks/claude_hook_request.cjs';
+const CLAUDE_MATCHER = 'Edit|Write|MultiEdit';
+const CURSOR_MANAGED_COMMANDS = new Set([
+  CURSOR_COMMAND,
+  CURSOR_OLD_COMMAND,
+]);
+const CLAUDE_MANAGED_COMMANDS = new Set([
+  CLAUDE_COMMAND,
+  CLAUDE_OLD_COMMAND,
+]);
+
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function readJsonFile(filePath, fallback) {
+  if (!fs.existsSync(filePath)) {
+    return { data: fallback, exists: false };
+  }
+
+  const raw = fs.readFileSync(filePath, 'utf8').trim();
+  if (!raw) {
+    return { data: fallback, exists: true };
+  }
+
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid JSON in ${filePath}: ${detail}`);
+  }
+
+  if (!isPlainObject(data)) {
+    throw new Error(`Expected top-level object in ${filePath}`);
+  }
+
+  return { data, exists: true };
+}
+
+function writeJsonFile(filePath, data) {
+  const nextContent = `${JSON.stringify(data, null, 2)}\n`;
+  if (fs.existsSync(filePath)) {
+    const currentContent = fs.readFileSync(filePath, 'utf8');
+    if (currentContent === nextContent) {
+      return false;
+    }
+  }
+
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, nextContent, 'utf8');
+  return true;
+}
+
+function removeFileIfExists(filePath, removedFiles) {
+  if (!fs.existsSync(filePath)) {
+    return;
+  }
+
+  fs.rmSync(filePath, { force: true });
+  removedFiles.push(filePath);
+}
+
+function removeKnownCommands(entries, commands) {
+  const input = Array.isArray(entries) ? entries : [];
+  return input.filter((entry) => {
+    return !(isPlainObject(entry) && entry.type === 'command' && commands.has(entry.command));
+  });
+}
+
+function ensureCursorHook(config) {
+  const next = isPlainObject(config) ? { ...config } : {};
+  const hooks = isPlainObject(next.hooks) ? { ...next.hooks } : {};
+  const afterFileEdit = Array.isArray(hooks.afterFileEdit) ? hooks.afterFileEdit.slice() : [];
+  const filtered = removeKnownCommands(afterFileEdit, CURSOR_MANAGED_COMMANDS);
+
+  filtered.push({
+    type: 'command',
+    command: CURSOR_COMMAND,
+  });
+
+  hooks.afterFileEdit = filtered;
+  next.version = next.version === undefined ? 1 : next.version;
+  next.hooks = hooks;
+  return next;
+}
+
+function splitClaudeHooks(hooksConfig) {
+  const nextHooks = isPlainObject(hooksConfig) ? { ...hooksConfig } : {};
+  const postToolUse = Array.isArray(nextHooks.PostToolUse) ? nextHooks.PostToolUse : [];
+  const keepEntries = [];
+  const desiredHooks = [];
+
+  for (const entry of postToolUse) {
+    if (!isPlainObject(entry)) {
+      keepEntries.push(entry);
+      continue;
+    }
+
+    if (entry.matcher !== CLAUDE_MATCHER) {
+      keepEntries.push(entry);
+      continue;
+    }
+
+    const existingHooks = Array.isArray(entry.hooks) ? entry.hooks : [];
+    for (const hook of existingHooks) {
+      if (!(isPlainObject(hook) && hook.type === 'command' && CLAUDE_MANAGED_COMMANDS.has(hook.command))) {
+        desiredHooks.push(hook);
+      }
+    }
+  }
+
+  desiredHooks.push({
+    type: 'command',
+    command: CLAUDE_COMMAND,
+  });
+
+  return {
+    withoutManagedHook: keepEntries,
+    desiredEntry: {
+      matcher: CLAUDE_MATCHER,
+      hooks: desiredHooks,
+    },
+  };
+}
+
+function ensureClaudeSettings(config) {
+  const next = isPlainObject(config) ? { ...config } : {};
+  const hooks = isPlainObject(next.hooks) ? { ...next.hooks } : {};
+  const { withoutManagedHook, desiredEntry } = splitClaudeHooks(hooks);
+
+  hooks.PostToolUse = withoutManagedHook.concat([desiredEntry]);
+  next.hooks = hooks;
+  return next;
+}
+
+function removeClaudeHookFromConfig(config) {
+  const next = isPlainObject(config) ? { ...config } : {};
+  if (!isPlainObject(next.hooks)) {
+    return next;
+  }
+
+  const hooks = { ...next.hooks };
+  const postToolUse = Array.isArray(hooks.PostToolUse) ? hooks.PostToolUse : [];
+  const cleaned = [];
+
+  for (const entry of postToolUse) {
+    if (!isPlainObject(entry)) {
+      cleaned.push(entry);
+      continue;
+    }
+
+    if (entry.matcher !== CLAUDE_MATCHER) {
+      cleaned.push(entry);
+      continue;
+    }
+
+    const existingHooks = Array.isArray(entry.hooks) ? entry.hooks : [];
+    const filteredHooks = removeKnownCommands(existingHooks, CLAUDE_MANAGED_COMMANDS);
+
+    if (filteredHooks.length > 0) {
+      cleaned.push({
+        ...entry,
+        hooks: filteredHooks,
+      });
+    }
+  }
+
+  if (cleaned.length > 0) {
+    hooks.PostToolUse = cleaned;
+  } else {
+    delete hooks.PostToolUse;
+  }
+
+  if (Object.keys(hooks).length > 0) {
+    next.hooks = hooks;
+  } else {
+    delete next.hooks;
+  }
+
+  return next;
+}
+
+function deployHooks(targetDir = process.cwd()) {
+  const baseDir = path.resolve(targetDir);
+  const removedFiles = [];
+  const updatedFiles = [];
+  const createdFiles = [];
+
+  removeFileIfExists(path.join(baseDir, '.cursor', 'hooks', 'cursor_hook_request.cjs'), removedFiles);
+  removeFileIfExists(path.join(baseDir, '.claude', 'hooks', 'claude_hook_request.cjs'), removedFiles);
+  removeFileIfExists(path.join(baseDir, '.claude', 'hooks', 'claide_hook_request.cjs'), removedFiles);
+
+  const cursorPath = path.join(baseDir, '.cursor', 'hooks.json');
+  const cursorResult = readJsonFile(cursorPath, {});
+  const nextCursor = ensureCursorHook(cursorResult.data);
+  if (writeJsonFile(cursorPath, nextCursor)) {
+    (cursorResult.exists ? updatedFiles : createdFiles).push(cursorPath);
+  }
+
+  const claudeSettingsPath = path.join(baseDir, '.claude', 'settings.json');
+  const claudeSettingsResult = readJsonFile(claudeSettingsPath, {});
+  const nextClaudeSettings = ensureClaudeSettings(claudeSettingsResult.data);
+  if (writeJsonFile(claudeSettingsPath, nextClaudeSettings)) {
+    (claudeSettingsResult.exists ? updatedFiles : createdFiles).push(claudeSettingsPath);
+  }
+
+  const localCandidates = [
+    path.join(baseDir, '.claude', 'settings.local.json'),
+    path.join(baseDir, '.claude', 'setting.local.json'),
+  ];
+
+  for (const localPath of localCandidates) {
+    if (!fs.existsSync(localPath)) {
+      continue;
+    }
+
+    const localResult = readJsonFile(localPath, {});
+    const nextLocal = removeClaudeHookFromConfig(localResult.data);
+    if (writeJsonFile(localPath, nextLocal)) {
+      updatedFiles.push(localPath);
+    }
+  }
+
+  return {
+    targetDir: baseDir,
+    removedFiles,
+    updatedFiles,
+    createdFiles,
+  };
+}
+
+module.exports = {
+  deployHooks,
+};

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "ronds_ai",
+  "version": "0.1.0",
+  "description": "CLI for reporting AI code edit events.",
+  "bin": {
+    "ronds_ai": "bin/ronds_ai.js"
+  },
+  "files": [
+    "bin",
+    "lib"
+  ],
+  "license": "MIT"
+}