safeword 0.2.3 → 0.2.4

package/packages/cli/tests/commands/setup-git.test.ts

@@ -0,0 +1,139 @@
+/**
+ * Test Suite 7: Git Repository Handling
+ *
+ * Tests for git detection and hook installation.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import {
+  createTempDir,
+  removeTempDir,
+  createTypeScriptPackageJson,
+  runCli,
+  readTestFile,
+  writeTestFile,
+  fileExists,
+  initGitRepo,
+} from '../helpers';
+
+describe('Test Suite 7: Git Repository Handling', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = createTempDir();
+  });
+
+  afterEach(() => {
+    removeTempDir(tempDir);
+  });
+
+  describe('Test 7.1: Prompts for git init when no .git', () => {
+    it('should mention git initialization in output', async () => {
+      createTypeScriptPackageJson(tempDir);
+      // No git init
+
+      // In non-interactive mode with --yes, we expect it to skip
+      // The prompt behavior is tested via TTY simulation
+      const result = await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      // Output should mention git
+      const output = result.stdout + result.stderr;
+      expect(output.toLowerCase()).toMatch(/git/i);
+    });
+  });
+
+  describe('Test 7.2: Runs git init when user confirms', () => {
+    // This test would require TTY simulation for interactive input
+    // For now, we test that git hooks work when .git exists
+    it('should work with existing git repository', async () => {
+      createTypeScriptPackageJson(tempDir);
+      initGitRepo(tempDir);
+
+      const result = await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      expect(result.exitCode).toBe(0);
+      expect(fileExists(tempDir, '.git')).toBe(true);
+    });
+  });
+
+  describe('Test 7.3: Skips git init when user declines', () => {
+    // In --yes mode, git init is skipped by default
+    it('should skip git init in non-interactive mode', async () => {
+      createTypeScriptPackageJson(tempDir);
+      // No git init
+
+      const result = await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      expect(result.exitCode).toBe(0);
+      // Git should NOT be initialized
+      expect(fileExists(tempDir, '.git')).toBe(false);
+
+      // Should warn about skipped git hooks
+      const output = result.stdout + result.stderr;
+      expect(output.toLowerCase()).toMatch(/skip|warning|git/i);
+    });
+  });
+
+  describe('Test 7.4: Installs git hooks when .git present', () => {
+    it('should create pre-commit hook with safeword markers', async () => {
+      createTypeScriptPackageJson(tempDir);
+      initGitRepo(tempDir);
+
+      await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      expect(fileExists(tempDir, '.git/hooks/pre-commit')).toBe(true);
+
+      const content = readTestFile(tempDir, '.git/hooks/pre-commit');
+      expect(content).toContain('SAFEWORD_ARCH_CHECK_START');
+      expect(content).toContain('SAFEWORD_ARCH_CHECK_END');
+    });
+  });
+
+  describe('Test 7.5: Preserves existing pre-commit hooks', () => {
+    it('should preserve custom hook content', async () => {
+      createTypeScriptPackageJson(tempDir);
+      initGitRepo(tempDir);
+
+      // Create existing pre-commit hook
+      const customHook = `#!/bin/bash
+# Custom hook for running tests
+echo "Running custom tests..."
+npm test
+`;
+      writeTestFile(tempDir, '.git/hooks/pre-commit', customHook);
+
+      await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      const content = readTestFile(tempDir, '.git/hooks/pre-commit');
+
+      // Original content preserved
+      expect(content).toContain('Running custom tests');
+      expect(content).toContain('npm test');
+
+      // Safeword markers added
+      expect(content).toContain('SAFEWORD_ARCH_CHECK_START');
+      expect(content).toContain('SAFEWORD_ARCH_CHECK_END');
+    });
+
+    it('should not duplicate markers on repeated setup', async () => {
+      createTypeScriptPackageJson(tempDir);
+      initGitRepo(tempDir);
+
+      // Run setup twice
+      await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      // For second run, we need to remove .safeword to allow setup
+      // Or use upgrade. Let's test via upgrade path
+      await runCli(['upgrade'], { cwd: tempDir });
+
+      const content = readTestFile(tempDir, '.git/hooks/pre-commit');
+
+      // Markers should appear exactly once
+      const startCount = (content.match(/SAFEWORD_ARCH_CHECK_START/g) || []).length;
+      const endCount = (content.match(/SAFEWORD_ARCH_CHECK_END/g) || []).length;
+
+      expect(startCount).toBe(1);
+      expect(endCount).toBe(1);
+    });
+  });
+});

package/packages/cli/tests/commands/setup-hooks.test.ts

@@ -0,0 +1,334 @@
+/**
+ * Test Suite 3: Setup - Hooks and Skills
+ *
+ * Tests for Claude Code hook registration and skill copying.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { chmodSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import {
+  createTempDir,
+  removeTempDir,
+  createTypeScriptPackageJson,
+  runCli,
+  readTestFile,
+  writeTestFile,
+  fileExists,
+  initGitRepo,
+} from '../helpers';
+
+describe('Test Suite 3: Setup - Hooks and Skills', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = createTempDir();
+  });
+
+  afterEach(() => {
+    removeTempDir(tempDir);
+  });
+
+  describe('Test 3.1: Registers hooks in settings.json', () => {
+    it('should create .claude/settings.json with hooks', async () => {
+      createTypeScriptPackageJson(tempDir);
+      initGitRepo(tempDir);
+
+      await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      expect(fileExists(tempDir, '.claude/settings.json')).toBe(true);
+
+      const settings = JSON.parse(readTestFile(tempDir, '.claude/settings.json'));
+
+      expect(settings.hooks).toBeDefined();
+      expect(settings.hooks.SessionStart).toBeDefined();
+      expect(Array.isArray(settings.hooks.SessionStart)).toBe(true);
+      expect(settings.hooks.UserPromptSubmit).toBeDefined();
+      expect(Array.isArray(settings.hooks.UserPromptSubmit)).toBe(true);
+      expect(settings.hooks.PostToolUse).toBeDefined();
+      expect(Array.isArray(settings.hooks.PostToolUse)).toBe(true);
+    });
+
+    it('should reference .safeword/hooks paths', async () => {
+      createTypeScriptPackageJson(tempDir);
+      initGitRepo(tempDir);
+
+      await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      const settings = JSON.parse(readTestFile(tempDir, '.claude/settings.json'));
+      const settingsStr = JSON.stringify(settings);
+
+      // At least one hook should reference .safeword/hooks
+      expect(settingsStr).toContain('.safeword/hooks');
+    });
+  });
+
+  describe('Test 3.2: Copies skills to .claude/skills', () => {
+    it('should create skills directory with safeword skills', async () => {
+      createTypeScriptPackageJson(tempDir);
+      initGitRepo(tempDir);
+
+      await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      expect(fileExists(tempDir, '.claude/skills')).toBe(true);
+
+      // Check for safeword skill directory
+      // Should match pattern safeword-* (e.g., safeword-quality-reviewer)
+      expect(fileExists(tempDir, '.claude/skills/safeword-quality-reviewer')).toBe(true);
+
+      // The skill should contain a SKILL.md file
+      expect(fileExists(tempDir, '.claude/skills/safeword-quality-reviewer/SKILL.md')).toBe(true);
+
+      const skillContent = readTestFile(
+        tempDir,
+        '.claude/skills/safeword-quality-reviewer/SKILL.md',
+      );
+      expect(skillContent).toContain('Quality Reviewer');
+    });
+  });
+
+  describe('Test 3.3: Preserves existing hooks', () => {
+    it('should append to existing hooks without replacing', async () => {
+      createTypeScriptPackageJson(tempDir);
+      initGitRepo(tempDir);
+
+      // Create existing settings with custom hook
+      const existingSettings = {
+        hooks: {
+          SessionStart: [
+            {
+              command: 'echo "My custom hook"',
+              description: 'Custom SessionStart hook',
+            },
+          ],
+        },
+      };
+      writeTestFile(tempDir, '.claude/settings.json', JSON.stringify(existingSettings, null, 2));
+
+      await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      const settings = JSON.parse(readTestFile(tempDir, '.claude/settings.json'));
+
+      // Custom hook should still be present
+      const hasCustomHook = settings.hooks.SessionStart.some(
+        (hook: { command?: string }) => hook.command === 'echo "My custom hook"',
+      );
+      expect(hasCustomHook).toBe(true);
+
+      // Safeword hooks should be added
+      expect(settings.hooks.SessionStart.length).toBeGreaterThan(1);
+    });
+  });
+
+  describe('Test 3.4: Includes SessionStart hook for AGENTS.md', () => {
+    it('should include AGENTS.md verification hook', async () => {
+      createTypeScriptPackageJson(tempDir);
+      initGitRepo(tempDir);
+
+      await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      const settings = JSON.parse(readTestFile(tempDir, '.claude/settings.json'));
+
+      // Find hook that references AGENTS.md check
+      const agentsHook = settings.hooks.SessionStart.find(
+        (hook: { command?: string }) =>
+          hook.command && (hook.command.includes('AGENTS') || hook.command.includes('agents')),
+      );
+
+      expect(agentsHook).toBeDefined();
+
+      // Hook script should exist
+      if (agentsHook?.command) {
+        // Extract script path from command if it's a bash script
+        const scriptMatch = agentsHook.command.match(/bash\s+([^\s]+)/);
+        if (scriptMatch) {
+          expect(fileExists(tempDir, scriptMatch[1])).toBe(true);
+        }
+      }
+    });
+  });
+
+  describe('Test 3.6: Includes UserPromptSubmit hook for timestamp injection', () => {
+    it('should include timestamp injection hook', async () => {
+      createTypeScriptPackageJson(tempDir);
+      initGitRepo(tempDir);
+
+      await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      const settings = JSON.parse(readTestFile(tempDir, '.claude/settings.json'));
+
+      // Find hook that references timestamp injection
+      const timestampHook = settings.hooks.UserPromptSubmit.find(
+        (hook: { command?: string }) =>
+          hook.command && hook.command.includes('inject-timestamp'),
+      );
+
+      expect(timestampHook).toBeDefined();
+
+      // Hook script should exist
+      expect(fileExists(tempDir, '.safeword/hooks/inject-timestamp.sh')).toBe(true);
+
+      // Script should contain timestamp output
+      const scriptContent = readTestFile(tempDir, '.safeword/hooks/inject-timestamp.sh');
+      expect(scriptContent).toContain('date');
+    });
+  });
+
+  describe('Test 3.5: Exit 1 if hook registration fails', () => {
+    it('should fail with exit 1 when settings.json is not writable', async () => {
+      createTypeScriptPackageJson(tempDir);
+      initGitRepo(tempDir);
+
+      // Create .claude directory with read-only settings.json
+      writeTestFile(tempDir, '.claude/settings.json', '{}');
+      chmodSync(join(tempDir, '.claude/settings.json'), 0o444);
+
+      const result = await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      // Restore permissions for cleanup
+      chmodSync(join(tempDir, '.claude/settings.json'), 0o644);
+
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr.toLowerCase()).toMatch(/hook|permission|write|failed/i);
+    });
+  });
+
+  describe('Test 3.7: Installs lib scripts', () => {
+    it('should install shared library scripts to .safeword/lib/', async () => {
+      createTypeScriptPackageJson(tempDir);
+      initGitRepo(tempDir);
+
+      await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      // Lib directory should exist with shell scripts
+      expect(fileExists(tempDir, '.safeword/lib')).toBe(true);
+
+      const libDir = join(tempDir, '.safeword/lib');
+      const shFiles = readdirSync(libDir).filter((f) => f.endsWith('.sh'));
+      expect(shFiles.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Test 3.8: Sets up MCP servers', () => {
+    it('should create .mcp.json with context7 and playwright', async () => {
+      createTypeScriptPackageJson(tempDir);
+      initGitRepo(tempDir);
+
+      await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      expect(fileExists(tempDir, '.mcp.json')).toBe(true);
+
+      const mcpConfig = JSON.parse(readTestFile(tempDir, '.mcp.json'));
+      expect(mcpConfig.mcpServers).toBeDefined();
+      expect(mcpConfig.mcpServers.context7).toBeDefined();
+      expect(mcpConfig.mcpServers.playwright).toBeDefined();
+    });
+  });
+
+  describe('Test 3.9: Preserves existing MCP servers', () => {
+    it('should preserve user MCP servers when adding safeword servers', async () => {
+      createTypeScriptPackageJson(tempDir);
+      initGitRepo(tempDir);
+
+      // Create existing .mcp.json with custom server
+      const existingMcp = {
+        mcpServers: {
+          'my-custom-server': {
+            command: 'my-server',
+            args: ['--port', '3000'],
+          },
+        },
+      };
+      writeTestFile(tempDir, '.mcp.json', JSON.stringify(existingMcp, null, 2));
+
+      await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      const mcpConfig = JSON.parse(readTestFile(tempDir, '.mcp.json'));
+
+      // Custom server should be preserved
+      expect(mcpConfig.mcpServers['my-custom-server']).toBeDefined();
+      expect(mcpConfig.mcpServers['my-custom-server'].command).toBe('my-server');
+
+      // Safeword servers should be added
+      expect(mcpConfig.mcpServers.context7).toBeDefined();
+      expect(mcpConfig.mcpServers.playwright).toBeDefined();
+    });
+  });
+
+  describe('Test 3.10: Installs slash commands', () => {
+    it('should install slash commands to .claude/commands/', async () => {
+      createTypeScriptPackageJson(tempDir);
+      initGitRepo(tempDir);
+
+      await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      // Commands directory should exist
+      expect(fileExists(tempDir, '.claude/commands')).toBe(true);
+
+      // Should contain markdown command files
+      const commandsDir = join(tempDir, '.claude/commands');
+      const mdFiles = readdirSync(commandsDir).filter((f) => f.endsWith('.md'));
+      expect(mdFiles.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Test 3.11: MCP servers work out of the box', () => {
+    it('should configure context7 with correct npx command', async () => {
+      createTypeScriptPackageJson(tempDir);
+      initGitRepo(tempDir);
+
+      await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      expect(fileExists(tempDir, '.mcp.json')).toBe(true);
+
+      const mcpConfig = JSON.parse(readTestFile(tempDir, '.mcp.json'));
+
+      // Context7 should use npx with the correct package
+      expect(mcpConfig.mcpServers.context7).toBeDefined();
+      expect(mcpConfig.mcpServers.context7.command).toBe('npx');
+      expect(mcpConfig.mcpServers.context7.args).toContain('@upstash/context7-mcp@latest');
+    });
+
+    it('should configure playwright with correct npx command', async () => {
+      createTypeScriptPackageJson(tempDir);
+      initGitRepo(tempDir);
+
+      await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      const mcpConfig = JSON.parse(readTestFile(tempDir, '.mcp.json'));
+
+      // Playwright should use npx with the correct package
+      expect(mcpConfig.mcpServers.playwright).toBeDefined();
+      expect(mcpConfig.mcpServers.playwright.command).toBe('npx');
+      expect(mcpConfig.mcpServers.playwright.args).toEqual(
+        expect.arrayContaining([expect.stringContaining('@playwright/mcp')]),
+      );
+    });
+
+    it('should have MCP packages that can be resolved by npx', async () => {
+      // Verify the packages exist on npm (can be resolved)
+      // This is a lightweight check - just verify npm can find the packages
+      const { execSync } = await import('node:child_process');
+
+      // Check context7 package exists
+      try {
+        execSync('npm view @upstash/context7-mcp version', {
+          encoding: 'utf-8',
+          timeout: 10000,
+        });
+      } catch {
+        expect.fail('@upstash/context7-mcp package not found on npm');
+      }
+
+      // Check playwright package exists
+      try {
+        execSync('npm view @playwright/mcp version', {
+          encoding: 'utf-8',
+          timeout: 10000,
+        });
+      } catch {
+        expect.fail('@playwright/mcp package not found on npm');
+      }
+    });
+  });
+});

package/packages/cli/tests/commands/setup-linting.test.ts

@@ -0,0 +1,189 @@
+/**
+ * Test Suite 4: Setup - Linting (Integration Tests)
+ *
+ * Tests for ESLint + Prettier configuration.
+ *
+ * Note: Unit tests for project type detection (Tests 4.1-4.3) are in
+ * src/utils/project-detector.test.ts. This file contains only the
+ * integration tests (Tests 4.4-4.8).
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { chmodSync } from 'node:fs';
+import { join } from 'node:path';
+import {
+  createTempDir,
+  removeTempDir,
+  createTypeScriptPackageJson,
+  runCli,
+  readTestFile,
+  fileExists,
+  initGitRepo,
+} from '../helpers';
+
+describe('Test Suite 4: Setup - Linting (Integration)', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = createTempDir();
+  });
+
+  afterEach(() => {
+    removeTempDir(tempDir);
+  });
+
+  describe('Test 4.4: Creates eslint.config.mjs', () => {
+    it('should create ESLint flat config', async () => {
+      createTypeScriptPackageJson(tempDir);
+      initGitRepo(tempDir);
+
+      await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      expect(fileExists(tempDir, 'eslint.config.mjs')).toBe(true);
+
+      const content = readTestFile(tempDir, 'eslint.config.mjs');
+      // Should be a valid ESLint flat config
+      expect(content).toContain('export');
+    });
+
+    it('should include TypeScript config when detected', async () => {
+      createTypeScriptPackageJson(tempDir);
+      initGitRepo(tempDir);
+
+      await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      const content = readTestFile(tempDir, 'eslint.config.mjs');
+      expect(content).toMatch(/typescript|@typescript-eslint/i);
+    });
+  });
+
+  describe('Test 4.5: Creates .prettierrc', () => {
+    it('should create Prettier config', async () => {
+      createTypeScriptPackageJson(tempDir);
+      initGitRepo(tempDir);
+
+      await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      expect(fileExists(tempDir, '.prettierrc')).toBe(true);
+
+      const content = readTestFile(tempDir, '.prettierrc');
+      // Should be valid JSON
+      expect(() => JSON.parse(content)).not.toThrow();
+    });
+  });
+
+  describe('Test 4.6: Adds lint script to package.json', () => {
+    it('should add lint script', async () => {
+      createTypeScriptPackageJson(tempDir);
+      initGitRepo(tempDir);
+
+      await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      const packageJson = JSON.parse(readTestFile(tempDir, 'package.json'));
+      expect(packageJson.scripts?.lint).toBe('eslint .');
+    });
+
+    it('should not overwrite existing lint script', async () => {
+      createTypeScriptPackageJson(tempDir, {
+        scripts: {
+          lint: 'eslint src/',
+        },
+      });
+      initGitRepo(tempDir);
+
+      await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      const packageJson = JSON.parse(readTestFile(tempDir, 'package.json'));
+      // Original script should be preserved
+      expect(packageJson.scripts?.lint).toBe('eslint src/');
+    });
+  });
+
+  describe('Test 4.7: Adds format script to package.json', () => {
+    it('should add format script', async () => {
+      createTypeScriptPackageJson(tempDir);
+      initGitRepo(tempDir);
+
+      await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      const packageJson = JSON.parse(readTestFile(tempDir, 'package.json'));
+      expect(packageJson.scripts?.format).toBe('prettier --write .');
+    });
+
+    it('should not overwrite existing format script', async () => {
+      createTypeScriptPackageJson(tempDir, {
+        scripts: {
+          format: 'prettier --write src/',
+        },
+      });
+      initGitRepo(tempDir);
+
+      await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      const packageJson = JSON.parse(readTestFile(tempDir, 'package.json'));
+      // Original script should be preserved
+      expect(packageJson.scripts?.format).toBe('prettier --write src/');
+    });
+  });
+
+  describe('Test 4.8: Exit 1 if linting setup fails', () => {
+    it('should fail with exit 1 when package.json is not writable', async () => {
+      createTypeScriptPackageJson(tempDir);
+      initGitRepo(tempDir);
+
+      // Make package.json read-only
+      chmodSync(join(tempDir, 'package.json'), 0o444);
+
+      const result = await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      // Restore permissions for cleanup
+      chmodSync(join(tempDir, 'package.json'), 0o644);
+
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr.toLowerCase()).toMatch(/lint|permission|write|failed|package/i);
+    });
+  });
+
+  describe('Test 4.9: Creates markdownlint config', () => {
+    it('should create .markdownlint.jsonc', async () => {
+      createTypeScriptPackageJson(tempDir);
+      initGitRepo(tempDir);
+
+      await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      // Implementation may place in .safeword/ or root
+      const hasMarkdownlintConfig =
+        fileExists(tempDir, '.markdownlint.jsonc') ||
+        fileExists(tempDir, '.safeword/.markdownlint.jsonc');
+
+      expect(hasMarkdownlintConfig).toBe(true);
+    });
+  });
+
+  describe('Test 4.10: Adds lint:md script', () => {
+    it('should add lint:md script to package.json', async () => {
+      createTypeScriptPackageJson(tempDir);
+      initGitRepo(tempDir);
+
+      await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      const packageJson = JSON.parse(readTestFile(tempDir, 'package.json'));
+      expect(packageJson.scripts?.['lint:md']).toBeDefined();
+      expect(packageJson.scripts?.['lint:md']).toContain('markdownlint');
+    });
+  });
+
+  describe('Test 4.11: Adds format:check script', () => {
+    it('should add format:check script to package.json', async () => {
+      createTypeScriptPackageJson(tempDir);
+      initGitRepo(tempDir);
+
+      await runCli(['setup', '--yes'], { cwd: tempDir });
+
+      const packageJson = JSON.parse(readTestFile(tempDir, 'package.json'));
+      expect(packageJson.scripts?.['format:check']).toBeDefined();
+      expect(packageJson.scripts?.['format:check']).toContain('prettier');
+      expect(packageJson.scripts?.['format:check']).toContain('--check');
+    });
+  });
+});