marmot-logger 1.0.0

package/README.md

@@ -0,0 +1,172 @@
+# Marmot
+
+Activity monitoring tool for developer workflows. Tracks file changes, terminal commands, git operations, and Claude Code hooks.
+
+## Installation
+
+```bash
+npm install -g marmot-logger
+```
+
+Or use with npx:
+
+```bash
+npx marmot-logger init
+```
+
+## Quick Start
+
+```bash
+# Initialize marmot in your project
+marmot init
+
+# Enable plugins
+marmot enable file-monitor    # Track file changes
+marmot enable terminal        # Log terminal commands
+marmot enable git-hooks       # Log git operations
+marmot enable claude-hooks    # Log Claude Code activity
+
+# Check status
+marmot status
+
+# View recent logs
+marmot logs --last 20
+```
+
+## Configuration
+
+### Environment Variables
+
+- `MARMOT_URL` - Signing service URL (default: `https://logging.drazou.net`)
+- `MARMOT_API_KEY` - API key for signing service (required)
+
+```bash
+export MARMOT_API_KEY=your-api-key
+```
+
+### Project Configuration
+
+Marmot creates `.marmotrc.json` in your project root:
+
+```json
+{
+  "logDir": "./logs",
+  "snapshotDir": "./.marmot-snapshot",
+  "plugins": {
+    "file-monitor": {
+      "enabled": true,
+      "exclude": [".git", "node_modules", ".marmot-snapshot"]
+    },
+    "terminal": { "enabled": true },
+    "git-hooks": { "enabled": true },
+    "claude-hooks": { "enabled": true }
+  }
+}
+```
+
+## Plugins
+
+### File Monitor
+
+Detects file changes using git diff against a snapshot.
+
+```bash
+marmot enable file-monitor
+
+# Run manually or via cron
+marmot monitor
+
+# Add to crontab for every minute:
+* * * * * cd /path/to/project && npx marmot monitor >> ./logs/cron.log 2>&1
+```
+
+### Terminal
+
+Logs terminal commands executed in the project directory.
+
+```bash
+marmot enable terminal
+
+# Add to ~/.bashrc:
+source "/path/to/project/.marmot/terminal-hook.sh"
+```
+
+### Git Hooks
+
+Logs git operations (commit, push, checkout, merge).
+
+```bash
+marmot enable git-hooks
+```
+
+Hooks are automatically installed in `.git/hooks/`.
+
+### Claude Hooks
+
+Logs Claude Code IDE activity.
+
+```bash
+marmot enable claude-hooks
+```
+
+Hooks are configured in `.claude/settings.local.json`.
+
+## CLI Commands
+
+| Command | Description |
+|---------|-------------|
+| `marmot init` | Initialize marmot in current project |
+| `marmot enable <plugin>` | Enable a plugin |
+| `marmot disable <plugin>` | Disable a plugin |
+| `marmot status` | Show status and enabled plugins |
+| `marmot logs` | View recent log entries |
+| `marmot logs --today` | View today's logs |
+| `marmot logs --last N` | View last N entries |
+| `marmot verify` | Verify log signatures |
+| `marmot monitor` | Run file monitor once |
+
+## Log Format
+
+Logs are stored as JSON Lines in `./logs/file_events_YYYY-MM-DD.log`:
+
+```json
+{"timestamp":"2025-12-22T14:30:00Z","uuid":"...","event":"modified","path":"/project/src/index.js","size":1234,"additions":10,"deletions":5,"signed":true}
+{"timestamp":"2025-12-22T14:31:00Z","uuid":"...","event":"terminal","path":"/project","command":"npm test","size":0,"signed":true}
+{"timestamp":"2025-12-22T14:32:00Z","uuid":"...","event":"git_commit","path":"abc1234: Fix bug","size":0,"signed":true}
+```
+
+## Event Types
+
+| Event | Description |
+|-------|-------------|
+| `created` | File created |
+| `modified` | File modified (includes additions/deletions) |
+| `deleted` | File deleted |
+| `terminal` | Terminal command executed |
+| `git_commit` | Git commit made |
+| `git_push` | Git push executed |
+| `git_checkout` | Git branch checkout |
+| `git_merge` | Git merge completed |
+| `make_command` | Make target executed |
+| `claude_hook_*` | Claude Code hook events |
+
+## API
+
+```javascript
+const marmot = require('marmot-logger');
+
+// Log an event programmatically
+await marmot.log({
+  event: 'custom_event',
+  path: '/path/to/file',
+  size: 1234,
+  metadata: { custom: 'data' }
+});
+
+// Verify logs
+const results = await marmot.verifyLogs('./logs/file_events_2025-12-22.log');
+```
+
+## License
+
+MIT

package/bin/marmot.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+const chalk = require('chalk');
+const pkg = require('../package.json');
+
+const init = require('../src/cli/init');
+const enable = require('../src/cli/enable');
+const disable = require('../src/cli/disable');
+const status = require('../src/cli/status');
+const verify = require('../src/cli/verify');
+const logs = require('../src/cli/logs');
+const monitor = require('../src/cli/monitor');
+const log = require('../src/cli/log');
+const login = require('../src/cli/login');
+
+program
+  .name('marmot')
+  .description('Activity monitoring tool for developer workflows')
+  .version(pkg.version);
+
+program
+  .command('init')
+  .description('Initialize marmot in current project')
+  .action(init);
+
+program
+  .command('enable <plugin>')
+  .description('Enable a plugin (file-monitor, terminal, git-hooks, makefile, claude-hooks)')
+  .action(enable);
+
+program
+  .command('disable <plugin>')
+  .description('Disable a plugin')
+  .action(disable);
+
+program
+  .command('status')
+  .description('Show marmot status and enabled plugins')
+  .action(status);
+
+program
+  .command('verify')
+  .description('Verify log signatures')
+  .option('-f, --file <path>', 'Log file to verify (default: today\'s log)')
+  .action(verify);
+
+program
+  .command('logs')
+  .description('View recent log entries')
+  .option('-t, --today', 'Show today\'s logs')
+  .option('-l, --last <n>', 'Show last N entries', '10')
+  .action(logs);
+
+program
+  .command('monitor')
+  .description('Run file monitor once (for cron/scripts)')
+  .action(monitor);
+
+program
+  .command('log <event>')
+  .description('Log an event (used by hooks)')
+  .option('-d, --data <json>', 'JSON data for the event')
+  .action(log);
+
+program
+  .command('login')
+  .description('Login with API key and save to .env')
+  .action(login);
+
+program.parse();

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "marmot-logger",
+  "version": "1.0.0",
+  "description": "Activity monitoring tool for developer workflows - tracks file changes, terminal commands, git operations, and Claude Code hooks",
+  "main": "src/index.js",
+  "bin": {
+    "marmot": "./bin/marmot.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "monitoring",
+    "logging",
+    "developer-tools",
+    "activity-tracking",
+    "git-hooks",
+    "claude-code"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^12.1.0",
+    "chalk": "^4.1.2"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "templates/"
+  ]
+}

package/src/cli/disable.js

@@ -0,0 +1,40 @@
+const chalk = require('chalk');
+const config = require('../core/config');
+const plugins = require('../plugins');
+
+const VALID_PLUGINS = ['file-monitor', 'terminal', 'git-hooks', 'makefile', 'claude-hooks'];
+
+module.exports = async function disable(pluginName) {
+  if (!VALID_PLUGINS.includes(pluginName)) {
+    console.log(chalk.red(`Unknown plugin: ${pluginName}`));
+    console.log('Available plugins:', VALID_PLUGINS.join(', '));
+    process.exit(1);
+  }
+
+  const projectConfig = config.loadConfig();
+  if (!projectConfig) {
+    console.log(chalk.red('Marmot not initialized. Run: marmot init'));
+    process.exit(1);
+  }
+
+  if (!config.isPluginEnabled(projectConfig, pluginName)) {
+    console.log(chalk.yellow(`Plugin '${pluginName}' is already disabled.`));
+    return;
+  }
+
+  // Run plugin-specific teardown
+  const plugin = plugins[pluginName];
+  if (plugin && plugin.disable) {
+    try {
+      await plugin.disable(projectConfig);
+    } catch (err) {
+      console.log(chalk.red(`Teardown error: ${err.message}`));
+    }
+  }
+
+  // Disable the plugin in config
+  config.disablePlugin(projectConfig, pluginName);
+  config.saveConfig(projectConfig);
+
+  console.log(chalk.green(`✓ Plugin '${pluginName}' disabled.`));
+};

package/src/cli/enable.js

@@ -0,0 +1,40 @@
+const chalk = require('chalk');
+const config = require('../core/config');
+const plugins = require('../plugins');
+
+const VALID_PLUGINS = ['file-monitor', 'terminal', 'git-hooks', 'makefile', 'claude-hooks'];
+
+module.exports = async function enable(pluginName) {
+  if (!VALID_PLUGINS.includes(pluginName)) {
+    console.log(chalk.red(`Unknown plugin: ${pluginName}`));
+    console.log('Available plugins:', VALID_PLUGINS.join(', '));
+    process.exit(1);
+  }
+
+  const projectConfig = config.loadConfig();
+  if (!projectConfig) {
+    console.log(chalk.red('Marmot not initialized. Run: marmot init'));
+    process.exit(1);
+  }
+
+  if (config.isPluginEnabled(projectConfig, pluginName)) {
+    console.log(chalk.yellow(`Plugin '${pluginName}' is already enabled.`));
+    return;
+  }
+
+  // Enable the plugin in config
+  config.enablePlugin(projectConfig, pluginName);
+  config.saveConfig(projectConfig);
+
+  console.log(chalk.green(`✓ Plugin '${pluginName}' enabled.`));
+
+  // Run plugin-specific setup
+  const plugin = plugins[pluginName];
+  if (plugin && plugin.enable) {
+    try {
+      await plugin.enable(projectConfig);
+    } catch (err) {
+      console.log(chalk.red(`Setup error: ${err.message}`));
+    }
+  }
+};

package/src/cli/init.js

@@ -0,0 +1,85 @@
+const chalk = require('chalk');
+const path = require('path');
+const config = require('../core/config');
+const fs = require('fs');
+
+function addToGitignore(projectDir, entry) {
+  const gitignorePath = path.join(projectDir, '.gitignore');
+
+  if (fs.existsSync(gitignorePath)) {
+    const content = fs.readFileSync(gitignorePath, 'utf8');
+    if (!content.includes(entry)) {
+      // Add entry with marmot section if not exists
+      let newContent = content;
+      if (!content.includes('# Marmot')) {
+        newContent = content.trimEnd() + '\n\n# Marmot\n' + entry + '\n';
+      } else {
+        // Add under existing Marmot section
+        newContent = content.replace('# Marmot\n', `# Marmot\n${entry}\n`);
+      }
+      fs.writeFileSync(gitignorePath, newContent);
+      return true;
+    }
+  } else {
+    fs.writeFileSync(gitignorePath, `# Marmot\n${entry}\n`);
+    return true;
+  }
+  return false;
+}
+
+module.exports = async function init() {
+  const projectDir = process.cwd();
+  const existingConfig = config.loadConfig(projectDir);
+
+  if (existingConfig) {
+    console.log(chalk.yellow('Marmot is already initialized in this project.'));
+    console.log(`Configuration file: ${config.getConfigPath(projectDir)}`);
+    return;
+  }
+
+  // Check for required environment variables
+  const signingUrl = config.getSigningUrl(projectDir);
+  const apiKey = config.getApiKey(projectDir);
+
+  if (!apiKey) {
+    console.log(chalk.yellow('Warning: MARMOT_API_KEY is not set.'));
+    console.log('Set it in your .env file or run:');
+    console.log(chalk.cyan('  marmot login'));
+    console.log('');
+  }
+
+  // Create marmot directory in /tmp
+  const marmotDir = config.getMarmotDir(projectDir);
+  if (!fs.existsSync(marmotDir)) {
+    fs.mkdirSync(marmotDir, { recursive: true });
+  }
+
+  // Create default config
+  const newConfig = config.createDefaultConfig(projectDir);
+
+  // Create logs directory in project
+  const logDir = config.getLogDir(newConfig, projectDir);
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true });
+  }
+
+  // Add marmot-logs to project's .gitignore
+  const logDirName = path.basename(logDir);
+  addToGitignore(projectDir, logDirName + '/');
+  addToGitignore(projectDir, '.marmot/');
+
+  console.log(chalk.green('✓ Marmot initialized successfully!'));
+  console.log('');
+  console.log('Marmot directory:', chalk.cyan(marmotDir));
+  console.log('Configuration file:', chalk.cyan(config.getConfigPath(projectDir)));
+  console.log('Logs directory:', chalk.cyan(logDir));
+  console.log('Signing URL:', chalk.cyan(signingUrl));
+  console.log('');
+  console.log('Next steps:');
+  console.log(chalk.cyan('  marmot enable file-monitor') + '  - Track file changes');
+  console.log(chalk.cyan('  marmot enable terminal') + '      - Log terminal commands');
+  console.log(chalk.cyan('  marmot enable git-hooks') + '     - Log git operations');
+  console.log(chalk.cyan('  marmot enable claude-hooks') + '  - Log Claude Code activity');
+  console.log('');
+  console.log('View status with:', chalk.cyan('marmot status'));
+};

package/src/cli/log.js

@@ -0,0 +1,102 @@
+const config = require('../core/config');
+const logger = require('../core/logger');
+
+module.exports = async function log(event, options) {
+  const projectConfig = config.loadConfig();
+
+  if (!projectConfig) {
+    // Silent fail for hook usage - don't break the calling process
+    process.exit(0);
+  }
+
+  let data = {};
+
+  // Try to parse JSON data from option or stdin
+  if (options.data) {
+    try {
+      data = JSON.parse(options.data);
+    } catch (e) {
+      // Ignore parse errors
+    }
+  } else {
+    // Try reading from stdin (for piped data from hooks)
+    try {
+      const stdin = require('fs').readFileSync(0, 'utf8');
+      if (stdin.trim()) {
+        data = JSON.parse(stdin);
+      }
+    } catch (e) {
+      // No stdin or parse error
+    }
+  }
+
+  // Extract details based on event type
+  let eventPath = data.path || '';
+  let size = data.size || 0;
+  const extra = {};
+
+  // Handle Claude hook events
+  if (event.startsWith('claude-')) {
+    const hookType = event.replace('claude-', '');
+    event = `claude_hook_${hookType}`;
+
+    // Extract relevant fields based on hook type
+    if (hookType === 'PreToolUse' || hookType === 'PostToolUse') {
+      const toolInput = data.tool_input || data;
+      const toolName = toolInput.tool_name || 'unknown';
+      const command = toolInput.command || '';
+      const filePath = toolInput.file_path || '';
+      const description = toolInput.description || '';
+
+      if (command) {
+        eventPath = `${toolName}: ${command.substring(0, 200)}`;
+      } else if (filePath) {
+        eventPath = `${toolName}: ${filePath}`;
+      } else if (description) {
+        eventPath = `${toolName}: ${description.substring(0, 200)}`;
+      } else {
+        eventPath = toolName;
+      }
+    } else if (hookType === 'Stop' || hookType === 'SubagentStop') {
+      eventPath = data.stop_reason || 'completed';
+    } else if (hookType === 'UserPromptSubmit') {
+      const prompt = data.prompt || data.user_prompt || '';
+      eventPath = `prompt: ${prompt.substring(0, 200)}`;
+    } else if (hookType === 'SessionStart' || hookType === 'SessionEnd') {
+      const sessionId = data.session_id || 'unknown';
+      eventPath = `${hookType.toLowerCase()}: ${sessionId}`;
+    }
+  }
+
+  // Handle git events
+  if (event.startsWith('git-')) {
+    const gitEvent = event.replace('git-', '');
+    event = `git_${gitEvent}`;
+    eventPath = data.path || data.details || '';
+  }
+
+  // Handle make events
+  if (event === 'make') {
+    event = 'make_command';
+    eventPath = data.target || data.path || '';
+  }
+
+  // Handle terminal events
+  if (event === 'terminal') {
+    extra.command = data.command || '';
+    eventPath = data.path || process.cwd();
+  }
+
+  // Add any additional fields
+  if (data.additions !== undefined) extra.additions = data.additions;
+  if (data.deletions !== undefined) extra.deletions = data.deletions;
+  if (data.command && event !== 'terminal') extra.command = data.command;
+
+  try {
+    await logger.logEvent(event, eventPath, size, extra);
+  } catch (err) {
+    // Silent fail for hook usage
+  }
+
+  process.exit(0);
+};

package/src/cli/login.js

@@ -0,0 +1,120 @@
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const config = require('../core/config');
+const signer = require('../core/signer');
+
+function prompt(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+function updateEnvFile(projectDir, key, value) {
+  const envPath = path.join(projectDir, '.env');
+  let content = '';
+
+  if (fs.existsSync(envPath)) {
+    content = fs.readFileSync(envPath, 'utf8');
+  }
+
+  // Check if key already exists
+  const regex = new RegExp(`^${key}=.*$`, 'm');
+  if (regex.test(content)) {
+    // Update existing key
+    content = content.replace(regex, `${key}=${value}`);
+  } else {
+    // Add new key
+    if (content && !content.endsWith('\n')) {
+      content += '\n';
+    }
+    // Add section comment if this is the first marmot key
+    if (!content.includes('# Marmot')) {
+      content += '\n# Marmot logging\n';
+    }
+    content += `${key}=${value}\n`;
+  }
+
+  fs.writeFileSync(envPath, content);
+}
+
+module.exports = async function login() {
+  const projectDir = process.cwd();
+  const projectConfig = config.loadConfig(projectDir);
+
+  if (!projectConfig) {
+    console.log(chalk.red('Marmot not initialized. Run: marmot init'));
+    process.exit(1);
+  }
+
+  console.log(chalk.bold('Marmot Login'));
+  console.log('─'.repeat(40));
+  console.log('');
+
+  // Check current status
+  const currentKey = config.getApiKey(projectDir);
+  if (currentKey) {
+    console.log(chalk.yellow('API key is already configured.'));
+    const overwrite = await prompt('Overwrite? (y/N): ');
+    if (overwrite.toLowerCase() !== 'y') {
+      console.log('Cancelled.');
+      return;
+    }
+    console.log('');
+  }
+
+  // Prompt for API key
+  const apiKey = await prompt('Enter your MARMOT_API_KEY: ');
+
+  if (!apiKey) {
+    console.log(chalk.red('No API key provided.'));
+    process.exit(1);
+  }
+
+  // Test the API key
+  console.log('');
+  console.log('Testing API key...');
+
+  // Temporarily set the key in environment for testing
+  process.env.MARMOT_API_KEY = apiKey;
+  signer.clearTokenCache();
+
+  try {
+    await signer.getToken(projectDir);
+    console.log(chalk.green('✓ API key is valid!'));
+  } catch (err) {
+    console.log(chalk.red(`✗ API key test failed: ${err.message}`));
+    console.log('');
+    console.log('The key was not saved. Please check your API key and try again.');
+    process.exit(1);
+  }
+
+  // Write to .env file
+  console.log('');
+  console.log('Saving to .env...');
+  updateEnvFile(projectDir, 'MARMOT_API_KEY', apiKey);
+
+  // Also save MARMOT_URL if not already set
+  const currentUrl = config.getSigningUrl(projectDir);
+  if (currentUrl === 'https://logging.drazou.net') {
+    // Check if it's from default or actually in .env
+    const envFile = config.loadEnvFile ? config.loadEnvFile(projectDir) : {};
+    if (!envFile.MARMOT_URL && !process.env.MARMOT_URL) {
+      updateEnvFile(projectDir, 'MARMOT_URL', 'https://logging.drazou.net');
+    }
+  }
+
+  console.log(chalk.green('✓ Credentials saved to .env'));
+  console.log('');
+  console.log('You can now use marmot with signed logging.');
+  console.log('Run', chalk.cyan('marmot status'), 'to verify.');
+};