marmot-logger 1.0.0

package/src/core/signer.js

@@ -0,0 +1,136 @@
+const https = require('https');
+const http = require('http');
+const { URL } = require('url');
+const config = require('./config');
+
+function request(url, options, data) {
+  return new Promise((resolve, reject) => {
+    const parsedUrl = new URL(url);
+    const protocol = parsedUrl.protocol === 'https:' ? https : http;
+
+    const req = protocol.request(url, options, (res) => {
+      let body = '';
+      res.on('data', (chunk) => body += chunk);
+      res.on('end', () => {
+        // Check for 401 Unauthorized
+        if (res.statusCode === 401) {
+          const err = new Error('Unauthorized');
+          err.statusCode = 401;
+          reject(err);
+          return;
+        }
+
+        try {
+          const json = JSON.parse(body);
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            resolve(json);
+          } else {
+            const err = new Error(json.detail || json.message || `HTTP ${res.statusCode}`);
+            err.statusCode = res.statusCode;
+            reject(err);
+          }
+        } catch (e) {
+          reject(new Error(`Invalid JSON response: ${body}`));
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.setTimeout(10000, () => {
+      req.destroy();
+      reject(new Error('Request timeout'));
+    });
+
+    if (data) {
+      req.write(JSON.stringify(data));
+    }
+    req.end();
+  });
+}
+
+function getCachedToken(projectDir = process.cwd()) {
+  return config.getBearerToken(projectDir);
+}
+
+async function refreshToken(projectDir = process.cwd()) {
+  const apiKey = config.getApiKey(projectDir);
+  if (!apiKey) {
+    throw new Error('MARMOT_API_KEY not found in .env or environment');
+  }
+
+  const signingUrl = config.getSigningUrl(projectDir);
+  const tokenUrl = `${signingUrl}/token`;
+
+  const result = await request(tokenUrl, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    }
+  }, { api_key: apiKey });
+
+  // Store token in config file
+  config.setBearerToken(result.token, projectDir);
+
+  return result.token;
+}
+
+async function getToken(projectDir = process.cwd()) {
+  // First try cached token from config
+  const cached = getCachedToken(projectDir);
+  if (cached && cached !== 'broken-bearer') {
+    return cached;
+  }
+
+  // Otherwise refresh
+  return refreshToken(projectDir);
+}
+
+async function sign(entry, projectDir = process.cwd()) {
+  const token = await getToken(projectDir);
+  const signingUrl = config.getSigningUrl(projectDir);
+  const signUrl = `${signingUrl}/sign`;
+
+  return await request(signUrl, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${token}`
+    }
+  }, entry);
+}
+
+async function verify(entry, projectDir = process.cwd()) {
+  const token = await getToken(projectDir);
+  const signingUrl = config.getSigningUrl(projectDir);
+  const verifyUrl = `${signingUrl}/verify`;
+
+  return await request(verifyUrl, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${token}`
+    }
+  }, entry);
+}
+
+async function healthCheck(projectDir = process.cwd()) {
+  const signingUrl = config.getSigningUrl(projectDir);
+  const healthUrl = `${signingUrl}/health`;
+
+  return await request(healthUrl, {
+    method: 'GET'
+  });
+}
+
+function clearTokenCache(projectDir = process.cwd()) {
+  config.setBearerToken('broken-bearer', projectDir);
+}
+
+module.exports = {
+  getToken,
+  refreshToken,
+  sign,
+  verify,
+  healthCheck,
+  clearTokenCache
+};

package/src/index.js

@@ -0,0 +1,20 @@
+const config = require('./core/config');
+const logger = require('./core/logger');
+const signer = require('./core/signer');
+
+module.exports = {
+  // Configuration
+  loadConfig: config.loadConfig,
+  saveConfig: config.saveConfig,
+  createDefaultConfig: config.createDefaultConfig,
+
+  // Logging
+  log: logger.logEvent,
+  readLogs: logger.readLogs,
+  verifyLogs: logger.verifyLogs,
+
+  // Signing
+  sign: signer.sign,
+  verify: signer.verify,
+  healthCheck: signer.healthCheck
+};

package/src/plugins/claude-hooks.js

@@ -0,0 +1,134 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+
+const CLAUDE_SETTINGS_DIR = '.claude';
+const CLAUDE_SETTINGS_FILE = 'settings.local.json';
+
+function getClaudeSettingsPath(projectDir = process.cwd()) {
+  return path.join(projectDir, CLAUDE_SETTINGS_DIR, CLAUDE_SETTINGS_FILE);
+}
+
+function loadClaudeSettings(projectDir = process.cwd()) {
+  const settingsPath = getClaudeSettingsPath(projectDir);
+
+  if (!fs.existsSync(settingsPath)) {
+    return {};
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+  } catch (e) {
+    return {};
+  }
+}
+
+function saveClaudeSettings(settings, projectDir = process.cwd()) {
+  const settingsDir = path.join(projectDir, CLAUDE_SETTINGS_DIR);
+  const settingsPath = getClaudeSettingsPath(projectDir);
+
+  if (!fs.existsSync(settingsDir)) {
+    fs.mkdirSync(settingsDir, { recursive: true });
+  }
+
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n');
+}
+
+function createHookConfig(hookType, projectDir) {
+  return {
+    matcher: '*',
+    hooks: [
+      {
+        type: 'command',
+        command: `cd "${projectDir}" && marmot log claude-${hookType}`
+      }
+    ]
+  };
+}
+
+async function enable(projectConfig) {
+  const projectDir = process.cwd();
+  const events = projectConfig.plugins?.['claude-hooks']?.events || [
+    'PreToolUse', 'PostToolUse', 'Stop', 'SubagentStop',
+    'UserPromptSubmit', 'SessionStart', 'SessionEnd'
+  ];
+
+  const settings = loadClaudeSettings(projectDir);
+
+  // Initialize hooks object if needed
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+
+  const installed = [];
+
+  for (const event of events) {
+    // Check if hook already exists
+    if (settings.hooks[event]) {
+      const existingHooks = settings.hooks[event];
+      const hasMarmot = existingHooks.some(h =>
+        h.hooks?.some(hh => hh.command?.includes('marmot'))
+      );
+      if (hasMarmot) continue;
+    }
+
+    if (!settings.hooks[event]) {
+      settings.hooks[event] = [];
+    }
+
+    settings.hooks[event].push(createHookConfig(event, projectDir));
+    installed.push(event);
+  }
+
+  saveClaudeSettings(settings, projectDir);
+
+  console.log('');
+  console.log(chalk.bold('Claude Hooks Plugin Setup:'));
+  console.log(`  Settings file: ${chalk.cyan(getClaudeSettingsPath(projectDir))}`);
+
+  if (installed.length > 0) {
+    console.log(`  Installed hooks: ${installed.join(', ')}`);
+  } else {
+    console.log(chalk.yellow('  All hooks were already installed.'));
+  }
+
+  console.log('');
+  console.log('Claude Code will now log activity when working in this project.');
+}
+
+async function disable(projectConfig) {
+  const projectDir = process.cwd();
+  const settings = loadClaudeSettings(projectDir);
+
+  if (!settings.hooks) {
+    return;
+  }
+
+  // Remove marmot hooks
+  for (const event of Object.keys(settings.hooks)) {
+    settings.hooks[event] = settings.hooks[event].filter(h =>
+      !h.hooks?.some(hh => hh.command?.includes('marmot'))
+    );
+
+    // Clean up empty arrays
+    if (settings.hooks[event].length === 0) {
+      delete settings.hooks[event];
+    }
+  }
+
+  // Clean up empty hooks object
+  if (Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+
+  saveClaudeSettings(settings, projectDir);
+
+  console.log('');
+  console.log(chalk.bold('Claude Hooks Plugin Disabled:'));
+  console.log('Marmot hooks removed from Claude settings.');
+}
+
+module.exports = {
+  enable,
+  disable
+};

package/src/plugins/file-monitor.js

@@ -0,0 +1,233 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync, spawnSync } = require('child_process');
+const chalk = require('chalk');
+const config = require('../core/config');
+const logger = require('../core/logger');
+const gitignore = require('../core/gitignore');
+
+const MARMOT_CRON_MARKER = '# marmot-monitor';
+
+function getCrontab() {
+  try {
+    const result = execSync('crontab -l 2>/dev/null', { encoding: 'utf8' });
+    return result;
+  } catch (err) {
+    return '';
+  }
+}
+
+function setCrontab(content) {
+  try {
+    execSync(`echo "${content.replace(/"/g, '\\"')}" | crontab -`, { encoding: 'utf8' });
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+async function run(projectConfig, projectDir = process.cwd()) {
+  const snapshotDir = config.getSnapshotDir(projectConfig, projectDir);
+  const logDir = config.getLogDir(projectConfig, projectDir);
+
+  // Ensure log directory exists
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true });
+  }
+
+  // Ensure snapshot parent directory exists
+  const snapshotParent = path.dirname(snapshotDir);
+  if (!fs.existsSync(snapshotParent)) {
+    fs.mkdirSync(snapshotParent, { recursive: true });
+  }
+
+  // Build rsync exclude args from .gitignore
+  const excludeArgs = gitignore.buildRsyncExcludes(projectDir);
+
+  // First run: create snapshot
+  if (!fs.existsSync(snapshotDir)) {
+    try {
+      execSync(`rsync -a ${excludeArgs.join(' ')} "${projectDir}/" "${snapshotDir}/"`, {
+        stdio: 'pipe'
+      });
+      await logger.logEvent('monitor_initialized', projectDir, 0, {}, projectDir);
+      return 1;
+    } catch (err) {
+      throw new Error(`Failed to create snapshot: ${err.message}`);
+    }
+  }
+
+  // Run git diff to detect changes
+  let diffOutput = '';
+  try {
+    const result = spawnSync('git', ['diff', '--no-index', '--name-status', snapshotDir, projectDir], {
+      encoding: 'utf8',
+      maxBuffer: 10 * 1024 * 1024
+    });
+    diffOutput = result.stdout || '';
+  } catch (err) {
+    // git diff returns exit code 1 when there are differences
+  }
+
+  if (!diffOutput.trim()) {
+    return 0; // No changes
+  }
+
+  let changesFound = 0;
+  const lines = diffOutput.trim().split('\n');
+
+  for (const line of lines) {
+    if (!line.trim()) continue;
+
+    const [status, ...pathParts] = line.split('\t');
+    const rawPath = pathParts.join('\t');
+
+    // Extract relative path
+    let relativePath = rawPath
+      .replace(snapshotDir + '/', '')
+      .replace(snapshotDir + '\\', '')
+      .replace(projectDir + '/', '')
+      .replace(projectDir + '\\', '');
+
+    const absPath = path.join(projectDir, relativePath);
+
+    // Skip excluded paths using gitignore patterns
+    if (gitignore.shouldExclude(relativePath, projectDir)) continue;
+
+    changesFound++;
+
+    switch (status) {
+      case 'A': // Added (created in current)
+        if (fs.existsSync(absPath) && fs.statSync(absPath).isFile()) {
+          const size = fs.statSync(absPath).size;
+          await logger.logEvent('created', absPath, size, {}, projectDir);
+        }
+        break;
+
+      case 'D': // Deleted
+        await logger.logEvent('deleted', absPath, 0, {}, projectDir);
+        break;
+
+      case 'M': // Modified
+        if (fs.existsSync(absPath) && fs.statSync(absPath).isFile()) {
+          const size = fs.statSync(absPath).size;
+          const snapshotFile = path.join(snapshotDir, relativePath);
+
+          let additions = 0;
+          let deletions = 0;
+
+          // Get additions/deletions using git diff --numstat
+          if (fs.existsSync(snapshotFile)) {
+            try {
+              const numstat = spawnSync('git', ['diff', '--no-index', '--numstat', snapshotFile, absPath], {
+                encoding: 'utf8'
+              });
+              const statLine = (numstat.stdout || '').trim().split('\n')[0];
+              if (statLine) {
+                const [add, del] = statLine.split('\t');
+                additions = add === '-' ? 0 : parseInt(add) || 0;
+                deletions = del === '-' ? 0 : parseInt(del) || 0;
+              }
+            } catch (e) {
+              // Ignore numstat errors
+            }
+          }
+
+          await logger.logEvent('modified', absPath, size, { additions, deletions }, projectDir);
+        }
+        break;
+    }
+  }
+
+  // Update snapshot
+  if (changesFound > 0) {
+    try {
+      execSync(`rsync -a --delete ${excludeArgs.join(' ')} "${projectDir}/" "${snapshotDir}/"`, {
+        stdio: 'pipe'
+      });
+    } catch (err) {
+      // Ignore rsync errors
+    }
+  }
+
+  return changesFound;
+}
+
+async function enable(projectConfig) {
+  const projectDir = process.cwd();
+  const snapshotDir = config.getSnapshotDir(projectConfig, projectDir);
+  const marmotDir = config.getMarmotDir(projectDir);
+  const logDir = config.getLogDir(projectConfig, projectDir);
+
+  console.log('');
+  console.log(chalk.bold('File Monitor Plugin Setup:'));
+  console.log(`  Marmot directory: ${chalk.cyan(marmotDir)}`);
+  console.log(`  Snapshot directory: ${chalk.cyan(snapshotDir)}`);
+  console.log(`  Exclusions: ${chalk.cyan('Using .gitignore')}`);
+
+  // Install cron job
+  const cronJob = `* * * * * cd "${projectDir}" && marmot monitor >> "${logDir}/cron.log" 2>&1 ${MARMOT_CRON_MARKER}`;
+  const currentCrontab = getCrontab();
+
+  if (currentCrontab.includes(projectDir) && currentCrontab.includes('marmot monitor')) {
+    console.log(`  Cron job: ${chalk.yellow('Already installed')}`);
+  } else {
+    const newCrontab = currentCrontab.trim() + '\n' + cronJob + '\n';
+    if (setCrontab(newCrontab)) {
+      console.log(`  Cron job: ${chalk.green('Installed (runs every minute)')}`);
+    } else {
+      console.log(`  Cron job: ${chalk.red('Failed to install')}`);
+      console.log('');
+      console.log('To add manually:');
+      console.log(chalk.cyan(`  crontab -e`));
+      console.log('Then add:');
+      console.log(chalk.cyan(`  ${cronJob}`));
+    }
+  }
+
+  console.log('');
+  console.log('Or run manually with:');
+  console.log(chalk.cyan('  marmot monitor'));
+}
+
+async function disable(projectConfig) {
+  const projectDir = process.cwd();
+  const snapshotDir = config.getSnapshotDir(projectConfig, projectDir);
+
+  console.log('');
+  console.log(chalk.bold('File Monitor Plugin Disabled:'));
+
+  // Remove cron job
+  const currentCrontab = getCrontab();
+  if (currentCrontab.includes(projectDir) && currentCrontab.includes('marmot monitor')) {
+    const lines = currentCrontab.split('\n');
+    const filteredLines = lines.filter(line => {
+      if (line.includes(projectDir) && line.includes('marmot monitor')) return false;
+      if (line.includes(MARMOT_CRON_MARKER)) return false;
+      return true;
+    });
+
+    const newCrontab = filteredLines.join('\n').replace(/\n{3,}/g, '\n\n').trim();
+
+    if (setCrontab(newCrontab + '\n')) {
+      console.log(`  Cron job: ${chalk.green('Removed')}`);
+    } else {
+      console.log(`  Cron job: ${chalk.red('Failed to remove')}`);
+      console.log('  Remove manually with: crontab -e');
+    }
+  } else {
+    console.log(`  Cron job: ${chalk.gray('Not found')}`);
+  }
+
+  // Keep snapshot but inform user
+  if (fs.existsSync(snapshotDir)) {
+    console.log(`  Snapshot: ${chalk.cyan(snapshotDir)} (preserved)`);
+    console.log('  To remove snapshot: rm -rf ' + snapshotDir);
+  }
+}
+
+module.exports = {
+  run,
+  enable,
+  disable
+};

package/src/plugins/git-hooks.js

@@ -0,0 +1,177 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+
+const MARMOT_MARKER = '# Marmot:';
+
+const HOOKS = {
+  'post-commit': `#!/bin/bash
+# Marmot: Log git commits
+COMMIT_HASH=$(git rev-parse --short HEAD)
+COMMIT_MSG=$(git log -1 --pretty=%s | head -c 100 | sed 's/"/\\\\"/g')
+cd "{{PROJECT_DIR}}" && marmot log git-commit -d "{\\"path\\": \\"$COMMIT_HASH: $COMMIT_MSG\\"}" 2>/dev/null &
+`,
+
+  'pre-push': `#!/bin/bash
+# Marmot: Log git pushes
+BRANCH=$(git symbolic-ref --short HEAD 2>/dev/null || echo "detached")
+REMOTE=$(git remote | head -1)
+cd "{{PROJECT_DIR}}" && marmot log git-push -d "{\\"path\\": \\"$BRANCH -> $REMOTE\\"}" 2>/dev/null &
+exit 0
+`,
+
+  'post-checkout': `#!/bin/bash
+# Marmot: Log git checkouts
+# $3 is branch flag: 1 = branch checkout, 0 = file checkout
+if [ "$3" = "1" ]; then
+  BRANCH=$(git symbolic-ref --short HEAD 2>/dev/null || echo "detached")
+  cd "{{PROJECT_DIR}}" && marmot log git-checkout -d "{\\"path\\": \\"$BRANCH\\"}" 2>/dev/null &
+fi
+`,
+
+  'post-merge': `#!/bin/bash
+# Marmot: Log git merges
+BRANCH=$(git symbolic-ref --short HEAD 2>/dev/null || echo "detached")
+cd "{{PROJECT_DIR}}" && marmot log git-merge -d "{\\"path\\": \\"$BRANCH\\"}" 2>/dev/null &
+`
+};
+
+const HOOK_NAMES = ['post-commit', 'pre-push', 'post-checkout', 'post-merge'];
+
+function getGitHooksDir(projectDir = process.cwd()) {
+  const gitDir = path.join(projectDir, '.git');
+  if (!fs.existsSync(gitDir)) {
+    return null;
+  }
+  return path.join(gitDir, 'hooks');
+}
+
+async function enable(projectConfig) {
+  const projectDir = process.cwd();
+  const hooksDir = getGitHooksDir(projectDir);
+
+  if (!hooksDir) {
+    console.log(chalk.yellow('Not a git repository. Git hooks not installed.'));
+    return;
+  }
+
+  // Ensure hooks directory exists
+  if (!fs.existsSync(hooksDir)) {
+    fs.mkdirSync(hooksDir, { recursive: true });
+  }
+
+  const events = projectConfig.plugins?.['git-hooks']?.events || ['commit', 'push', 'checkout', 'merge'];
+  const installed = [];
+
+  for (const event of events) {
+    let hookName;
+    switch (event) {
+      case 'commit': hookName = 'post-commit'; break;
+      case 'push': hookName = 'pre-push'; break;
+      case 'checkout': hookName = 'post-checkout'; break;
+      case 'merge': hookName = 'post-merge'; break;
+      default: continue;
+    }
+
+    const hookPath = path.join(hooksDir, hookName);
+    const hookContent = HOOKS[hookName].replace(/\{\{PROJECT_DIR\}\}/g, projectDir);
+
+    // Check for existing hook
+    if (fs.existsSync(hookPath)) {
+      const existing = fs.readFileSync(hookPath, 'utf8');
+      // Skip if marmot hook already installed (check marker or marmot command)
+      if (existing.includes(MARMOT_MARKER) || existing.includes('marmot log')) {
+        installed.push(hookName);
+        continue;
+      }
+      // Append to existing non-marmot hook
+      fs.appendFileSync(hookPath, '\n' + hookContent);
+    } else {
+      fs.writeFileSync(hookPath, hookContent);
+    }
+
+    fs.chmodSync(hookPath, '755');
+    installed.push(hookName);
+  }
+
+  console.log('');
+  console.log(chalk.bold('Git Hooks Plugin Setup:'));
+  console.log(`  Hooks directory: ${chalk.cyan(hooksDir)}`);
+  console.log(`  Installed hooks: ${installed.join(', ')}`);
+}
+
+async function disable(projectConfig) {
+  const projectDir = process.cwd();
+  const hooksDir = getGitHooksDir(projectDir);
+
+  if (!hooksDir) {
+    return;
+  }
+
+  console.log('');
+  console.log(chalk.bold('Git Hooks Plugin Disabled:'));
+
+  let removed = 0;
+
+  for (const hookName of HOOK_NAMES) {
+    const hookPath = path.join(hooksDir, hookName);
+
+    if (!fs.existsSync(hookPath)) {
+      continue;
+    }
+
+    const content = fs.readFileSync(hookPath, 'utf8');
+
+    // Skip if no marmot content (check marker or marmot command)
+    if (!content.includes(MARMOT_MARKER) && !content.includes('marmot log')) {
+      continue;
+    }
+
+    // Remove all lines containing marmot-related content
+    const lines = content.split('\n');
+    const filteredLines = lines.filter(line => {
+      // Keep shebang
+      if (line.startsWith('#!')) return true;
+      // Remove marmot marker comments
+      if (line.includes(MARMOT_MARKER)) return false;
+      // Remove marmot-specific comments (like "# $3 is branch flag")
+      if (line.includes('$3 is branch flag')) return false;
+      // Remove lines with marmot commands
+      if (line.includes('marmot log')) return false;
+      // Remove variable assignments used by marmot hooks
+      if (/^\s*(COMMIT_HASH|COMMIT_MSG|BRANCH|REMOTE)=/.test(line)) return false;
+      // Remove if blocks checking $3 (marmot checkout hook)
+      if (/^\s*if \[ "\$3"/.test(line)) return false;
+      // Remove fi statements (but only if this is a marmot-only hook)
+      if (line.trim() === 'fi' && content.includes('if [ "$3"')) return false;
+      // Remove exit 0 (marmot pre-push)
+      if (line.trim() === 'exit 0' && content.includes(MARMOT_MARKER)) return false;
+      // Keep everything else
+      return true;
+    });
+
+    // Clean up the result
+    let cleanedContent = filteredLines.join('\n')
+      .replace(/\n{3,}/g, '\n\n')
+      .trim();
+
+    // If only shebang remains (or empty), delete the file
+    if (!cleanedContent || cleanedContent === '#!/bin/bash' || cleanedContent.match(/^#!\/bin\/bash\s*$/)) {
+      fs.unlinkSync(hookPath);
+      console.log(`  Removed: ${chalk.cyan(hookName)}`);
+    } else {
+      fs.writeFileSync(hookPath, cleanedContent + '\n');
+      console.log(`  Cleaned: ${chalk.cyan(hookName)} (preserved non-marmot content)`);
+    }
+    removed++;
+  }
+
+  if (removed === 0) {
+    console.log('  No marmot hooks found to remove.');
+  }
+}
+
+module.exports = {
+  enable,
+  disable
+};

package/src/plugins/index.js

@@ -0,0 +1,7 @@
+module.exports = {
+  'file-monitor': require('./file-monitor'),
+  'terminal': require('./terminal'),
+  'git-hooks': require('./git-hooks'),
+  'makefile': require('./makefile'),
+  'claude-hooks': require('./claude-hooks')
+};