jettypod 3.0.1

package/features/claude-md-protection/steps.js

@@ -0,0 +1,487 @@
+const { Given, When, Then, Before, After } = require('@cucumber/cucumber');
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const { execSync, spawnSync } = require('child_process');
+
+const testDir = path.join('/tmp', 'jettypod-hook-test-' + Date.now());
+let originalDir;
+let hookResponse;
+let claudeMdContent;
+let editAttempt;
+
+Before(function () {
+  originalDir = process.cwd();
+});
+
+After(function () {
+  if (originalDir) {
+    process.chdir(originalDir);
+  }
+  // SAFETY: Only delete if testDir is in /tmp
+  if (fs.existsSync(testDir) && testDir.startsWith('/tmp/')) {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+});
+
+Given('a JettyPod project with hook installed', function () {
+  // SAFETY: Only delete if testDir is in /tmp
+  if (fs.existsSync(testDir) && testDir.startsWith('/tmp/')) {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+  fs.mkdirSync(testDir, { recursive: true });
+  process.chdir(testDir);
+
+  execSync('git init', { stdio: 'pipe' });
+  execSync('git config user.email "test@test.com"', { stdio: 'pipe' });
+  execSync('git config user.name "Test"', { stdio: 'pipe' });
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} init`, { stdio: 'pipe' });
+
+  // Verify hook was installed
+  const hookPath = path.join(testDir, '.jettypod', 'hooks', 'protect-claude-md.js');
+  assert(fs.existsSync(hookPath), 'Hook file not installed');
+});
+
+Given('CLAUDE.md contains {string}', function (content) {
+  claudeMdContent = fs.readFileSync('CLAUDE.md', 'utf-8');
+  assert(claudeMdContent.includes(content), `CLAUDE.md does not contain: ${content}`);
+});
+
+Given('CLAUDE.md has the default content after init', function () {
+  claudeMdContent = fs.readFileSync('CLAUDE.md', 'utf-8');
+  // Check that there's no actual current_work section with content (not just the reference in jettypod_workflow)
+  const hasCurrentWorkSection = claudeMdContent.match(/<current_work>\s*Working on:/);
+  assert(!hasCurrentWorkSection, 'CLAUDE.md should not have an active current_work section after init');
+});
+
+Given('CLAUDE.md has stage {string} after init', function (stage) {
+  claudeMdContent = fs.readFileSync('CLAUDE.md', 'utf-8');
+  assert(claudeMdContent.includes(`<stage>${stage}</stage>`), `CLAUDE.md should contain stage ${stage}`);
+});
+
+Given('CLAUDE.md has the default mission', function () {
+  claudeMdContent = fs.readFileSync('CLAUDE.md', 'utf-8');
+  assert(claudeMdContent.includes('<mission>'), 'CLAUDE.md should have a mission section');
+});
+
+Given('CLAUDE.md has a tech_stack section', function () {
+  claudeMdContent = fs.readFileSync('CLAUDE.md', 'utf-8');
+  assert(claudeMdContent.includes('<tech_stack>'), 'CLAUDE.md should have a tech_stack section');
+});
+
+Given('a file {string} exists', function (filePath) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, 'const x = 1;');
+});
+
+Given('CLAUDE.md does not exist', function () {
+  if (fs.existsSync('CLAUDE.md')) {
+    fs.unlinkSync('CLAUDE.md');
+  }
+});
+
+Given('a new empty directory', function () {
+  if (fs.existsSync(testDir)) {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+  fs.mkdirSync(testDir, { recursive: true });
+  process.chdir(testDir);
+
+  // Set testDir on this context so other step files can use it
+  this.testDir = testDir;
+
+  // Initialize git for jettypod init
+  execSync('git init', { stdio: 'pipe' });
+  execSync('git config user.email "test@test.com"', { stdio: 'pipe' });
+  execSync('git config user.name "Test"', { stdio: 'pipe' });
+});
+
+Given('the hook receives invalid JSON input', function () {
+  editAttempt = {
+    invalidInput: true,
+    input: 'not valid json {'
+  };
+});
+
+Given('a JettyPod project in discovery mode', function () {
+  if (fs.existsSync(testDir)) {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+  fs.mkdirSync(testDir, { recursive: true });
+  process.chdir(testDir);
+
+  execSync('git init', { stdio: 'pipe' });
+  execSync('git config user.email "test@test.com"', { stdio: 'pipe' });
+  execSync('git config user.name "Test"', { stdio: 'pipe' });
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} init`, { stdio: 'pipe' });
+
+  // Mode is now managed by work items, not project-level config
+  const config = JSON.parse(fs.readFileSync('.jettypod/config.json', 'utf-8'));
+  assert(config.name, 'Config should have project name');
+});
+
+Given('the Claude Code hook is active', function () {
+  const settingsPath = path.join(testDir, '.claude', 'settings.json');
+  assert(fs.existsSync(settingsPath), 'Claude Code settings not found');
+
+  const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+  assert(settings.hooks, 'No hooks in settings');
+  assert(settings.hooks.PreToolUse, 'No PreToolUse hooks');
+});
+
+When('Claude Code attempts to edit it to {string}', function (newContent) {
+  const hookPath = path.join(testDir, '.jettypod', 'hooks', 'protect-claude-md.js');
+
+  // Find the old content from the last Given step
+  let oldContent;
+  if (claudeMdContent.includes('<mode>')) {
+    oldContent = claudeMdContent.match(/<mode>\w+<\/mode>/)?.[0] || '<mode>discovery</mode>';
+  } else if (claudeMdContent.includes('Status:')) {
+    oldContent = claudeMdContent.match(/Status: \w+/)?.[0] || 'Status: in_progress';
+  } else if (claudeMdContent.includes('<stage>')) {
+    oldContent = claudeMdContent.match(/<stage>\w+<\/stage>/)?.[0] || '<stage>mature</stage>';
+  } else if (claudeMdContent.includes('<mission>')) {
+    oldContent = '<mission>Old mission</mission>';
+  } else if (claudeMdContent.includes('<standards>')) {
+    oldContent = '<standards>Old standards</standards>';
+  } else {
+    oldContent = '<project_summary>test</project_summary>';
+  }
+
+  const hookInput = JSON.stringify({
+    session_id: 'test-session',
+    transcript_path: '/tmp/transcript.md',
+    cwd: testDir,
+    hook_event_name: 'PreToolUse',
+    tool_name: 'Edit',
+    tool_input: {
+      file_path: path.join(testDir, 'CLAUDE.md'),
+      old_string: oldContent,
+      new_string: newContent
+    }
+  });
+
+  const result = spawnSync('node', [hookPath], {
+    input: hookInput,
+    encoding: 'utf-8'
+  });
+
+  hookResponse = JSON.parse(result.stdout);
+  editAttempt = { oldContent, newContent };
+});
+
+When('Claude Code attempts to add {string}', function (newContent) {
+  const hookPath = path.join(testDir, '.jettypod', 'hooks', 'protect-claude-md.js');
+
+  const hookInput = JSON.stringify({
+    session_id: 'test-session',
+    transcript_path: '/tmp/transcript.md',
+    cwd: testDir,
+    hook_event_name: 'PreToolUse',
+    tool_name: 'Edit',
+    tool_input: {
+      file_path: path.join(testDir, 'CLAUDE.md'),
+      old_string: '<project_summary>test</project_summary>',
+      new_string: newContent
+    }
+  });
+
+  const result = spawnSync('node', [hookPath], {
+    input: hookInput,
+    encoding: 'utf-8'
+  });
+
+  hookResponse = JSON.parse(result.stdout);
+});
+
+When('Claude Code attempts to add a current_work section', function () {
+  const hookPath = path.join(testDir, '.jettypod', 'hooks', 'protect-claude-md.js');
+
+  const hookInput = JSON.stringify({
+    session_id: 'test-session',
+    transcript_path: '/tmp/transcript.md',
+    cwd: testDir,
+    hook_event_name: 'PreToolUse',
+    tool_name: 'Edit',
+    tool_input: {
+      file_path: path.join(testDir, 'CLAUDE.md'),
+      old_string: '</claude_context>',
+      new_string: '<current_work>Working on: [#75]</current_work>\n</claude_context>'
+    }
+  });
+
+  const result = spawnSync('node', [hookPath], {
+    input: hookInput,
+    encoding: 'utf-8'
+  });
+
+  hookResponse = JSON.parse(result.stdout);
+});
+
+When('Claude Code attempts to change stage to {string}', function (newStage) {
+  const hookPath = path.join(testDir, '.jettypod', 'hooks', 'protect-claude-md.js');
+
+  const claudeContent = fs.readFileSync('CLAUDE.md', 'utf-8');
+  const oldStage = claudeContent.match(/<stage>\w+<\/stage>/)?.[0];
+
+  const hookInput = JSON.stringify({
+    session_id: 'test-session',
+    transcript_path: '/tmp/transcript.md',
+    cwd: testDir,
+    hook_event_name: 'PreToolUse',
+    tool_name: 'Edit',
+    tool_input: {
+      file_path: path.join(testDir, 'CLAUDE.md'),
+      old_string: oldStage,
+      new_string: `<stage>${newStage}</stage>`
+    }
+  });
+
+  const result = spawnSync('node', [hookPath], {
+    input: hookInput,
+    encoding: 'utf-8'
+  });
+
+  hookResponse = JSON.parse(result.stdout);
+});
+
+When('Claude Code attempts to change the mission', function () {
+  const hookPath = path.join(testDir, '.jettypod', 'hooks', 'protect-claude-md.js');
+
+  const claudeContent = fs.readFileSync('CLAUDE.md', 'utf-8');
+  const oldMission = claudeContent.match(/<mission>[\s\S]*?<\/mission>/)?.[0];
+
+  const hookInput = JSON.stringify({
+    session_id: 'test-session',
+    transcript_path: '/tmp/transcript.md',
+    cwd: testDir,
+    hook_event_name: 'PreToolUse',
+    tool_name: 'Edit',
+    tool_input: {
+      file_path: path.join(testDir, 'CLAUDE.md'),
+      old_string: oldMission,
+      new_string: '<mission>New mission text</mission>'
+    }
+  });
+
+  const result = spawnSync('node', [hookPath], {
+    input: hookInput,
+    encoding: 'utf-8'
+  });
+
+  hookResponse = JSON.parse(result.stdout);
+});
+
+When('Claude Code attempts to change the tech_stack', function () {
+  const hookPath = path.join(testDir, '.jettypod', 'hooks', 'protect-claude-md.js');
+
+  const claudeContent = fs.readFileSync('CLAUDE.md', 'utf-8');
+  const oldTechStack = claudeContent.match(/<tech_stack>[\s\S]*?<\/tech_stack>/)?.[0];
+
+  const hookInput = JSON.stringify({
+    session_id: 'test-session',
+    transcript_path: '/tmp/transcript.md',
+    cwd: testDir,
+    hook_event_name: 'PreToolUse',
+    tool_name: 'Edit',
+    tool_input: {
+      file_path: path.join(testDir, 'CLAUDE.md'),
+      old_string: oldTechStack,
+      new_string: '<tech_stack>React, TypeScript</tech_stack>'
+    }
+  });
+
+  const result = spawnSync('node', [hookPath], {
+    input: hookInput,
+    encoding: 'utf-8'
+  });
+
+  hookResponse = JSON.parse(result.stdout);
+});
+
+When('Claude Code attempts to edit any content in it', function () {
+  const hookPath = path.join(testDir, '.jettypod', 'hooks', 'protect-claude-md.js');
+
+  const hookInput = JSON.stringify({
+    session_id: 'test-session',
+    transcript_path: '/tmp/transcript.md',
+    cwd: testDir,
+    hook_event_name: 'PreToolUse',
+    tool_name: 'Edit',
+    tool_input: {
+      file_path: path.join(testDir, 'src', 'index.js'),
+      old_string: 'const x = 1;',
+      new_string: 'const x = 2;'
+    }
+  });
+
+  const result = spawnSync('node', [hookPath], {
+    input: hookInput,
+    encoding: 'utf-8'
+  });
+
+  hookResponse = JSON.parse(result.stdout);
+});
+
+When('Claude Code attempts to Write a new CLAUDE.md file', function () {
+  const hookPath = path.join(testDir, '.jettypod', 'hooks', 'protect-claude-md.js');
+
+  const hookInput = JSON.stringify({
+    session_id: 'test-session',
+    transcript_path: '/tmp/transcript.md',
+    cwd: testDir,
+    hook_event_name: 'PreToolUse',
+    tool_name: 'Write',
+    tool_input: {
+      file_path: path.join(testDir, 'CLAUDE.md'),
+      content: '<claude_context>new file</claude_context>'
+    }
+  });
+
+  const result = spawnSync('node', [hookPath], {
+    input: hookInput,
+    encoding: 'utf-8'
+  });
+
+  hookResponse = JSON.parse(result.stdout);
+});
+
+When('I run jettypod command {string}', function (command) {
+  const result = execSync(`node ${path.join(originalDir, 'jettypod.js')} ${command.replace('jettypod ', '')}`, {
+    stdio: 'pipe',
+    encoding: 'utf-8'
+  });
+  this.commandOutput = result;
+});
+
+When('the hook executes', function () {
+  const hookPath = path.join(originalDir, '.jettypod', 'hooks', 'protect-claude-md.js');
+
+  const result = spawnSync('node', [hookPath], {
+    input: editAttempt.input,
+    encoding: 'utf-8'
+  });
+
+  // Should not crash, should fail open with allow
+  hookResponse = result.stdout ? JSON.parse(result.stdout) : { hookSpecificOutput: { permissionDecision: 'allow' } };
+});
+
+When('Claude Code tries to change mode to speed by editing CLAUDE.md', function () {
+  const hookPath = path.join(testDir, '.jettypod', 'hooks', 'protect-claude-md.js');
+
+  const claudeContent = fs.readFileSync('CLAUDE.md', 'utf-8');
+  const oldMode = claudeContent.match(/<mode>discovery<\/mode>/)?.[0];
+
+  const hookInput = JSON.stringify({
+    session_id: 'test-session',
+    transcript_path: '/tmp/transcript.md',
+    cwd: testDir,
+    hook_event_name: 'PreToolUse',
+    tool_name: 'Edit',
+    tool_input: {
+      file_path: path.join(testDir, 'CLAUDE.md'),
+      old_string: oldMode,
+      new_string: '<mode>speed</mode>'
+    }
+  });
+
+  const result = spawnSync('node', [hookPath], {
+    input: hookInput,
+    encoding: 'utf-8'
+  });
+
+  hookResponse = JSON.parse(result.stdout);
+});
+
+When('I run jettypod command {string} instead', function (command) {
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} ${command.replace('jettypod ', '')}`, {
+    stdio: 'pipe'
+  });
+});
+
+Then('the edit is blocked with permission decision {string}', function (decision) {
+  assert(hookResponse, 'No hook response received');
+  assert(hookResponse.hookSpecificOutput, 'No hookSpecificOutput in response');
+  assert.strictEqual(hookResponse.hookSpecificOutput.permissionDecision, decision);
+});
+
+Then('the error message suggests {string}', function (suggestion) {
+  assert(hookResponse.hookSpecificOutput.permissionDecisionReason, 'No reason provided');
+  assert(hookResponse.hookSpecificOutput.permissionDecisionReason.includes(suggestion),
+    `Expected suggestion to include "${suggestion}", got: ${hookResponse.hookSpecificOutput.permissionDecisionReason}`);
+});
+
+Then('the edit is allowed with permission decision {string}', function (decision) {
+  assert(hookResponse, 'No hook response received');
+  assert(hookResponse.hookSpecificOutput, 'No hookSpecificOutput in response');
+  assert.strictEqual(hookResponse.hookSpecificOutput.permissionDecision, decision);
+});
+
+Then('the hook file {string} should exist', function (filePath) {
+  const fullPath = path.join(testDir, filePath);
+  assert(fs.existsSync(fullPath), `File ${filePath} does not exist`);
+});
+
+Then('the hook file should be executable', function () {
+  const hookPath = path.join(testDir, '.jettypod', 'hooks', 'protect-claude-md.js');
+  const stats = fs.statSync(hookPath);
+  // Check if executable bit is set (mode & 0o111 checks user/group/other exec bits)
+  assert((stats.mode & 0o111) !== 0, 'Hook file is not executable');
+});
+
+Then('the file {string} should exist', function (filePath) {
+  const fullPath = path.join(testDir, filePath);
+  assert(fs.existsSync(fullPath), `File ${filePath} does not exist`);
+});
+
+Then('{string} should contain PreToolUse configuration for Edit', function (filePath) {
+  const fullPath = path.join(testDir, filePath);
+  const settings = JSON.parse(fs.readFileSync(fullPath, 'utf-8'));
+
+  assert(settings.hooks, 'No hooks in settings');
+  assert(settings.hooks.PreToolUse, 'No PreToolUse hooks');
+
+  const editHook = settings.hooks.PreToolUse.find(h => h.matcher === 'Edit');
+  assert(editHook, 'No Edit hook found');
+  assert(editHook.hooks[0].command.includes('protect-claude-md.js'), 'Hook command not correct');
+});
+
+Then('{string} should contain PreToolUse configuration for Write', function (filePath) {
+  const fullPath = path.join(testDir, filePath);
+  const settings = JSON.parse(fs.readFileSync(fullPath, 'utf-8'));
+
+  const writeHook = settings.hooks.PreToolUse.find(h => h.matcher === 'Write');
+  assert(writeHook, 'No Write hook found');
+  assert(writeHook.hooks[0].command.includes('protect-claude-md.js'), 'Hook command not correct');
+});
+
+Then('the command output should contain {string}', function (expectedOutput) {
+  // Output is captured in this.commandOutput from When step
+  assert(this.commandOutput && this.commandOutput.includes(expectedOutput),
+    `Expected output to contain "${expectedOutput}"`);
+});
+
+Then('no error is raised', function () {
+  // If we got here, no error was raised
+  assert(true);
+});
+
+Then('the edit is blocked', function () {
+  assert(hookResponse, 'No hook response received');
+  assert.strictEqual(hookResponse.hookSpecificOutput.permissionDecision, 'deny');
+});
+
+Then('Claude Code receives error {string}', function (errorText) {
+  assert(hookResponse.hookSpecificOutput.permissionDecisionReason.includes(errorText),
+    `Expected error to include "${errorText}"`);
+});
+
+Then('CLAUDE.md is updated to speed mode', function () {
+  const content = fs.readFileSync('CLAUDE.md', 'utf-8');
+  assert(content.includes('<mode>speed</mode>'), 'CLAUDE.md not updated to speed mode');
+});
+
+Then('the update succeeds', function () {
+  const content = fs.readFileSync('CLAUDE.md', 'utf-8');
+  assert(content.includes('<mode>speed</mode>'), 'Mode change did not succeed');
+});